lyx_mirror/src/frontends/qt2/lyx_gui.C

/**
 * \file qt2/lyx_gui.C
 * This file is part of LyX, the document processor.
 * Licence details can be found in the file COPYING.
 *
 * \author unknown
 * \author John Levon
 *
 * Full author contact details are available in file CREDITS
 */

#include <config.h>


#include "support/lyxlib.h"
#include "support/os.h"
#include "support/filetools.h"
#include "support/lstrings.h"
#include "debug.h"
#include "qt_helpers.h"

#include "lyx_gui.h"
#include "lyx_main.h"
#include "lyxrc.h"
#include "lyxfont.h"
#include "funcrequest.h"
#include "graphics/LoaderQueue.h"

// FIXME: move this stuff out again
#include "bufferlist.h"
#include "buffer_funcs.h"
#include "lyxfunc.h"
#include "lyxserver.h"
#include "BufferView.h"

// Dear Lord, deliver us from Evil,
// aka the Qt headers
#include <boost/shared_ptr.hpp>
#include <boost/function/function0.hpp>
#include <boost/signals/signal1.hpp>
#include <boost/bind.hpp>

#include "QtView.h"
#include "QLImage.h"
#include "qfont_loader.h"
#include "io_callback.h"
#include "lcolorcache.h"

#include <qapplication.h>
#include <qwidget.h>
#include <qpaintdevicemetrics.h>
#include <qfont.h>
#include <qfontinfo.h>

#include <fcntl.h>
#include <cstdlib>

#ifndef CXX_GLOBAL_CSTD
using std::exit;
#endif

using std::vector;
using std::map;
using std::endl;

extern BufferList bufferlist;

namespace {

float getDPI()
{
	QWidget w;
	QPaintDeviceMetrics pdm(&w);
	return 0.5 * (pdm.logicalDpiX() + pdm.logicalDpiY());
}

map<int, io_callback *> io_callbacks;

} // namespace anon

// FIXME: wrong place !
LyXServer * lyxserver;

// in QLyXKeySym.C
extern void initEncodings();

#ifdef Q_WS_X11
extern bool lyxX11EventFilter(XEvent * xev);
#endif


class LQApplication : public QApplication
{
public:
	LQApplication(int & argc, char ** argv);
	~LQApplication();
#ifdef Q_WS_X11
	bool x11EventFilter (XEvent * ev) { return lyxX11EventFilter(ev); }
#endif
};


LQApplication::LQApplication(int & argc, char ** argv)
	: QApplication(argc, argv)
{}


LQApplication::~LQApplication()
{}

namespace lyx_gui {

bool use_gui = true;


void parse_init(int & argc, char * argv[])
{
	static LQApplication a(argc, argv);

	using namespace grfx;

	Image::newImage = boost::bind(&QLImage::newImage);
	Image::loadableFormats = boost::bind(&QLImage::loadableFormats);

	// needs to be done before reading lyxrc
	lyxrc.dpi = getDPI();

	initEncodings();

	LoaderQueue::setPriority(10,100);
}


void parse_lyxrc()
{}


void start(string const & batch, vector<string> const & files)
{
	// initial geometry
	unsigned int width = 690;
	unsigned int height = 510;

	QtView view(width, height);
	view.show();
	view.init();

	Buffer * last = 0;

	// FIXME: some code below needs moving

	lyxserver = new LyXServer(&view.getLyXFunc(), lyxrc.lyxpipes);

	vector<string>::const_iterator cit = files.begin();
	vector<string>::const_iterator end = files.end();
	for (; cit != end; ++cit) {
		Buffer * b = bufferlist.newBuffer(*cit);
		if (loadLyXFile(b, *cit))
			last = b;
	}

	// switch to the last buffer successfully loaded
	if (last) {
		view.view()->buffer(last);
	}

	// handle the batch commands the user asked for
	if (!batch.empty()) {
		view.getLyXFunc().dispatch(batch);
	}

	qApp->exec();

	// FIXME
	delete lyxserver;
	lyxserver = 0;
}


void sync_events()
{
	qApp->processEvents();
}


void exit()
{
	delete lyxserver;
	lyxserver = 0;

	// we cannot call qApp->exit(0) - that could return us
	// into a static dialog return in the lyx code (for example,
	// load autosave file QMessageBox. We have to just get the hell
	// out.

	::exit(0);
}


FuncStatus getStatus(FuncRequest const & ev)
{
	FuncStatus flag;
	switch (ev.action) {
	case LFUN_DIALOG_SHOW:
		if (ev.argument == "preamble" || ev.argument == "forks")
			flag.unknown(true);
		break;
	case LFUN_TOOLTIPS_TOGGLE:
		flag.unknown(true);
		break;
	default:
		break;
	}
	return flag;
}


string const hexname(LColor::color col)
{
	return ltrim(fromqstr(lcolorcache.get(col).name()), "#");
}


void update_color(LColor::color)
{
	// FIXME: Bleh, can't we just clear them all at once ?
	lcolorcache.clear();
}


void update_fonts()
{
	fontloader.update();
}


bool font_available(LyXFont const & font)
{
	return fontloader.available(font);
}


void set_read_callback(int fd, LyXComm * comm)
{
	io_callbacks[fd] = new io_callback(fd, comm);
}


void remove_read_callback(int fd)
{
	map<int, io_callback *>::iterator it = io_callbacks.find(fd);
	if (it != io_callbacks.end()) {
		delete it->second;
		io_callbacks.erase(it);
	}
}


string const roman_font_name()
{
	if (!use_gui)
		return "serif";

	QFont font;
	font.setStyleHint(QFont::Serif);
	font.setFamily("serif");
	return QFontInfo(font).family().latin1();
}


string const sans_font_name()
{
	if (!use_gui)
		return "sans";

	QFont font;
	font.setStyleHint(QFont::SansSerif);
	font.setFamily("sans");
	return QFontInfo(font).family().latin1();
}


string const typewriter_font_name()
{
	if (!use_gui)
		return "monospace";

	QFont font;
	font.setStyleHint(QFont::TypeWriter);
	font.setFamily("monospace");
	return QFontInfo(font).family().latin1();
}

}; // namespace lyx_gui