← Back to branch summary

~ubuntu-branches/ubuntu/precise/guayadeque/precise

« back to all changes in this revision

Viewing changes to src/dbus/mpris2.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2011-05-14 15:08:03 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20110514150803-8b5evqetnaj35j34
Tags: 0.3.1~dfsg0-1
* New upstream release.
* Strip wxsqlite3 stuff out of upstream's tarballs.
* Update get-orig-source target in debian/rules.
* Update gbp config file.
* Bump Standards.
* Build-depend on libwxsqlite3-2.8-dev
* Enable parallel builds.
* Link binaries against the system-wide copy of wxsqlite3.
* Point sources to the correct wxcurl's headers location.
* Update copyright file as per DEP-5
* Improve debian/watch to handle the ~dfsg\d* suffix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dbus/mpris2.cpp
1
1
// -------------------------------------------------------------------------------- //
2
 
//      Copyright (C) 2008-2010 J.Rios
 
2
//      Copyright (C) 2008-2011 J.Rios
3
3
//      anonbeat@gmail.com
4
4
//
5
5
//    This Program is free software; you can redistribute it and/or modify
6
6
//    it under the terms of the GNU General Public License as published by
7
 
//    the Free Software Foundation; either version 2, or (at your option)
 
7
//    the Free Software Foundation; either version 3, or (at your option)
8
8
//    any later version.
9
9
//
10
10
//    This Program is distributed in the hope that it will be useful,
33
33
#define GUAYADEQUE_MPRIS2_INTERFACE_ROOT        "org.mpris.MediaPlayer2"
34
34
#define GUAYADEQUE_MPRIS2_INTERFACE_PLAYER      "org.mpris.MediaPlayer2.Player"
35
35
#define GUAYADEQUE_MPRIS2_INTERFACE_TRACKLIST   "org.mpris.MediaPlayer2.TrackList"
 
36
#define GUAYADEQUE_MPRIS2_INTERFACE_PLAYLISTS   "org.mpris.MediaPlayer2.Playlists"
36
37
 
37
38
const char * guMPRIS2_INTROSPECTION_XML =
38
 
        "<node>"
39
 
        "  <interface name='org.mpris.MediaPlayer2'>"
40
 
        "    <method name='Raise'/>"
41
 
        "    <method name='Quit'/>"
42
 
        "    <property name='CanQuit' type='b' access='read'/>"
43
 
        "    <property name='CanRaise' type='b' access='read'/>"
44
 
        "    <property name='HasTrackList' type='b' access='read'/>"
45
 
        "    <property name='Identity' type='s' access='read'/>"
46
 
        "    <property name='DesktopEntry' type='s' access='read'/>"
47
 
        "    <property name='SupportedUriSchemes' type='as' access='read'/>"
48
 
        "    <property name='SupportedMimeTypes' type='as' access='read'/>"
49
 
        "  </interface>"
50
 
        "  <interface name='org.mpris.MediaPlayer2.Player'>"
51
 
        "    <method name='Next'/>"
52
 
        "    <method name='Previous'/>"
53
 
        "    <method name='Pause'/>"
54
 
        "    <method name='PlayPause'/>"
55
 
        "    <method name='Stop'/>"
56
 
        "    <method name='Play'/>"
57
 
        "    <method name='Seek'>"
58
 
        "      <arg direction='in' name='Offset' type='x'/>"
59
 
        "    </method>"
60
 
        "    <method name='SetPosition'>"
61
 
        "      <arg direction='in' name='TrackId' type='o'/>"
62
 
        "      <arg direction='in' name='Position' type='x'/>"
63
 
        "    </method>"
64
 
        "    <method name='OpenUri'>"
65
 
        "      <arg direction='in' name='Uri' type='s'/>"
66
 
        "    </method>"
67
 
        "    <signal name='Seeked'>"
68
 
        "      <arg name='Position' type='x'/>"
69
 
        "    </signal>"
70
 
        "    <property name='PlaybackStatus' type='s' access='read'/>"
71
 
        "    <property name='LoopStatus' type='s' access='readwrite'/>"
72
 
        "    <property name='Rate' type='d' access='readwrite'/>"
73
 
        "    <property name='Shuffle' type='b' access='readwrite'/>"
74
 
        "    <property name='Metadata' type='a{sv}' access='read'/>"
75
 
        "    <property name='Volume' type='d' access='readwrite'/>"
76
 
        "    <property name='Position' type='x' access='read'/>"
77
 
        "    <property name='MinimumRate' type='d' access='read'/>"
78
 
        "    <property name='MaximumRate' type='d' access='read'/>"
79
 
        "    <property name='CanGoNext' type='b' access='read'/>"
80
 
        "    <property name='CanGoPrevious' type='b' access='read'/>"
81
 
        "    <property name='CanPlay' type='b' access='read'/>"
82
 
        "    <property name='CanPause' type='b' access='read'/>"
83
 
        "    <property name='CanSeek' type='b' access='read'/>"
84
 
        "    <property name='CanControl' type='b' access='read'/>"
85
 
        "  </interface>"
86
 
        "  <interface name='org.mpris.MediaPlayer2.TrackList'>"
87
 
        "    <method name='GetTracksMetadata'>"
88
 
        "      <arg direction='in' name='TrackIds' type='ao'/>"
89
 
        "      <arg direction='out' name='Metadata' type='aa{sv}'/>"
90
 
        "    </method>"
91
 
        "    <method name='AddTrack'>"
92
 
        "      <arg direction='in' name='Uri' type='s'/>"
93
 
        "      <arg direction='in' name='AfterTrack' type='o'/>"
94
 
        "      <arg direction='in' name='SetAsCurrent' type='b'/>"
95
 
        "    </method>"
96
 
        "    <method name='RemoveTrack'>"
97
 
        "      <arg direction='in' name='TrackId' type='o'/>"
98
 
        "    </method>"
99
 
        "    <method name='GoTo'>"
100
 
        "      <arg direction='in' name='TrackId' type='o'/>"
101
 
        "    </method>"
102
 
        "    <signal name='TrackListReplaced'>"
103
 
        "      <arg name='Tracks' type='ao'/>"
104
 
        "      <arg name='CurrentTrack' type='o'/>"
105
 
        "    </signal>"
106
 
        "    <signal name='TrackAdded'>"
107
 
        "      <arg name='Metadata' type='a{sv}'/>"
108
 
        "      <arg name='AfterTrack' type='o'/>"
109
 
        "    </signal>"
110
 
        "    <signal name='TrackRemoved'>"
111
 
        "      <arg name='TrackId' type='o'/>"
112
 
        "    </signal>"
113
 
        "    <signal name='TrackMetadataChanged'>"
114
 
        "      <arg name='TrackId' type='o'/>"
115
 
        "      <arg name='Metadata' type='a{sv}'/>"
116
 
        "    </signal>"
117
 
        "    <property name='Tracks' type='ao' access='read'/>"
118
 
        "    <property name='CanEditTracks' type='b' access='read'/>"
119
 
        "  </interface>"
120
 
        "</node>";
 
39
    "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
 
40
    "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
 
41
        "<node>\n"
 
42
        "  <interface name='org.mpris.MediaPlayer2'>\n"
 
43
        "    <method name='Raise'/>\n"
 
44
        "    <method name='Quit'/>\n"
 
45
        "    <property name='CanQuit' type='b' access='read'/>\n"
 
46
        "    <property name='CanRaise' type='b' access='read'/>\n"
 
47
        "    <property name='HasTrackList' type='b' access='read'/>\n"
 
48
        "    <property name='Identity' type='s' access='read'/>\n"
 
49
        "    <property name='DesktopEntry' type='s' access='read'/>\n"
 
50
        "    <property name='SupportedUriSchemes' type='as' access='read'/>\n"
 
51
        "    <property name='SupportedMimeTypes' type='as' access='read'/>\n"
 
52
        "  </interface>\n"
 
53
        "  <interface name='org.mpris.MediaPlayer2.Player'>\n"
 
54
        "    <method name='Next'/>\n"
 
55
        "    <method name='Previous'/>\n"
 
56
        "    <method name='Pause'/>\n"
 
57
        "    <method name='PlayPause'/>\n"
 
58
        "    <method name='Stop'/>\n"
 
59
        "    <method name='Play'/>\n"
 
60
        "    <method name='Seek'>\n"
 
61
        "      <arg direction='in' name='Offset' type='x'/>\n"
 
62
        "    </method>\n"
 
63
        "    <method name='SetPosition'>\n"
 
64
        "      <arg direction='in' name='TrackId' type='o'/>\n"
 
65
        "      <arg direction='in' name='Position' type='x'/>\n"
 
66
        "    </method>\n"
 
67
        "    <method name='OpenUri'>\n"
 
68
        "      <arg direction='in' name='Uri' type='s'/>\n"
 
69
        "    </method>\n"
 
70
        "    <signal name='Seeked'>\n"
 
71
        "      <arg name='Position' type='x'/>\n"
 
72
        "    </signal>\n"
 
73
        "    <property name='PlaybackStatus' type='s' access='read'/>\n"
 
74
        "    <property name='LoopStatus' type='s' access='readwrite'/>\n"
 
75
        "    <property name='Rate' type='d' access='readwrite'/>\n"
 
76
        "    <property name='Shuffle' type='b' access='readwrite'/>\n"
 
77
        "    <property name='Metadata' type='a{sv}' access='read'/>\n"
 
78
        "    <property name='Volume' type='d' access='readwrite'/>\n"
 
79
        "    <property name='Position' type='x' access='read'/>\n"
 
80
        "    <property name='MinimumRate' type='d' access='read'/>\n"
 
81
        "    <property name='MaximumRate' type='d' access='read'/>\n"
 
82
        "    <property name='CanGoNext' type='b' access='read'/>\n"
 
83
        "    <property name='CanGoPrevious' type='b' access='read'/>\n"
 
84
        "    <property name='CanPlay' type='b' access='read'/>\n"
 
85
        "    <property name='CanPause' type='b' access='read'/>\n"
 
86
        "    <property name='CanSeek' type='b' access='read'/>\n"
 
87
        "    <property name='CanControl' type='b' access='read'/>\n"
 
88
        "  </interface>\n"
 
89
        "  <interface name='org.mpris.MediaPlayer2.TrackList'>\n"
 
90
        "    <method name='GetTracksMetadata'>\n"
 
91
        "      <arg direction='in' name='TrackIds' type='ao'/>\n"
 
92
        "      <arg direction='out' name='Metadata' type='aa{sv}'/>\n"
 
93
        "    </method>\n"
 
94
        "    <method name='AddTrack'>\n"
 
95
        "      <arg direction='in' name='Uri' type='s'/>\n"
 
96
        "      <arg direction='in' name='AfterTrack' type='o'/>\n"
 
97
        "      <arg direction='in' name='SetAsCurrent' type='b'/>\n"
 
98
        "    </method>\n"
 
99
        "    <method name='RemoveTrack'>\n"
 
100
        "      <arg direction='in' name='TrackId' type='o'/>\n"
 
101
        "    </method>\n"
 
102
        "    <method name='GoTo'>\n"
 
103
        "      <arg direction='in' name='TrackId' type='o'/>\n"
 
104
        "    </method>\n"
 
105
        "    <signal name='TrackListReplaced'>\n"
 
106
        "      <arg name='Tracks' type='ao'/>\n"
 
107
        "      <arg name='CurrentTrack' type='o'/>\n"
 
108
        "    </signal>\n"
 
109
        "    <signal name='TrackAdded'>\n"
 
110
        "      <arg name='Metadata' type='a{sv}'/>\n"
 
111
        "      <arg name='AfterTrack' type='o'/>\n"
 
112
        "    </signal>\n"
 
113
        "    <signal name='TrackRemoved'>\n"
 
114
        "      <arg name='TrackId' type='o'/>\n"
 
115
        "    </signal>\n"
 
116
        "    <signal name='TrackMetadataChanged'>\n"
 
117
        "      <arg name='TrackId' type='o'/>\n"
 
118
        "      <arg name='Metadata' type='a{sv}'/>\n"
 
119
        "    </signal>\n"
 
120
        "    <property name='Tracks' type='ao' access='read'/>\n"
 
121
        "    <property name='CanEditTracks' type='b' access='read'/>\n"
 
122
        "  </interface>\n"
 
123
        "  <interface name='org.mpris.MediaPlayer2.Playlists'>\n"
 
124
        "    <method name='ActivatePlaylist'>\n"
 
125
        "      <arg direction='in' name='PlaylistId' type='o'/>\n"
 
126
        "    </method>\n"
 
127
        "    <method name='GetPlaylists'>\n"
 
128
        "      <arg direction='in' name='Index' type='u'/>\n"
 
129
        "      <arg direction='in' name='MaxCount' type='u'/>\n"
 
130
        "      <arg direction='in' name='Order' type='s'/>\n"
 
131
        "      <arg direction='in' name='ReverseOrder' type='b'/>\n"
 
132
        "      <arg direction='out' name='Playlists' type='a(oss)'/>\n"
 
133
        "    </method>\n"
 
134
        "    <signal name='PlaylistChanged'>\n"
 
135
        "      <arg name='Playlist' type='b(oss)'/>\n"
 
136
        "    </signal>\n"
 
137
        "    <property name='PlaylistCount' type='u' access='read'/>\n"
 
138
        "    <property name='Orderings' type='as' access='read'/>\n"
 
139
        "    <property name='ActivePlaylist' type='b(oss)' access='read'/>\n"
 
140
        "  </interface>\n"
 
141
        "</node>\n";
121
142
 
 
143
guMPRIS2 * guMPRIS2::m_MPRIS2 = NULL;
122
144
 
123
145
// -------------------------------------------------------------------------------- //
124
 
guMPRIS2::guMPRIS2( guDBusServer * server, guPlayerPanel * playerpanel ) : guDBusClient( server )
 
146
guMPRIS2::guMPRIS2( guDBusServer * server, guPlayerPanel * playerpanel, guDbLibrary * db ) : guDBusClient( server )
125
147
{
126
148
    m_PlayerPanel = playerpanel;
 
149
    m_Db = db;
127
150
 
128
151
    RegisterClient();
129
152
 
140
163
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const char * value )
141
164
{
142
165
    DBusMessageIter dict_entry, variant;
143
 
    if( value && strlen( value ) )
 
166
    if( value )
144
167
    {
145
168
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
146
169
 
154
177
}
155
178
 
156
179
// -------------------------------------------------------------------------------- //
 
180
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const char ** value )
 
181
{
 
182
    const char **Str;
 
183
    DBusMessageIter dict_entry, variant, array;
 
184
    if( value )
 
185
    {
 
186
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
 
187
 
 
188
        dbus_message_iter_append_basic( &dict_entry, DBUS_TYPE_STRING, &name );
 
189
 
 
190
        dbus_message_iter_open_container( &dict_entry, DBUS_TYPE_VARIANT, "as", &variant );
 
191
 
 
192
        dbus_message_iter_open_container( &variant, DBUS_TYPE_ARRAY, "s", &array );
 
193
 
 
194
        for( Str = value; * Str; Str++ )
 
195
            dbus_message_iter_append_basic( &array, DBUS_TYPE_STRING, Str );
 
196
 
 
197
        dbus_message_iter_close_container( &variant, &array );
 
198
 
 
199
        dbus_message_iter_close_container( &dict_entry, &variant );
 
200
 
 
201
        dbus_message_iter_close_container( Iter, &dict_entry );
 
202
    }
 
203
}
 
204
 
 
205
// -------------------------------------------------------------------------------- //
157
206
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const int value )
158
207
{
159
208
    DBusMessageIter dict_entry, variant;
160
 
    if( value )
 
209
    if( name )
161
210
    {
162
211
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
163
212
 
175
224
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const gint64 value )
176
225
{
177
226
    DBusMessageIter dict_entry, variant;
178
 
    if( value )
 
227
    if( name )
179
228
    {
180
229
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
181
230
 
192
241
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const double value )
193
242
{
194
243
    DBusMessageIter dict_entry, variant;
195
 
    if( value )
 
244
    if( name )
196
245
    {
197
246
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
198
247
 
206
255
}
207
256
 
208
257
// -------------------------------------------------------------------------------- //
209
 
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const bool value )
 
258
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const dbus_bool_t value )
210
259
{
211
260
    DBusMessageIter dict_entry, variant;
212
 
    if( value )
 
261
    if( name )
213
262
    {
214
263
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
215
264
 
223
272
}
224
273
 
225
274
// -------------------------------------------------------------------------------- //
 
275
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const dbus_bool_t plstate,
 
276
                            const char * plpath, const char * plname, const char * plicon )
 
277
{
 
278
    DBusMessageIter dict_entry, vstruct, ostruct, plstruct;
 
279
    if( name )
 
280
    {
 
281
        guLogMessage( wxT( "playlist active %i" ), plstate );
 
282
 
 
283
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
 
284
 
 
285
        dbus_message_iter_append_basic( &dict_entry, DBUS_TYPE_STRING, &name );
 
286
 
 
287
        dbus_message_iter_open_container( &dict_entry, DBUS_TYPE_VARIANT, "(b(oss))", &vstruct );
 
288
 
 
289
        dbus_message_iter_open_container( &vstruct, DBUS_TYPE_STRUCT, NULL, &ostruct );
 
290
 
 
291
        dbus_message_iter_append_basic( &ostruct, DBUS_TYPE_BOOLEAN, &plstate );
 
292
 
 
293
        dbus_message_iter_open_container( &ostruct, DBUS_TYPE_STRUCT, NULL, &plstruct );
 
294
 
 
295
        dbus_message_iter_append_basic( &plstruct, DBUS_TYPE_OBJECT_PATH, &plpath );
 
296
        dbus_message_iter_append_basic( &plstruct, DBUS_TYPE_STRING, &plname );
 
297
        dbus_message_iter_append_basic( &plstruct, DBUS_TYPE_STRING, &plicon );
 
298
 
 
299
        dbus_message_iter_close_container( &ostruct, &plstruct );
 
300
 
 
301
        dbus_message_iter_close_container( &vstruct, &ostruct );
 
302
 
 
303
        dbus_message_iter_close_container( &dict_entry, &vstruct );
 
304
 
 
305
        dbus_message_iter_close_container( Iter, &dict_entry );
 
306
    }
 
307
}
 
308
 
 
309
// -------------------------------------------------------------------------------- //
226
310
static void FillMetadataAsList( DBusMessageIter * Iter, const char * name, const char * value )
227
311
{
228
312
    DBusMessageIter dict_entry, variant, array;
246
330
    }
247
331
}
248
332
 
249
 
//// -------------------------------------------------------------------------------- //
250
 
//void FillMetadataArgs( guDBusMessage * reply, const guTrack * CurTrack )
251
 
//{
252
 
//    DBusMessageIter dict;
253
 
//    DBusMessageIter args;
254
 
//
255
 
//    wxASSERT( CurTrack );
256
 
//
257
 
//    const char * metadata_names[] = {
258
 
//        "location", "title", "artist", "album", "tracknumber",
259
 
//        "time", "mtime", "genre", "rating", "year", "arturl", "bitrate"
260
 
//    };
261
 
//
262
 
//    dbus_message_iter_init_append( reply->GetMessage(), &args );
263
 
//
264
 
//    dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "{sv}", &dict );
265
 
//
266
 
//    FillMetadataDetails( &dict, metadata_names[ 0 ], ( const char * ) ( wxT( "file://" ) + CurTrack->m_FileName ).mb_str( wxConvUTF8 ) );
267
 
//    FillMetadataDetails( &dict, metadata_names[ 1 ], ( const char * ) CurTrack->m_SongName.mb_str( wxConvUTF8 ) );
268
 
//    FillMetadataDetails( &dict, metadata_names[ 2 ], ( const char * ) CurTrack->m_ArtistName.mb_str( wxConvUTF8 ) );
269
 
//    FillMetadataDetails( &dict, metadata_names[ 3 ], ( const char * ) CurTrack->m_AlbumName.mb_str( wxConvUTF8 ) );
270
 
//    if( CurTrack->m_Number )
271
 
//        FillMetadataDetails( &dict, metadata_names[ 4 ], ( const int ) CurTrack->m_Number );
272
 
//    FillMetadataDetails( &dict, metadata_names[ 5 ], ( const int ) CurTrack->m_Length );
273
 
//    FillMetadataDetails( &dict, metadata_names[ 6 ], ( const int ) CurTrack->m_Length * 1000 );
274
 
//    FillMetadataDetails( &dict, metadata_names[ 7 ], ( const char * ) CurTrack->m_GenreName.mb_str( wxConvUTF8 ) );
275
 
//
276
 
//    if( CurTrack->m_Rating >= 0 )
277
 
//        FillMetadataDetails( &dict, metadata_names[ 8 ], ( const int ) CurTrack->m_Rating );
278
 
//
279
 
//    if( CurTrack->m_Year )
280
 
//        FillMetadataDetails( &dict, metadata_names[ 9 ], ( const int ) CurTrack->m_Year );
281
 
//
282
 
////    if( !CurTrack->m_CoverPath.IsEmpty() )
283
 
////        FillMetadataDetails( &dict, metadata_names[ 10 ], ( const char * ) ( wxT( "file://" ) + CurTrack->m_CoverPath ).mb_str( wxConvUTF8 ) );
284
 
//
285
 
//    if( CurTrack->m_Rating )
286
 
//        FillMetadataDetails( &dict, metadata_names[ 11 ], ( const int ) CurTrack->m_Bitrate );
287
 
//
288
 
//    dbus_message_iter_close_container( &args, &dict );
289
 
//
290
 
//}
291
 
 
292
333
// -------------------------------------------------------------------------------- //
293
334
static void FillMetadataIter( DBusMessageIter * iter, const guCurrentTrack * curtrack, const int trackid )
294
335
{
296
337
 
297
338
    dbus_message_iter_open_container( iter, DBUS_TYPE_ARRAY, "{sv}", &dict );
298
339
 
299
 
    if( curtrack->m_Loaded )
 
340
    FillMetadataDetails( &dict, "mpris:trackid", ( const char * ) wxString::Format( wxT( "/org/mpris/MediaPlayer2/Track/%u" ), trackid ).mb_str( wxConvUTF8 ) );
 
341
 
 
342
    if( curtrack && curtrack->m_Loaded )
300
343
    {
301
 
        FillMetadataDetails( &dict, "mpris:trackid", ( const char * ) wxString::Format( wxT( "/org/mpris/MediaPlayer2/Track/%u" ), trackid ).mb_str( wxConvUTF8 ) );
302
344
        wxString LocationUrl = wxT( "file://" ) + curtrack->m_FileName;
303
345
        LocationUrl.Replace( wxT( " "), wxT( "%20" ) );
304
346
        FillMetadataDetails( &dict, "xesam:url", ( const char * ) LocationUrl.mb_str( wxConvUTF8 ) );
345
387
}
346
388
 
347
389
// -------------------------------------------------------------------------------- //
 
390
static void FillMetadataDetails( DBusMessageIter * Iter, const char * name, const guCurrentTrack * curtrack, const int trackid )
 
391
{
 
392
    DBusMessageIter dict_entry, variant;
 
393
    if( name && strlen( name ) )
 
394
    {
 
395
        dbus_message_iter_open_container( Iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry );
 
396
 
 
397
        dbus_message_iter_append_basic( &dict_entry, DBUS_TYPE_STRING, &name );
 
398
 
 
399
        dbus_message_iter_open_container( &dict_entry, DBUS_TYPE_VARIANT, "a{sv}", &variant );
 
400
 
 
401
        FillMetadataIter( &variant, curtrack, trackid );
 
402
 
 
403
        dbus_message_iter_close_container( &dict_entry, &variant );
 
404
 
 
405
        dbus_message_iter_close_container( Iter, &dict_entry );
 
406
    }
 
407
}
 
408
 
 
409
// -------------------------------------------------------------------------------- //
348
410
static void FillMetadataArgs( guDBusMessage * reply, const guCurrentTrack * curtrack, const int trackid )
349
411
{
350
412
    DBusMessageIter args, variant;
449
511
 
450
512
        int Caps = m_PlayerPanel->GetCaps();
451
513
 
452
 
        bool CanGoNext = Caps & MPRIS_CAPS_CAN_GO_NEXT;
 
514
        dbus_bool_t CanGoNext = ( Caps & MPRIS_CAPS_CAN_GO_NEXT ) > 0;
453
515
        FillMetadataDetails( &dict, "CanGoNext", CanGoNext );
454
516
 
455
 
        bool CanGoPrev = Caps & MPRIS_CAPS_CAN_GO_PREV;
456
 
        FillMetadataDetails( &dict, "CanGoPrevious", ( bool ) CanGoPrev );
 
517
        dbus_bool_t CanGoPrev = ( Caps & MPRIS_CAPS_CAN_GO_PREV ) > 0;
 
518
        FillMetadataDetails( &dict, "CanGoPrevious", CanGoPrev );
457
519
 
458
 
        bool CanPlay = Caps & MPRIS_CAPS_CAN_PLAY;
 
520
        dbus_bool_t CanPlay = ( Caps & MPRIS_CAPS_CAN_PLAY ) > 0;
459
521
        FillMetadataDetails( &dict, "CanPlay", CanPlay );
460
522
 
461
 
        bool CanPause = Caps & MPRIS_CAPS_CAN_PAUSE;
 
523
        dbus_bool_t CanPause = ( Caps & MPRIS_CAPS_CAN_PAUSE ) > 0;
462
524
        FillMetadataDetails( &dict, "CanPause", CanPause );
463
525
 
464
 
        bool CanSeek = Caps & MPRIS_CAPS_CAN_SEEK;
 
526
        dbus_bool_t CanSeek = ( Caps & MPRIS_CAPS_CAN_SEEK ) > 0;
465
527
        FillMetadataDetails( &dict, "CanSeek", CanSeek );
466
528
 
467
529
 
554
616
 
555
617
        int Caps = m_PlayerPanel->GetCaps();
556
618
 
557
 
        bool CanGoNext = Caps & MPRIS_CAPS_CAN_GO_NEXT;
 
619
        dbus_bool_t CanGoNext = ( Caps & MPRIS_CAPS_CAN_GO_NEXT ) > 0;
558
620
        FillMetadataDetails( &dict, "CanGoNext", CanGoNext );
559
621
 
560
 
        bool CanGoPrev = Caps & MPRIS_CAPS_CAN_GO_PREV;
 
622
        dbus_bool_t CanGoPrev = ( Caps & MPRIS_CAPS_CAN_GO_PREV ) > 0;
561
623
        FillMetadataDetails( &dict, "CanGoPrevious", CanGoPrev );
562
624
 
563
 
        bool CanPlay = Caps & MPRIS_CAPS_CAN_PLAY;
 
625
        dbus_bool_t CanPlay = ( Caps & MPRIS_CAPS_CAN_PLAY ) > 0;
564
626
        FillMetadataDetails( &dict, "CanPlay", CanPlay );
565
627
 
566
 
        bool CanPause = Caps & MPRIS_CAPS_CAN_PAUSE;
 
628
        dbus_bool_t CanPause = ( Caps & MPRIS_CAPS_CAN_PAUSE ) > 0;
567
629
        FillMetadataDetails( &dict, "CanPause", CanPause );
568
630
 
569
631
 
582
644
    }
583
645
}
584
646
 
585
 
 
586
647
// -------------------------------------------------------------------------------- //
587
648
void guMPRIS2::OnPlayerVolumeChange( void )
588
649
{
623
684
}
624
685
 
625
686
// -------------------------------------------------------------------------------- //
 
687
void inline IterAppendBasic( DBusMessageIter * iter, const int type, const char * value )
 
688
{
 
689
    dbus_message_iter_append_basic( iter, type, &value );
 
690
}
 
691
 
 
692
// -------------------------------------------------------------------------------- //
 
693
void AppendPlaylist( DBusMessageIter * iter, guListItem &playlist )
 
694
{
 
695
    DBusMessageIter plstruct;
 
696
    const char * plicon = "";
 
697
 
 
698
    dbus_message_iter_open_container( iter, DBUS_TYPE_STRUCT, NULL, &plstruct );
 
699
 
 
700
    IterAppendBasic( &plstruct, DBUS_TYPE_OBJECT_PATH,
 
701
        wxString::Format( wxT( "/org/mpris/MediaPlayer2/guayadeque/Playlist/%i" ), playlist.m_Id ).mb_str( wxConvUTF8 ) );
 
702
    IterAppendBasic( &plstruct, DBUS_TYPE_STRING, playlist.m_Name.mb_str( wxConvUTF8 ) );
 
703
    IterAppendBasic( &plstruct, DBUS_TYPE_STRING, plicon );
 
704
 
 
705
    dbus_message_iter_close_container( iter, &plstruct );
 
706
 
 
707
}
 
708
 
 
709
// -------------------------------------------------------------------------------- //
 
710
bool guMPRIS2::GetPlaylists( DBusMessage * msg, const dbus_int32_t start, const dbus_int32_t maxcount,
 
711
                     const char * order, const dbus_bool_t reverseorder )
 
712
{
 
713
    DBusMessageIter args, arrentry;
 
714
    guListItems Playlists;
 
715
    m_Db->GetPlayLists( Playlists );
 
716
 
 
717
    dbus_message_iter_init_append( msg, &args );
 
718
 
 
719
    dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "(oss)", &arrentry );
 
720
 
 
721
    int Index;
 
722
    int Count = wxMin( start + maxcount, ( int ) Playlists.Count() );
 
723
 
 
724
    for( Index = start; Index < Count; Index++ )
 
725
    {
 
726
        AppendPlaylist( &arrentry, Playlists[ Index ] );
 
727
    }
 
728
 
 
729
    dbus_message_iter_close_container( &args, &arrentry );
 
730
 
 
731
    return true;
 
732
}
 
733
 
 
734
// -------------------------------------------------------------------------------- //
626
735
DBusHandlerResult guMPRIS2::HandleMessages( guDBusMessage * msg, guDBusMessage * reply )
627
736
{
628
 
    wxASSERT( msg );
629
737
    //
630
738
    DBusHandlerResult RetVal = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
631
739
    const char *    Interface = msg->GetInterface();
635
743
//    int             Serial = msg->GetSerial();
636
744
//    int             RSerial = msg->GetReplySerial();
637
745
 
638
 
//    // Show the details of the msg
 
746
    // Show the details of the msg
 
747
//    const char *    Dest = msg->GetDestination();
639
748
//    guLogMessage( wxT( "==MPRIS2========================" ) );
640
749
//    guLogMessage( wxT( "Type   : %i" ), Type );
641
750
//    guLogMessage( wxT( "Iface  : %s" ), wxString::FromAscii( Interface ).c_str() );
 
751
//    guLogMessage( wxT( "Dest   : %s" ), wxString::FromAscii( Dest ).c_str() );
642
752
//    guLogMessage( wxT( "Path   : %s" ), wxString::FromAscii( Path ).c_str() );
643
753
//    guLogMessage( wxT( "OPath  : %s" ), wxString::FromAscii( msg->GetObjectPath() ).c_str() );
644
754
//    guLogMessage( wxT( "Member : %s" ), wxString::FromAscii( Member ).c_str() );
656
766
        {
657
767
            if( !strcmp( Member, "Introspect" ) )
658
768
            {
659
 
                DBusMessageIter args;
660
 
                dbus_message_iter_init_append( reply->GetMessage(), &args );
 
769
                const char *    Dest = msg->GetDestination();
 
770
                if( Dest && !strcmp( Dest, GUAYADEQUE_MPRIS2_SERVICE_NAME ) )
 
771
                {
 
772
                    DBusMessageIter args;
 
773
                    dbus_message_iter_init_append( reply->GetMessage(), &args );
661
774
 
662
 
                if( !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &guMPRIS2_INTROSPECTION_XML ) )
663
 
                {
664
 
                    guLogError( wxT( "Failed to attach the Introspection info" ) );
 
775
                    if( !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &guMPRIS2_INTROSPECTION_XML ) )
 
776
                    {
 
777
                        guLogError( wxT( "Failed to attach the Introspection info" ) );
 
778
                    }
 
779
                    Send( reply );
 
780
                    Flush();
 
781
                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
665
782
                }
666
 
                Send( reply );
667
 
                Flush();
668
 
                RetVal = DBUS_HANDLER_RESULT_HANDLED;
669
783
            }
670
784
        }
671
785
        else if( !strcmp( Interface, GUAYADEQUE_PROPERTIES_INTERFACE ) )
672
786
        {
673
 
            DBusError error;
674
 
            dbus_error_init( &error );
675
 
 
676
 
            const char *    QueryIface;
677
 
            const char *    QueryProperty;
678
 
 
679
 
            dbus_message_get_args( msg->GetMessage(), &error,
680
 
                  DBUS_TYPE_STRING, &QueryIface,
681
 
                  DBUS_TYPE_STRING, &QueryProperty,
682
 
                  DBUS_TYPE_INVALID );
683
 
 
684
 
            //guLogMessage( wxT( "Asking for '%s' -> '%s' parameter" ), wxString( QueryIface, wxConvUTF8 ).c_str(), wxString( QueryProperty, wxConvUTF8 ).c_str() );
685
 
 
686
 
            if( dbus_error_is_set( &error ) )
687
 
            {
688
 
                guLogMessage( wxT( "Could not read the '"GUAYADEQUE_PROPERTIES_INTERFACE "' parameter : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
689
 
                dbus_error_free( &error );
690
 
            }
691
 
            else
692
 
            {
693
 
                if( !strcmp( Path, "/org/mpris/MediaPlayer2" ) )
 
787
            if( !strcmp( Path, "/org/mpris/MediaPlayer2" ) )
 
788
            {
 
789
                DBusError error;
 
790
                dbus_error_init( &error );
 
791
 
 
792
                if( !strcmp( Member, "GetAll" ) )
694
793
                {
695
 
                    if( !strcmp( Member, "Get" ) )
696
 
                    {
 
794
                    const char *    QueryIface;
 
795
 
 
796
                    dbus_message_get_args( msg->GetMessage(), &error,
 
797
                          DBUS_TYPE_STRING, &QueryIface,
 
798
                          DBUS_TYPE_INVALID );
 
799
 
 
800
//                    guLogMessage( wxT( "QIface : %s" ), wxString::FromAscii( QueryIface ).c_str() );
 
801
 
 
802
                    if( dbus_error_is_set( &error ) )
 
803
                    {
 
804
                        guLogMessage( wxT( "Could not read the parameter : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
 
805
                        dbus_error_free( &error );
 
806
                    }
 
807
                    else
 
808
                    {
 
809
                        DBusMessageIter args;
 
810
                        DBusMessageIter dict;
 
811
 
697
812
                        if( !strcmp( QueryIface, "org.mpris.MediaPlayer2" ) )
698
813
                        {
699
 
                            if( !strcmp( QueryProperty, "CanQuit" ) )
700
 
                            {
701
 
                                bool ReplyVal = true;
702
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &ReplyVal ) )
703
 
                                {
704
 
                                    Send( reply );
705
 
                                    Flush();
706
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
707
 
                                }
708
 
                            }
709
 
                            else if( !strcmp( QueryProperty, "CanRaise" ) )
710
 
                            {
711
 
                                bool ReplyVal = true;
712
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &ReplyVal ) )
713
 
                                {
714
 
                                    Send( reply );
715
 
                                    Flush();
716
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
717
 
                                }
718
 
                            }
719
 
                            else if( !strcmp( QueryProperty, "HasTrackList" ) )
720
 
                            {
721
 
                                bool ReplyVal = true;
722
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &ReplyVal ) )
723
 
                                {
724
 
                                    Send( reply );
725
 
                                    Flush();
726
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
727
 
                                }
728
 
                            }
729
 
                            else if( !strcmp( QueryProperty, "Identity" ) )
730
 
                            {
731
 
                                const char * AppName = "Guayadeque " ID_GUAYADEQUE_VERSION;
732
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &AppName ) )
733
 
                                {
734
 
                                    Send( reply );
735
 
                                    Flush();
736
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
737
 
                                }
738
 
                            }
739
 
                            else if( !strcmp( QueryProperty, "DesktopEntry" ) )
740
 
                            {
741
 
                                const char * DesktopPath = "/usr/share/applications/guayadeque.desktop";
742
 
                                if( !wxFileExists( wxString( DesktopPath, wxConvUTF8 ) ) )
743
 
                                {
744
 
                                    const char * DesktopPath = "/usr/local/share/applications/guayadeque.desktop";
745
 
                                    if( !wxFileExists( wxString( DesktopPath, wxConvUTF8 ) ) )
746
 
                                    {
747
 
                                        DesktopPath = NULL;
748
 
                                    }
749
 
                                }
750
 
 
751
 
                                if( DesktopPath && AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &DesktopPath ) )
752
 
                                {
753
 
                                    Send( reply );
754
 
                                    Flush();
755
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
756
 
                                }
757
 
                            }
758
 
                            else if( !strcmp( QueryProperty, "SupportedUriSchemes" ) )
759
 
                            {
760
 
                                const char * SupportedUriSchemes[] = { "file", "http", "smb", "sftp", NULL };
761
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_ARRAY, &SupportedUriSchemes ) )
762
 
                                {
763
 
                                    Send( reply );
764
 
                                    Flush();
765
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
766
 
                                }
767
 
                            }
768
 
                            else if( !strcmp( QueryProperty, "SupportedMimeTypes" ) )
769
 
                            {
770
 
                                const char * SupportedMimeTypes[] = {
771
 
                                   "application/ogg",
772
 
                                   "application/x-ogg",
773
 
                                   "application/x-ogm-audio",
774
 
                                   "audio/aac",
775
 
                                   "audio/ape",
776
 
                                   "audio/mp4",
777
 
                                   "audio/mpc",
778
 
                                   "audio/mpeg",
779
 
                                   "audio/mpegurl",
780
 
                                   "audio/ogg",
781
 
                                   "audio/vnd.rn-realaudio",
782
 
                                   "audio/vorbis",
783
 
                                   "audio/x-flac",
784
 
                                   "audio/x-mp3",
785
 
                                   "audio/x-mpeg",
786
 
                                   "audio/x-mpegurl",
787
 
                                   "audio/x-ms-wma",
788
 
                                   "audio/x-musepack",
789
 
                                   "audio/x-oggflac",
790
 
                                   "audio/x-pn-realaudio",
791
 
                                   "audio/x-scpls",
792
 
                                   "audio/x-speex",
793
 
                                   "audio/x-vorbis",
794
 
                                   "audio/x-vorbis+ogg",
795
 
                                   "audio/x-wav",
796
 
                                   "video/x-ms-asf",
797
 
                                   "x-content/audio-player",
798
 
                                   NULL };
799
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_ARRAY, &SupportedMimeTypes ) )
800
 
                                {
801
 
                                    Send( reply );
802
 
                                    Flush();
803
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
804
 
                                }
805
 
                            }
 
814
                            dbus_bool_t ReplyVal = true;
 
815
 
 
816
                            dbus_message_iter_init_append( reply->GetMessage(), &args );
 
817
 
 
818
                            dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "{sv}", &dict );
 
819
 
 
820
                            FillMetadataDetails( &dict, "CanQuit", ReplyVal );
 
821
                            FillMetadataDetails( &dict, "CanRaise", ReplyVal );
 
822
                            FillMetadataDetails( &dict, "HasTrackList", ReplyVal );
 
823
                            const char * AppName = "Guayadeque Music Player";
 
824
                            FillMetadataDetails( &dict, "Identity", AppName );
 
825
                            const char * DesktopPath = "guayadeque";
 
826
                            FillMetadataDetails( &dict, "DesktopEntry", DesktopPath );
 
827
                            const char * SupportedUriSchemes[] = { "file", "http", "smb", "sftp", "cdda", NULL };
 
828
                            FillMetadataDetails( &dict, "SupportedUriSchemes", SupportedUriSchemes );
 
829
                            const char * SupportedMimeTypes[] = {
 
830
                               "application/ogg",
 
831
                               "application/x-ogg",
 
832
                               "application/x-ogm-audio",
 
833
                               "audio/aac",
 
834
                               "audio/ape",
 
835
                               "audio/mp4",
 
836
                               "audio/mpc",
 
837
                               "audio/mpeg",
 
838
                               "audio/mpegurl",
 
839
                               "audio/ogg",
 
840
                               "audio/vnd.rn-realaudio",
 
841
                               "audio/vorbis",
 
842
                               "audio/x-flac",
 
843
                               "audio/x-mp3",
 
844
                               "audio/x-mpeg",
 
845
                               "audio/x-mpegurl",
 
846
                               "audio/x-ms-wma",
 
847
                               "audio/x-musepack",
 
848
                               "audio/x-oggflac",
 
849
                               "audio/x-pn-realaudio",
 
850
                               "audio/x-scpls",
 
851
                               "audio/x-speex",
 
852
                               "audio/x-vorbis",
 
853
                               "audio/x-vorbis+ogg",
 
854
                               "audio/x-wav",
 
855
                               "video/x-ms-asf",
 
856
                               "x-content/audio-player",
 
857
                               NULL };
 
858
                            FillMetadataDetails( &dict, "SupportedMimeTypes", SupportedMimeTypes );
 
859
 
 
860
                            dbus_message_iter_close_container( &args, &dict );
 
861
 
 
862
                            Send( reply );
 
863
                            Flush();
 
864
                            RetVal = DBUS_HANDLER_RESULT_HANDLED;
806
865
                        }
807
866
                        else if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.Player" ) )
808
867
                        {
809
 
                            if( !strcmp( QueryProperty, "PlaybackStatus" ) )
810
 
                            {
811
 
                                const char * PlaybackStatus;
812
 
                                guMediaState State = m_PlayerPanel->GetState();
813
 
                                if( State == guMEDIASTATE_STOPPED )
814
 
                                    PlaybackStatus = "Stopped";
815
 
                                else if( State == guMEDIASTATE_PAUSED )
816
 
                                    PlaybackStatus = "Paused";
817
 
                                else //if( State == guMEDIASTATE_PLAYING )
818
 
                                    PlaybackStatus = "Playing";
819
 
 
820
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &PlaybackStatus ) )
821
 
                                {
822
 
                                    Send( reply );
823
 
                                    Flush();
824
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
825
 
                                }
826
 
                            }
827
 
                            else if( !strcmp( QueryProperty, "LoopStatus" ) )
828
 
                            {
829
 
                                const char * LoopStatus;
830
 
                                int PlayLoop = m_PlayerPanel->GetPlayLoop();
831
 
                                if( PlayLoop == guPLAYER_PLAYLOOP_NONE )
832
 
                                    LoopStatus = "None";
833
 
                                else if( PlayLoop == guPLAYER_PLAYLOOP_TRACK )
834
 
                                    LoopStatus = "Track";
835
 
                                else //if( PlayLoop == guPLAYER_PLAYLOOP_PLAYLIST )
836
 
                                    LoopStatus = "Playlist";
837
 
 
838
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &LoopStatus ) )
839
 
                                {
840
 
                                    Send( reply );
841
 
                                    Flush();
842
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
843
 
                                }
844
 
                            }
845
 
                            else if( !strcmp( QueryProperty, "Rate" ) )
846
 
                            {
847
 
                                double Rate = 1.0;
848
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &Rate ) )
849
 
                                {
850
 
                                    Send( reply );
851
 
                                    Flush();
852
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
853
 
                                }
854
 
                            }
855
 
                            else if( !strcmp( QueryProperty, "Shuffle" ) )
856
 
                            {
857
 
                                bool Shuffle = false;
858
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &Shuffle ) )
859
 
                                {
860
 
                                    Send( reply );
861
 
                                    Flush();
862
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
863
 
                                }
864
 
                            }
865
 
                            else if( !strcmp( QueryProperty, "Metadata" ) )
866
 
                            {
867
 
                                const guCurrentTrack * CurTrack = m_PlayerPanel->GetCurrentTrack();
868
 
 
869
 
                                FillMetadataArgs( reply, CurTrack, m_PlayerPanel->GetCurrentItem() );
870
 
 
871
 
                                Send( reply );
872
 
                                Flush();
873
 
                                RetVal = DBUS_HANDLER_RESULT_HANDLED;
874
 
                            }
875
 
                            else if( !strcmp( QueryProperty, "Volume" ) )
876
 
                            {
877
 
                                double CurVolume = m_PlayerPanel->GetVolume() / 100;
878
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &CurVolume ) )
879
 
                                {
880
 
                                    Send( reply );
881
 
                                    Flush();
882
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
883
 
                                }
884
 
                            }
885
 
                            else if( !strcmp( QueryProperty, "Position" ) )
886
 
                            {
887
 
                                double CurPosition = m_PlayerPanel->GetPosition() * 1000;
888
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &CurPosition ) )
889
 
                                {
890
 
                                    Send( reply );
891
 
                                    Flush();
892
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
893
 
                                }
894
 
                            }
895
 
                            else if( !strcmp( QueryProperty, "MinimumRate" ) )
896
 
                            {
897
 
                                double Rate = 1.0;
898
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &Rate ) )
899
 
                                {
900
 
                                    Send( reply );
901
 
                                    Flush();
902
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
903
 
                                }
904
 
                            }
905
 
                            else if( !strcmp( QueryProperty, "MaximumRate" ) )
906
 
                            {
907
 
                                double Rate = 1.0;
908
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &Rate ) )
909
 
                                {
910
 
                                    Send( reply );
911
 
                                    Flush();
912
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
913
 
                                }
914
 
                            }
915
 
                            else if( !strcmp( QueryProperty, "CanGoNext" ) )
916
 
                            {
917
 
                                bool CanGoNext = m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_GO_NEXT;
918
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanGoNext ) )
919
 
                                {
920
 
                                    Send( reply );
921
 
                                    Flush();
922
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
923
 
                                }
924
 
                            }
925
 
                            else if( !strcmp( QueryProperty, "CanGoPrevious" ) )
926
 
                            {
927
 
                                bool CanGoPrev = m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_GO_PREV;
928
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanGoPrev ) )
929
 
                                {
930
 
                                    Send( reply );
931
 
                                    Flush();
932
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
933
 
                                }
934
 
                            }
935
 
                            else if( !strcmp( QueryProperty, "CanPlay" ) )
936
 
                            {
937
 
                                bool CanPlay = m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_PLAY;
938
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanPlay ) )
939
 
                                {
940
 
                                    Send( reply );
941
 
                                    Flush();
942
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
943
 
                                }
944
 
                            }
945
 
                            else if( !strcmp( QueryProperty, "CanPause" ) )
946
 
                            {
947
 
                                bool CanPause = m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_PAUSE;
948
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanPause ) )
949
 
                                {
950
 
                                    Send( reply );
951
 
                                    Flush();
952
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
953
 
                                }
954
 
                            }
955
 
                            else if( !strcmp( QueryProperty, "CanSeek" ) )
956
 
                            {
957
 
                                bool CanSeek = m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_SEEK;
958
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanSeek ) )
959
 
                                {
960
 
                                    Send( reply );
961
 
                                    Flush();
962
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
963
 
                                }
964
 
                            }
965
 
                            else if( !strcmp( QueryProperty, "CanControl" ) )
966
 
                            {
967
 
                                bool CanControl = true;
968
 
                                if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanControl ) )
969
 
                                {
970
 
                                    Send( reply );
971
 
                                    Flush();
972
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
973
 
                                }
974
 
                            }
975
 
                        }
976
 
                        else if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.TrackList" ) )
977
 
                        {
978
 
                            if( !strcmp( QueryProperty, "Tracks" ) )
979
 
                            {
980
 
                            }
981
 
                            else if( !strcmp( QueryProperty, "CanEditTracks" ) )
982
 
                            {
983
 
                            }
984
 
                        }
985
 
                    }
986
 
                    else if( !strcmp( Member, "Set" ) )
987
 
                    {
988
 
                        if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.Player" ) )
989
 
                        {
990
 
                            if( !strcmp( QueryProperty, "LoopStatus" ) )
991
 
                            {
992
 
                                const char * LoopStatus;
993
 
                                if( GetVariant( msg->GetMessage(), DBUS_TYPE_STRING, &LoopStatus ) )
994
 
                                {
995
 
                                    int PlayLoop;
996
 
                                    if( !strcmp( LoopStatus, "None" ) )
997
 
                                    {
998
 
                                        PlayLoop = guPLAYER_PLAYLOOP_NONE;
999
 
                                    }
1000
 
                                    else if( !strcmp( LoopStatus, "Track" ) )
1001
 
                                    {
1002
 
                                        PlayLoop = guPLAYER_PLAYLOOP_TRACK;
1003
 
                                    }
1004
 
                                    else //if( !strcmp( LoopStatus, "Playlist" ) )
1005
 
                                    {
1006
 
                                        PlayLoop = guPLAYER_PLAYLOOP_PLAYLIST;
1007
 
                                    }
1008
 
 
1009
 
                                    wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYERPANEL_SETLOOP );
1010
 
                                    event.SetInt( PlayLoop );
1011
 
                                    wxPostEvent( m_PlayerPanel, event );
1012
 
 
1013
 
                                    Send( reply );
1014
 
                                    Flush();
1015
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
1016
 
                                }
1017
 
                            }
1018
 
                            else if( !strcmp( QueryProperty, "Rate" ) )
1019
 
                            {
1020
 
                                // We are not going to support rate
1021
 
                                Send( reply );
1022
 
                                Flush();
1023
 
                                RetVal = DBUS_HANDLER_RESULT_HANDLED;
1024
 
                            }
1025
 
                            else if( !strcmp( QueryProperty, "Shuffle" ) )
1026
 
                            {
1027
 
                                wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYERPANEL_SETRANDOM );
1028
 
                                wxPostEvent( m_PlayerPanel, event );
1029
 
                                Send( reply );
1030
 
                                Flush();
1031
 
                                RetVal = DBUS_HANDLER_RESULT_HANDLED;
1032
 
                            }
1033
 
                            else if( !strcmp( QueryProperty, "Volume" ) )
1034
 
                            {
1035
 
                                double Volume;
1036
 
                                if( GetVariant( msg->GetMessage(), DBUS_TYPE_DOUBLE, &Volume ) )
1037
 
                                {
1038
 
                                    wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYERPANEL_SETVOLUME );
1039
 
                                    event.SetInt( Volume );
1040
 
                                    wxPostEvent( m_PlayerPanel, event );
1041
 
                                    Send( reply );
1042
 
                                    Flush();
1043
 
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
1044
 
                                }
1045
 
                            }
1046
 
                        }
1047
 
 
 
868
                            dbus_message_iter_init_append( reply->GetMessage(), &args );
 
869
 
 
870
                            dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "{sv}", &dict );
 
871
 
 
872
                            ////////////////////////////////////////////////////////////////////////
 
873
                            const char * PlaybackStatus;
 
874
                            guMediaState State = m_PlayerPanel->GetState();
 
875
                            if( State == guMEDIASTATE_STOPPED )
 
876
                                PlaybackStatus = "Stopped";
 
877
                            else if( State == guMEDIASTATE_PAUSED )
 
878
                                PlaybackStatus = "Paused";
 
879
                            else //if( State == guMEDIASTATE_PLAYING )
 
880
                                PlaybackStatus = "Playing";
 
881
 
 
882
                            FillMetadataDetails( &dict, "PlaybackStatus", PlaybackStatus );
 
883
 
 
884
                            ////////////////////////////////////////////////////////////////////////
 
885
                            const char * LoopStatus;
 
886
                            int PlayLoop = m_PlayerPanel->GetPlayLoop();
 
887
                            if( PlayLoop == guPLAYER_PLAYLOOP_NONE )
 
888
                                LoopStatus = "None";
 
889
                            else if( PlayLoop == guPLAYER_PLAYLOOP_TRACK )
 
890
                                LoopStatus = "Track";
 
891
                            else //if( PlayLoop == guPLAYER_PLAYLOOP_PLAYLIST )
 
892
                                LoopStatus = "Playlist";
 
893
 
 
894
                            FillMetadataDetails( &dict, "LoopStatus", LoopStatus );
 
895
 
 
896
                            ////////////////////////////////////////////////////////////////////////
 
897
                            double Rate = 1.0;
 
898
                            FillMetadataDetails( &dict, "Rate", Rate );
 
899
 
 
900
 
 
901
                            ////////////////////////////////////////////////////////////////////////
 
902
                            dbus_bool_t Shuffle = false;
 
903
                            FillMetadataDetails( &dict, "Shuffle", Shuffle );
 
904
 
 
905
 
 
906
                            ////////////////////////////////////////////////////////////////////////
 
907
                            const guCurrentTrack * CurTrack = m_PlayerPanel->GetCurrentTrack();
 
908
                            FillMetadataDetails( &dict, "Metadata", CurTrack, m_PlayerPanel->GetCurrentItem() );
 
909
 
 
910
 
 
911
                            ////////////////////////////////////////////////////////////////////////
 
912
                            double CurVolume = m_PlayerPanel->GetVolume() / 100;
 
913
                            FillMetadataDetails( &dict, "Volume", CurVolume );
 
914
 
 
915
 
 
916
                            ////////////////////////////////////////////////////////////////////////
 
917
                            double CurPosition = m_PlayerPanel->GetPosition() * 1000;
 
918
                            FillMetadataDetails( &dict, "Position", CurPosition );
 
919
 
 
920
 
 
921
                            ////////////////////////////////////////////////////////////////////////
 
922
                            FillMetadataDetails( &dict, "MinimumRate", Rate );
 
923
 
 
924
 
 
925
                            ////////////////////////////////////////////////////////////////////////
 
926
                            FillMetadataDetails( &dict, "MaximumRate", Rate );
 
927
 
 
928
 
 
929
                            ////////////////////////////////////////////////////////////////////////
 
930
                            dbus_bool_t CanGoNext = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_GO_NEXT ) > 0;
 
931
                            FillMetadataDetails( &dict, "CanGoNext", CanGoNext );
 
932
 
 
933
 
 
934
                            ////////////////////////////////////////////////////////////////////////
 
935
                            dbus_bool_t CanGoPrev = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_GO_PREV ) > 0;
 
936
                            FillMetadataDetails( &dict, "CanGoPrev", CanGoPrev );
 
937
 
 
938
 
 
939
                            ////////////////////////////////////////////////////////////////////////
 
940
                            dbus_bool_t CanPlay = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_PLAY ) > 0;
 
941
                            FillMetadataDetails( &dict, "CanPlay", CanPlay );
 
942
 
 
943
 
 
944
                            ////////////////////////////////////////////////////////////////////////
 
945
                            dbus_bool_t CanPause = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_PAUSE ) > 0;
 
946
                            FillMetadataDetails( &dict, "CanPause", CanPause );
 
947
 
 
948
 
 
949
                            ////////////////////////////////////////////////////////////////////////
 
950
                            dbus_bool_t CanSeek = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_SEEK ) > 0;
 
951
                            FillMetadataDetails( &dict, "CanSeek", CanSeek );
 
952
 
 
953
 
 
954
                            ////////////////////////////////////////////////////////////////////////
 
955
                            dbus_bool_t CanControl = true;
 
956
                            FillMetadataDetails( &dict, "CanControl", CanControl );
 
957
 
 
958
                            dbus_message_iter_close_container( &args, &dict );
 
959
 
 
960
                            Send( reply );
 
961
                            Flush();
 
962
                            RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
963
                        }
 
964
                        else if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.Tracklist" ) )
 
965
                        {
 
966
                        }
 
967
                        else if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.Playlists" ) )
 
968
                        {
 
969
                            dbus_message_iter_init_append( reply->GetMessage(), &args );
 
970
 
 
971
                            dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "{sv}", &dict );
 
972
 
 
973
                            int PlaylistCount = m_Db->GetPlayListsCount();
 
974
                            FillMetadataDetails( &dict, "PlaylistCount", PlaylistCount );
 
975
 
 
976
                            const char * PlaylistOrders[] = {
 
977
                               "Default",
 
978
                               NULL };
 
979
                            FillMetadataDetails( &dict, "Orderings", PlaylistOrders );
 
980
 
 
981
                            dbus_bool_t plstate = false;
 
982
                            const char * plpath = "/org/mpris/MediaPlayer2/guayadeque/Playlist/0";
 
983
                            const char * plname = "";
 
984
                            const char * plicon = "";
 
985
                            FillMetadataDetails( &dict, "ActivePlaylist", plstate, plpath, plname, plicon );
 
986
 
 
987
                            dbus_message_iter_close_container( &args, &dict );
 
988
 
 
989
                            Send( reply );
 
990
                            Flush();
 
991
                            RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
992
                        }
 
993
                    }
 
994
                }
 
995
                else
 
996
                {
 
997
                    const char *    QueryIface;
 
998
                    const char *    QueryProperty;
 
999
 
 
1000
                    dbus_message_get_args( msg->GetMessage(), &error,
 
1001
                          DBUS_TYPE_STRING, &QueryIface,
 
1002
                          DBUS_TYPE_STRING, &QueryProperty,
 
1003
                          DBUS_TYPE_INVALID );
 
1004
 
 
1005
//                    guLogMessage( wxT( "QIface : %s" ), wxString::FromAscii( QueryIface ).c_str() );
 
1006
//                    guLogMessage( wxT( "QProp. : %s" ), wxString::FromAscii( QueryProperty ).c_str() );
 
1007
 
 
1008
                    if( dbus_error_is_set( &error ) )
 
1009
                    {
 
1010
                        guLogMessage( wxT( "Could not read the '" GUAYADEQUE_PROPERTIES_INTERFACE "' parameter : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
 
1011
                        dbus_error_free( &error );
 
1012
                    }
 
1013
                    else
 
1014
                    {
 
1015
                        if( !strcmp( Member, "Get" ) )
 
1016
                        {
 
1017
                            if( !strcmp( QueryIface, "org.mpris.MediaPlayer2" ) )
 
1018
                            {
 
1019
                                if( !strcmp( QueryProperty, "CanQuit" ) )
 
1020
                                {
 
1021
                                    dbus_bool_t ReplyVal = true;
 
1022
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &ReplyVal ) )
 
1023
                                    {
 
1024
                                        Send( reply );
 
1025
                                        Flush();
 
1026
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1027
                                    }
 
1028
                                }
 
1029
                                else if( !strcmp( QueryProperty, "CanRaise" ) )
 
1030
                                {
 
1031
                                    dbus_bool_t ReplyVal = true;
 
1032
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &ReplyVal ) )
 
1033
                                    {
 
1034
                                        Send( reply );
 
1035
                                        Flush();
 
1036
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1037
                                    }
 
1038
                                }
 
1039
                                else if( !strcmp( QueryProperty, "HasTrackList" ) )
 
1040
                                {
 
1041
                                    dbus_bool_t ReplyVal = true;
 
1042
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &ReplyVal ) )
 
1043
                                    {
 
1044
                                        Send( reply );
 
1045
                                        Flush();
 
1046
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1047
                                    }
 
1048
                                }
 
1049
                                else if( !strcmp( QueryProperty, "Identity" ) )
 
1050
                                {
 
1051
                                    const char * AppName = "Guayadeque Music Player";
 
1052
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &AppName ) )
 
1053
                                    {
 
1054
                                        Send( reply );
 
1055
                                        Flush();
 
1056
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1057
                                    }
 
1058
                                }
 
1059
                                else if( !strcmp( QueryProperty, "DesktopEntry" ) )
 
1060
                                {
 
1061
                                    const char * DesktopPath = "guayadeque";
 
1062
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &DesktopPath ) )
 
1063
                                    {
 
1064
                                        Send( reply );
 
1065
                                        Flush();
 
1066
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1067
                                    }
 
1068
                                }
 
1069
                                else if( !strcmp( QueryProperty, "SupportedUriSchemes" ) )
 
1070
                                {
 
1071
                                    const char * SupportedUriSchemes[] = { "file", "http", "smb", "sftp", "cdda", NULL };
 
1072
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_ARRAY, &SupportedUriSchemes ) )
 
1073
                                    {
 
1074
                                        Send( reply );
 
1075
                                        Flush();
 
1076
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1077
                                    }
 
1078
                                }
 
1079
                                else if( !strcmp( QueryProperty, "SupportedMimeTypes" ) )
 
1080
                                {
 
1081
                                    const char * SupportedMimeTypes[] = {
 
1082
                                       "application/ogg",
 
1083
                                       "application/x-ogg",
 
1084
                                       "application/x-ogm-audio",
 
1085
                                       "audio/aac",
 
1086
                                       "audio/ape",
 
1087
                                       "audio/mp4",
 
1088
                                       "audio/mpc",
 
1089
                                       "audio/mpeg",
 
1090
                                       "audio/mpegurl",
 
1091
                                       "audio/ogg",
 
1092
                                       "audio/vnd.rn-realaudio",
 
1093
                                       "audio/vorbis",
 
1094
                                       "audio/x-flac",
 
1095
                                       "audio/x-mp3",
 
1096
                                       "audio/x-mpeg",
 
1097
                                       "audio/x-mpegurl",
 
1098
                                       "audio/x-ms-wma",
 
1099
                                       "audio/x-musepack",
 
1100
                                       "audio/x-oggflac",
 
1101
                                       "audio/x-pn-realaudio",
 
1102
                                       "audio/x-scpls",
 
1103
                                       "audio/x-speex",
 
1104
                                       "audio/x-vorbis",
 
1105
                                       "audio/x-vorbis+ogg",
 
1106
                                       "audio/x-wav",
 
1107
                                       "video/x-ms-asf",
 
1108
                                       "x-content/audio-player",
 
1109
                                       NULL };
 
1110
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_ARRAY, &SupportedMimeTypes ) )
 
1111
                                    {
 
1112
                                        Send( reply );
 
1113
                                        Flush();
 
1114
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1115
                                    }
 
1116
                                }
 
1117
                            }
 
1118
                            else if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.Player" ) )
 
1119
                            {
 
1120
                                if( !strcmp( QueryProperty, "PlaybackStatus" ) )
 
1121
                                {
 
1122
                                    const char * PlaybackStatus;
 
1123
                                    guMediaState State = m_PlayerPanel->GetState();
 
1124
                                    if( State == guMEDIASTATE_STOPPED )
 
1125
                                        PlaybackStatus = "Stopped";
 
1126
                                    else if( State == guMEDIASTATE_PAUSED )
 
1127
                                        PlaybackStatus = "Paused";
 
1128
                                    else //if( State == guMEDIASTATE_PLAYING )
 
1129
                                        PlaybackStatus = "Playing";
 
1130
 
 
1131
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &PlaybackStatus ) )
 
1132
                                    {
 
1133
                                        Send( reply );
 
1134
                                        Flush();
 
1135
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1136
                                    }
 
1137
                                }
 
1138
                                else if( !strcmp( QueryProperty, "LoopStatus" ) )
 
1139
                                {
 
1140
                                    const char * LoopStatus;
 
1141
                                    int PlayLoop = m_PlayerPanel->GetPlayLoop();
 
1142
                                    if( PlayLoop == guPLAYER_PLAYLOOP_NONE )
 
1143
                                        LoopStatus = "None";
 
1144
                                    else if( PlayLoop == guPLAYER_PLAYLOOP_TRACK )
 
1145
                                        LoopStatus = "Track";
 
1146
                                    else //if( PlayLoop == guPLAYER_PLAYLOOP_PLAYLIST )
 
1147
                                        LoopStatus = "Playlist";
 
1148
 
 
1149
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_STRING, &LoopStatus ) )
 
1150
                                    {
 
1151
                                        Send( reply );
 
1152
                                        Flush();
 
1153
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1154
                                    }
 
1155
                                }
 
1156
                                else if( !strcmp( QueryProperty, "Rate" ) )
 
1157
                                {
 
1158
                                    double Rate = 1.0;
 
1159
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &Rate ) )
 
1160
                                    {
 
1161
                                        Send( reply );
 
1162
                                        Flush();
 
1163
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1164
                                    }
 
1165
                                }
 
1166
                                else if( !strcmp( QueryProperty, "Shuffle" ) )
 
1167
                                {
 
1168
                                    dbus_bool_t Shuffle = false;
 
1169
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &Shuffle ) )
 
1170
                                    {
 
1171
                                        Send( reply );
 
1172
                                        Flush();
 
1173
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1174
                                    }
 
1175
                                }
 
1176
                                else if( !strcmp( QueryProperty, "Metadata" ) )
 
1177
                                {
 
1178
                                    const guCurrentTrack * CurTrack = m_PlayerPanel->GetCurrentTrack();
 
1179
 
 
1180
                                    FillMetadataArgs( reply, CurTrack, m_PlayerPanel->GetCurrentItem() );
 
1181
 
 
1182
                                    Send( reply );
 
1183
                                    Flush();
 
1184
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1185
                                }
 
1186
                                else if( !strcmp( QueryProperty, "Volume" ) )
 
1187
                                {
 
1188
                                    double CurVolume = m_PlayerPanel->GetVolume() / 100;
 
1189
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &CurVolume ) )
 
1190
                                    {
 
1191
                                        Send( reply );
 
1192
                                        Flush();
 
1193
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1194
                                    }
 
1195
                                }
 
1196
                                else if( !strcmp( QueryProperty, "Position" ) )
 
1197
                                {
 
1198
                                    double CurPosition = m_PlayerPanel->GetPosition() * 1000;
 
1199
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &CurPosition ) )
 
1200
                                    {
 
1201
                                        Send( reply );
 
1202
                                        Flush();
 
1203
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1204
                                    }
 
1205
                                }
 
1206
                                else if( !strcmp( QueryProperty, "MinimumRate" ) )
 
1207
                                {
 
1208
                                    double Rate = 1.0;
 
1209
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &Rate ) )
 
1210
                                    {
 
1211
                                        Send( reply );
 
1212
                                        Flush();
 
1213
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1214
                                    }
 
1215
                                }
 
1216
                                else if( !strcmp( QueryProperty, "MaximumRate" ) )
 
1217
                                {
 
1218
                                    double Rate = 1.0;
 
1219
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_DOUBLE, &Rate ) )
 
1220
                                    {
 
1221
                                        Send( reply );
 
1222
                                        Flush();
 
1223
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1224
                                    }
 
1225
                                }
 
1226
                                else if( !strcmp( QueryProperty, "CanGoNext" ) )
 
1227
                                {
 
1228
                                    dbus_bool_t CanGoNext = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_GO_NEXT ) > 0;
 
1229
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanGoNext ) )
 
1230
                                    {
 
1231
                                        Send( reply );
 
1232
                                        Flush();
 
1233
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1234
                                    }
 
1235
                                }
 
1236
                                else if( !strcmp( QueryProperty, "CanGoPrevious" ) )
 
1237
                                {
 
1238
                                    dbus_bool_t CanGoPrev = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_GO_PREV ) > 0;
 
1239
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanGoPrev ) )
 
1240
                                    {
 
1241
                                        Send( reply );
 
1242
                                        Flush();
 
1243
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1244
                                    }
 
1245
                                }
 
1246
                                else if( !strcmp( QueryProperty, "CanPlay" ) )
 
1247
                                {
 
1248
                                    dbus_bool_t CanPlay = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_PLAY ) > 0;
 
1249
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanPlay ) )
 
1250
                                    {
 
1251
                                        Send( reply );
 
1252
                                        Flush();
 
1253
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1254
                                    }
 
1255
                                }
 
1256
                                else if( !strcmp( QueryProperty, "CanPause" ) )
 
1257
                                {
 
1258
                                    dbus_bool_t CanPause = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_PAUSE ) > 0;
 
1259
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanPause ) )
 
1260
                                    {
 
1261
                                        Send( reply );
 
1262
                                        Flush();
 
1263
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1264
                                    }
 
1265
                                }
 
1266
                                else if( !strcmp( QueryProperty, "CanSeek" ) )
 
1267
                                {
 
1268
                                    dbus_bool_t CanSeek = ( m_PlayerPanel->GetCaps() & MPRIS_CAPS_CAN_SEEK ) > 0;
 
1269
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanSeek ) )
 
1270
                                    {
 
1271
                                        Send( reply );
 
1272
                                        Flush();
 
1273
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1274
                                    }
 
1275
                                }
 
1276
                                else if( !strcmp( QueryProperty, "CanControl" ) )
 
1277
                                {
 
1278
                                    dbus_bool_t CanControl = true;
 
1279
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanControl ) )
 
1280
                                    {
 
1281
                                        Send( reply );
 
1282
                                        Flush();
 
1283
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1284
                                    }
 
1285
                                }
 
1286
                            }
 
1287
                            else if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.TrackList" ) )
 
1288
                            {
 
1289
                                if( !strcmp( QueryProperty, "Tracks" ) )
 
1290
                                {
 
1291
                                }
 
1292
                                else if( !strcmp( QueryProperty, "CanEditTracks" ) )
 
1293
                                {
 
1294
                                    dbus_bool_t CanEdit = true;
 
1295
                                    if( AddVariant( reply->GetMessage(), DBUS_TYPE_BOOLEAN, &CanEdit ) )
 
1296
                                    {
 
1297
                                        Send( reply );
 
1298
                                        Flush();
 
1299
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1300
                                    }
 
1301
                                }
 
1302
                            }
 
1303
                            else if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.Playlists" ) )
 
1304
                            {
 
1305
                                if( !strcmp( QueryProperty, "PlaylistCount" ) )
 
1306
                                {
 
1307
                                }
 
1308
                                else if( !strcmp( QueryProperty, "Orderings" ) )
 
1309
                                {
 
1310
                                }
 
1311
                                else if( !strcmp( QueryProperty, "ActivePlaylist" ) )
 
1312
                                {
 
1313
                                }
 
1314
                            }
 
1315
                        }
 
1316
                        else if( !strcmp( Member, "Set" ) )
 
1317
                        {
 
1318
                            if( !strcmp( QueryIface, "org.mpris.MediaPlayer2.Player" ) )
 
1319
                            {
 
1320
                                if( !strcmp( QueryProperty, "LoopStatus" ) )
 
1321
                                {
 
1322
                                    const char * LoopStatus;
 
1323
                                    if( GetVariant( msg->GetMessage(), DBUS_TYPE_STRING, &LoopStatus ) )
 
1324
                                    {
 
1325
                                        int PlayLoop;
 
1326
                                        if( !strcmp( LoopStatus, "None" ) )
 
1327
                                        {
 
1328
                                            PlayLoop = guPLAYER_PLAYLOOP_NONE;
 
1329
                                        }
 
1330
                                        else if( !strcmp( LoopStatus, "Track" ) )
 
1331
                                        {
 
1332
                                            PlayLoop = guPLAYER_PLAYLOOP_TRACK;
 
1333
                                        }
 
1334
                                        else //if( !strcmp( LoopStatus, "Playlist" ) )
 
1335
                                        {
 
1336
                                            PlayLoop = guPLAYER_PLAYLOOP_PLAYLIST;
 
1337
                                        }
 
1338
 
 
1339
                                        wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYERPANEL_SETLOOP );
 
1340
                                        event.SetInt( PlayLoop );
 
1341
                                        wxPostEvent( m_PlayerPanel, event );
 
1342
 
 
1343
                                        Send( reply );
 
1344
                                        Flush();
 
1345
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1346
                                    }
 
1347
                                }
 
1348
                                else if( !strcmp( QueryProperty, "Rate" ) )
 
1349
                                {
 
1350
                                    // We are not going to support rate
 
1351
                                    Send( reply );
 
1352
                                    Flush();
 
1353
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1354
                                }
 
1355
                                else if( !strcmp( QueryProperty, "Shuffle" ) )
 
1356
                                {
 
1357
                                    wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYERPANEL_SETRANDOM );
 
1358
                                    wxPostEvent( m_PlayerPanel, event );
 
1359
                                    Send( reply );
 
1360
                                    Flush();
 
1361
                                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1362
                                }
 
1363
                                else if( !strcmp( QueryProperty, "Volume" ) )
 
1364
                                {
 
1365
                                    double Volume;
 
1366
                                    if( GetVariant( msg->GetMessage(), DBUS_TYPE_DOUBLE, &Volume ) )
 
1367
                                    {
 
1368
                                        wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYERPANEL_SETVOLUME );
 
1369
                                        event.SetInt( Volume );
 
1370
                                        wxPostEvent( m_PlayerPanel, event );
 
1371
                                        Send( reply );
 
1372
                                        Flush();
 
1373
                                        RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1374
                                    }
 
1375
                                }
 
1376
                            }
 
1377
 
 
1378
                        }
1048
1379
                    }
1049
1380
                }
1050
1381
            }
1055
1386
            {
1056
1387
                if( !strcmp( Member, "Raise" ) )
1057
1388
                {
1058
 
                    guMainFrame * MainFrame = ( guMainFrame * ) wxTheApp->GetTopWindow();
1059
 
                    if( !MainFrame->IsShown() )
1060
 
                    {
1061
 
                        MainFrame->Show( true );
1062
 
                        if( MainFrame->IsIconized() )
1063
 
                            MainFrame->Iconize( false );
1064
 
                    }
 
1389
                    wxCommandEvent RaiseCmd( wxEVT_COMMAND_MENU_SELECTED, ID_MAINFRAME_WINDOW_RAISE );
 
1390
                    wxPostEvent( wxTheApp->GetTopWindow(), RaiseCmd );
 
1391
 
1065
1392
                    Send( reply );
1066
1393
                    Flush();
1067
1394
                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
1068
1395
                }
1069
1396
                else if( !strcmp( Member, "Quit" ) )
1070
1397
                {
1071
 
                    guMainFrame * MainFrame = ( guMainFrame * ) wxTheApp->GetTopWindow();
1072
1398
                    wxCommandEvent QuitCmd( wxEVT_COMMAND_MENU_SELECTED, ID_MENU_QUIT );
1073
 
                    wxPostEvent( MainFrame, QuitCmd );
 
1399
                    wxPostEvent( wxTheApp->GetTopWindow(), QuitCmd );
1074
1400
                    Send( reply );
1075
1401
                    Flush();
1076
1402
                    RetVal = DBUS_HANDLER_RESULT_HANDLED;
1192
1518
                }
1193
1519
                else if( !strcmp( Member, "OpenUri" ) )
1194
1520
                {
 
1521
                    DBusError error;
 
1522
                    dbus_error_init( &error );
 
1523
 
 
1524
                    const char * Uri;
 
1525
                    dbus_message_get_args( msg->GetMessage(), &error,
 
1526
                            DBUS_TYPE_STRING, &Uri,
 
1527
                            DBUS_TYPE_INVALID );
 
1528
 
 
1529
                    if( dbus_error_is_set( &error ) )
 
1530
                    {
 
1531
                        guLogMessage( wxT( "Could not read the OpenUri parameter : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
 
1532
                        dbus_error_free( &error );
 
1533
                    }
 
1534
                    else
 
1535
                    {
 
1536
                        wxArrayString Streams;
 
1537
                        Streams.Add( wxString( Uri, wxConvUTF8 ) );
 
1538
 
 
1539
                        m_PlayerPanel->SetPlayList( Streams );
 
1540
                    }
 
1541
                }
 
1542
            }
 
1543
        }
 
1544
        else if( !strcmp( Interface, GUAYADEQUE_MPRIS2_INTERFACE_TRACKLIST ) )
 
1545
        {
 
1546
            if( !strcmp( Path, GUAYADEQUE_MPRIS2_OBJECT_PATH ) )
 
1547
            {
 
1548
                if( !strcmp( Member, "GetTracksMetadata" ) )
 
1549
                {
 
1550
                }
 
1551
                else if( !strcmp( Member, "AddTrack" ) )
 
1552
                {
 
1553
                }
 
1554
                else if( !strcmp( Member, "RemoveTrack" ) )
 
1555
                {
 
1556
                }
 
1557
                else if( !strcmp( Member, "GoTo" ) )
 
1558
                {
 
1559
                }
 
1560
            }
 
1561
        }
 
1562
        else if( !strcmp( Interface, GUAYADEQUE_MPRIS2_INTERFACE_PLAYLISTS ) )
 
1563
        {
 
1564
            if( !strcmp( Path, GUAYADEQUE_MPRIS2_OBJECT_PATH ) )
 
1565
            {
 
1566
                if( !strcmp( Member, "ActivatePlaylist" ) )
 
1567
                {
 
1568
                    DBusError error;
 
1569
                    dbus_error_init( &error );
 
1570
 
 
1571
                    const char * PlaylistPath;
 
1572
                    dbus_message_get_args( msg->GetMessage(), &error,
 
1573
                            DBUS_TYPE_OBJECT_PATH, &PlaylistPath,
 
1574
                            DBUS_TYPE_INVALID );
 
1575
 
 
1576
                    if( dbus_error_is_set( &error ) )
 
1577
                    {
 
1578
                        guLogMessage( wxT( "Could not read the ActivatePlaylist parameter : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
 
1579
                        dbus_error_free( &error );
 
1580
                    }
 
1581
                    else
 
1582
                    {
 
1583
                        wxString PlaylistName = wxString( PlaylistPath, wxConvUTF8 ).AfterLast( wxT( '/' ) );
 
1584
                        long PlaylistId;
 
1585
                        if( PlaylistName.ToLong( &PlaylistId ) )
 
1586
                        {
 
1587
                            // Send Event to the PlayerPanel to load the playlist
 
1588
                            wxCommandEvent CmdEvent( wxEVT_COMMAND_MENU_SELECTED, ID_MAINFRAME_LOAD_PLAYLIST );
 
1589
                            CmdEvent.SetInt( PlaylistId );
 
1590
                            wxPostEvent( wxTheApp->GetTopWindow(), CmdEvent );
 
1591
 
 
1592
                            Send( reply );
 
1593
                            Flush();
 
1594
                            RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1595
                        }
 
1596
                    }
 
1597
                }
 
1598
                else if( !strcmp( Member, "GetPlaylists" ) )
 
1599
                {
 
1600
                    DBusError error;
 
1601
                    dbus_error_init( &error );
 
1602
 
 
1603
                    dbus_uint32_t    Index;
 
1604
                    dbus_uint32_t    MaxCount;
 
1605
                    const char *    Order;
 
1606
                    dbus_bool_t     ReverseOrder;
 
1607
 
 
1608
                    dbus_message_get_args( msg->GetMessage(), &error,
 
1609
                            DBUS_TYPE_UINT32, &Index,
 
1610
                            DBUS_TYPE_UINT32, &MaxCount,
 
1611
                            DBUS_TYPE_STRING, &Order,
 
1612
                            DBUS_TYPE_BOOLEAN, &ReverseOrder,
 
1613
                            DBUS_TYPE_INVALID );
 
1614
 
 
1615
                    if( dbus_error_is_set( &error ) )
 
1616
                    {
 
1617
                        guLogMessage( wxT( "Could not read the GetPlaylists parameter : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
 
1618
                        dbus_error_free( &error );
 
1619
                    }
 
1620
                    else
 
1621
                    {
 
1622
                        if( GetPlaylists( reply->GetMessage(), Index, MaxCount, Order, ReverseOrder ) )
 
1623
                        {
 
1624
                            Send( reply );
 
1625
                            Flush();
 
1626
                            RetVal = DBUS_HANDLER_RESULT_HANDLED;
 
1627
                        }
 
1628
                    }
1195
1629
                }
1196
1630
            }
1197
1631
        }
1200
1634
    return RetVal;
1201
1635
}
1202
1636
 
 
1637
#define INDICATORS_SOUND_RETRY_COUNT    10
 
1638
#define INDICATORS_SOUND_WAIT_TIME      100
 
1639
 
 
1640
// -------------------------------------------------------------------------------- //
 
1641
int guMPRIS2::Indicators_Sound_BlacklistMediaPlayer( const dbus_bool_t blacklist )
 
1642
{
 
1643
    int RetryCnt = 0;
 
1644
    guDBusMethodCall * Msg = new guDBusMethodCall( "com.canonical.indicators.sound",
 
1645
                                               "/com/canonical/indicators/sound/service",
 
1646
                                               "com.canonical.indicators.sound",
 
1647
                                               "BlacklistMediaPlayer" );
 
1648
 
 
1649
    const char * desktopname = "guayadeque";
 
1650
    int RetVal = wxNOT_FOUND;
 
1651
 
 
1652
    dbus_message_append_args( Msg->GetMessage(), DBUS_TYPE_STRING, &desktopname, DBUS_TYPE_BOOLEAN, &blacklist, DBUS_TYPE_INVALID );
 
1653
 
 
1654
    guDBusMessage * Reply = NULL;
 
1655
    do {
 
1656
        Reply = SendWithReplyAndBlock( Msg );
 
1657
        if( Reply )
 
1658
        {
 
1659
            DBusError error;
 
1660
            dbus_error_init( &error );
 
1661
 
 
1662
            dbus_bool_t Changed = false;
 
1663
 
 
1664
            dbus_message_get_args( Reply->GetMessage(), &error, DBUS_TYPE_BOOLEAN, &Changed, DBUS_TYPE_INVALID );
 
1665
 
 
1666
            if( dbus_error_is_set( &error ) )
 
1667
            {
 
1668
                guLogMessage( wxT( "Indicator Sound parameter error : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
 
1669
                dbus_error_free( &error );
 
1670
            }
 
1671
            else
 
1672
            {
 
1673
                RetVal = Changed;
 
1674
            }
 
1675
 
 
1676
            delete Reply;
 
1677
        }
 
1678
        else
 
1679
        {
 
1680
            if( RetryCnt++ > INDICATORS_SOUND_RETRY_COUNT )
 
1681
                break;
 
1682
 
 
1683
            wxMilliSleep( INDICATORS_SOUND_WAIT_TIME );
 
1684
        }
 
1685
 
 
1686
    } while( !Reply );
 
1687
 
 
1688
    delete Msg;
 
1689
 
 
1690
    guLogMessage( wxT( "Indicators_Sound_BlacklistMediaPlayer( %i ) => %i" ), blacklist, RetVal );
 
1691
    return RetVal;
 
1692
}
 
1693
 
 
1694
// -------------------------------------------------------------------------------- //
 
1695
int guMPRIS2::Indicators_Sound_IsBlackListed( void )
 
1696
{
 
1697
    int RetryCnt = 0;
 
1698
    int RetVal = wxNOT_FOUND;
 
1699
 
 
1700
    guDBusMethodCall * Msg = new guDBusMethodCall( "com.canonical.indicators.sound",
 
1701
                                               "/com/canonical/indicators/sound/service",
 
1702
                                               "com.canonical.indicators.sound",
 
1703
                                               "IsBlacklisted" );
 
1704
 
 
1705
    const char * desktopname = "guayadeque";
 
1706
 
 
1707
    dbus_message_append_args( Msg->GetMessage(), DBUS_TYPE_STRING, &desktopname, DBUS_TYPE_INVALID );
 
1708
 
 
1709
    guDBusMessage * Reply = NULL;
 
1710
    do {
 
1711
        Reply = SendWithReplyAndBlock( Msg );
 
1712
        if( Reply )
 
1713
        {
 
1714
            DBusError error;
 
1715
            dbus_error_init( &error );
 
1716
 
 
1717
            dbus_bool_t Blacklisted = false;
 
1718
 
 
1719
            dbus_message_get_args( Reply->GetMessage(), &error, DBUS_TYPE_BOOLEAN, &Blacklisted, DBUS_TYPE_INVALID );
 
1720
 
 
1721
            if( dbus_error_is_set( &error ) )
 
1722
            {
 
1723
                guLogMessage( wxT( "Indicator Sound parameter error : %s" ), wxString( error.message, wxConvUTF8 ).c_str() );
 
1724
                dbus_error_free( &error );
 
1725
            }
 
1726
            else
 
1727
            {
 
1728
                RetVal = Blacklisted;
 
1729
            }
 
1730
 
 
1731
            delete Reply;
 
1732
        }
 
1733
        else
 
1734
        {
 
1735
            if( RetryCnt++ > INDICATORS_SOUND_RETRY_COUNT )
 
1736
                break;
 
1737
 
 
1738
            wxMilliSleep( INDICATORS_SOUND_WAIT_TIME );
 
1739
        }
 
1740
 
 
1741
    } while( !Reply );
 
1742
 
 
1743
    delete Msg;
 
1744
 
 
1745
    guLogMessage( wxT( "Indicators_Sound_IsBlacklisted() => %i" ), RetVal );
 
1746
    return RetVal;
 
1747
}
 
1748
 
 
1749
// -------------------------------------------------------------------------------- //
 
1750
bool guMPRIS2::Indicators_Sound_Available( void )
 
1751
{
 
1752
    bool RetVal = HasOwner( "com.canonical.indicators.sound" );
 
1753
    guLogMessage( wxT( "Indicators_Sound_Available() => %i" ), RetVal );
 
1754
    return RetVal;
 
1755
}
 
1756
 
1203
1757
// -------------------------------------------------------------------------------- //