Exemple #1
0
void
quit()
{
    debug_printf ("Quitting.\n");

    prefs_set_stream_prefs (&g_rmo, "stream defaults");
    prefs_set_wstreamripper_prefs (&g_gui_prefs);
    prefs_save ();

    CloseHandle (m_hpipe_exe_read);
    CloseHandle (m_hpipe_exe_write);

    if (m_bRipping)
	rip_manager_stop (m_rmi);

    rip_manager_cleanup ();

    debug_printf ("Going to render_destroy()...\n");
    render_destroy();
    debug_printf ("Going to DestroyWindow()...\n");
    DestroyWindow(m_hwnd);
    Shell_NotifyIcon(NIM_DELETE, &m_nid);
    DestroyIcon(m_nid.hIcon);
    debug_printf ("Going to UnregisterClass()...\n");
    UnregisterClass(m_szWindowClass, m_hinstance); // unregister window class
    debug_printf ("Finished UnregisterClass()\n");
}
Exemple #2
0
static void dump_pref_file(void (*dump)(ang_file *), const char *title, int row)
{
	char ftmp[80];
	char buf[1024];

	screen_save();

	/* Prompt */
	prt(format("%s to a pref file", title), row, 0);
	
	/* Prompt */
	prt("File: ", row + 2, 0);
	
	/* Default filename */
	strnfmt(ftmp, sizeof ftmp, "%s.prf", op_ptr.base_name);
	
	/* Get a filename */
	if (askfor_aux(ftmp, sizeof ftmp, null))
	{
		/* Build the filename */
		path_build(buf, sizeof(buf), ANGBAND_DIR_USER, ftmp);
	
		prt("", 0, 0);
		if (prefs_save(buf, dump, title))
			msg("Dumped %s", strstr(title, " ") + 1);
		else
			msg("Failed");
	}

	screen_load();

	return;
}
/**
 * Save the game
 */
void save_game(void)
{
	char name[80];
	char path[1024];

	/* Disturb the player */
	disturb(player, 1);

	/* Clear messages */
	event_signal(EVENT_MESSAGE_FLUSH);

	/* Handle stuff */
	handle_stuff(player);

	/* Message */
	prt("Saving game...", 0, 0);

	/* Refresh */
	Term_fresh();

	/* The player is not dead */
	my_strcpy(player->died_from, "(saved)", sizeof(player->died_from));

	/* Forbid suspend */
	signals_ignore_tstp();

	/* Save the player */
	if (savefile_save(savefile))
		prt("Saving game... done.", 0, 0);
	else
		prt("Saving game... failed!", 0, 0);

	/* Refresh */
	Term_fresh();

	/* Save the window prefs */
	strnfmt(name, sizeof(name), "%s.prf", player_safe_name(player, TRUE));
	path_build(path, sizeof(path), ANGBAND_DIR_USER, name);
	if (!prefs_save(path, option_dump, "Dump window settings"))
		prt("Failed to save subwindow preferences", 0, 0);

	/* Allow suspend again */
	signals_handle_tstp();

	/* Refresh */
	Term_fresh();

	/* Note that the player is not dead */
	my_strcpy(player->died_from, "(alive and well)", sizeof(player->died_from));
}
Exemple #4
0
static gint
prefs_respond(GtkWidget *widget, 
                   gint       response_id,
                   gpointer   data)
{
  if (   response_id == GTK_RESPONSE_APPLY 
      || response_id == GTK_RESPONSE_OK) {
    prefs_update_prefs_from_dialog();
    prefs_save();
    diagram_redraw_all();
  }

  if (response_id != GTK_RESPONSE_APPLY)
    gtk_widget_hide(widget);

  return 0;
}
Exemple #5
0
static void dump_pref_file(void (*dump)(ang_file *), const char *title, int row)
{
	char buf[1024];

	/* Get filename from user */
	if (!get_pref_path(title, row, buf, sizeof(buf)))
		return;

	/* Try to save */
	if (prefs_save(buf, dump, title))
		msg("Saved %s.", strstr(title, " ") + 1);
	else
		msg("Failed to save %s.", strstr(title, " ") + 1);

	event_signal(EVENT_MESSAGE_FLUSH);

	return;
}
Exemple #6
0
int
init ()
{
    WNDCLASS wc;
    char* sr_debug_env;
    int rc;

    sr_debug_env = getenv ("STREAMRIPPER_DEBUG");
    if (sr_debug_env) {
	debug_enable();
	debug_set_filename (sr_debug_env);
    }

    winamp_init (m_hinstance);

    rc = prefs_load ();
    prefs_get_stream_prefs (&g_rmo, "");
    if (rc == 0) {
	options_get_desktop_folder (g_rmo.output_directory);
    }
    prefs_get_wstreamripper_prefs (&g_gui_prefs);
    prefs_save ();

    /* GCS FIX */
    //m_guiOpt.m_enabled = 1;
    //debug_printf ("Checking if enabled.\n");
    //if (!m_guiOpt.m_enabled)
    //	return 0;
    //debug_printf ("Was enabled.\n");

    memset (&wc,0,sizeof(wc));
    wc.lpfnWndProc = WndProc;			// our window procedure
    wc.hInstance = m_hinstance;
    wc.lpszClassName = m_szWindowClass;		// our window class name
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);

    // Load systray popup menu
    m_hmenu_systray = LoadMenu (m_hinstance, MAKEINTRESOURCE(IDR_TASKBAR_POPUP));
    m_hmenu_systray_sub = GetSubMenu (m_hmenu_systray, 0);
    SetMenuDefaultItem (m_hmenu_systray_sub, 0, TRUE);

    if (!RegisterClass(&wc)) {
	MessageBox (NULL,"Error registering window class","blah",MB_OK);
	return 1;
    }

    /* Ref: http://msdn2.microsoft.com/en-us/library/bb776822.aspx */
    if (g_running_standalone) {
	m_hwnd = CreateWindowEx (
			WS_EX_APPWINDOW,
			m_szWindowClass, "Streamripper Plugin", WS_POPUP,
			g_gui_prefs.oldpos_x, g_gui_prefs.oldpos_y, WINDOW_WIDTH, WINDOW_HEIGHT, 
			NULL, NULL, m_hinstance, NULL);
    } else {
	m_hwnd = CreateWindowEx (
			WS_EX_TOOLWINDOW,
			m_szWindowClass, "Streamripper Plugin", WS_POPUP,
			g_gui_prefs.oldpos_x, g_gui_prefs.oldpos_y, WINDOW_WIDTH, WINDOW_HEIGHT, 
			NULL, NULL, m_hinstance, NULL);
    }

    // Create a systray icon
    memset(&m_nid, 0, sizeof(NOTIFYICONDATA));
    m_nid.cbSize = sizeof(NOTIFYICONDATA);
    m_nid.hIcon = LoadImage(m_hinstance, MAKEINTRESOURCE(IDI_SR_ICON), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
    m_nid.hWnd = m_hwnd;
    strcpy(m_nid.szTip, m_szToopTip);
    m_nid.uCallbackMessage = WM_MY_TRAY_NOTIFICATION;
    m_nid.uFlags =  NIF_MESSAGE | NIF_ICON | NIF_TIP;
    m_nid.uID = 1;
    Shell_NotifyIcon(NIM_ADD, &m_nid);

    // Load main popup menu 
    m_hmenu_context = LoadMenu (m_hinstance, MAKEINTRESOURCE(IDR_HISTORY_POPUP));
    m_hmenu_context_sub = GetSubMenu (m_hmenu_context, 0);
    SetMenuDefaultItem (m_hmenu_context_sub, 0, TRUE);

    // Populate main popup menu
    populate_history_popup ();

    if (!g_gui_prefs.m_start_minimized)
	dock_show_window(m_hwnd, SW_SHOWNORMAL);
    else
	dock_show_window(m_hwnd, SW_HIDE);
	
    return 0;
}
Exemple #7
0
gboolean
app_exit(void)
{
  GList *list;
  GSList *slist;

  /*
   * The following "solves" a crash related to a second call of app_exit,
   * after gtk_main_quit was called. It may be a win32 gtk-1.3.x bug only
   * but the check shouldn't hurt on *ix either.          --hb
   */
  static gboolean app_exit_once = FALSE;

  if (app_exit_once) {
    g_error(_("This shouldn't happen.  Please file a bug report at bugzilla.gnome.org\n"
	      "describing how you caused this message to appear.\n"));
    return FALSE;
  }

  if (diagram_modified_exists()) {
    if (is_integrated_ui ())
    {
      GtkWidget                *dialog;
      int                       result;
      exit_dialog_item_array_t *items  = NULL;
      GList *                   list; 
      Diagram *                 diagram;
      
      dialog = exit_dialog_make (GTK_WINDOW (interface_get_toolbox_shell ()), 
                                _("Exiting Dia"));

      list = dia_open_diagrams();
      while (list)
      {
        diagram = list->data;

        if (diagram_is_modified (diagram))
        {
          const gchar * name = diagram_get_name (diagram);
          const gchar * path = diagram->filename;
          exit_dialog_add_item (dialog, name, path, diagram);
        }

        list = g_list_next (list);
      }

      result = exit_dialog_run (dialog, &items);
  
      gtk_widget_destroy (dialog);

      if (result == EXIT_DIALOG_EXIT_CANCEL)
      {
        return FALSE;
      }
      else if (result == EXIT_DIALOG_EXIT_SAVE_SELECTED)
      {
	    DiaContext *ctx = dia_context_new(_("Save"));
        int i;
        for (i = 0 ; i < items->array_size ; i++) {
	  gchar *filename;

	  diagram  = items->array[i].data;
	  filename = g_filename_from_utf8 (diagram->filename, -1, NULL, NULL, NULL);
	  diagram_update_extents (diagram);
	  dia_context_set_filename (ctx, filename);
	  if (!diagram_save (diagram, filename, ctx)) {
	    exit_dialog_free_items (items);
	    dia_context_release (ctx);
	    return FALSE;
	  } else {
	    dia_context_reset (ctx);
	  }
	  g_free (filename);
	}
	dia_context_release (ctx);
	exit_dialog_free_items (items);
      } 
      else if (result == EXIT_DIALOG_EXIT_NO_SAVE) 
      {
        list = dia_open_diagrams();
        while (list) {
          diagram = list->data;

	  /* slight hack: don't ask again */
          diagram_set_modified (diagram, FALSE);
	  undo_clear(diagram->undo);
          list = g_list_next (list);
	}
      }
    }
    else
    {
    GtkWidget *dialog;
    GtkWidget *button;
    dialog = gtk_message_dialog_new(
	       NULL, GTK_DIALOG_MODAL,
               GTK_MESSAGE_QUESTION,
               GTK_BUTTONS_NONE, /* no standard buttons */
	       _("Quitting without saving modified diagrams"));
    gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
		 _("Modified diagrams exist. "
		 "Are you sure you want to quit Dia "
 		 "without saving them?"));

    gtk_window_set_title (GTK_WINDOW(dialog), _("Quit Dia"));
  
    button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
    gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_CANCEL);
#if GTK_CHECK_VERSION(2,18,0)
    gtk_widget_set_can_default (GTK_WIDGET (button), TRUE);
#else
    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
#endif
    gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);

    button = gtk_button_new_from_stock (GTK_STOCK_QUIT);
    gtk_dialog_add_action_widget (GTK_DIALOG(dialog), button, GTK_RESPONSE_OK);

    gtk_widget_show_all (dialog);

    if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
      gtk_widget_destroy(dialog);
      return FALSE;
    }
    gtk_widget_destroy(dialog);
    }
  }
  prefs_save();

  persistence_save();

  dynobj_refresh_finish();

  {
    DiaContext *ctx = dia_context_new (_("Exit"));
    dia_object_defaults_save (NULL, ctx);
    dia_context_release (ctx);
  }
  /* Free loads of stuff (toolbox) */

  list = dia_open_diagrams();
  while (list!=NULL) {
    Diagram *dia = (Diagram *)list->data;
    list = g_list_next(list);

    slist = dia->displays;
    while (slist!=NULL) {
      DDisplay *ddisp = (DDisplay *)slist->data;
      slist = g_slist_next(slist);

      gtk_widget_destroy(ddisp->shell);
    }
    /* The diagram is freed when the last display is destroyed */
  }
  
  /* save pluginrc */
  if (dia_is_interactive)
    dia_pluginrc_write();

  gtk_main_quit();

  /* This printf seems to prevent a race condition with unrefs. */
  /* Yuck.  -Lars */
  /* Trying to live without it. -Lars 10/8/07*/
  /* g_print(_("Thank you for using Dia.\n")); */
  app_exit_once = TRUE;

  return TRUE;
}
Exemple #8
0
int main(int argc, char **argv)
{
    const char *device_param = default_pcm_device;
    char *prefsdir;
    char thefile[1024];
    char str[1024];
    float start_vol = 1.0;
    int ap_result = 0;
    int use_fragsize = -1; // Initialized
    int use_fragcount = -1; // later
    int do_loopsong = 0;
    int do_looplist = 0;
    int do_enqueue = 0;
    int do_replace = 0;
    int do_realtime = 0;
    int do_remote_control = 0;
    int do_shuffle = 0;
    int do_start = 0;
    int do_stop = 0;
    int do_prev = 0;
    int do_next = 0;
    int do_pause = 0;
    int do_jump = -1;
    int do_clear = 0;
    int do_seek = -1;
    int do_relative = 0;
    int do_setvol = 0;
    int do_quit = 0;
    int do_status = 0;
    int do_speed = 0;
    float speed_val = 0.0;
    int do_onebyone = 0;

    int use_freq = OUTPUT_RATE;
    float use_vol = 1.0;
    int use_session = 0;
    int do_crossfade = 0;
    int do_save = 1;
    int bool_val = 0;
    const char *use_output = NULL;
    char *use_interface = NULL;
    char *use_config = NULL;
    char *use_loopsong = NULL;
    char *use_onebyone = NULL;
    char *use_looplist = NULL;

    int opt;
    int option_index;
    const char *options = "Cc:d:eEf:F:g:hi:J:I:l:n:NMp:qrs:vRSQVxo:";
    struct option long_options[] = {
        /*	{ "long_option", take_argument, 0, 'short_option' }, */
        { "config", 1, 0, 'c' },
        { "device", 1, 0, 'd' },
        { "enqueue", 0, 0, 'e' },
        { "replace", 0, 0, 'E' },
        { "fragsize", 1, 0, 'f' },
        { "frequency", 1, 0, 'F' },
        { "fragcount", 1, 0, 'g' },
        { "help", 0, 0, 'h' },
        { "interface", 1, 0, 'i' },
        { "volume", 1, 0, 'Y' },
        { "session", 1, 0, 'n' },
        { "nosave", 0, 0, 'N' },
        { "path", 1, 0, 'p' },
        { "quiet", 0, 0, 'q' },
        { "realtime", 0, 0, 'r' },
        { "script", 1, 0, 'I'},
        { "session-name", 1, 0, 's' },
        { "version", 0, 0, 'v' },
        { "verbose", 0, 0, 'V' },
        { "reverb", 0, 0, 'R' },
        { "loopsong", 1, 0, 'L' },
        { "looplist", 1, 0, 'P' },
        { "crossfade", 0, 0, 'x' },
        { "output", 1, 0, 'o' },
        { "stop", 0, 0, 'U' },
        { "pause", 0, 0, 'O' },
        { "start", 0, 0, 'T' },
        { "shuffle", 0, 0, 'S' },
        { "prev", 0, 0, 'Q' },
        { "next", 0, 0, 'M' },
        { "jump", 1, 0, 'J' },
        { "seek", 1, 0, 'X' },
        { "relative", 1, 0, 'Z' },
        { "speed", 1, 0, 'H' },
        { "clear", 0, 0, 'C' },
        { "startvolume", 1, 0, 'l' },
        { "quit", 0, 0, 'A' },
        { "status", 0, 0, 'B' },
        { "onebyone", 1, 0, 't' },

        // Options that we want to be able to pass on to gtk_init(). See man
        // gtk-options(7).
        // Give all of these an option number of 128 because we're going to
        // ignore them option switch statement anyway.
        { "gtk-module", 1, 0, 128 },
        { "gtk-debug", 1, 0, 128 },
        { "gtk-no-debug", 1, 0, 128 },
        { "g-fatal-warnings", 0, 0, 128 },

        { "display", 1, 0, 128 },
        { "screen", 1, 0, 128 },
        { "sync", 0, 0, 128 },
        { "no-xshm", 0, 0, 128 },
        { "name", 1, 0, 128 },
        { "class", 1, 0, 128 },
        { "gxid_host", 1, 0, 128 },
        { "gxid_port", 1, 0, 128 },
        { "xim-preedit", 0, 0, 128 },
        { "xim-status", 0, 0, 128 },
        { "gdk-debug", 1, 0, 128 },
        { "gdk-no-debug", 1, 0, 128 },

        // End of list marker.
        { 0, 0, 0, 0 }
    };


    // First setup signal handler
    signal(SIGPIPE, nonfatal_sighandler);   // PIPE (socket control)
    signal(SIGTERM, exit_sighandler);	// kill
    signal(SIGHUP, exit_sighandler);	// kill -HUP / xterm closed
    signal(SIGINT, exit_sighandler);	// Interrupt from keyboard
    signal(SIGQUIT, exit_sighandler);	// Quit from keyboard
    // fatal errors
    signal(SIGBUS, exit_sighandler);	// bus error
    //signal(SIGSEGV, exit_sighandler);	// segfault
    signal(SIGILL, exit_sighandler);	// illegal instruction
    signal(SIGFPE, exit_sighandler);	// floating point exc.
    signal(SIGABRT, exit_sighandler);	// abort()

    // Enable locale support
#ifdef ENABLE_NLS
    setlocale (LC_ALL, "");
    bindtextdomain(PACKAGE, LOCALEDIR);
    textdomain(PACKAGE);
    bind_textdomain_codeset (PACKAGE, "UTF-8");
#endif

    // Init global mutexes
    pthread_mutex_init(&playlist_sort_seq_mutex, NULL);
#if !defined(EMBEDDED)
    init_effects();
#endif
    while ((opt = getopt_long(argc, argv, options, long_options, &option_index)) != EOF) {
        switch(opt) {
        case 'A':
            do_remote_control = 1;
            do_quit = 1;
            break;
        case 'B':
            do_remote_control = 1;
            do_status = 1;
            break;
        case 'c':
            if (strlen(optarg) < 1023) {
                use_config = optarg;
            } else {
                alsaplayer_error("config file path too long");
                return 1;
            }
            break;
        case 'd':
            device_param = optarg;
            break;
        case 'E':
            do_replace = 1;
        case 'e':
            do_enqueue = 1;
            break;
        case 'f':
            use_fragsize = atoi(optarg);
            if (!use_fragsize) {
                alsaplayer_error("invalid fragment size");
                return 1;
            }
            if (use_fragsize > 32768) {
                alsaplayer_error("fragment size (%d) out of range (0-32768)", use_fragsize);
                return 1;
            }
            break;
        case 'F':
            use_freq = atoi(optarg);
            if (use_freq < 8000 || use_freq > 48000) {
                alsaplayer_error("frequency (%d) out of range (8000-48000)", use_freq);
                return 1;
            }
            break;
        case 'g':
            use_fragcount = atoi(optarg);
            if (use_fragcount < 2 || use_fragcount > 128) {
                alsaplayer_error("fragcount (%d) out of range (2-128)", use_fragcount);
                return 1;
            }
            break;
        case 'h':
            help();
            return 0;
        case 'H':
            if ((sscanf(optarg, "%f", &speed_val))) {
                do_remote_control = 1;
                do_speed = 1;
            }
            break;
        case 'i':
            use_interface = optarg;
            break;
        case 'l':
            start_vol = atof(optarg);
            if (start_vol < 0.0 || start_vol > 1.0) {
                alsaplayer_error("volume (%.3f) out of range: using 1.0", start_vol);
                start_vol = 1.0;
            }
            break;
        case 'L':
            do_remote_control = 1;
            do_loopsong = 1;
            use_loopsong = optarg;
            break;
        case 'Y':
            do_remote_control = 1;
            do_setvol = 1;
            use_vol = atof(optarg);
            if (use_vol < 0.0 || use_vol > 1.0) {
                alsaplayer_error("volume (%.3f) out of range: using 1.0", use_vol);
                use_vol = 1.0;
            }
            break;
        case 'n':
            use_session = atoi(optarg);
            break;
        case 'N':
            do_save = 0;
            break;
        case 'O':
            do_remote_control = 1;
            do_pause = 1;
            break;
        case 'p':
            global_pluginroot = optarg;
            break;
        case 'q':
            global_quiet = 1;
            break;
        case 'r':
            do_realtime = 1;
            break;
        case 's':
            if (strlen(optarg) < 32) {
                global_session_name = strdup(optarg);
            } else {
                alsaplayer_error("max 32 char session name, ignoring");
            }
            break;
        case 'v':
            version();
            return 0;
        case 'V':
            global_verbose = 1;
            break;
        case 'R':
            break;
        case 'P':
            do_remote_control = 1;
            do_looplist = 1;
            use_looplist = optarg;
            break;
        case 'x':
            do_crossfade = 1;
            break;
        case 'o':
            use_output = optarg;
            break;
        case '?':
            return 1;
        case 'I':
            global_interface_script = optarg;
            break;
        case 'U':
            do_remote_control = 1;
            do_stop = 1;
            break;
        case 'T':
            do_remote_control = 1;
            do_start = 1;
            break;
        case 'S':
            do_remote_control = 1;
            do_shuffle = 1;
            break;
        case 'Q':
            do_remote_control = 1;
            do_prev = 1;
            break;
        case 'M':
            do_remote_control = 1;
            do_next = 1;
            break;
        case 'J':
            do_remote_control = 1;
            do_jump = atoi(optarg);
            break;
        case 'C':
            do_remote_control = 1;
            do_clear = 1;
            break;
        case 'X':
            do_remote_control = 1;
            do_seek = atoi(optarg);
            break;
        case 'Z':
            do_remote_control = 1;
            do_relative = 1;
            do_seek = atoi(optarg);
            break;
        case 't':
            do_remote_control = 1;
            do_onebyone = 1;
            use_onebyone = optarg;
            break;
        case 128:
            // Gtk-option which we ignore.
            break;
        default:
            alsaplayer_error("Unknown option '%c'", opt);
            break;
        }
    }

    prefsdir = get_prefsdir();

    mkdir(prefsdir, 0700);	/* XXX We don't do any error checking here */
    snprintf(thefile, sizeof(thefile)-21, "%s/config", prefsdir);
    if (use_config)
        ap_prefs = prefs_load(use_config);
    else
        ap_prefs = prefs_load(thefile);
    if (!ap_prefs) {
        alsaplayer_error("Invalid config file %s\n", use_config ? use_config : thefile);
        return 1;
    }
    /* Initialize some settings (and populate the prefs system if needed */

    if (use_fragsize < 0)
        use_fragsize = prefs_get_int(ap_prefs, "main", "period_size", 4096);
    if (use_fragcount < 0)
        use_fragcount = prefs_get_int(ap_prefs, "main", "period_count", 8);


    if (global_verbose)
        puts(copyright_string);

    if (!global_pluginroot) {
        global_pluginroot = strdup (ADDON_DIR);
    }


    if (use_session == 0) {
        for (; use_session < MAX_REMOTE_SESSIONS+1; use_session++) {
            ap_result = ap_session_running(use_session);

            if (ap_result)
                break;
        }
        if (use_session == (MAX_REMOTE_SESSIONS+1)) {
            //alsaplayer_error("No remote session found");
            if (do_remote_control) {
                alsaplayer_error("No active sessions");
                return 1;
            }
            do_enqueue = 0;
        } else {
            //alsaplayer_error("Found session %d", use_session);
            if (prefs_get_bool(ap_prefs, "main", "multiopen", 1) == 0) {
                // We should not spawn another alsaplayer
                //alsaplayer_error("Using session %d, not doing multiopen", use_session);
                do_enqueue = 1;
                do_replace = 1;
            }
        }
    }

    // Check if we're in remote control mode
    if (do_remote_control) {
        if (do_quit) {
            ap_quit(use_session);
            return 0;
        } else if (do_status) {
            char res[1024];
            float fres;
            int ires;
            fprintf(stdout, "---------------- Session ----------------\n");
            if (ap_get_session_name(use_session, res) && strlen(res))
                fprintf(stdout, "name: %s\n", res);
            if (ap_get_playlist_length(use_session, &ires))
                fprintf(stdout, "playlist_length: %d\n", ires);
            if (ap_get_volume(use_session, &fres))
                fprintf(stdout, "volume: %.2f\n", fres);
            if (ap_get_speed(use_session, &fres))
                fprintf(stdout, "speed: %d%%\n", (int)(fres * 100));
            fprintf(stdout, "-------------- Current Track ------------\n");
            if (ap_get_artist(use_session, res) && strlen(res))
                fprintf(stdout, "artist: %s\n", res);
            if (ap_get_title(use_session, res) && strlen(res))
                fprintf(stdout, "title: %s\n", res);
            if (ap_get_album(use_session, res) && strlen(res))
                fprintf(stdout, "album: %s\n", res);
            if (ap_get_genre(use_session, res) && strlen(res))
                fprintf(stdout, "genre: %s\n", res);
            if (ap_get_file_path(use_session, res) && strlen(res))
                fprintf(stdout, "path: %s\n", res);
            if (ap_get_blocks(use_session, &ires))
                fprintf(stdout, "blocks: %d\n", ires);
            if (ap_get_length(use_session, &ires))
                fprintf(stdout, "length: %d second%s\n", ires, (ires == 1) ? "": "s");
            if (ap_get_position(use_session, &ires))
                fprintf(stdout, "position: %d\n", ires);
            fprintf(stdout, "-----------------------------------------\n");
            return 0;
        } else if (do_setvol) {
            ap_set_volume(use_session, use_vol);
            return 0;
        } else if (do_shuffle) {
            ap_shuffle_playlist(use_session);
            return 0;
        } else if (do_start) {
            ap_play(use_session);
            return 0;
        } else if (do_stop) {
            ap_stop(use_session);
            return 0;
        } else if (do_pause) {
            if (ap_is_paused(use_session, &bool_val)) {
                if (bool_val)
                    ap_unpause(use_session);
                else
                    ap_pause(use_session);
            }
            return 0;
        } else if (do_next) {
            ap_next(use_session);
            return 0;
        } else if (do_prev) {
            ap_prev(use_session);
            return 0;
        } else if (do_jump >= 0) {
            ap_jump_to(use_session, do_jump);
            return 0;
        } else if (do_clear) {
            ap_clear_playlist(use_session);
            return 0;
        } else if (do_relative) {
            if (do_seek != 0)
                ap_set_position_relative(use_session, do_seek);
            return 0;
        } else if (do_speed) {
            if (speed_val < -10.0 || speed_val > 10.0) {
                alsaplayer_error("Speed out of range, must be between -10.00 and 10.00");
                return 1;
            }
            ap_set_speed(use_session, speed_val);
            return 0;
        } else if (do_seek >= 0) {
            ap_set_position(use_session, do_seek);
            return 0;
        } else if (do_loopsong) {
            if (strcasecmp(use_loopsong, "on") != 0) {
                do_loopsong = false;
            }
            ap_set_looping(use_session, do_loopsong);
            return 0;
        } else if (do_onebyone) {
            if (strcasecmp(use_onebyone, "on") != 0) {
                do_onebyone = false;
            }
            ap_set_onebyone(use_session, do_onebyone);
            return 0;
        } else if (do_looplist) {
            if (strcasecmp(use_looplist, "on") != 0) {
                do_looplist = false;
            }
            ap_set_playlist_looping(use_session, do_looplist);
            return 0;
        } else
            alsaplayer_error("No remote control command executed.");
    }


    // Check if we need to enqueue the files
    if (do_enqueue) {
        char queue_name[2048];
        int count = 0;
        int was_playing = 0;
        int playlist_length = 0;

        count = optind;
        ap_result = 1;

        if (do_replace && count < argc) {
            ap_is_playing(use_session, &was_playing);
            if (was_playing) {
                ap_stop(use_session);
            }
            ap_clear_playlist(use_session);
        } else {
            ap_get_playlist_length(use_session, &playlist_length);
            if (!playlist_length) { // Empty list so fire up after add
                was_playing = 1;
            }
        }
        while (count < argc && ap_result) {
            if (is_playlist(argv[count])) {
                ap_add_playlist(use_session, argv[count]);
                count++;
                continue;
            }
            if (argv[count][0] != '/' &&
                    strncmp(argv[count], "http://", 7) != 0 &&
                    strncmp(argv[count], "ftp://", 6) != 0) {
                // Not absolute so append cwd
                if (getcwd(queue_name, 1024) == NULL) {
                    alsaplayer_error("error getting cwd");
                    return 1;
                }
                ap_strlcat(queue_name, "/", sizeof(queue_name));
                ap_strlcat(queue_name, argv[count], sizeof(queue_name));
            } else
                ap_strlcpy(queue_name, argv[count], sizeof(queue_name));
            count++;
            //alsaplayer_error("Adding %s", queue_name);
            ap_result = ap_add_path(use_session, queue_name);
            //alsaplayer_error("ap_result = %d", ap_result);
        }
        if (was_playing)
            ap_jump_to(use_session, 1);
        if (ap_result)
            return 0;
    }

    AlsaNode *node;

    // Check if we want jack
    if (strcmp(argv[0], "jackplayer") == 0) {
        use_output = "jack";
    }

    // Check the output option
    if (use_output == NULL) {
        use_output = prefs_get_string(ap_prefs, "main",
                                      "default_output", "alsa");
    }

    // Else do the usual plugin based thing
    node = new AlsaNode(use_output, device_param, do_realtime);

    if (!node->RegisterPlugin(use_output)) {
        alsaplayer_error("Failed to load output plugin \"%s\". Trying defaults.", use_output);
        if (!node->RegisterPlugin())
            return 1;
    }
    int output_is_ok = 0;
    int output_alternate = 0;

    do {
        if (!node || !node->ReadyToRun()) {
            alsaplayer_error
            ("failed to load output plugin (%s). exitting...",
             use_output ? use_output: "alsa,etc.");
            return 1;
        }
        if (!node->SetSamplingRate(use_freq) ||
                !node->SetStreamBuffers(use_fragsize, use_fragcount, 2)) {
            alsaplayer_error
            ("failed to configure output device...trying OSS");
            /* Special case for OSS, since it's easiest to get going, so try it */
            if (!output_alternate) {
                output_alternate = 1;
                node->RegisterPlugin("oss");
                continue;
            } else {
                return 1;
            }
        }
        output_is_ok = 1;	/* output device initialized */
    } while (!output_is_ok);

    // Initialise reader
    reader_init ();

    // Initialise playlist - must be done before things try to register with it
    playlist = new Playlist(node);

    if (!prefs_get_bool(ap_prefs, "main", "play_on_start", false))
        playlist->Pause();
    else
        playlist->UnPause();

    if (!playlist) {
        alsaplayer_error("Failed to create Playlist object");
        return 1;
    }
    // Add any command line arguments to the playlist
    if (optind < argc) {
        std::vector < std::string > newitems;
        while (optind < argc) {
            if (is_playlist(argv[optind])) {
                if (global_verbose)
                    alsaplayer_error("Loading playlist (%s)", argv[optind]);
                playlist->Load(std::string(argv[optind++]),
                               playlist->Length(), false);
            } else {
                newitems.push_back(std::string(argv[optind++]));
            }
        }
        playlist->Insert(newitems, playlist->Length());
    } else {
        prefsdir = get_prefsdir();
        snprintf(thefile, sizeof(thefile)-28, "%s/alsaplayer.m3u", prefsdir);
        playlist->Load(thefile, playlist->Length(), false);
    }

    // Loop song
    if (do_loopsong) {
        playlist->LoopSong();
    }
    // Loop Playlist
    if (do_looplist) {
        playlist->LoopPlaylist();
    }
    // Play songs one by one
    if (do_onebyone) {
        playlist->SetOneByOne();
    }
    // Cross fading
    if (do_crossfade) {
        playlist->Crossfade();
    }
    // Set start volume
    playlist->GetCorePlayer()->SetVolume(start_vol);


    interface_plugin_info_type interface_plugin_info;
    interface_plugin *ui;

    if (get_interface_from_argv0 (argv[0], str))
        use_interface = str;

    if (use_interface && *use_interface) {
        if (!(interface_plugin_info = load_interface(use_interface))) {
            alsaplayer_error("Failed to load interface %s\n", use_interface);
            goto _fatal_err;
        }
    } else {
        const char *interface = prefs_get_string
                                (ap_prefs, "main", "default_interface", "gtk2");
        // if we're trying to use the old gtk-1 interface, use gtk-2 instead
        if (strcmp (interface, "gtk") == 0)
            interface = "gtk2";
        // if we're trying to use the gtk interface, but we have no
        // $DISPLAY, use the text interface instead
        if (strcmp (interface, "gtk2") == 0 && !getenv("DISPLAY"))
            interface = "text";
        if (!(interface_plugin_info = load_interface(interface))) {
            if (!(interface_plugin_info = load_interface(prefs_get_string
                                          (ap_prefs, "main", "fallback_interface", "text")))) {
                alsaplayer_error("Failed to load text interface. This is bad (%s,%s,%s)",
                                 interface, interface,
                                 global_pluginroot);
                goto _fatal_err;
            }
        }
    }
    if (interface_plugin_info) {
        ui = interface_plugin_info();

        if (global_verbose)
            printf("Interface plugin: %s\n", ui->name);
        if (!ui->init()) {
            alsaplayer_error("Failed to load interface plugin. Should fall back to text\n");
        } else {
            control_socket_start(playlist, ui);
            ui->start(playlist, argc, argv);
            ui->close();
            // Unfortunately gtk+ is a pig when it comes to
            // cleaning up its resources; it doesn't!
            // so we can never safely dlclose gtk+ based
            // user interfaces, bah!
            //dlclose(ui->handle);
            control_socket_stop();
        }
    }
    // Save playlist before exit
    prefsdir = get_prefsdir();
    snprintf(thefile, sizeof(thefile)-25, "%s/alsaplayer", prefsdir);
    playlist->Save(thefile, PL_FORMAT_M3U);

    // Save preferences
    if (ap_prefs && do_save) {
        if (prefs_save(ap_prefs) < 0) {
            alsaplayer_error("failed to save preferences.");
        }
    }

_fatal_err:
    delete playlist;
    //delete p;
    delete node;
    if (global_session_name)
        free(global_session_name);

    return 0;
}