Changeset 34

Timestamp:

03/02/2008 17:28:19 (3 years ago)

Author:

douglas

Message:

Welcome to the horrible Glib doom that is Audacious 1.4, die in a fire!

Files:

• Audacious/Audacious.cpp (modified) (8 diffs)
• Audacious/Audacious.hpp (modified) (7 diffs)
• Audacious/Audacious.mk (modified) (1 diff)
• SteeringWheelRemote/SteeringWheelRemote.cpp (modified) (1 diff)

Audacious/Audacious.cpp

@@ -5 +5 @@
 // $Id$
 
-#include <audacious/beepctrl.h>
+#include <audacious/audctrl.h>
+#include <audacious/dbus.h>
 
 #include "Audacious.hpp"
 
+namespace Audacious
+{
+
+Audacious::Audacious()
+{
+        ::g_type_init();
+
+        ::GError *error(NULL);
+        ::DBusGConnection *connection(::dbus_g_bus_get(DBUS_BUS_SESSION, &error));
+
+        if (connection == NULL)
+                throw Error(error);
+
+        session = ::dbus_g_proxy_new_for_name(connection, AUDACIOUS_DBUS_SERVICE, AUDACIOUS_DBUS_PATH, AUDACIOUS_DBUS_INTERFACE);
+}
+
 void Audacious::Playlist(char **list, int size, bool enqueue)
 {
-        ::xmms_remote_playlist(session, list, size, enqueue);
-}
-
-int Audacious::GetVersion() const
-{
-        return ::xmms_remote_get_version(session);
+        ::audacious_remote_playlist(session, list, size, enqueue);
+}
+
+std::string Audacious::GetVersion() const
+{
+        return ::audacious_remote_get_version(session);
 }
 
 void Audacious::PlaylistAdd(::GList *list)
 {
-        ::xmms_remote_playlist_add(session, list);
-}
-
-void Audacious::PlaylistDelete(int position)
-{
-        ::xmms_remote_playlist_delete(session, position);
+        ::audacious_remote_playlist_add(session, list);
+}
+
+void Audacious::PlaylistDelete(unsigned position)
+{
+        ::audacious_remote_playlist_delete(session, position);
 }
 
 void Audacious::Play()
 {
-        ::xmms_remote_play(session);
+        ::audacious_remote_play(session);
 }
 
 void Audacious::Pause()
 {
-        ::xmms_remote_pause(session);
+        ::audacious_remote_pause(session);
 }
 
 void Audacious::Stop()
 {
-        ::xmms_remote_stop(session);
+        ::audacious_remote_stop(session);
 }
 
 bool Audacious::IsPlaying() const
 {
-        return ::xmms_remote_is_playing(session);
+        return ::audacious_remote_is_playing(session);
 }
 
 bool Audacious::IsPaused() const
 {
-        return ::xmms_remote_is_paused(session);
+        return ::audacious_remote_is_paused(session);
 }
 
 int Audacious::GetPlaylistPosition() const
 {
-        return ::xmms_remote_get_playlist_pos(session);
-}
-
-void Audacious::SetPlaylistPosition(int position)
-{
-        ::xmms_remote_set_playlist_pos(session, position);
+        return ::audacious_remote_get_playlist_pos(session);
+}
+
+void Audacious::SetPlaylistPosition(unsigned position)
+{
+        ::audacious_remote_set_playlist_pos(session, position);
 }
 
 int Audacious::GetPlaylistLength() const
 {
-        return ::xmms_remote_get_playlist_length(session);
+        return ::audacious_remote_get_playlist_length(session);
 }
 
 void Audacious::PlaylistClear()
 {
-        return ::xmms_remote_playlist_clear(session);
+        return ::audacious_remote_playlist_clear(session);
 }
 
 int Audacious::GetOutputTime() const
 {
-        return ::xmms_remote_get_output_time(session);
+        return ::audacious_remote_get_output_time(session);
 }
 
 void Audacious::JumpToTime(int position)
 {
-        ::xmms_remote_jump_to_time(session, position);
+        ::audacious_remote_jump_to_time(session, position);
 }
 
 void Audacious::GetVolume(int& left, int& right) const
 {
-        ::xmms_remote_get_volume(session, &left, &right);
+        ::audacious_remote_get_volume(session, &left, &right);
 }
 
 int Audacious::GetMainVolume() const
 {
-        return ::xmms_remote_get_main_volume(session);
+        return ::audacious_remote_get_main_volume(session);
 }
 
 int Audacious::GetBalance() const
 {
-        return ::xmms_remote_get_balance(session);
+        return ::audacious_remote_get_balance(session);
 }
 
 void Audacious::SetVolume(int left, int right)
 {
-        ::xmms_remote_set_volume(session, left, right);
+        ::audacious_remote_set_volume(session, left, right);
 }
 
 void Audacious::SetMainVolume(int volume)
 {
-        ::xmms_remote_set_main_volume(session, volume);
+        ::audacious_remote_set_main_volume(session, volume);
 }
 
 void Audacious::SetBalance(int balance)
 {
-        ::xmms_remote_set_balance(session, balance);
+        ::audacious_remote_set_balance(session, balance);
 }
 
 std::string Audacious::GetSkin() const
 {
-        return ::xmms_remote_get_skin(session);
+        return ::audacious_remote_get_skin(session);
 }
 
 void Audacious::SetSkin(const std::string &skin)
 {
-        ::xmms_remote_set_skin(session, const_cast<char*>(skin.c_str()));
+        ::audacious_remote_set_skin(session, const_cast<char*>(skin.c_str()));
 }
 
 std::string Audacious::GetPlaylistFile(int position) const
 {
-        return ::xmms_remote_get_playlist_file(session, position);
+        return ::audacious_remote_get_playlist_file(session, position);
 }
 
 std::string Audacious::GetPlaylistTitle(int position) const
 {
-        return ::xmms_remote_get_playlist_title(session, position);
+        return ::audacious_remote_get_playlist_title(session, position);
 }
 
 int Audacious::GetPlaylistTime(int position) const
 {
-        return ::xmms_remote_get_playlist_time(session, position);
+        return ::audacious_remote_get_playlist_time(session, position);
 }
 
 void Audacious::GetInfo(int &rate, int &frequency, int &channels) const
 {
-        ::xmms_remote_get_info(session, &rate, &frequency, &channels);
+        ::audacious_remote_get_info(session, &rate, &frequency, &channels);
 }
 
 void Audacious::MainWindowToggle(bool show)
 {
-        ::xmms_remote_main_win_toggle(session, show);
+        ::audacious_remote_main_win_toggle(session, show);
 }
 
 void Audacious::PlaylistWindowToggle(bool show)
 {
-        ::xmms_remote_pl_win_toggle(session, show);
+        ::audacious_remote_pl_win_toggle(session, show);
 }
 
 void Audacious::EqualizerWindowToggle(bool show)
 {
-        ::xmms_remote_eq_win_toggle(session, show);
+        ::audacious_remote_eq_win_toggle(session, show);
 }
 
 bool Audacious::IsMainWindow() const
 {
-        return ::xmms_remote_is_main_win(session);
+        return ::audacious_remote_is_main_win(session);
 }
 
 bool Audacious::IsPlaylistWindow() const
 {
-        return ::xmms_remote_is_pl_win(session);
+        return ::audacious_remote_is_pl_win(session);
 }
 
 bool Audacious::IsEqualizerWindow() const
 {
-        return ::xmms_remote_is_eq_win(session);
+        return ::audacious_remote_is_eq_win(session);
 }
 
 void Audacious::ShowPreferencesBox()
 {
-        ::xmms_remote_show_prefs_box(session);
+        ::audacious_remote_show_prefs_box(session);
 }
 
 void Audacious::ToggleAlwaysOnTop(bool always)
 {
-        ::xmms_remote_toggle_aot(session, always);
+        ::audacious_remote_toggle_aot(session, always);
 }
 
 void Audacious::Eject()
 {
-        ::xmms_remote_eject(session);
+        ::audacious_remote_eject(session);
 }
 
 void Audacious::PlaylistPrevious()
 {
-        ::xmms_remote_playlist_prev(session);
+        ::audacious_remote_playlist_prev(session);
 }
 
 void Audacious::PlaylistNext()
 {
-        ::xmms_remote_playlist_next(session);
+        ::audacious_remote_playlist_next(session);
 }
 
 void Audacious::PlaylistAddUrl(const std::string &url)
 {
-        ::xmms_remote_playlist_add_url_string(session, const_cast<char*>(url.c_str()));
+        ::audacious_remote_playlist_add_url_string(session, const_cast<char*>(url.c_str()));
 }
 
 bool Audacious::IsRunning() const
 {
-        return ::xmms_remote_is_running(session);
+        return ::audacious_remote_is_running(session);
 }
 
 void Audacious::ToggleRepeat()
 {
-        ::xmms_remote_toggle_repeat(session);
+        ::audacious_remote_toggle_repeat(session);
 }
 
 void Audacious::ToggleShuffle()
 {
-        ::xmms_remote_toggle_shuffle(session);
+        ::audacious_remote_toggle_shuffle(session);
 }
 
 bool Audacious::IsRepeat() const
 {
-        return ::xmms_remote_is_repeat(session);
+        return ::audacious_remote_is_repeat(session);
 }
 
 bool Audacious::IsShuffle() const
 {
-        return ::xmms_remote_is_shuffle(session);
-}
-
-void Audacious::GetEqualizer(float& preamp, float bands[10]) const
-{
-        float* bands_;
-
-        ::xmms_remote_get_eq(session, &preamp, &bands_);
-
-        _forall (uint8_t, index, 0, 10)
-                bands[index] = bands[index];
+        return ::audacious_remote_is_shuffle(session);
+}
+
+void Audacious::GetEqualizer(double& preamp, double bands[10]) const
+{
+        ::GArray* bands_;
+
+        ::audacious_remote_get_eq(session, &preamp, &bands_);
+
+        _forall (unsigned, index, 0, 10)
+                bands[index] = g_array_index(bands_, ::gdouble, index);
 
         ::g_free(bands_);
 }
 
-float Audacious::GetEqualizerPreamp() const
-{
-        return ::xmms_remote_get_eq_preamp(session);
-}
-
-float Audacious::GetEqualizerBand(int band) const
-{
-        return ::xmms_remote_get_eq_band(session, band);
-}
-
-void Audacious::SetEqualizer(float preamp, float bands[10])
-{
-        ::xmms_remote_set_eq(session, preamp, bands);
-}
-
-void Audacious::SetEqualizerPreamp(float preamp)
-{
-        ::xmms_remote_set_eq_preamp(session, preamp);
-}
-
-void Audacious::SetEqualizerBand(int band, float value)
-{
-        ::xmms_remote_set_eq_band(session, band, value);
+double Audacious::GetEqualizerPreamp() const
+{
+        return ::audacious_remote_get_eq_preamp(session);
+}
+
+double Audacious::GetEqualizerBand(int band) const
+{
+        return ::audacious_remote_get_eq_band(session, band);
+}
+
+void Audacious::SetEqualizer(double preamp, double bands[10])
+{
+        ::GArray *bands_(::g_array_sized_new(FALSE, FALSE, sizeof (::gdouble), 10));
+
+        _forall (unsigned, index, 0, 10)
+                ::g_array_append_val(bands_, bands[index]);
+
+        ::audacious_remote_set_eq(session, preamp, bands_);
+}
+
+void Audacious::SetEqualizerPreamp(double preamp)
+{
+        ::audacious_remote_set_eq_preamp(session, preamp);
+}
+
+void Audacious::SetEqualizerBand(int band, double value)
+{
+        ::audacious_remote_set_eq_band(session, band, value);
 }
 
@@ -269 +291 @@
 void Audacious::Quit()
 {
-        ::xmms_remote_quit(session);
+        ::audacious_remote_quit(session);
 }
 
@@ -275 +297 @@
 void Audacious::PlayPause()
 {
-        ::xmms_remote_play_pause(session);
+        ::audacious_remote_play_pause(session);
 }
 
 void Audacious::PlaylistInsertUrl(const std::string &url, int position)
 {
-        ::xmms_remote_playlist_ins_url_string(session, const_cast<char*>(url.c_str()), position);
+        ::audacious_remote_playlist_ins_url_string(session, const_cast<char*>(url.c_str()), position);
 }
 
@@ -286 +308 @@
 void Audacious::PlayqueueAdd(int position)
 {
-        ::xmms_remote_playqueue_add(session, position);
+        ::audacious_remote_playqueue_add(session, position);
 }
 
 void Audacious::PlayqueueRemove(int position)
 {
-        ::xmms_remote_playqueue_remove(session, position);
+        ::audacious_remote_playqueue_remove(session, position);
 }
 
 int Audacious::GetPlayqueueLength() const
 {
-        return ::xmms_remote_get_playqueue_length(session);
+        return ::audacious_remote_get_playqueue_length(session);
 }
 
 void Audacious::ToggleAdvance()
 {
-        ::xmms_remote_toggle_advance(session);
+        ::audacious_remote_toggle_advance(session);
 }
 
 bool Audacious::IsAdvance() const
 {
-        return ::xmms_remote_is_advance(session);
+        return ::audacious_remote_is_advance(session);
 }
 
@@ -312 +334 @@
 void Audacious::Activate()
 {
-        ::xmms_remote_activate(session);
+        ::audacious_remote_activate(session);
 }
 
@@ -318 +340 @@
 void Audacious::ShowJumpToFileBox()
 {
-        ::xmms_remote_show_jtf_box(session);
+        ::audacious_remote_show_jtf_box(session);
 }
 
 void Audacious::PlayqueueClear()
 {
-        ::xmms_remote_playqueue_clear(session);
+        ::audacious_remote_playqueue_clear(session);
 }
 
 bool Audacious::PlayqueueIsQueued(int position) const
 {
-        return ::xmms_remote_playqueue_is_queued(session, position);
-}
-
-int Audacious::GetPlayqueuePosition(int position) const
-{
-        return ::xmms_remote_get_playqueue_position(session, position);
+        return ::audacious_remote_playqueue_is_queued(session, position);
 }
 
 int Audacious::GetPlayqueueQueuePosition(int position) const
 {
-        return ::xmms_remote_get_playqueue_queue_position(session, position);
-}
-
-// Audacious 1.2
-void Audacious::SetSessionUri(const std::string &uri)
-{
-        ::audacious_set_session_uri(const_cast<char *>(uri.c_str()));
-}
-
-std::string Audacious::GetSessionUri() const
-{
-        return ::audacious_get_session_uri(session);
-}
-
-void Audacious::SetSessionType(Type type)
-{
-        ::audacious_set_session_type(type);
+        return ::audacious_remote_get_playqueue_queue_position(session, position);
 }
 
@@ -360 +361 @@
 void Audacious::PlaylistEnqueueToTemp(const std::string &string)
 {
-        ::xmms_remote_playlist_enqueue_to_temp(session, const_cast<char *>(string.c_str()));
+        ::audacious_remote_playlist_enqueue_to_temp(session, const_cast<char *>(string.c_str()));
 }
 
@@ -367 +368 @@
         return ::audacious_get_tuple_field_data(session, const_cast<char *>(field.c_str()), position);
 }
+
+// Audacious 1.4
+void Audacious::ShowAboutBox()
+{
+        ::audacious_remote_show_about_box(session);
+}
+
+void Audacious::ToggleAboutBox(bool show)
+{
+        ::audacious_remote_toggle_about_box(session, show);
+}
+
+void Audacious::ToggleJumpToFileBox(bool show)
+{
+        ::audacious_remote_toggle_jtf_box(session, show);
+}
+
+void Audacious::TogglePreferencesBox(bool show)
+{
+        ::audacious_remote_toggle_prefs_box(session, show);
+}
+
+void Audacious::ToggleFileBrowser(bool show)
+{
+        ::audacious_remote_toggle_filebrowser(session, show);
+}
+
+void Audacious::EqualizerActivate(bool active)
+{
+        ::audacious_remote_eq_activate(session, active);
+}
+
+}

Audacious/Audacious.hpp

@@ -11 +11 @@
 #include <string>
 
+#include <dbus/dbus-glib.h>
 #include <glib.h>
 
 #include <foreach.hpp>
 
+namespace Audacious
+{
+
+class Error : public std::exception
+{
+        ::GError *error;
+public:
+        Error(::GError *error) : error(error) {}
+        virtual ~Error() throw() { ::g_error_free(error); }
+        virtual const char *what() const throw() { return error->message; }
+};
+
 class Audacious
 {
-        int session;
+        ::DBusGProxy *session;
 public:
-        Audacious(int session = 0) : session(session) {}
+        Audacious();
 
         template <typename Type_>
@@ -40 +53 @@
 
         void Playlist(char **list, int size, bool enqueue = false);
-        int GetVersion() const;
+        std::string GetVersion() const;
 
         template <typename Type_>
@@ -55 +68 @@
 
         void PlaylistAdd(::GList *list);
-        void PlaylistDelete(int position);
+        void PlaylistDelete(unsigned position);
         void Play();
         void Pause();
@@ -62 +75 @@
         bool IsPaused() const;
         int GetPlaylistPosition() const;
-        void SetPlaylistPosition(int position);
+        void SetPlaylistPosition(unsigned position);
         int GetPlaylistLength() const;
         void PlaylistClear();
@@ -109 +122 @@
         }
 
-        void GetEqualizer(float &preamp, float bands[10]) const;
-        float GetEqualizerPreamp() const;
-        float GetEqualizerBand(int band) const;
-        void SetEqualizer(float preamp, float bands[10]);
-        void SetEqualizerPreamp(float preamp);
-        void SetEqualizerBand(int band, float value);
+        void GetEqualizer(double &preamp, double bands[10]) const;
+        double GetEqualizerPreamp() const;
+        double GetEqualizerBand(int band) const;
+        void SetEqualizer(double preamp, double bands[10]);
+        void SetEqualizerPreamp(double preamp);
+        void SetEqualizerBand(int band, double value);
 
         // XMMS 1.2.1
@@ -143 +156 @@
         void PlayqueueClear();
         bool PlayqueueIsQueued(int position) const;
-        int GetPlayqueuePosition(int position) const;
         int GetPlayqueueQueuePosition(int position) const;
-
-        // Audacious 1.2
-        void SetSessionUri(const std::string &uri);
-        std::string GetSessionUri() const;
-
-        enum Type { Unix, Tcp };
-
-        void SetSessionType(Type type);
 
         // Audacious 1.3
         void PlaylistEnqueueToTemp(const std::string &string);
         std::string GetTupleFieldData(const std::string &field, int position);
+
+        // Audacious 1.4
+        void ShowAboutBox();
+        void ToggleAboutBox(bool show);
+        void ToggleJumpToFileBox(bool show);
+        void TogglePreferencesBox(bool show);
+        void ToggleFileBrowser(bool show);
+        void EqualizerActivate(bool active);
 };
 
@@ -167 +179 @@
 }
 
+}
+
 #endif//_Audacious_hpp_

Audacious/Audacious.mk

@@ -5 +5 @@
 # $Id$
 
-CPPFLAGS += -I$(audacious) $(shell pkg-config --cflags-only-I audacious)
-CFLAGS += $(shell pkg-config --cflags-only-other audacious)
-LDFLAGS += -L$(audacious) $(shell pkg-config --libs-only-L audacious) $(shell pkg-config --libs-only-other audacious)
-LDLIBS += -lAudacious $(shell pkg-config --libs-only-l audacious)
+CPPFLAGS += -I$(audacious) $(shell pkg-config --cflags-only-I audacious dbus-glib-1)
+CFLAGS += $(shell pkg-config --cflags-only-other audacious dbus-glib-1)
+LDFLAGS += -L$(audacious) $(shell pkg-config --libs-only-L audacious dbus-glib-1) $(shell pkg-config --libs-only-other audacious dbus-glib-1)
+LDLIBS += -lAudacious $(shell pkg-config --libs-only-l audacious dbus-glib-1)

SteeringWheelRemote/SteeringWheelRemote.cpp

@@ -140 +140 @@
                 uint8_t bytes[8];
                 Buttons buttons;
-                Audacious audacious;
+                Audacious::Audacious audacious;
 
                 _forever