~vcs-imports/lince/trunk

/***************************************************************************
 *            main.cc
 *
 *  Copyright  2008  Fernando Tarín Morales
 *  icemanf@gmail.com
 ****************************************************************************/

/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor Boston, MA 02110-1301,  USA
 */

#include <gtkmm/main.h>
#include <glibmmconfig.h>
#include <glibmm/i18n.h>

#include <boost/program_options.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>

#include "../config.h"
#include "Lince/Core.h"
#include "Lince/Utils.h"

#include "Utils.h"
#include "MainWindow.h"
#include "GuiSetupManager.h"

#include <iostream>

using namespace Lince;

bool is_Primary=true;
// This signal will connect the request to add a torrent from another app
// using dbus or from the command line
sigc::signal<void, std::string> sig_to_add_a_torrent_file;
sigc::signal<void, std::string> sig_to_add_a_magnet_link;


class Options : public Glib::OptionGroup
{
public:
	Options();
	~Options();

	bool version, quit;
	std::vector<Glib::ustring> uris;
};

Options::Options()
: Glib::OptionGroup(PACKAGE_NAME, "Command line options"),
	version(false),
	quit(false)
{
	Glib::OptionEntry e_version;
	e_version.set_long_name("version") ;
	e_version.set_description(_("Show version and quit"));
	add_entry(e_version, version);

	Glib::OptionEntry e_remaining;
	e_remaining.set_long_name(G_OPTION_REMAINING);
	add_entry(e_remaining, uris);
}

Options::~Options()
{
}

#if HAVE_DBUS
static DBusConnection* conn;

bool init_dbus()
{
	DBusMessage* msg;
	DBusMessageIter args;
	DBusError err;
	int ret;
	dbus_uint32_t serial = 0;
	
	// initialise the error value
	dbus_error_init(&err);
	
	// connect to the DBUS system bus, and check for errors
	conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
	if (dbus_error_is_set(&err))
	{ 
		std::cerr << "Connection Error (" << err.message << ")" << std::endl;
		dbus_error_free(&err);
	}
	
	if (NULL == conn)
		return false; 
	
	// register our name on the bus, and check for errors
	ret = dbus_bus_request_name(conn, DBUS_NAME_LINCE, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
	if (dbus_error_is_set(&err)) 
	{
		std::cerr << "Connection Error (" << err.message << ")" << std::endl;
		dbus_error_free(&err); 
	}
	
	if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret)
		return false;
	
	return true;
}

bool send_message(Glib::ustring mess)
{
	DBusMessage *msg;
	DBusMessageIter iter;
	const char * message = mess.c_str();

	msg = dbus_message_new_signal(
          	DBUS_PATH_LINCE,
	        DBUS_INTERFACE_LINCE, "SendUri");

	dbus_message_iter_init_append (msg, &iter);
	dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &message);

	if (!dbus_connection_send (conn, msg, NULL))
        	return false;

	dbus_connection_has_messages_to_send(conn);
	dbus_message_unref (msg);
	dbus_connection_flush (conn);

	return true;
}

#else
void set_lockup_file()
{
	boost::filesystem::path p = get_base_directory() / std::string(".lock");
	boost::filesystem::ofstream in(p, std::ios_base::binary);
	in.close();
}

void remove_lockup_file()
{
	boost::filesystem::path p = get_base_directory() / std::string(".lock");
	boost::filesystem::remove(p);
}

bool check_lockup_file()
{
	boost::filesystem::path p = get_base_directory() / std::string(".lock");
	return boost::filesystem::exists(p);
}
#endif

void add_uri(Glib::ustring &uri)
{
	if (Utils::isAMagnetLink(uri))
		sig_to_add_a_magnet_link(uri);
	else
		sig_to_add_a_torrent_file.emit(uri);
}

struct manage_uri : public std::unary_function<void, Glib::ustring>
{
	void operator()(Glib::ustring uri)
	{
		if (!Glib::path_is_absolute(uri) && !Utils::isAMagnetLink(uri))
				uri = Glib::build_filename(Glib::get_current_dir(), uri);

		// Send the files to the primary session.
		if (!is_Primary)
		{
#if HAVE_DBUS
			send_message(uri);
#endif
		}
		// Add the files to the session.
		else
		{
			add_uri(uri);
		}
	}
};

int main(int ac, char* av[]){
	// Set locale translations.
	bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
	textdomain(GETTEXT_PACKAGE);
	
	Gtk::Main kit(ac, av);
	
	if(!Glib::thread_supported()) 
		Glib::thread_init();
	
	Options options;
	//work around for gnomemm bug
	Glib::OptionContext* context = new Glib::OptionContext(
		_("[FILE...] \n\nA BitTorrent client\n"));
	context->set_main_group(options);
	
	try
	{
		context->parse(ac, av);
	}
	catch (const Glib::OptionError& e)
	{
		std::cerr << e.what() << std::endl;
		std::cout << _("Run \"lince --help\" to see a full list of available command line options.\n");
		return 1;
	}
	delete context;
	
	if (options.version)
	{
		std::cout << PACKAGE_VERSION << std::endl;
		return 0;
	}
	
#if HAVE_DBUS
	if (!init_dbus())
	{
		is_Primary = false;
		
		if (!options.uris.empty())
			std::for_each(options.uris.begin(), options.uris.end(), manage_uri());
		else
			Utils::warningDialog(_("Lince is already running"),
							 _("Only one instance of Lince can be executed"));
		return 1;
	}
	
	DBusError error;
	dbus_error_init (&error);

	dbus_bus_add_match (conn, "type='signal', interface='net.p2p.lince.addtorrent'", &error);

	if (dbus_error_is_set(&error))
	{
		std::cerr << "Connection Error (" << error.message << ")" << std::endl;
		dbus_error_free(&error);
	}

#else
	if (check_lockup_file())
	{
		bool ret;
		ret = Utils::askDialog(_("Warning!"),
							   _("Lince is already running"),
							   _("If Lince is not running remove the lock file.\n"
								 "Do you want to remove the lock file?"));
		
		if (ret)
			remove_lockup_file();
			
		return 1;
	}

	// Set that lince is running.
	set_lockup_file();
#endif
		
	Core::init();
	
#if HAVE_DBUS
	MainWindow m(conn);
#else
	MainWindow m;
#endif
	
	// Connect the signal to the proper handler in MainWindow
	sig_to_add_a_torrent_file.connect(sigc::mem_fun(m,
			&MainWindow::load_file_from_request) );

	sig_to_add_a_magnet_link.connect(sigc::mem_fun(m,
			&MainWindow::load_magnet_from_request) );

	if (!options.uris.empty())
		std::for_each(options.uris.begin(), options.uris.end(), manage_uri());
	
	//Gtk::Main::run(m); //Shows the window and returns when it is closed.
	gtk_widget_show_all((GtkWidget*) m.gobj());
 	gtk_main();

	Core::uninit();
	
#if !HAVE_DBUS
	// Remove file lock
	remove_lockup_file();
#endif

	return 0;
}