Attachment #142404 for bug #199620

View | Details | Raw Unified | Return to bug 199620
Collapse All | Expand All




static gint style_id;
static GkrellmTicks *pGK;

DBusGProxy* proxy = NULL;

/* drag and drop support */

enum {

  if (!xmms_running) return ;

  switch (i) {
    case gkrellmms_prev: audacious_remote_playlist_prev(proxy); break;
    case gkrellmms_play:
      if (audacious_remote_is_playing(proxy) && 
          !audacious_remote_is_paused(proxy)) 
        audacious_remote_pause(proxy);
      else
        audacious_remote_play(proxy);
      break;
    case gkrellmms_paus: audacious_remote_pause(proxy); break;
    case gkrellmms_stop:
      audacious_remote_stop(proxy);
// FIXME      time_krell->previous = t = 0;
      break;
    case gkrellmms_next: audacious_remote_playlist_next(proxy); break;
    case gkrellmms_eject:
      if (eject_opens_playlist)
        pl_show_playlist();
      else
        audacious_remote_eject(proxy);
      break;
  }
}


  playlist_changed = update_playlist();

	if ((xmms_running = audacious_remote_is_running(proxy))) {
    /* position is changed in the playlist when the playlist is changed too !
     */
    position_changed = 
      pl_get_current_position() != prev_position || playlist_changed;
    prev_position = pl_get_current_position();
		xmms_playing = audacious_remote_is_playing(proxy);

		if (scroll_panel) {
			/* Scrollbar */

				scrolling_title_text = get_scrolling_title_text(&len, FALSE);
				time = pl_get_current_time();
				if (scrolling_tooltip != NULL) {
					audacious_remote_get_info(proxy, &rate, &freq, &nch);
					prev_scrolling_tooltip_text = scrolling_tooltip_text;
          scrolling_tooltip_text = g_strdup_printf("%s\n%d%s - %dHz - %s",
				  scrolling_title_text, rate / 1000,

	if (slider_in_motion == NULL) {
		xmms_decal->x_off = 1;
		if(xmms_running && (xmms_playing || position_changed) && draw_time){ 
		  output_time = audacious_remote_get_output_time(proxy);
      /* calculate slider position */
  	  slider_position = pl_get_current_time() ? 
                             ((output_time * 100) / pl_get_current_time()) : 0;

		if (!xmms_running)  {
      on_index = led_playing_index;
      off_index = led_off_index;
    } else if (audacious_remote_is_paused(proxy)) {
			on_index = led_off_index;	/* invert the duty cycle */
			off_index = led_paused_index;
		} else if (!xmms_playing) {

drag_data_received(GtkWidget *window,GdkDragContext *context, gint x, gint y,
                   GtkSelectionData *data,guint info,guint time,gpointer date) {
  if (data->data) {
    audacious_remote_playlist_clear(proxy);
    audacious_remote_playlist_add_url_string(proxy,(gchar *)data->data);
    audacious_remote_play(proxy);
    update_playlist();
  }
}

     | P200 I really notice some bugs without it.
     */
    if (!xmms_playing)
      audacious_remote_play(proxy);
    timer = time(&lt);

    /* Do nothing, wait until xmms really plays;
     | stop waiting after 10 seconds.
     */
    /* FIXME ugly evil code */
    while (!audacious_remote_is_playing(proxy) && ((time(&lt) - timer) < 10))
    {
      usleep(0);
    }

    audacious_remote_jump_to_time(proxy, where_to_jump);

    timer = localtime(&lt)->tm_sec;

    /* Wait till really jumped before we continue. */
    while ((audacious_remote_get_output_time(proxy) / 1000) 
        != (where_to_jump / 1000) && ((time(&lt) - timer) < 10))
      usleep(0);
  }
  else if((slider_in_motion != NULL) && !xmms_playing)
    audacious_remote_play(proxy);

  slider_in_motion = NULL;
  got_motion = FALSE;

        xmms_start_func();
      break;
    case 2:
      if (xmms_running && audacious_remote_is_playing(proxy))
      {
        if (krell_mmb_pause)
          audacious_remote_pause(proxy);
        else
          audacious_remote_stop(proxy);
      }
      else if (xmms_running)
        audacious_remote_play(proxy);
      else
        xmms_start_func();
      break;

	static GkrellmPiximage *bg_scroll_image;

	if (first_create) {
		xmms_running = audacious_remote_is_running(proxy);
		if (auto_main_close && xmms_running)
			audacious_remote_main_win_toggle(proxy, FALSE);
		if (xmms_autostart && !xmms_running)  xmms_start_func();
    		pl_init();
    pl_init();
		control_panel = gkrellm_panel_new0();
	} else {
		update_playlist();
	}

	style = gkrellm_meter_style(DEFAULT_STYLE);
	if (scroll_style) g_free(scroll_style);


    if (scrolling_tooltip == NULL) {
		scrolling_tooltip = gtk_tooltips_new();
		scrolling_tooltip_text = g_strdup("audacious");
		gtk_tooltips_set_tip(scrolling_tooltip, scroll_panel->drawing_area,
					scrolling_tooltip_text, NULL);
		gtk_tooltips_set_delay(scrolling_tooltip, 750);

	gkrellm_set_krell_full_scale(time_krell, 100, 1);

	m = gkrellm_get_style_margins(style);
	w = gkrellm_gdk_string_width(ts->font, "-000:00xxx");
	xmms_decal = gkrellm_create_decal_text(control_panel, (gchar *) "A0", ts,
				style, -1, -1, w);
	xmms_decal->x += m->left;

void mainwin_back_func()
{
  if (auto_main_close && xmms_running)
    audacious_remote_main_win_toggle(proxy, TRUE);
}

static GkrellmMonitor  plugin_mon  =

GkrellmMonitor *
gkrellm_init_plugin(void) {
  gchar *tmp;
  GError *error = NULL;
  static DBusGConnection *connection = NULL;

#ifdef ENABLE_NLS
   bind_textdomain_codeset(PACKAGE, "UTF-8");

	running_factory = options_menu_factory(1);
	not_running_factory = options_menu_factory(0);



  connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);

  proxy = dbus_g_proxy_new_for_name(connection, AUDACIOUS_DBUS_SERVICE,
                                    AUDACIOUS_DBUS_PATH,
                                    AUDACIOUS_DBUS_INTERFACE);

  /* Default settings */
  control_panel = NULL;
  xmms_running = FALSE;


  playlist_dir = g_strdup(gkrellm_homedir());
  files_directory = g_strdup("/");
  gkrellmms_label = g_strdup("audacious");
  xmms_session = 0;
  scroll_enable = TRUE;
  scroll_separator = g_strdup(SCROLL_SEPARATOR);
  draw_time = 1;
  xmms_exec_command = g_strdup("audacious");
  xmms_exec_command = g_strdup("beep-media-player");
#else
  xmms_exec_command = g_strdup("xmms");
#endif
  xmms_autostart = 0;
  auto_main_close = 0;
  auto_hide_all = 0;




#include <time.h>
#include <gkrellm2/gkrellm.h>

#include <audacious/audctrl.h>
#include <audacious/dbus.h>

#include <xmms/xmmsctrl.h>
#endif

#include "playlist.h"
/* You can change these ones, but at your own risk.



/* Very global vars */
extern DBusGProxy* proxy;

GtkItemFactory *running_factory;
GtkItemFactory *not_running_factory;


gchar *scroll_separator;
gint scroll_enable;
gint enable_buttonbar;
gint xmms_session;
gint xmms_autostart;
gint auto_main_close;
gint auto_hide_all;




IMLIB_INCLUDE ?= 
IMLIB_LIB ?= 

XMMS_INCLUDE ?= `pkg-config audacious --cflags`
XMMS_LIB ?= `pkg-config audacious --libs`

DBUS_INCLUDE ?= `pkg-config dbus-1 --cflags`
DBUS_LIB ?= `pkg-config dbus-1 --libs`
   XMMS_LIB ?= `xmms-config --libs`
endif

PLUGIN_DIR ?= /usr/local/lib/gkrellm2/plugins

FLAGS = -O2 -Wall -fPIC $(GTK_INCLUDE) $(IMLIB_INCLUDE) $(DBUS_INCLUDE) $(XMMS_INCLUDE)
LIBS = $(GTK_LIB) $(IMLIB_LIB) $(DBUS_LIB) $(XMMS_LIB)
LFLAGS = -shared -lpthread

ifdef USE_BMP
   FLAGS += -DUSE_BMP
endif

LOCALEDIR ?= /usr/share/locale
ifeq ($(enable_nls),1)
   FLAGS += -DENABLE_NLS -DLOCALEDIR=\"$(LOCALEDIR)\"




                 *playlist_dir_entry,
                 *label_entry,
                 *separator_entry,
                 *session_entry,
                 *xmms_start_entry,
                 *scroll_enable_entry,
                 *main_close_entry,

  switch (type)
  {
    case gkrellmms_mainwin:
      audacious_remote_main_win_toggle(proxy,
        !audacious_remote_is_main_win(proxy));
      break;
    case gkrellmms_playlist:
      audacious_remote_pl_win_toggle(proxy,
        !audacious_remote_is_pl_win(proxy));
      break;
    case gkrellmms_eq:
      audacious_remote_eq_win_toggle(proxy,
        !audacious_remote_is_eq_win(proxy));
      break;
    case gkrellmms_repeat:
      audacious_remote_toggle_repeat(proxy);
      break;
    case gkrellmms_shuffle:
      audacious_remote_toggle_shuffle(proxy);
      break;
    case gkrellmms_eject:
      audacious_remote_eject(proxy);
      break;
    case gkrellmms_prefs:
      audacious_remote_show_prefs_box(proxy);
      break;
    default:
      do_xmms_command(type);


void aot_func(GtkWidget *w, gpointer data)
{
  audacious_remote_toggle_aot(proxy, GPOINTER_TO_INT(data));
}

void save_time(gint);

	 */
  /* FIXME supposed ugly evil code */
  timer = time(&lt);
  while (!audacious_remote_is_running(proxy) && ((time(&lt) - timer) < 10))
				usleep(0);

	xmms_running = audacious_remote_is_running(proxy);

	if (auto_hide_all && xmms_running) {
    audacious_remote_main_win_toggle(proxy, FALSE);
    audacious_remote_pl_win_toggle(proxy, FALSE);
    audacious_remote_eq_win_toggle(proxy, FALSE);
	}
}


  time(&lt);
  timer = lt;

  audacious_remote_quit(proxy);
  while (audacious_remote_is_running(proxy)
         && ((time(&lt) - timer) < 10)) {
    /* Do nothing; wait until xmms really quits, but not longer than 10sec! */
    usleep(0);


static GtkItemFactoryEntry gkrellmms_factory[] =
{
  {N_("/Toggles"),                   NULL, NULL,          0,        "<Branch>"},
  {N_("/Toggles/Main Window"),       NULL, toggles_func,  gkrellmms_mainwin,  "<Item>"},
  {N_("/Toggles/Playlist"),          NULL, toggles_func,  gkrellmms_playlist, "<Item>"},
  {N_("/Toggles/EQ"),                NULL, toggles_func,  gkrellmms_eq,       "<Item>"},
  {N_("/Toggles/Repeat"),            NULL, toggles_func,  gkrellmms_repeat,   "<Item>"},
  {N_("/Toggles/Shuffle"),           NULL, toggles_func,  gkrellmms_shuffle,  "<Item>"},
  {N_("/Toggles/-"),                 NULL, NULL,          0,        "<Separator>"},
  {N_("/Toggles/Always on top on"),  NULL, aot_func,      ON,       "<Item>"},
  {N_("/Toggles/Always on top off"), NULL, aot_func,      OFF,      "<Item>"},
  {N_("/Toggles.../Always on top off"), NULL, aot_func,      OFF,      "<Item>"},
  {"/-",                                NULL, NULL,          0,        "<Separator>"},
  {"/Audacious",                          NULL, NULL,          0,        "<Branch>"},
  {N_("/Audacious/Previous"),             NULL, toggles_func,  gkrellmms_prev,     "<Item>"},
  {N_("/Audacious/Play"),                 NULL, toggles_func,  gkrellmms_play,     "<Item>"},
  {N_("/Audacious/Pause"),                NULL, toggles_func,  gkrellmms_paus,     "<Item>"},
  {N_("/Audacious/Stop"),                 NULL, toggles_func,  gkrellmms_stop,     "<Item>"},
  {N_("/Audacious/Next"),                 NULL, toggles_func,  gkrellmms_next,     "<Item>"},
  {"/-",                                NULL, NULL,          0,        "<Separator>"},
  {N_("/Playlist Editor"),              NULL, open_playlist_cb, 0,        "<Item>"},
  {N_("/GKrellMMS Options"),            NULL, open_options_cb, 0,        "<Item>"},
  {"/-",                                NULL, NULL,          0,        "<Separator>"},
  {N_("/Open file(s)"),                 NULL, toggles_func,  gkrellmms_eject,    "<Item>"},
  {N_("/Open Playlist"),                NULL, load_playlist_cb,  0,        "<Item>"},
  {N_("/Audacious Preferences"),                   NULL, toggles_func,  gkrellmms_prefs,    "<Item>"},
  {"/-",                                NULL, NULL,          0,        "<Separator>"},
  {N_("/Quit XMMS"),                    NULL, quit_func,     0,        "<Item>"},
  {"/-",                                NULL, NULL,          0,        "<Separator>"},
  {N_("/Quit Audacious"),                    NULL, quit_func,     0,        "<Item>"},
};

static GtkItemFactoryEntry gkrellmms_factory_norun[] =
{
  {N_("/Launch Audacious"),                 NULL, start_func,    0,    "<Item>"},
  {N_("/Launch XMMS"),                 NULL, start_func,    0,    "<Item>"},
  {"/-",                           NULL, NULL,          0,    "<Separator>"},
};

GtkItemFactory *options_menu_factory(gint run_menu)

  scroll_separator = g_strdup(gtk_entry_get_text(GTK_ENTRY(separator_entry)));
	gkrellmms_set_scroll_separator_len();

  xmms_session = gtk_spin_button_get_value_as_int(
                                                GTK_SPIN_BUTTON(session_entry));

  /* Toggles */
  prev_scroll_enable = scroll_enable;
  scroll_enable = GTK_TOGGLE_BUTTON(scroll_enable_entry)->active;

void save_gkrellmms_config(FILE *f)
{
  fprintf(f, "%s scroll_enable %d\n", CONFIG_KEYWORD, scroll_enable);
  fprintf(f, "%s xmms_session %d\n", CONFIG_KEYWORD, xmms_session);
  fprintf(f, "%s draw_time %d\n", CONFIG_KEYWORD, draw_time);
  fprintf(f, "%s xmms_autostart %d\n", CONFIG_KEYWORD, xmms_autostart);
  fprintf(f, "%s auto_main_close %d\n", CONFIG_KEYWORD, auto_main_close);

  {
    if (strcmp(config, "scroll_enable") == 0)
      sscanf(item, "%d\n", &scroll_enable);
    else if (strcmp(config, "xmms_session") == 0)
      sscanf(item, "%d\n", &xmms_session);
    else if (strcmp(config, "xmms_autostart") == 0)
      sscanf(item, "%d\n", &xmms_autostart);
    else if (strcmp(config, "auto_main_close") == 0)

            *time_draw_entry,
            *pause_entry,
            *time_fmt_entry;
  GtkAdjustment *adjust;
  GSList *eject_group = NULL,
         *time_draw_group = NULL,
         *pause_group = NULL,

  gint i;
  static gchar *gkrellmms_help_text[] =
  {
    N_("GKrellMMS is a GKrellM Audacious-plugin which allows you to control \n" \
    "Audacious from within GKrellM. It features some cool things, such as: \n" \
    "\n" \
    "- A scrolling title. \n" \
    "- A Krell which indicates where you are in a song. \n" \
    "- Themeable buttons for controlling Audacious. \n" \
    "- A playlist editor. \n" \
    "- A gtk-popup-menu with misc. Audacious-functions. \n" \
    "\n"),

    N_("<b>How to use GKrellMMS: \n"),
    N_("\n" \
    "You can do some cool stuff with the Audacious-Krell, by using your mouse. \n" \
    "\n"),

    N_("<b>Mouse actions: \n" \

    N_("Jump through song. \n"),

    N_("<b>\tMiddle mouse-button: "),
    N_("Pause/stop/play Audacious (configurable), \n" \
    "\t  or launch Audacious if it's not running. \n"),

    N_("<b>\tRight mouse-button: "),
    N_("Popup-menu. \n" \

    "\n"),

    N_("<b>\tConstant red: "),
    N_("Audacious is turned off. \n"),

    N_("<b>\tConstant green: "),
    N_("Audacious is playing. \n"),

    N_("<b>\tRed, blinking green: "),
    N_("Audacious is stopped. \n"),

    N_("<b>\tGreen, blinking red: "),
    N_("Audacious is paused. \n" \
    "\n"),

    N_("<b>Configurabilities:\n"),


    N_("<b>Configs tab: \n" \
    "\n" \
    "\tAudacious Executable: \n"),

    N_("\tHow the Audacious-executable (+ eventually path) \n" \
    "\tis called on your computer. Default is audacious\n" \
    "\n"),

    N_("<b>\tFiles Directory: \n"),
    N_("\tThe directory where your mp3's/xm's/whatever \n" \
    "\tare stored in. When starting Audacious from GKrellM, it will go to this \n" \
    "\tdirectory when ejecting. \n" \
    "\n"),
  

    "\n"),

    N_("<b>\tKrell label: \n"),
    N_("\tThe text-label you want in the krell when Audacious isn't running/playing. \n" \
    "\n"),
  
    N_("<b>\tScroll separator: \n"),

    "\tIt defaults to '   ***   ' (that's 3 spaces, 3 *'s and 3 spaces). \n" \
    "\n"),

    N_("<b>\tXMMS Session to use: \n"),
    N_("\tThe XMMS-session you want to use with GKrellMMS. \n" \
    "\tUse 0 if you only have 1 XMMS running. \n" \
    "\n"),
  
    N_("<b>Toggles tab: \n" \
    "\n" \
    "\tDraw minus (-) with remaining time: \n"),

    N_("\tDraw a minus (-) before the remaining time, when you have \n" \
    "\tthe output-time displaying remaining time. \n\n"),

    N_("<b>\tAudacious Auto Launch: \n"),
    N_("\tAuto launch Audacious when starting GKrellMMS. \n" \
    "\n"),
  
    N_("<b>\tAuto Mainwindow Close: \n"),
    N_("\tAutomatically close the Audacious-mainwindow \n" \
    "\twhen GKrellMMS starts, and Audacious is already running, or when \n" \
    "\tlaunching Audacious while GKrellMMS runs. This option also enables the \n" \
    "\tmainwindow back when you quit gkrellm (some people really do). \n" \
    "\n"),

    N_("<b>\tAuto hide all Audacious windows: \n"),
    N_("\tAutomatically hide all Audacious windows when GKrellMMS starts. \n" \
     "\n"),

    N_("<b>\tAuto start playing: \n"),
    N_("\tAutomatically start playing when launching Audacious. \n\n"),

    N_("<b>\tEnable scrolling title: \n"),
    N_("\tEnable/disable the scrolling title-panel. \n" \

    "\tEject opens: \n"),

    N_("\tCheck whether the eject-button on the button-bar opens a \n" \
    "\tplaylist or an other Audacious-file. \n" \
    "\n"),
  
    N_("<b>\tMMB on krell click: \n"),
    N_("\tCheck whether GKrellMMS should pause/continue or \n" \
    "\tstop/play the current song on a MMB-click on the krell. MMB Click will \n" \
    "\talways start playing the song if Audacious isn't playing. \n" \
    "\n"),

    N_("<b>\tLoad file-info: \n"),

    "\tplaylist editor, or are playing on a slow network/cdrom. \n\n"),

    N_("<b>\tDraw in time bar: \n"),
    N_("\tCheck whether to draw the output time or 'audacious' in \n" \
    "\tthe time-krell panel. \n" \
    "\n"),


  hbox = gtk_hbox_new(FALSE, 5);

  zbox = gtk_vbox_new(FALSE, 0);
  label = gtk_label_new(_("Audacious Executable:"));
  gtk_box_pack_start(GTK_BOX(zbox), label, TRUE, FALSE, 0);
  label = gtk_label_new(_("Files Directory:"));
  gtk_box_pack_start(GTK_BOX(zbox), label, TRUE, FALSE, 0);

  gtk_box_pack_start(GTK_BOX(hbox), zbox, FALSE, FALSE, 0);
  gtk_container_add(GTK_CONTAINER(vbox), hbox);

  hbox = gtk_hbox_new(FALSE, 5);
  adjust = (GtkAdjustment *) gtk_adjustment_new((gfloat) xmms_session, 0.0,
                             100.0, 1.0, 5.0, 0.0);
  session_entry = gtk_spin_button_new(adjust, 1.0, 1);
  gtk_spin_button_set_digits(GTK_SPIN_BUTTON(session_entry), (guint) 0);
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(session_entry), xmms_session);
  gtk_box_pack_start(GTK_BOX(hbox), session_entry, FALSE, FALSE, 0);
  label = gtk_label_new(_("XMMS Session to use"));
  gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
  gtk_container_add(GTK_CONTAINER(vbox), hbox);

  label = gtk_label_new(_("Configs"));
  gtk_container_add(GTK_CONTAINER(frame), vbox);
  gtk_notebook_append_page(GTK_NOTEBOOK(laptop), frame, label);

  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(draw_minus_entry), draw_minus);  
  gtk_container_add(GTK_CONTAINER(vbox), draw_minus_entry);

  xmms_start_entry = gtk_check_button_new_with_label(_("Auto launch Audacious on GKrellMMS startup"));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(xmms_start_entry), xmms_autostart);
  gtk_container_add(GTK_CONTAINER(vbox), xmms_start_entry);

  main_close_entry = gtk_check_button_new_with_label(_("Auto close (and open) Audacious Mainwin"));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(main_close_entry), auto_main_close);
  gtk_container_add(GTK_CONTAINER(vbox), main_close_entry);

  hide_all_entry = gtk_check_button_new_with_label(_("Auto hide all Audacious windows on Audacious startup"));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hide_all_entry), auto_hide_all);
  gtk_container_add(GTK_CONTAINER(vbox), hide_all_entry);

  auto_play_entry = gtk_check_button_new_with_label(_("Auto start playing on Audaciou launch"));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auto_play_entry), auto_play_start);
  gtk_container_add(GTK_CONTAINER(vbox), auto_play_entry);


  gtk_signal_connect(GTK_OBJECT(time_draw_entry), "pressed",
                     (GtkSignalFunc) time_type_set, GINT_TO_POINTER(1));

  time_draw_entry = gtk_radio_button_new_with_label(time_draw_group, _("Audacious-text"));
  gtk_box_pack_start(GTK_BOX(zbox), time_draw_entry, FALSE, FALSE, 0);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(time_draw_entry), !draw_time);
  gtk_signal_connect(GTK_OBJECT(time_draw_entry), "pressed",

  /* About */
  gkrellmms_info_text = g_strdup_printf(
    _("GKrellMMS %d.%d.%d\n" \
    "GKrellM Audacious Plugin\n" \
    "\n" \
    "Copyright (C) 2008      Sascha Hlusiak <contact@saschahlusiak.de>\n"\
    "Copyright (C) 2000-2002 Sander Klein Lebbink <sander@cerberus.demon.nl>\n"\
    "Current Maintainer: Sjoerd Simons <sjoerd@luon.net>\n" \
    "http://gkrellm.luon.net/\n" \




void update_playlist_position(void) {
  GtkTreeIter iter;

  current_position = audacious_remote_get_playlist_pos(proxy) + 1;
  g_free(current_title);
  g_free(current_file);
  if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(playlist),
                                &iter, NULL, current_position -1))  {
    current_file = audacious_remote_get_playlist_file(proxy,
                                                     current_position -1);
    current_title = audacious_remote_get_playlist_title(proxy,
                                                     current_position -1);
    current_time =  audacious_remote_get_playlist_time(proxy,
                                                     current_position -1);

    current_file = string_to_utf8(current_file, TRUE);


  total_plist_time = 0;

  if (!audacious_remote_is_running(proxy)) return;

  len = audacious_remote_get_playlist_length(proxy);
  playlist_length = len;

  for (i = 0 ; i < len ; i ++) {
    filename =  audacious_remote_get_playlist_file(proxy, i);
    if (filename == NULL) {
      /* error occurred empty playlist and try again */
      empty_playlist();


    gtk_list_store_append(playlist,&iter);
    if (always_load_info) {
      title = audacious_remote_get_playlist_title(proxy, i);
      if (title != NULL) { 
        title = string_to_utf8(title, FALSE);
      } 
      time = audacious_remote_get_playlist_time(proxy, i);
      gtk_list_store_set(playlist,&iter,
                         PLAYLIST_POSITION,i+ 1,
                         PLAYLIST_TITLE,title == NULL ? "" : title,

  char *filename = NULL;

  /* playlist lenght changed, reload */
  if (playlist_length != audacious_remote_get_playlist_length(proxy)) {
    empty_playlist();
    playlist_length = -1;
    load_playlist();
    return TRUE;
  }
  filename = string_to_utf8(
               audacious_remote_get_playlist_file(proxy,current_position-1),
               TRUE
             );
  

  }
  g_free(filename);

  if (audacious_remote_get_playlist_pos(proxy) != current_position + 1) {
    update_playlist_position();
  }
  return TRUE;

    }
    list = g_list_append(list,path);
  }
  if (audacious_remote_is_running(proxy)) {
    audacious_remote_playlist_clear(proxy);
    audacious_remote_playlist_add(proxy, list);
  }

  for (tlist = list; tlist != NULL; tlist = g_list_next(tlist)) {

  gtk_tree_model_get(GTK_TREE_MODEL(playlist),&iter,
                     PLAYLIST_POSITION,&position,
                     -1);
  audacious_remote_set_playlist_pos(proxy,position - 1);
  audacious_remote_play(proxy);
  return TRUE;
}


Lines 24-34 Link Here

(-)../gkrellmms/playlist.h (-5 / +1 lines)
24	#include <stdio.h>	24	#include <stdio.h>
25	#include <time.h>	25	#include <time.h>
26		26
27	#ifdef USE_BMP	27	#include <audacious/auddrct.h>
28	#include <bmp/beepctrl.h>
29	#else
30	#include <xmms/xmmsctrl.h>
31	#endif
32		28
33	#include "gkrellmms.h"	29	#include "gkrellmms.h"
34		30

Return to bug 199620

Lines 107-122 Link Here

(-)../gkrellmms/playlist.c (-17 / +18 lines)
107	void update_playlist_position(void) {	107	void update_playlist_position(void) {
108	GtkTreeIter iter;	108	GtkTreeIter iter;
109		109
110	current_position = xmms_remote_get_playlist_pos(xmms_session) + 1;	110	current_position = audacious_remote_get_playlist_pos(proxy) + 1;
111	g_free(current_title);	111	g_free(current_title);
112	g_free(current_file);	112	g_free(current_file);
113	if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(playlist),	113	if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(playlist),
114	&iter, NULL, current_position -1)) {	114	&iter, NULL, current_position -1)) {
115	current_file = xmms_remote_get_playlist_file(xmms_session,	115	current_file = audacious_remote_get_playlist_file(proxy,
116	current_position -1);	116	current_position -1);
117	current_title = xmms_remote_get_playlist_title(xmms_session,	117	current_title = audacious_remote_get_playlist_title(proxy,
118	current_position -1);	118	current_position -1);
119	current_time = xmms_remote_get_playlist_time(xmms_session,	119	current_time = audacious_remote_get_playlist_time(proxy,
120	current_position -1);	120	current_position -1);
121		121
122	current_file = string_to_utf8(current_file, TRUE);	122	current_file = string_to_utf8(current_file, TRUE);
Lines 154-166 Link Here
154		154
155	total_plist_time = 0;	155	total_plist_time = 0;
156		156
157	if (!xmms_remote_is_running(xmms_session)) return;	157	if (!audacious_remote_is_running(proxy)) return;
158		158
159	len = xmms_remote_get_playlist_length(xmms_session);	159	len = audacious_remote_get_playlist_length(proxy);
160	playlist_length = len;	160	playlist_length = len;
161		161
162	for (i = 0 ; i < len ; i ++) {	162	for (i = 0 ; i < len ; i ++) {
163	filename = xmms_remote_get_playlist_file(xmms_session, i);	163	filename = audacious_remote_get_playlist_file(proxy, i);
164	if (filename == NULL) {	164	if (filename == NULL) {
165	/* error occurred empty playlist and try again */	165	/* error occurred empty playlist and try again */
166	empty_playlist();	166	empty_playlist();
Lines 173-183 Link Here
173		173
174	gtk_list_store_append(playlist,&iter);	174	gtk_list_store_append(playlist,&iter);
175	if (always_load_info) {	175	if (always_load_info) {
176	title = xmms_remote_get_playlist_title(xmms_session, i);	176	title = audacious_remote_get_playlist_title(proxy, i);
177	if (title != NULL) {	177	if (title != NULL) {
178	title = string_to_utf8(title, FALSE);	178	title = string_to_utf8(title, FALSE);
179	}	179	}
180	time = xmms_remote_get_playlist_time(xmms_session, i);	180	time = audacious_remote_get_playlist_time(proxy, i);
181	gtk_list_store_set(playlist,&iter,	181	gtk_list_store_set(playlist,&iter,
182	PLAYLIST_POSITION,i+ 1,	182	PLAYLIST_POSITION,i+ 1,
183	PLAYLIST_TITLE,title == NULL ? "" : title,	183	PLAYLIST_TITLE,title == NULL ? "" : title,
Lines 206-218 Link Here
206	char *filename = NULL;	206	char *filename = NULL;
207		207
208	/* playlist lenght changed, reload */	208	/* playlist lenght changed, reload */
209	if (playlist_length != xmms_remote_get_playlist_length(xmms_session)) {	209	if (playlist_length != audacious_remote_get_playlist_length(proxy)) {
210	empty_playlist();	210	empty_playlist();
		211	playlist_length = -1;
211	load_playlist();	212	load_playlist();
212	return TRUE;	213	return TRUE;
213	}	214	}
214	filename = string_to_utf8(	215	filename = string_to_utf8(
215	xmms_remote_get_playlist_file(xmms_session,current_position-1),	216	audacious_remote_get_playlist_file(proxy,current_position-1),
216	TRUE	217	TRUE
217	);	218	);
218		219
Lines 224-230 Link Here
224	}	225	}
225	g_free(filename);	226	g_free(filename);
226		227
227	if (xmms_remote_get_playlist_pos(xmms_session) != current_position + 1) {	228	if (audacious_remote_get_playlist_pos(proxy) != current_position + 1) {
228	update_playlist_position();	229	update_playlist_position();
229	}	230	}
230	return TRUE;	231	return TRUE;
Lines 273-281 Link Here
273	}	274	}
274	list = g_list_append(list,path);	275	list = g_list_append(list,path);
275	}	276	}
276	if (xmms_remote_is_running(xmms_session)) {	277	if (audacious_remote_is_running(proxy)) {
277	xmms_remote_playlist_clear(xmms_session);	278	audacious_remote_playlist_clear(proxy);
278	xmms_remote_playlist_add(xmms_session, list);	279	audacious_remote_playlist_add(proxy, list);
279	}	280	}
280		281
281	for (tlist = list; tlist != NULL; tlist = g_list_next(tlist)) {	282	for (tlist = list; tlist != NULL; tlist = g_list_next(tlist)) {
Lines 386-393 Link Here
386	gtk_tree_model_get(GTK_TREE_MODEL(playlist),&iter,	387	gtk_tree_model_get(GTK_TREE_MODEL(playlist),&iter,
387	PLAYLIST_POSITION,&position,	388	PLAYLIST_POSITION,&position,
388	-1);	389	-1);
389	xmms_remote_set_playlist_pos(xmms_session,position - 1);	390	audacious_remote_set_playlist_pos(proxy,position - 1);
390	xmms_remote_play(xmms_session);	391	audacious_remote_play(proxy);
391	return TRUE;	392	return TRUE;
392	}	393	}
393		394

Lines 82-87 Link Here

(-)../gkrellmms/gkrellmms.c (-42 / +48 lines)
82	static gint style_id;	82	static gint style_id;
83	static GkrellmTicks *pGK;	83	static GkrellmTicks *pGK;
84		84
		85	DBusGProxy* proxy = NULL;
		86
85	/* drag and drop support */	87	/* drag and drop support */
86		88
87	enum {	89	enum {
Lines 103-127 Link Here
103	if (!xmms_running) return ;	105	if (!xmms_running) return ;
104		106
105	switch (i) {	107	switch (i) {
106	case gkrellmms_prev: xmms_remote_playlist_prev(xmms_session); break;	108	case gkrellmms_prev: audacious_remote_playlist_prev(proxy); break;
107	case gkrellmms_play:	109	case gkrellmms_play:
108	if (xmms_remote_is_playing(xmms_session) &&	110	if (audacious_remote_is_playing(proxy) &&
109	!xmms_remote_is_paused(xmms_session))	111	!audacious_remote_is_paused(proxy))
110	xmms_remote_pause(xmms_session);	112	audacious_remote_pause(proxy);
111	else	113	else
112	xmms_remote_play(xmms_session);	114	audacious_remote_play(proxy);
113	break;	115	break;
114	case gkrellmms_paus: xmms_remote_pause(xmms_session); break;	116	case gkrellmms_paus: audacious_remote_pause(proxy); break;
115	case gkrellmms_stop:	117	case gkrellmms_stop:
116	xmms_remote_stop(xmms_session);	118	audacious_remote_stop(proxy);
117	// FIXME time_krell->previous = t = 0;	119	// FIXME time_krell->previous = t = 0;
118	break;	120	break;
119	case gkrellmms_next: xmms_remote_playlist_next(xmms_session); break;	121	case gkrellmms_next: audacious_remote_playlist_next(proxy); break;
120	case gkrellmms_eject:	122	case gkrellmms_eject:
121	if (eject_opens_playlist)	123	if (eject_opens_playlist)
122	pl_show_playlist();	124	pl_show_playlist();
123	else	125	else
124	xmms_remote_eject(xmms_session);	126	audacious_remote_eject(proxy);
125	break;	127	break;
126	}	128	}
127	}	129	}
Lines 211-223 Link Here
211		213
212	playlist_changed = update_playlist();	214	playlist_changed = update_playlist();
213		215
214	if ((xmms_running = xmms_remote_is_running(xmms_session))) {	216	if ((xmms_running = audacious_remote_is_running(proxy))) {
215	/* position is changed in the playlist when the playlist is changed too !	217	/* position is changed in the playlist when the playlist is changed too !
216	*/	218	*/
217	position_changed =	219	position_changed =
218	pl_get_current_position() != prev_position \|\| playlist_changed;	220	pl_get_current_position() != prev_position \|\| playlist_changed;
219	prev_position = pl_get_current_position();	221	prev_position = pl_get_current_position();
220	xmms_playing = xmms_remote_is_playing(xmms_session);	222	xmms_playing = audacious_remote_is_playing(proxy);
221		223
222	if (scroll_panel) {	224	if (scroll_panel) {
223	/* Scrollbar */	225	/* Scrollbar */
Lines 228-234 Link Here
228	scrolling_title_text = get_scrolling_title_text(&len, FALSE);	230	scrolling_title_text = get_scrolling_title_text(&len, FALSE);
229	time = pl_get_current_time();	231	time = pl_get_current_time();
230	if (scrolling_tooltip != NULL) {	232	if (scrolling_tooltip != NULL) {
231	xmms_remote_get_info(xmms_session, &rate, &freq, &nch);	233	audacious_remote_get_info(proxy, &rate, &freq, &nch);
232	prev_scrolling_tooltip_text = scrolling_tooltip_text;	234	prev_scrolling_tooltip_text = scrolling_tooltip_text;
233	scrolling_tooltip_text = g_strdup_printf("%s\n%d%s - %dHz - %s",	235	scrolling_tooltip_text = g_strdup_printf("%s\n%d%s - %dHz - %s",
234	scrolling_title_text, rate / 1000,	236	scrolling_title_text, rate / 1000,
Lines 297-303 Link Here
297	if (slider_in_motion == NULL) {	299	if (slider_in_motion == NULL) {
298	xmms_decal->x_off = 1;	300	xmms_decal->x_off = 1;
299	if(xmms_running && (xmms_playing \|\| position_changed) && draw_time){	301	if(xmms_running && (xmms_playing \|\| position_changed) && draw_time){
300	output_time = xmms_remote_get_output_time(xmms_session);	302	output_time = audacious_remote_get_output_time(proxy);
301	/* calculate slider position */	303	/* calculate slider position */
302	slider_position = pl_get_current_time() ?	304	slider_position = pl_get_current_time() ?
303	((output_time * 100) / pl_get_current_time()) : 0;	305	((output_time * 100) / pl_get_current_time()) : 0;
Lines 334-340 Link Here
334	if (!xmms_running) {	336	if (!xmms_running) {
335	on_index = led_playing_index;	337	on_index = led_playing_index;
336	off_index = led_off_index;	338	off_index = led_off_index;
337	} else if (xmms_remote_is_paused(xmms_session)) {	339	} else if (audacious_remote_is_paused(proxy)) {
338	on_index = led_off_index; /* invert the duty cycle */	340	on_index = led_off_index; /* invert the duty cycle */
339	off_index = led_paused_index;	341	off_index = led_paused_index;
340	} else if (!xmms_playing) {	342	} else if (!xmms_playing) {
Lines 397-405 Link Here
397	drag_data_received(GtkWidget window,GdkDragContext context, gint x, gint y,	399	drag_data_received(GtkWidget window,GdkDragContext context, gint x, gint y,
398	GtkSelectionData *data,guint info,guint time,gpointer date) {	400	GtkSelectionData *data,guint info,guint time,gpointer date) {
399	if (data->data) {	401	if (data->data) {
400	xmms_remote_playlist_clear(xmms_session);	402	audacious_remote_playlist_clear(proxy);
401	xmms_remote_playlist_add_url_string(xmms_session,(gchar *)data->data);	403	audacious_remote_playlist_add_url_string(proxy,(gchar *)data->data);
402	xmms_remote_play(xmms_session);	404	audacious_remote_play(proxy);
403	update_playlist();	405	update_playlist();
404	}	406	}
405	}	407	}
Lines 437-465 Link Here
437	\| P200 I really notice some bugs without it.	439	\| P200 I really notice some bugs without it.
438	*/	440	*/
439	if (!xmms_playing)	441	if (!xmms_playing)
440	xmms_remote_play(xmms_session);	442	audacious_remote_play(proxy);
441	timer = time(&lt);	443	timer = time(&lt);
442		444
443	/* Do nothing, wait until xmms really plays;	445	/* Do nothing, wait until xmms really plays;
444	\| stop waiting after 10 seconds.	446	\| stop waiting after 10 seconds.
445	*/	447	*/
446	/* FIXME ugly evil code */	448	/* FIXME ugly evil code */
447	while (!xmms_remote_is_playing(xmms_session) && ((time(&lt) - timer) < 10))	449	while (!audacious_remote_is_playing(proxy) && ((time(&lt) - timer) < 10))
448	{	450	{
449	usleep(0);	451	usleep(0);
450	}	452	}
451		453
452	xmms_remote_jump_to_time(xmms_session, where_to_jump);	454	audacious_remote_jump_to_time(proxy, where_to_jump);
453		455
454	timer = localtime(&lt)->tm_sec;	456	timer = localtime(&lt)->tm_sec;
455		457
456	/* Wait till really jumped before we continue. */	458	/* Wait till really jumped before we continue. */
457	while ((xmms_remote_get_output_time(xmms_session) / 1000)	459	while ((audacious_remote_get_output_time(proxy) / 1000)
458	!= (where_to_jump / 1000) && ((time(&lt) - timer) < 10))	460	!= (where_to_jump / 1000) && ((time(&lt) - timer) < 10))
459	usleep(0);	461	usleep(0);
460	}	462	}
461	else if((slider_in_motion != NULL) && !xmms_playing)	463	else if((slider_in_motion != NULL) && !xmms_playing)
462	xmms_remote_play(xmms_session);	464	audacious_remote_play(proxy);
463		465
464	slider_in_motion = NULL;	466	slider_in_motion = NULL;
465	got_motion = FALSE;	467	got_motion = FALSE;
Lines 482-496 Link Here
482	xmms_start_func();	484	xmms_start_func();
483	break;	485	break;
484	case 2:	486	case 2:
485	if (xmms_running && xmms_remote_is_playing(xmms_session))	487	if (xmms_running && audacious_remote_is_playing(proxy))
486	{	488	{
487	if (krell_mmb_pause)	489	if (krell_mmb_pause)
488	xmms_remote_pause(xmms_session);	490	audacious_remote_pause(proxy);
489	else	491	else
490	xmms_remote_stop(xmms_session);	492	audacious_remote_stop(proxy);
491	}	493	}
492	else if (xmms_running)	494	else if (xmms_running)
493	xmms_remote_play(xmms_session);	495	audacious_remote_play(proxy);
494	else	496	else
495	xmms_start_func();	497	xmms_start_func();
496	break;	498	break;
Lines 811-826 Link Here
811	static GkrellmPiximage *bg_scroll_image;	813	static GkrellmPiximage *bg_scroll_image;
812		814
813	if (first_create) {	815	if (first_create) {
814	xmms_running = xmms_remote_is_running(xmms_session);	816	xmms_running = audacious_remote_is_running(proxy);
815	if (auto_main_close && xmms_running)	817	if (auto_main_close && xmms_running)
816	xmms_remote_main_win_toggle(xmms_session, FALSE);	818	audacious_remote_main_win_toggle(proxy, FALSE);
817	if (xmms_autostart && !xmms_running) xmms_start_func();	819	if (xmms_autostart && !xmms_running) xmms_start_func();
818		820	pl_init();
819	pl_init();
820	control_panel = gkrellm_panel_new0();	821	control_panel = gkrellm_panel_new0();
821	} else {	822	} else {
822	update_playlist();	823	update_playlist();
823	}	824	}
824		825
825	style = gkrellm_meter_style(DEFAULT_STYLE);	826	style = gkrellm_meter_style(DEFAULT_STYLE);
826	if (scroll_style) g_free(scroll_style);	827	if (scroll_style) g_free(scroll_style);
Lines 860-866 Link Here
860		861
861	if (scrolling_tooltip == NULL) {	862	if (scrolling_tooltip == NULL) {
862	scrolling_tooltip = gtk_tooltips_new();	863	scrolling_tooltip = gtk_tooltips_new();
863	scrolling_tooltip_text = g_strdup("xmms");	864	scrolling_tooltip_text = g_strdup("audacious");
864	gtk_tooltips_set_tip(scrolling_tooltip, scroll_panel->drawing_area,	865	gtk_tooltips_set_tip(scrolling_tooltip, scroll_panel->drawing_area,
865	scrolling_tooltip_text, NULL);	866	scrolling_tooltip_text, NULL);
866	gtk_tooltips_set_delay(scrolling_tooltip, 750);	867	gtk_tooltips_set_delay(scrolling_tooltip, 750);
Lines 874-880 Link Here
874	gkrellm_set_krell_full_scale(time_krell, 100, 1);	875	gkrellm_set_krell_full_scale(time_krell, 100, 1);
875		876
876	m = gkrellm_get_style_margins(style);	877	m = gkrellm_get_style_margins(style);
877	w = gkrellm_gdk_string_width(ts->font, "-000:00");	878	w = gkrellm_gdk_string_width(ts->font, "-000:00xxx");
878	xmms_decal = gkrellm_create_decal_text(control_panel, (gchar *) "A0", ts,	879	xmms_decal = gkrellm_create_decal_text(control_panel, (gchar *) "A0", ts,
879	style, -1, -1, w);	880	style, -1, -1, w);
880	xmms_decal->x += m->left;	881	xmms_decal->x += m->left;
Lines 973-979 Link Here
973	void mainwin_back_func()	974	void mainwin_back_func()
974	{	975	{
975	if (auto_main_close && xmms_running)	976	if (auto_main_close && xmms_running)
976	xmms_remote_main_win_toggle(xmms_session, TRUE);	977	audacious_remote_main_win_toggle(proxy, TRUE);
977	}	978	}
978		979
979	static GkrellmMonitor plugin_mon =	980	static GkrellmMonitor plugin_mon =
Lines 1007-1012 Link Here
1007	GkrellmMonitor *	1008	GkrellmMonitor *
1008	gkrellm_init_plugin(void) {	1009	gkrellm_init_plugin(void) {
1009	gchar *tmp;	1010	gchar *tmp;
		1011	GError *error = NULL;
		1012	static DBusGConnection *connection = NULL;
1010		1013
1011	#ifdef ENABLE_NLS	1014	#ifdef ENABLE_NLS
1012	bind_textdomain_codeset(PACKAGE, "UTF-8");	1015	bind_textdomain_codeset(PACKAGE, "UTF-8");
Lines 1016-1021 Link Here
1016	running_factory = options_menu_factory(1);	1019	running_factory = options_menu_factory(1);
1017	not_running_factory = options_menu_factory(0);	1020	not_running_factory = options_menu_factory(0);
1018		1021
		1022
		1023
		1024	connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
		1025
		1026	proxy = dbus_g_proxy_new_for_name(connection, AUDACIOUS_DBUS_SERVICE,
		1027	AUDACIOUS_DBUS_PATH,
		1028	AUDACIOUS_DBUS_INTERFACE);
		1029
1019	/* Default settings */	1030	/* Default settings */
1020	control_panel = NULL;	1031	control_panel = NULL;
1021	xmms_running = FALSE;	1032	xmms_running = FALSE;
Lines 1033-1048 Link Here
1033		1044
1034	playlist_dir = g_strdup(gkrellm_homedir());	1045	playlist_dir = g_strdup(gkrellm_homedir());
1035	files_directory = g_strdup("/");	1046	files_directory = g_strdup("/");
1036	gkrellmms_label = g_strdup("xmms");	1047	gkrellmms_label = g_strdup("audacious");
1037	xmms_session = 0;
1038	scroll_enable = TRUE;	1048	scroll_enable = TRUE;
1039	scroll_separator = g_strdup(SCROLL_SEPARATOR);	1049	scroll_separator = g_strdup(SCROLL_SEPARATOR);
1040	draw_time = 1;	1050	draw_time = 1;
1041	#ifdef USE_BMP	1051	xmms_exec_command = g_strdup("audacious");
1042	xmms_exec_command = g_strdup("beep-media-player");
1043	#else
1044	xmms_exec_command = g_strdup("xmms");
1045	#endif
1046	xmms_autostart = 0;	1052	xmms_autostart = 0;
1047	auto_main_close = 0;	1053	auto_main_close = 0;
1048	auto_hide_all = 0;	1054	auto_hide_all = 0;

Lines 25-35 Link Here

(-)../gkrellmms/gkrellmms.h (-6 / +5 lines)
25	#include <time.h>	25	#include <time.h>
26	#include <gkrellm2/gkrellm.h>	26	#include <gkrellm2/gkrellm.h>
27		27
28	#ifdef USE_BMP	28	#include <audacious/audctrl.h>
29	#include <bmp/beepctrl.h>	29	#include <audacious/dbus.h>
30	#else	30
31	#include <xmms/xmmsctrl.h>
32	#endif
33		31
34	#include "playlist.h"	32	#include "playlist.h"
35	/* You can change these ones, but at your own risk.	33	/* You can change these ones, but at your own risk.
Lines 105-110 Link Here
105		103
106		104
107	/* Very global vars */	105	/* Very global vars */
		106	extern DBusGProxy* proxy;
		107
108	GtkItemFactory *running_factory;	108	GtkItemFactory *running_factory;
109	GtkItemFactory *not_running_factory;	109	GtkItemFactory *not_running_factory;
110		110
Lines 120-126 Link Here
120	gchar *scroll_separator;	120	gchar *scroll_separator;
121	gint scroll_enable;	121	gint scroll_enable;
122	gint enable_buttonbar;	122	gint enable_buttonbar;
123	gint xmms_session;
124	gint xmms_autostart;	123	gint xmms_autostart;
125	gint auto_main_close;	124	gint auto_main_close;
126	gint auto_hide_all;	125	gint auto_hide_all;

Lines 8-31 Link Here

(-)../gkrellmms/Makefile (-13 / +7 lines)
8	IMLIB_INCLUDE ?=	8	IMLIB_INCLUDE ?=
9	IMLIB_LIB ?=	9	IMLIB_LIB ?=
10		10
11	ifdef USE_BMP	11	XMMS_INCLUDE ?= `pkg-config audacious --cflags`
12	XMMS_INCLUDE ?= `pkg-config bmp --cflags`	12	XMMS_LIB ?= `pkg-config audacious --libs`
13	XMMS_LIB ?= `pkg-config bmp --libs`	13
14	else	14	DBUS_INCLUDE ?= `pkg-config dbus-1 --cflags`
15	XMMS_INCLUDE ?= `xmms-config --cflags`	15	DBUS_LIB ?= `pkg-config dbus-1 --libs`
16	XMMS_LIB ?= `xmms-config --libs`
17	endif
18		16
19	PLUGIN_DIR ?= /usr/local/lib/gkrellm2/plugins	17	PLUGIN_DIR ?= /usr/local/lib/gkrellm2/plugins
20		18
21	FLAGS = -O2 -Wall -fPIC $(GTK_INCLUDE) $(IMLIB_INCLUDE) $(XMMS_INCLUDE)	19	FLAGS = -O2 -Wall -fPIC $(GTK_INCLUDE) $(IMLIB_INCLUDE) $(DBUS_INCLUDE) $(XMMS_INCLUDE)
22	LIBS = $(GTK_LIB) $(IMLIB_LIB) $(XMMS_LIB)	20	LIBS = $(GTK_LIB) $(IMLIB_LIB) $(DBUS_LIB) $(XMMS_LIB)
23	LFLAGS = -shared -lpthread	21	LFLAGS = -shared -lpthread
24		22
25	ifdef USE_BMP
26	FLAGS += -DUSE_BMP
27	endif
28
29	LOCALEDIR ?= /usr/share/locale	23	LOCALEDIR ?= /usr/share/locale
30	ifeq ($(enable_nls),1)	24	ifeq ($(enable_nls),1)
31	FLAGS += -DENABLE_NLS -DLOCALEDIR=\"$(LOCALEDIR)\"	25	FLAGS += -DENABLE_NLS -DLOCALEDIR=\"$(LOCALEDIR)\"