Audacious $Id:Doxyfile42802007-03-2104:39:00Znenolod$
audctrl.c
Go to the documentation of this file.
00001 /*
00002  * Audacious: A cross-platform multimedia player
00003  * Copyright (c) 2007 Ben Tucker
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; under version 3 of the License.
00008  *
00009  * This program is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  * GNU General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00016  */
00017 
00018 #ifdef HAVE_CONFIG_H
00019 #    include "config.h"
00020 #endif
00021 
00022 #include <stdlib.h>
00023 #include <glib.h>
00024 #include <string.h>
00025 #include <dbus/dbus-glib.h>
00026 #include "audacious/dbus.h"
00027 #include "audacious/dbus-client-bindings.h"
00028 #include "audctrl.h"
00029 
00030 static GError *error = NULL; //it must be hidden from outside, otherwise symbol conflict likely to happen.
00031 
00041 void audacious_remote_playlist(DBusGProxy *proxy, gchar **list, gint num, gboolean enqueue) {
00042     GList *glist = NULL;
00043     gchar **data = list;
00044 
00045     g_return_if_fail(list != NULL);
00046     g_return_if_fail(num > 0);
00047 
00048     if (!enqueue)
00049         audacious_remote_playlist_clear(proxy);
00050 
00051     // construct a GList
00052     while(data) {
00053         glist = g_list_append(glist, (gpointer)data);
00054         data++;
00055     }
00056 
00057     org_atheme_audacious_playlist_add(proxy, (gpointer)glist, &error);
00058 
00059     g_list_free(glist);
00060     glist = NULL;
00061 
00062     if (!enqueue)
00063         audacious_remote_play(proxy);
00064 }
00065 
00072 gchar *audacious_remote_get_version(DBusGProxy *proxy) {
00073     char *string = NULL;
00074     org_atheme_audacious_version(proxy, &string, &error);
00075     g_clear_error(&error);
00076 
00077     return (string ? string : NULL);
00078 }
00079 
00086 void audacious_remote_playlist_add (DBusGProxy * proxy, GList * list)
00087 {
00088     const gchar * filenames[g_list_length (list) + 1];
00089     int count;
00090     
00091     for (count = 0; list != NULL; count ++, list = list->next)
00092         filenames[count] = list->data;
00093     
00094     filenames[count] = NULL;
00095 
00096     org_atheme_audacious_add_list (proxy, filenames, & error);
00097     g_clear_error (& error);
00098 }
00099 
00106 void audacious_remote_playlist_open_list (DBusGProxy * proxy, GList * list)
00107 {
00108     const gchar * filenames[g_list_length (list) + 1];
00109     int count;
00110     
00111     for (count = 0; list != NULL; count ++, list = list->next)
00112         filenames[count] = list->data;
00113     
00114     filenames[count] = NULL;
00115 
00116     org_atheme_audacious_open_list (proxy, filenames, & error);
00117     g_clear_error (& error);
00118 }
00119 
00127 void audacious_remote_playlist_open_list_to_temp (DBusGProxy * proxy, GList *
00128  list)
00129 {
00130     const gchar * filenames[g_list_length (list) + 1];
00131     int count;
00132     
00133     for (count = 0; list != NULL; count ++, list = list->next)
00134         filenames[count] = list->data;
00135     
00136     filenames[count] = NULL;
00137 
00138     org_atheme_audacious_open_list_to_temp (proxy, filenames, & error);
00139     g_clear_error (& error);
00140 }
00141 
00148 void audacious_remote_playlist_delete(DBusGProxy *proxy, guint pos) {
00149     org_atheme_audacious_delete(proxy, pos, &error);
00150     g_clear_error(&error);
00151 }
00152 
00158 void audacious_remote_play(DBusGProxy *proxy) {
00159     org_atheme_audacious_play(proxy, &error);
00160     g_clear_error(&error);
00161 }
00162 
00168 void audacious_remote_pause(DBusGProxy *proxy) {
00169     org_atheme_audacious_pause(proxy, &error);
00170     g_clear_error(&error);
00171 }
00172 
00178 void audacious_remote_stop(DBusGProxy *proxy) {
00179     org_atheme_audacious_stop(proxy, &error);
00180     g_clear_error(&error);
00181 }
00182 
00189 gboolean audacious_remote_is_playing(DBusGProxy *proxy) {
00190     gboolean is_playing = FALSE;
00191     org_atheme_audacious_playing(proxy, &is_playing, &error);
00192     g_clear_error(&error);
00193     return is_playing;
00194 }
00195 
00204 gboolean audacious_remote_is_paused(DBusGProxy *proxy) {
00205     gboolean is_paused = FALSE;
00206     org_atheme_audacious_paused(proxy, &is_paused, &error);
00207     g_clear_error(&error);
00208     return is_paused;
00209 }
00210 
00219 gint audacious_remote_get_playlist_pos(DBusGProxy *proxy) {
00220     guint pos = 0;
00221     org_atheme_audacious_position(proxy, &pos, &error);
00222     g_clear_error(&error);
00223     return pos;
00224 }
00225 
00233 void audacious_remote_set_playlist_pos(DBusGProxy *proxy, guint pos) {
00234     org_atheme_audacious_jump (proxy, pos, &error);
00235     g_clear_error(&error);
00236 }
00237 
00246 gint audacious_remote_get_playlist_length(DBusGProxy *proxy) {
00247     gint len = 0;
00248     org_atheme_audacious_length(proxy, &len, &error);
00249     g_clear_error(&error);
00250     return len;
00251 }
00252 
00259 void audacious_remote_playlist_clear(DBusGProxy *proxy) {
00260     org_atheme_audacious_clear(proxy, &error);
00261     g_clear_error(&error);
00262 }
00263 
00272 gint audacious_remote_get_output_time(DBusGProxy *proxy) {
00273     guint time = 0;
00274     org_atheme_audacious_time(proxy, &time, &error);
00275     g_clear_error(&error);
00276     return time;
00277 }
00278 
00286 void audacious_remote_jump_to_time(DBusGProxy *proxy, guint pos) {
00287     org_atheme_audacious_seek (proxy, pos, &error);
00288     g_clear_error(&error);
00289 }
00290 
00298 void audacious_remote_get_volume(DBusGProxy *proxy, gint * vl, gint * vr) {
00299     org_atheme_audacious_volume(proxy, vl, vr, &error);
00300     g_clear_error(&error);
00301 }
00302 
00309 gint audacious_remote_get_main_volume(DBusGProxy *proxy) {
00310     gint vl = 0, vr = 0;
00311 
00312     audacious_remote_get_volume(proxy, &vl, &vr);
00313 
00314     return (vl > vr) ? vl : vr;
00315 }
00316 
00323 gint audacious_remote_get_balance(DBusGProxy *proxy) {
00324     gint balance = 50;
00325     org_atheme_audacious_balance(proxy, &balance,  &error);
00326     g_clear_error(&error);
00327     return balance;
00328 }
00329 
00337 void audacious_remote_set_volume(DBusGProxy *proxy, gint vl, gint vr) {
00338     org_atheme_audacious_set_volume(proxy, vl, vr,  &error);
00339     g_clear_error(&error);
00340 }
00341 
00342 
00349 void audacious_remote_set_main_volume(DBusGProxy *proxy, gint v) {
00350     gint b = 50, vl = 0, vr = 0;
00351 
00352     b = audacious_remote_get_balance(proxy);
00353 
00354     if (b < 0) {
00355         vl = v;
00356         vr = (v * (100 - abs(b))) / 100;
00357     } else if (b > 0) {
00358         vl = (v * (100 - b)) / 100;
00359         vr = v;
00360     } else
00361         vl = vr = v;
00362     audacious_remote_set_volume(proxy, vl, vr);
00363 }
00364 
00371 void audacious_remote_set_balance(DBusGProxy *proxy, gint b) {
00372     gint v = 0, vl = 0, vr = 0;
00373 
00374     if (b < -100)
00375         b = -100;
00376     if (b > 100)
00377         b = 100;
00378 
00379     v = audacious_remote_get_main_volume(proxy);
00380 
00381     if (b < 0) {
00382         vl = v;
00383         vr = (v * (100 - abs(b))) / 100;
00384     } else if (b > 0) {
00385         vl = (v * (100 - b)) / 100;
00386         vr = v;
00387     } else
00388         vl = vr = v;
00389     audacious_remote_set_volume(proxy, vl, vr);
00390 }
00391 
00399 gchar *audacious_remote_get_playlist_file(DBusGProxy *proxy, guint pos) {
00400     gchar *out = NULL;
00401     org_atheme_audacious_song_filename(proxy, pos, &out, &error);
00402     g_clear_error(&error);
00403     return out;
00404 }
00405 
00413 gchar *audacious_remote_get_playlist_title(DBusGProxy *proxy, guint pos) {
00414     gchar *out = NULL;
00415     org_atheme_audacious_song_title(proxy, pos, &out, &error);
00416     g_clear_error(&error);
00417     return out;
00418 }
00419 
00427 gint audacious_remote_get_playlist_time(DBusGProxy *proxy, guint pos) {
00428     gint out = 0;
00429     org_atheme_audacious_song_frames(proxy, pos, &out, &error);
00430     g_clear_error(&error);
00431     return out;
00432 }
00433 
00442 void audacious_remote_get_info(DBusGProxy *proxy, gint *rate, gint *freq,
00443                                gint *nch) {
00444     org_atheme_audacious_info(proxy, rate, freq, nch, &error);
00445     g_clear_error(&error);
00446 }
00447 
00454 void audacious_remote_main_win_toggle(DBusGProxy *proxy, gboolean show) {
00455     org_atheme_audacious_show_main_win(proxy, show, &error);
00456     g_clear_error(&error);
00457 }
00458 
00465 void audacious_remote_pl_win_toggle(DBusGProxy *proxy, gboolean show) {
00466     org_atheme_audacious_show_playlist(proxy, show, &error);
00467     g_clear_error(&error);
00468 }
00469 
00476 void audacious_remote_eq_win_toggle(DBusGProxy *proxy, gboolean show) {
00477     org_atheme_audacious_show_equalizer(proxy, show, &error);
00478     g_clear_error(&error);
00479 }
00480 
00487 gboolean audacious_remote_is_main_win(DBusGProxy *proxy) {
00488     gboolean visible = TRUE;
00489     org_atheme_audacious_main_win_visible(proxy, &visible, &error);
00490     g_clear_error(&error);
00491     return visible;
00492 }
00493 
00500 gboolean audacious_remote_is_pl_win(DBusGProxy *proxy) {
00501     gboolean visible = TRUE;
00502     org_atheme_audacious_playlist_visible(proxy, &visible, &error);
00503     g_clear_error(&error);
00504     return visible;
00505 }
00506 
00513 gboolean audacious_remote_is_eq_win(DBusGProxy *proxy) {
00514     gboolean visible = FALSE;
00515     org_atheme_audacious_equalizer_visible(proxy, &visible, &error);
00516     g_clear_error(&error);
00517     return visible;
00518 }
00519 
00525 void audacious_remote_show_prefs_box(DBusGProxy *proxy) {
00526     audacious_remote_toggle_prefs_box(proxy, TRUE);
00527 }
00528 
00535 void audacious_remote_toggle_prefs_box(DBusGProxy *proxy, gboolean show) {
00536     org_atheme_audacious_show_prefs_box(proxy, show, &error);
00537     g_clear_error(&error);
00538 }
00539 
00545 void audacious_remote_show_about_box(DBusGProxy *proxy) {
00546     audacious_remote_toggle_about_box(proxy, TRUE);
00547 }
00548 
00555 void audacious_remote_toggle_about_box(DBusGProxy *proxy, gboolean show) {
00556     org_atheme_audacious_show_about_box(proxy, show, &error);
00557     g_clear_error(&error);
00558 }
00559 
00566 void audacious_remote_toggle_aot(DBusGProxy *proxy, gboolean ontop) {
00567     org_atheme_audacious_toggle_aot(proxy, ontop, &error);
00568         g_clear_error(&error);
00569 }
00570 
00576 void audacious_remote_eject(DBusGProxy *proxy) {
00577     org_atheme_audacious_eject(proxy, &error);
00578     g_clear_error(&error);
00579 }
00580 
00587 void audacious_remote_playlist_prev(DBusGProxy *proxy) {
00588     org_atheme_audacious_reverse(proxy, &error);
00589     g_clear_error(&error);
00590 }
00591 
00597 void audacious_remote_playlist_next(DBusGProxy *proxy) {
00598     org_atheme_audacious_advance(proxy, &error);
00599     g_clear_error(&error);
00600 }
00601 
00608 void audacious_remote_playlist_add_url_string(DBusGProxy *proxy,
00609                                               gchar *string) {
00610     org_atheme_audacious_add_url(proxy, string, &error);
00611     g_clear_error(&error);
00612 }
00613 
00620 gboolean audacious_remote_is_running(DBusGProxy *proxy) {
00621     char *string = NULL;
00622     org_atheme_audacious_version(proxy, &string, &error);
00623     g_clear_error(&error);
00624     if(string) {
00625         g_free(string);
00626         return TRUE;
00627     }
00628     else
00629         return FALSE;
00630 }
00631 
00637 void audacious_remote_toggle_repeat(DBusGProxy *proxy) {
00638     org_atheme_audacious_toggle_repeat(proxy, &error);
00639     g_clear_error(&error);
00640 }
00641 
00647 void audacious_remote_toggle_shuffle(DBusGProxy *proxy) {
00648     org_atheme_audacious_toggle_shuffle (proxy, &error);
00649     g_clear_error(&error);
00650 }
00651 
00658 gboolean audacious_remote_is_repeat(DBusGProxy *proxy) {
00659     gboolean is_repeat;
00660     org_atheme_audacious_repeat(proxy, &is_repeat, &error);
00661     g_clear_error(&error);
00662     return is_repeat;
00663 }
00664 
00671 gboolean audacious_remote_is_shuffle(DBusGProxy *proxy) {
00672     gboolean is_shuffle;
00673     org_atheme_audacious_shuffle(proxy, &is_shuffle, &error);
00674     g_clear_error(&error);
00675     return is_shuffle;
00676 }
00677 
00685 void audacious_remote_get_eq(DBusGProxy *proxy, gdouble *preamp, GArray **bands) {
00686     org_atheme_audacious_get_eq(proxy, preamp, bands, &error);
00687     g_clear_error(&error);
00688 }
00689 
00696 gdouble audacious_remote_get_eq_preamp(DBusGProxy *proxy) {
00697     gdouble preamp = 0.0;
00698 
00699     org_atheme_audacious_get_eq_preamp(proxy, &preamp, &error);
00700     g_clear_error(&error);
00701 
00702     return preamp;
00703 }
00704 
00712 gdouble audacious_remote_get_eq_band(DBusGProxy *proxy, gint band) {
00713     gdouble value = 0.0;
00714 
00715     org_atheme_audacious_get_eq_band(proxy, band, &value, &error);
00716     g_clear_error(&error);
00717 
00718     return value;
00719 }
00720 
00728 void audacious_remote_set_eq(DBusGProxy *proxy, gdouble preamp, GArray *bands) {
00729     org_atheme_audacious_set_eq(proxy, preamp, bands, &error);
00730     g_clear_error(&error);
00731 }
00732 
00739 void audacious_remote_set_eq_preamp(DBusGProxy *proxy, gdouble preamp) {
00740     org_atheme_audacious_set_eq_preamp(proxy, preamp, &error);
00741     g_clear_error(&error);
00742 }
00743 
00751 void audacious_remote_set_eq_band(DBusGProxy *proxy, gint band, gdouble value) {
00752     org_atheme_audacious_set_eq_band(proxy, band, value, &error);
00753     g_clear_error(&error);
00754 }
00755 
00761 void audacious_remote_quit(DBusGProxy *proxy) {
00762     org_atheme_audacious_quit(proxy, &error);
00763     g_clear_error(&error);
00764 }
00765 
00771 void audacious_remote_play_pause(DBusGProxy *proxy) {
00772     org_atheme_audacious_play_pause(proxy, &error);
00773 }
00774 
00782 void audacious_remote_playlist_ins_url_string(DBusGProxy *proxy,
00783                                               gchar *string, guint pos) {
00784     org_atheme_audacious_playlist_ins_url_string (proxy, string, pos, &error);
00785     g_clear_error(&error);
00786 }
00787 
00794 void audacious_remote_playqueue_add(DBusGProxy *proxy, guint pos) {
00795     org_atheme_audacious_playqueue_add (proxy, pos, &error);
00796     g_clear_error(&error);
00797 }
00798 
00805 void audacious_remote_playqueue_remove(DBusGProxy *proxy, guint pos) {
00806     org_atheme_audacious_playqueue_remove (proxy, pos, &error);
00807     g_clear_error(&error);
00808 }
00809 
00818 gint audacious_remote_get_playqueue_length(DBusGProxy *proxy) {
00819     gint len = 0;
00820     org_atheme_audacious_length(proxy, &len, &error);
00821     g_clear_error(&error);
00822     return len;
00823 }
00824 
00830 void audacious_remote_toggle_advance(DBusGProxy *proxy) {
00831     org_atheme_audacious_toggle_auto_advance(proxy, &error);
00832     g_clear_error(&error);
00833 }
00834 
00843 gboolean audacious_remote_is_advance(DBusGProxy *proxy) {
00844     gboolean is_advance = FALSE;
00845     org_atheme_audacious_auto_advance(proxy, &is_advance, &error);
00846     g_clear_error(&error);
00847     return is_advance;
00848 }
00849 
00855 void audacious_remote_activate(DBusGProxy *proxy) {
00856     org_atheme_audacious_activate(proxy, &error);
00857     g_clear_error(&error);
00858 }
00859 
00865 void audacious_remote_show_jtf_box(DBusGProxy *proxy) {
00866     audacious_remote_toggle_jtf_box(proxy, TRUE);
00867 }
00868 
00875 void audacious_remote_toggle_jtf_box(DBusGProxy *proxy, gboolean show) {
00876     org_atheme_audacious_show_jtf_box(proxy, show, &error);
00877     g_clear_error(&error);
00878 }
00879 
00886 void audacious_remote_toggle_filebrowser(DBusGProxy *proxy, gboolean show) {
00887     org_atheme_audacious_show_filebrowser(proxy, show, &error);
00888     g_clear_error(&error);
00889 }
00890 
00897 void audacious_remote_playqueue_clear(DBusGProxy *proxy) {
00898     org_atheme_audacious_playqueue_clear(proxy, &error);
00899     g_clear_error(&error);
00900 }
00901 
00909 gboolean audacious_remote_playqueue_is_queued(DBusGProxy *proxy, guint pos) {
00910     gboolean is_queued;
00911     org_atheme_audacious_playqueue_is_queued (proxy, pos, &is_queued, &error);
00912     g_clear_error(&error);
00913     return is_queued;
00914 }
00915 
00923 gint audacious_remote_get_playqueue_queue_position(DBusGProxy *proxy, guint pos) {
00924     guint qpos = 0;
00925     org_atheme_audacious_queue_get_queue_pos (proxy, pos, &qpos, &error);
00926     g_clear_error(&error);
00927     return qpos;
00928 }
00929 
00938 gint audacious_remote_get_playqueue_list_position(DBusGProxy *proxy, guint qpos) {
00939     guint pos = 0;
00940     org_atheme_audacious_queue_get_list_pos (proxy, qpos, &pos, &error);
00941     g_clear_error(&error);
00942     return pos;
00943 }
00944 
00951 void audacious_remote_playlist_enqueue_to_temp(DBusGProxy *proxy,
00952                                                gchar *string) {
00953     org_atheme_audacious_playlist_enqueue_to_temp(proxy, string, &error);
00954         g_clear_error(&error);
00955 }
00956 
00965 gchar *audacious_get_tuple_field_data(DBusGProxy *proxy, gchar *field,
00966                                       guint pos) {
00967     GValue value = {0};
00968     gchar *s = NULL;
00969 
00970     org_atheme_audacious_song_tuple(proxy, pos, field, &value, &error);
00971 
00972     g_clear_error(&error);
00973 
00974     if (G_IS_VALUE(&value) == FALSE)
00975         return NULL;
00976 
00977     /* I think the original "purpose" of using g_strescape() here
00978      * has probably been to escape only \n, \t, \r, etc. but the function
00979      * actually escapes all non-ASCII characters. Which is bad, since we
00980      * are using UTF-8.  -- ccr
00981      */
00982     if (G_VALUE_HOLDS_STRING(&value))
00983         //s = g_strescape(g_value_get_string(&value), NULL);
00984         s = g_strdup(g_value_get_string(&value));
00985     else if (g_value_type_transformable(G_VALUE_TYPE(&value), G_TYPE_STRING))
00986     {
00987         GValue tmp_value = { 0, };
00988 
00989         g_value_init(&tmp_value, G_TYPE_STRING);
00990         g_value_transform(&value, &tmp_value);
00991 
00992         //s = g_strescape(g_value_get_string(&tmp_value), NULL);
00993         s = g_strdup(g_value_get_string(&tmp_value));
00994 
00995         g_value_unset(&tmp_value);
00996     }
00997     else
00998         s = g_strdup("<unknown type>");
00999 
01000     g_value_unset(&value);
01001     return s;
01002 }
01003 
01010 void audacious_remote_eq_activate(DBusGProxy *proxy, gboolean active) {
01011     org_atheme_audacious_equalizer_activate (proxy, active, &error);
01012     g_clear_error(&error);
01013 }
01014 
01021 gchar **audacious_remote_get_tuple_fields(DBusGProxy *proxy) {
01022     gchar **res = NULL;
01023     org_atheme_audacious_get_tuple_fields (proxy, &res, &error);
01024     g_clear_error(&error);
01025     return res;
01026 }
01027 
01031 gchar *audacious_remote_playlist_get_active_name(DBusGProxy *proxy) {
01032     char *string = NULL;
01033     org_atheme_audacious_get_active_playlist_name (proxy, &string, &error);
01034     g_clear_error(&error);
01035 
01036     return (string ? string : NULL);
01037 }