truck/DashInterface/Display.cpp

// Beep Remote
//
// Douglas Thrift
//
// $Id$

#include <cxx/standard.hh>

#include <audacious/beepctrl.h>

#include "Audacious.hpp"

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);
}

void Audacious::PlaylistAdd(::GList *list)
{
        ::xmms_remote_playlist_add(session, list);
}

void Audacious::PlaylistDelete(int position)
{
        ::xmms_remote_playlist_delete(session, position);
}

void Audacious::Play()
{
        ::xmms_remote_play(session);
}

void Audacious::Pause()
{
        ::xmms_remote_pause(session);
}

void Audacious::Stop()
{
        ::xmms_remote_stop(session);
}

bool Audacious::IsPlaying() const
{
        return ::xmms_remote_is_playing(session);
}

bool Audacious::IsPaused() const
{
        return ::xmms_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);
}

int Audacious::GetPlaylistLength() const
{
        return ::xmms_remote_get_playlist_length(session);
}

void Audacious::PlaylistClear()
{
        return ::xmms_remote_playlist_clear(session);
}

int Audacious::GetOutputTime() const
{
        return ::xmms_remote_get_output_time(session);
}

void Audacious::JumpToTime(int position)
{
        ::xmms_remote_jump_to_time(session, position);
}

void Audacious::GetVolume(int& left, int& right) const
{
        ::xmms_remote_get_volume(session, &left, &right);
}

int Audacious::GetMainVolume() const
{
        return ::xmms_remote_get_main_volume(session);
}

int Audacious::GetBalance() const
{
        return ::xmms_remote_get_balance(session);
}

void Audacious::SetVolume(int left, int right)
{
        ::xmms_remote_set_volume(session, left, right);
}

void Audacious::SetMainVolume(int volume)
{
        ::xmms_remote_set_main_volume(session, volume);
}

void Audacious::SetBalance(int balance)
{
        ::xmms_remote_set_balance(session, balance);
}

cse::String Audacious::GetSkin() const
{
        return ::xmms_remote_get_skin(session);
}

void Audacious::SetSkin(const cse::String &skin)
{
        ::xmms_remote_set_skin(session, const_cast<char*>(skin.NullTerminate()));
}

cse::String Audacious::GetPlaylistFile(int position) const
{
        return ::xmms_remote_get_playlist_file(session, position);
}

cse::String Audacious::GetPlaylistTitle(int position) const
{
        return ::xmms_remote_get_playlist_title(session, position);
}

int Audacious::GetPlaylistTime(int position) const
{
        return ::xmms_remote_get_playlist_time(session, position);
}

void Audacious::GetInfo(int &rate, int &frequency, int &channels) const
{
        ::xmms_remote_get_info(session, &rate, &frequency, &channels);
}

void Audacious::MainWindowToggle(bool show)
{
        ::xmms_remote_main_win_toggle(session, show);
}

void Audacious::PlaylistWindowToggle(bool show)
{
        ::xmms_remote_pl_win_toggle(session, show);
}

void Audacious::EqualizerWindowToggle(bool show)
{
        ::xmms_remote_eq_win_toggle(session, show);
}

bool Audacious::IsMainWindow() const
{
        return ::xmms_remote_is_main_win(session);
}

bool Audacious::IsPlaylistWindow() const
{
        return ::xmms_remote_is_pl_win(session);
}

bool Audacious::IsEqualizerWindow() const
{
        return ::xmms_remote_is_eq_win(session);
}

void Audacious::ShowPreferencesBox()
{
        ::xmms_remote_show_prefs_box(session);
}

void Audacious::ToggleAlwaysOnTop(bool always)
{
        ::xmms_remote_toggle_aot(session, always);
}

void Audacious::Eject()
{
        ::xmms_remote_eject(session);
}

void Audacious::PlaylistPrevious()
{
        ::xmms_remote_playlist_prev(session);
}

void Audacious::PlaylistNext()
{
        ::xmms_remote_playlist_next(session);
}

void Audacious::PlaylistAddUrl(const cse::String &url)
{
        ::xmms_remote_playlist_add_url_string(session, const_cast<char*>(url.NullTerminate()));
}

bool Audacious::IsRunning() const
{
        return ::xmms_remote_is_running(session);
}

void Audacious::ToggleRepeat()
{
        ::xmms_remote_toggle_repeat(session);
}

void Audacious::ToggleShuffle()
{
        ::xmms_remote_toggle_shuffle(session);
}

bool Audacious::IsRepeat() const
{
        return ::xmms_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];

        ::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);
}

// XMMS 1.2.1
void Audacious::Quit()
{
        ::xmms_remote_quit(session);
}

// XMMS 1.2.6
void Audacious::PlayPause()
{
        ::xmms_remote_play_pause(session);
}

void Audacious::PlaylistInsertUrl(const cse::String &url, int position)
{
        ::xmms_remote_playlist_ins_url_string(session, const_cast<char*>(url.NullTerminate()), position);
}

// XMMS 1.2.11
void Audacious::PlayqueueAdd(int position)
{
        ::xmms_remote_playqueue_add(session, position);
}

void Audacious::PlayqueueRemove(int position)
{
        ::xmms_remote_playqueue_remove(session, position);
}

int Audacious::GetPlayqueueLength() const
{
        return ::xmms_remote_get_playqueue_length(session);
}

void Audacious::ToggleAdvance()
{
        ::xmms_remote_toggle_advance(session);
}

bool Audacious::IsAdvance() const
{
        return ::xmms_remote_is_advance(session);
}

// BMP 0.9.7
void Audacious::Activate()
{
        ::xmms_remote_activate(session);
}

// Audacious 1.1
void Audacious::ShowJumpToFileBox()
{
        ::xmms_remote_show_jtf_box(session);
}

void Audacious::PlayqueueClear()
{
        ::xmms_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);
}

int Audacious::GetPlayqueueQueuePosition(int position) const
{
        return ::xmms_remote_get_playqueue_queue_position(session, position);
}

// Audacious 1.2
void Audacious::SetSessionUri(const cse::String &uri)
{
        ::audacious_set_session_uri(const_cast<char *>(uri.NullTerminate()));
}

cse::String Audacious::GetSessionUri() const
{
        return ::audacious_get_session_uri(session);
}

void Audacious::SetSessionType(Type type)
{
        ::audacious_set_session_type(type);
}

// Audacious 1.3
void Audacious::PlaylistEnqueueToTemp(const cse::String &string)
{
        ::xmms_remote_playlist_enqueue_to_temp(session, const_cast<char *>(string.NullTerminate()));
}

cse::String Audacious::GetTupleFieldData(const cse::String &field, int position)
{
        return ::audacious_get_tuple_field_data(session, const_cast<char *>(field.NullTerminate()), position);
}
Revision:	12
Committed:	2007-05-13T04:38:16-07:00 (18 years, 1 month ago) by douglas
Original Path:	*SteeringWheelRemote/Audacious.cpp*
File size:	7115 byte(s)
Log Message:	Switch to Menes C++, hmm?
#	User	Rev	Content
1	douglas	6	// Beep Remote
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7	douglas	12	#include <cxx/standard.hh>
8
9	douglas	6	#include <audacious/beepctrl.h>
10
11			#include "Audacious.hpp"
12
13			void Audacious::Playlist(char **list, int size, bool enqueue)
14			{
15			::xmms_remote_playlist(session, list, size, enqueue);
16			}
17
18			int Audacious::GetVersion() const
19			{
20			return ::xmms_remote_get_version(session);
21			}
22
23	douglas	7	void Audacious::PlaylistAdd(::GList *list)
24			{
25			::xmms_remote_playlist_add(session, list);
26			}
27
28			void Audacious::PlaylistDelete(int position)
29			{
30			::xmms_remote_playlist_delete(session, position);
31			}
32
33			void Audacious::Play()
34			{
35			::xmms_remote_play(session);
36			}
37
38			void Audacious::Pause()
39			{
40			::xmms_remote_pause(session);
41			}
42
43			void Audacious::Stop()
44			{
45			::xmms_remote_stop(session);
46			}
47
48			bool Audacious::IsPlaying() const
49			{
50			return ::xmms_remote_is_playing(session);
51			}
52
53			bool Audacious::IsPaused() const
54			{
55			return ::xmms_remote_is_paused(session);
56			}
57
58			int Audacious::GetPlaylistPosition() const
59			{
60			return ::xmms_remote_get_playlist_pos(session);
61			}
62
63			void Audacious::SetPlaylistPosition(int position)
64			{
65			::xmms_remote_set_playlist_pos(session, position);
66			}
67
68			int Audacious::GetPlaylistLength() const
69			{
70			return ::xmms_remote_get_playlist_length(session);
71			}
72
73			void Audacious::PlaylistClear()
74			{
75			return ::xmms_remote_playlist_clear(session);
76			}
77
78			int Audacious::GetOutputTime() const
79			{
80			return ::xmms_remote_get_output_time(session);
81			}
82
83			void Audacious::JumpToTime(int position)
84			{
85			::xmms_remote_jump_to_time(session, position);
86			}
87
88			void Audacious::GetVolume(int& left, int& right) const
89			{
90			::xmms_remote_get_volume(session, &left, &right);
91			}
92
93	douglas	6	int Audacious::GetMainVolume() const
94			{
95			return ::xmms_remote_get_main_volume(session);
96			}
97
98	douglas	7	int Audacious::GetBalance() const
99			{
100			return ::xmms_remote_get_balance(session);
101			}
102
103			void Audacious::SetVolume(int left, int right)
104			{
105			::xmms_remote_set_volume(session, left, right);
106			}
107
108	douglas	6	void Audacious::SetMainVolume(int volume)
109			{
110			::xmms_remote_set_main_volume(session, volume);
111			}
112
113	douglas	7	void Audacious::SetBalance(int balance)
114			{
115			::xmms_remote_set_balance(session, balance);
116			}
117
118	douglas	12	cse::String Audacious::GetSkin() const
119	douglas	7	{
120			return ::xmms_remote_get_skin(session);
121			}
122
123	douglas	12	void Audacious::SetSkin(const cse::String &skin)
124	douglas	7	{
125	douglas	12	::xmms_remote_set_skin(session, const_cast<char*>(skin.NullTerminate()));
126	douglas	7	}
127
128	douglas	12	cse::String Audacious::GetPlaylistFile(int position) const
129	douglas	7	{
130			return ::xmms_remote_get_playlist_file(session, position);
131			}
132
133	douglas	12	cse::String Audacious::GetPlaylistTitle(int position) const
134	douglas	7	{
135			return ::xmms_remote_get_playlist_title(session, position);
136			}
137
138			int Audacious::GetPlaylistTime(int position) const
139			{
140			return ::xmms_remote_get_playlist_time(session, position);
141			}
142
143			void Audacious::GetInfo(int &rate, int &frequency, int &channels) const
144			{
145			::xmms_remote_get_info(session, &rate, &frequency, &channels);
146			}
147
148			void Audacious::MainWindowToggle(bool show)
149			{
150			::xmms_remote_main_win_toggle(session, show);
151			}
152
153			void Audacious::PlaylistWindowToggle(bool show)
154			{
155			::xmms_remote_pl_win_toggle(session, show);
156			}
157
158			void Audacious::EqualizerWindowToggle(bool show)
159			{
160			::xmms_remote_eq_win_toggle(session, show);
161			}
162
163			bool Audacious::IsMainWindow() const
164			{
165			return ::xmms_remote_is_main_win(session);
166			}
167
168			bool Audacious::IsPlaylistWindow() const
169			{
170			return ::xmms_remote_is_pl_win(session);
171			}
172
173			bool Audacious::IsEqualizerWindow() const
174			{
175			return ::xmms_remote_is_eq_win(session);
176			}
177
178			void Audacious::ShowPreferencesBox()
179			{
180			::xmms_remote_show_prefs_box(session);
181			}
182
183			void Audacious::ToggleAlwaysOnTop(bool always)
184			{
185			::xmms_remote_toggle_aot(session, always);
186			}
187
188			void Audacious::Eject()
189			{
190			::xmms_remote_eject(session);
191			}
192
193	douglas	6	void Audacious::PlaylistPrevious()
194			{
195			::xmms_remote_playlist_prev(session);
196			}
197
198			void Audacious::PlaylistNext()
199			{
200			::xmms_remote_playlist_next(session);
201			}
202
203	douglas	12	void Audacious::PlaylistAddUrl(const cse::String &url)
204	douglas	7	{
205	douglas	12	::xmms_remote_playlist_add_url_string(session, const_cast<char*>(url.NullTerminate()));
206	douglas	7	}
207
208	douglas	6	bool Audacious::IsRunning() const
209			{
210			return ::xmms_remote_is_running(session);
211			}
212
213	douglas	7	void Audacious::ToggleRepeat()
214			{
215			::xmms_remote_toggle_repeat(session);
216			}
217
218			void Audacious::ToggleShuffle()
219			{
220			::xmms_remote_toggle_shuffle(session);
221			}
222
223			bool Audacious::IsRepeat() const
224			{
225			return ::xmms_remote_is_repeat(session);
226			}
227
228			bool Audacious::IsShuffle() const
229			{
230			return ::xmms_remote_is_shuffle(session);
231			}
232
233			void Audacious::GetEqualizer(float& preamp, float bands[10]) const
234			{
235			float* bands_;
236
237			::xmms_remote_get_eq(session, &preamp, &bands_);
238
239			_forall (uint8_t, index, 0, 10)
240			bands[index] = bands[index];
241
242			::g_free(bands_);
243			}
244
245			float Audacious::GetEqualizerPreamp() const
246			{
247			return ::xmms_remote_get_eq_preamp(session);
248			}
249
250			float Audacious::GetEqualizerBand(int band) const
251			{
252			return ::xmms_remote_get_eq_band(session, band);
253			}
254
255			void Audacious::SetEqualizer(float preamp, float bands[10])
256			{
257			::xmms_remote_set_eq(session, preamp, bands);
258			}
259
260			void Audacious::SetEqualizerPreamp(float preamp)
261			{
262			::xmms_remote_set_eq_preamp(session, preamp);
263			}
264
265			void Audacious::SetEqualizerBand(int band, float value)
266			{
267			::xmms_remote_set_eq_band(session, band, value);
268			}
269
270			// XMMS 1.2.1
271			void Audacious::Quit()
272			{
273			::xmms_remote_quit(session);
274			}
275
276			// XMMS 1.2.6
277	douglas	6	void Audacious::PlayPause()
278			{
279			::xmms_remote_play_pause(session);
280			}
281	douglas	7
282	douglas	12	void Audacious::PlaylistInsertUrl(const cse::String &url, int position)
283	douglas	7	{
284	douglas	12	::xmms_remote_playlist_ins_url_string(session, const_cast<char*>(url.NullTerminate()), position);
285	douglas	7	}
286
287			// XMMS 1.2.11
288			void Audacious::PlayqueueAdd(int position)
289			{
290			::xmms_remote_playqueue_add(session, position);
291			}
292
293			void Audacious::PlayqueueRemove(int position)
294			{
295			::xmms_remote_playqueue_remove(session, position);
296			}
297
298			int Audacious::GetPlayqueueLength() const
299			{
300			return ::xmms_remote_get_playqueue_length(session);
301			}
302
303			void Audacious::ToggleAdvance()
304			{
305			::xmms_remote_toggle_advance(session);
306			}
307
308			bool Audacious::IsAdvance() const
309			{
310			return ::xmms_remote_is_advance(session);
311			}
312
313			// BMP 0.9.7
314			void Audacious::Activate()
315			{
316			::xmms_remote_activate(session);
317			}
318
319			// Audacious 1.1
320			void Audacious::ShowJumpToFileBox()
321			{
322			::xmms_remote_show_jtf_box(session);
323			}
324
325			void Audacious::PlayqueueClear()
326			{
327			::xmms_remote_playqueue_clear(session);
328			}
329
330			bool Audacious::PlayqueueIsQueued(int position) const
331			{
332			return ::xmms_remote_playqueue_is_queued(session, position);
333			}
334
335			int Audacious::GetPlayqueuePosition(int position) const
336			{
337			return ::xmms_remote_get_playqueue_position(session, position);
338			}
339
340			int Audacious::GetPlayqueueQueuePosition(int position) const
341			{
342			return ::xmms_remote_get_playqueue_queue_position(session, position);
343			}
344
345			// Audacious 1.2
346	douglas	12	void Audacious::SetSessionUri(const cse::String &uri)
347	douglas	7	{
348	douglas	12	::audacious_set_session_uri(const_cast<char *>(uri.NullTerminate()));
349	douglas	7	}
350
351	douglas	12	cse::String Audacious::GetSessionUri() const
352	douglas	7	{
353			return ::audacious_get_session_uri(session);
354			}
355
356			void Audacious::SetSessionType(Type type)
357			{
358			::audacious_set_session_type(type);
359			}
360
361			// Audacious 1.3
362	douglas	12	void Audacious::PlaylistEnqueueToTemp(const cse::String &string)
363	douglas	7	{
364	douglas	12	::xmms_remote_playlist_enqueue_to_temp(session, const_cast<char *>(string.NullTerminate()));
365	douglas	7	}
366
367	douglas	12	cse::String Audacious::GetTupleFieldData(const cse::String &field, int position)
368	douglas	7	{
369	douglas	12	return ::audacious_get_tuple_field_data(session, const_cast<char *>(field.NullTerminate()), position);
370	douglas	7	}