AC_LANG_CPLUSPLUS
SAVE_CXXFLAGS=$CXXFLAGS
CXXFLAGS="$CXXFLAGS $QT4_INCLUDES $QT4_LDFLAGS"
+ for libname in '-lQtCore -lQtCore4'
+ do
+ QT4_TRY_LINK($libname)
+ if test -n "$qt4_cv_libname"; then
+ QT4_CORE_LIB="$qt4_cv_libname"
+ break;
+ fi
+ done
for libname in '-lQtCore -lQtGui' \
'-lQtCore4 -lQtGui4'
do
PKG_CONFIG_PATH=$qt4_cv_dir/lib:$PKG_CONFIG_PATH
export PKG_CONFIG_PATH
fi
+ PKG_CHECK_MODULES(QT4_CORE, QtCore)
+ if test "$pkg_failed" == "no" ; then
+ QT4_CORE_INCLUDES=$QT4_CORE_CFLAGS
+ AC_SUBST(QT4_CORE_INCLUDES)
+ QT4_CORE_LDFLAGS=`$PKG_CONFIG --libs-only-L QtCore`
+ AC_SUBST(QT4_CORE_LDFLAGS)
+ QT4_CORE_LIB=`$PKG_CONFIG --libs-only-l QtCore`
+ AC_SUBST(QT4_CORE_LIB)
+ fi
PKG_CHECK_MODULES(QT4_FRONTEND, QtCore QtGui)
if test "$pkg_failed" == "no" ; then
QT4_INCLUDES=$QT4_FRONTEND_CFLAGS
AC_SUBST(QT4_VERSION)
QT4_LIB=`$PKG_CONFIG --libs-only-l QtCore QtGui`
AC_SUBST(QT4_LIB)
- else
- QT4_DO_MANUAL_CONFIG
fi
PKG_CONFIG_PATH=$save_PKG_CONFIG_PATH
])
dnl flags for compilation
QT4_INCLUDES=
QT4_LDFLAGS=
+ QT4_CORE_INCLUDES=
+ QT4_CORE_LDFLAGS=
if test -n "$qt4_cv_includes"; then
QT4_INCLUDES="-I$qt4_cv_includes"
for i in Qt QtCore QtGui; do
QT4_INCLUDES="$QT4_INCLUDES -I$qt4_cv_includes/$i"
done
+ QT4_CORE_INCLUDES="-I$qt4_cv_includes -I$qt4_cv_includes/QtCore"
fi
if test -n "$qt4_cv_libraries"; then
QT4_LDFLAGS="-L$qt4_cv_libraries"
+ QT4_CORE_LDFLAGS="-L$qt4_cv_libraries"
fi
AC_SUBST(QT4_INCLUDES)
+ AC_SUBST(QT4_CORE_INCLUDES)
AC_SUBST(QT4_LDFLAGS)
+ AC_SUBST(QT4_CORE_LDFLAGS)
QT4_CHECK_COMPILE
QT4_LIB=$qt4_cv_libname;
AC_SUBST(QT4_LIB)
+ AC_SUBST(QT4_CORE_LIB)
if test -n "$qt4_cv_libname"; then
QT4_GET_VERSION
os_win32.h
package.h
path.h
+ qstring_helpers.h
socktools.h
std_istream.h
std_ostream.h
os.C
package.C
path.C
+ qstring_helpers.C
rename.C
socktools.C
systemcall.C
// Class CmdLineParser -------------------------------------------------------
class CmdLineParser {
public:
- typedef int (*optfunc)(vector<char *> const & args);
+ typedef int (*optfunc)(vector<docstring> const & args);
std::map<string, optfunc> helper;
std::map<string, bool> isset;
bool parse(int, char * []);
{
int opt = 1;
while (opt < argc) {
- vector<char *> args;
+ vector<docstring> args;
if (helper[argv[opt]]) {
isset[argv[opt]] = true;
int arg = opt + 1;
while ((arg < argc) && (!helper[argv[arg]])) {
- args.push_back(argv[arg]);
+ args.push_back(from_local8bit(argv[arg]));
++arg;
}
int taken = helper[argv[opt]](args);
}
-int h(vector<char *> const &)
+int h(vector<docstring> const &)
{
usage();
exit(0);
}
-string clientName(support::itoa(::getppid()) + ">" + support::itoa(::getpid()));
+docstring clientName(from_ascii(support::itoa(::getppid()) + ">" + support::itoa(::getpid())));
-int n(vector<char *> const & arg)
+int n(vector<docstring> const & arg)
{
if (arg.size() < 1) {
cerr << "lyxclient: The option -n requires 1 argument."
}
-string singleCommand;
+docstring singleCommand;
-int c(vector<char *> const & arg)
+int c(vector<docstring> const & arg)
{
if (arg.size() < 1) {
cerr << "lyxclient: The option -c requires 1 argument."
}
-int g(vector<char *> const & arg)
+int g(vector<docstring> const & arg)
{
if (arg.size() < 2) {
cerr << "lyxclient: The option -g requires 2 arguments."
return -1;
}
singleCommand = "LYXCMD:server-goto-file-row "
- + string(arg[0]) + ' '
- + string(arg[1]);
+ + arg[0] + ' '
+ + arg[1];
return 2;
}
-// 0 if LYXSOCKET is not set in the environment
-char * serverAddress = getenv("LYXSOCKET");
+// empty if LYXSOCKET is not set in the environment
+docstring serverAddress;
-int a(vector<char *> const & arg)
+int a(vector<docstring> const & arg)
{
if (arg.size() < 1) {
cerr << "lyxclient: The option -a requires 1 argument."
}
-string mainTmp("/tmp");
+docstring mainTmp(from_ascii("/tmp"));
-int t(vector<char *> const & arg)
+int t(vector<docstring> const & arg)
{
if (arg.size() < 1) {
cerr << "lyxclient: The option -t requires 1 argument."
string serverPid; // Init to empty string
-int p(vector<char *> const & arg)
+int p(vector<docstring> const & arg)
{
if (arg.size() < 1) {
cerr << "lyxclient: The option -p requires 1 argument."
<< endl;
return -1;
}
- serverPid = arg[0];
+ serverPid = to_ascii(arg[0]);
return 1;
}
using namespace lyx;
lyxerr.rdbuf(cerr.rdbuf());
+ char const * const lyxsocket = getenv("LYXSOCKET");
+ if (lyxsocket)
+ cmdline::serverAddress = from_local8bit(lyxsocket);
+
CmdLineParser args;
args.helper["-h"] = cmdline::h;
args.helper["-c"] = cmdline::c;
scoped_ptr<LyXDataSocket> server;
- if (cmdline::serverAddress) {
- server.reset(new LyXDataSocket(cmdline::serverAddress));
+ if (!cmdline::serverAddress.empty()) {
+ server.reset(new LyXDataSocket(to_utf8(cmdline::serverAddress)));
if (!server->connected()) {
cerr << "lyxclient: " << "Could not connect to "
- << cmdline::serverAddress << endl;
+ << to_utf8(cmdline::serverAddress) << endl;
return EXIT_FAILURE;
}
} else {
// We have to look for an address.
// serverPid can be empty.
- vector<fs::path> addrs = support::lyxSockets(cmdline::mainTmp, cmdline::serverPid);
+ vector<fs::path> addrs = support::lyxSockets(to_utf8(cmdline::mainTmp), cmdline::serverPid);
vector<fs::path>::const_iterator addr = addrs.begin();
vector<fs::path>::const_iterator end = addrs.end();
for (; addr != end; ++addr) {
string answer;
// Send greeting
- server->writeln("HELLO:" + cmdline::clientName);
+ server->writeln("HELLO:" + to_utf8(cmdline::clientName));
// wait at most 2 seconds until server responds
iowatch.wait(2.0);
if (iowatch.isset(serverfd) && server->readln(answer)) {
}
if (args.isset["-g"] || args.isset["-c"]) {
- server->writeln(cmdline::singleCommand);
+ server->writeln(to_utf8(cmdline::singleCommand));
iowatch.wait(2.0);
if (iowatch.isset(serverfd) && server->readln(answer)) {
cout << answer;
namespace lyx {
-
-using lyx::support::isStrDbl;
-using lyx::char_type;
-using lyx::docstring;
+using support::isStrDbl;
using std::vector;
using std::make_pair;
}
-#if QT_VERSION < 0x040200
-// We use QString::fromUcs4 in Qt 4.2 and higher
-QString const toqstr(docstring const & str)
-{
- QString s;
- int i = static_cast<int>(str.size());
- s.resize(i);
- for (; --i >= 0;)
- s[i] = ucs4_to_qchar(str[i]);
- return s;
-}
-#endif
-
-
-docstring const qstring_to_ucs4(QString const & qstr)
-{
-#if QT_VERSION >= 0x040200
- QVector<uint> const ucs4 = qstr.toUcs4();
- return docstring(ucs4.begin(), ucs4.end());
-#else
- // This does not properly convert surrogate pairs
- int const ls = qstr.size();
- docstring ucs4;
- for (int i = 0; i < ls; ++i)
- ucs4 += static_cast<char_type>(qstr[i].unicode());
- return ucs4;
-#endif
-}
-
-
QString const qt_(char const * str, const char *)
{
return toqstr(_(str));
}
-string const fromqstr(QString const & str)
-{
- return str.isEmpty() ? string() : string(str.toUtf8());
-}
-
-
docstring const formatted(docstring const & text, int w)
{
docstring sout;
#include "lyxlength.h"
#include "support/docstring.h"
+#include "support/qstring_helpers.h"
-#include <QChar>
#include <QString>
-#include <vector>
#include <utility>
-#include <boost/assert.hpp>
class QComboBox;
class QLineEdit;
docstring const formatted(docstring const & text, int w = 80);
-/**
- * toqstr - convert a UTF8 encoded char * into a QString
- *
- * This should not be used, since all possibly non-ASCII stuff should be
- * stored in a docstring.
- */
-inline QString const toqstr(char const * str)
-{
- return QString::fromUtf8(str);
-}
-
-
-/**
- * toqstr - convert a UTF8 encoded std::string into a QString
- *
- * This should not be used, since all possibly non-ASCII stuff should be
- * stored in a docstring.
- */
-inline QString const toqstr(std::string const & str)
-{
- return toqstr(str.c_str());
-}
-
-
-/**
- * Convert a QChar into a UCS4 character.
- * This is a hack (it does only make sense for the common part of the UCS4
- * and UTF16 encodings) and should not be used.
- * This does only exist because of performance reasons (a real conversion
- * using iconv is too slow on windows).
- */
-inline char_type const qchar_to_ucs4(QChar const & qchar)
-{
- return static_cast<char_type>(qchar.unicode());
-}
-
-
-/**
- * Convert a UCS4 character into a QChar.
- * This is a hack (it does only make sense for the common part of the UCS4
- * and UTF16 encodings) and should not be used.
- * This does only exist because of performance reasons (a real conversion
- * using iconv is too slow on windows).
- */
-inline QChar const ucs4_to_qchar(char_type const ucs4)
-{
- // FIXME: The following cast is not a real conversion but it work
- // for the ucs2 subrange of unicode. Instead of an assertion we should
- // return some special characters that indicates that its display is
- // not supported.
- BOOST_ASSERT(ucs4 < 65536);
- return QChar(static_cast<unsigned short>(ucs4));
-}
-
-
-/**
- * toqstr - convert a UCS4 encoded docstring into a QString
- *
- * This is the preferred method of converting anything that possibly
- * contains non-ASCII stuff to QString.
- */
-#if QT_VERSION >= 0x040200
-inline QString const toqstr(docstring const & ucs4)
-{
- // If possible we let qt do the work, since this version does not
- // need to be superfast.
- return QString::fromUcs4(reinterpret_cast<uint const *>(ucs4.data()), ucs4.length());
-}
-#else
-QString const toqstr(docstring const & ucs4);
-#endif
-
-
-/**
- * ucs4_to_qstring - convert a UCS4 encoded char_type * into a QString
- *
- * This is a hack for the painter and font metrics and should not be used
- * elsewhere. Since it uses ucs4_to_qchar it has the same limitations.
- */
-inline void ucs4_to_qstring(char_type const * str, size_t ls, QString & s)
-{
- int i = static_cast<int>(ls);
- s.resize(i);
- for (; --i >= 0;)
- s[i] = ucs4_to_qchar(str[i]);
-}
-
-
-/**
- * qstring_to_ucs4 - convert a QString into a UCS4 encoded docstring
- *
- * This is the preferred method of converting anything that possibly
- * contains non-ASCII stuff to docstring.
- */
-docstring const qstring_to_ucs4(QString const & qstr);
-
-
/**
* qt_ - i18nize string and convert to QString
*
*/
QString const qt_(std::string const & str);
-
-/**
- * fromqstr - convert a QString into a UTF8 encoded std::string
- *
- * This should not be used except for output to lyxerr, since all possibly
- * non-ASCII stuff should be stored in a docstring.
- */
-std::string const fromqstr(QString const & str);
-
} // namespace lyx
#endif // QTHELPERS_H
// we need to parse for "-dbg" and "-help"
easyParse(argc, argv);
- support::init_package(argv[0], cl_system_support, cl_user_support,
- support::top_build_dir_is_one_level_up);
+ support::init_package(to_utf8(from_local8bit(argv[0])),
+ cl_system_support, cl_user_support,
+ support::top_build_dir_is_one_level_up);
if (!use_gui) {
// FIXME: create a ConsoleApplication
for (int argi = argc - 1; argi >= 1; --argi) {
// get absolute path of file and add ".lyx" to
// the filename if necessary
- pimpl_->files_to_load_.push_back(fileSearch(string(), os::internal_path(argv[argi]), "lyx"));
+ pimpl_->files_to_load_.push_back(fileSearch(string(),
+ os::internal_path(to_utf8(from_local8bit(argv[argi]))), "lyx"));
}
if (first_start)
if (it == cmdmap.end())
continue;
- string arg((i + 1 < argc) ? argv[i + 1] : "");
- string arg2((i + 2 < argc) ? argv[i + 2] : "");
+ string const arg((i + 1 < argc) ? to_utf8(from_local8bit(argv[i + 1])) : string());
+ string const arg2((i + 2 < argc) ? to_utf8(from_local8bit(argv[i + 2])) : string());
int const remove = 1 + it->second(arg, arg2);
noinst_LTLIBRARIES = libsupport.la
-libsupport_la_LIBADD = $(LIBSHLWAPI)
+libsupport_la_LIBADD = $(LIBSHLWAPI) $(QT4_CORE_LIB)
+libsupport_la_LDFLAGS = $(QT4_CORE_LDFLAGS)
BUILT_SOURCES = $(PCH_FILE) package.C
AM_CPPFLAGS += $(PCH_FLAGS) -I$(srcdir)/.. $(BOOST_INCLUDES)
+AM_CPPFLAGS += $(QT4_CPPFLAGS) $(QT4_CORE_INCLUDES)
libsupport_la_SOURCES = \
FileMonitor.h \
path.h \
package.C \
package.h \
+ qstring_helpers.C \
+ qstring_helpers.h \
rename.C \
socktools.C \
socktools.h \
#include <config.h>
#include "docstring.h"
+#include "qstring_helpers.h"
#include "unicode.h"
#include <locale>
}
+docstring const from_local8bit(std::string const & s)
+{
+ return qstring_to_ucs4(QString::fromLocal8Bit(s.data(), s.length()));
+}
+
+
+const char* to_local8bit_failure::what() const throw()
+{
+ return "A string could not be converted from unicode to the local 8 bit encoding.";
+}
+
+
+std::string const to_local8bit(docstring const & s)
+{
+ // This conversion can fail, depending on input.
+ if (s.empty())
+ return std::string();
+ QByteArray const local = toqstr(s).toLocal8Bit();
+ if (local.size() == 0)
+ throw to_local8bit_failure();
+ return std::string(local.begin(), local.end());
+}
+
+
bool operator==(lyx::docstring const & l, char const * r)
{
int const len = l.length();
#include "support/types.h"
#include <string>
+#include <typeinfo>
namespace lyx {
/// Creates a UTF8 string from a docstring. This should go eventually.
std::string const to_utf8(docstring const &);
+/// convert \p s from the encoding of the locale to ucs4.
+docstring const from_local8bit(std::string const & s);
+
+/// Exception thrown by to_local8bit if the string could not be converted
+class to_local8bit_failure : public std::bad_cast {
+public:
+ to_local8bit_failure() throw() : std::bad_cast() {}
+ virtual ~to_local8bit_failure() throw() {}
+ virtual const char* what() const throw();
+};
+
+/**
+ * Convert \p s from ucs4 to the encoding of the locale.
+ * This may fail and throw an exception, the caller is expected to act
+ * appropriately.
+ */
+std::string const to_local8bit(docstring const & s);
+
/// Compare a docstring with a C string of ASCII characters
bool operator==(lyx::docstring const &, char const *);
#include "support/filetools.h"
#include "support/lstrings.h"
#include "support/os.h"
+#include "support/qstring_helpers.h"
+
+#include <QFile>
#include <boost/assert.hpp>
string const FileName::toFilesystemEncoding() const
{
- // FIXME UNICODE: correct encoding not implemented yet
- return name_;
+ QByteArray const encoded = QFile::encodeName(toqstr(name_));
+ return string(encoded.begin(), encoded.end());
}
--- /dev/null
+/**
+ * \file qstring_helpers.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Dekel Tsur
+ * \author Jürgen Spitzmüller
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#include <config.h>
+
+#include "qstring_helpers.h"
+
+#include <QVector>
+
+
+namespace lyx {
+
+using std::string;
+
+#if QT_VERSION < 0x040200
+// We use QString::fromUcs4 in Qt 4.2 and higher
+QString const toqstr(docstring const & str)
+{
+ QString s;
+ int i = static_cast<int>(str.size());
+ s.resize(i);
+ for (; --i >= 0;)
+ s[i] = ucs4_to_qchar(str[i]);
+ return s;
+}
+#endif
+
+
+docstring const qstring_to_ucs4(QString const & qstr)
+{
+#if QT_VERSION >= 0x040200
+ QVector<uint> const ucs4 = qstr.toUcs4();
+ return docstring(ucs4.begin(), ucs4.end());
+#else
+ // This does not properly convert surrogate pairs
+ int const ls = qstr.size();
+ docstring ucs4;
+ for (int i = 0; i < ls; ++i)
+ ucs4 += static_cast<char_type>(qstr[i].unicode());
+ return ucs4;
+#endif
+}
+
+
+string const fromqstr(QString const & str)
+{
+ return str.isEmpty() ? string() : string(str.toUtf8());
+}
+
+} // namespace lyx
--- /dev/null
+// -*- C++ -*-
+/**
+ * \file qstring_helpers.h
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * \author Dekel Tsur
+ *
+ * Full author contact details are available in file CREDITS.
+ */
+
+#ifndef QSTRING_HELPERS_H
+#define QSTRING_HELPERS_H
+
+#include "support/docstring.h"
+
+#include <QChar>
+#include <QString>
+
+#include <boost/assert.hpp>
+
+namespace lyx {
+
+/**
+ * toqstr - convert a UTF8 encoded char * into a QString
+ *
+ * This should not be used, since all possibly non-ASCII stuff should be
+ * stored in a docstring.
+ */
+inline QString const toqstr(char const * str)
+{
+ return QString::fromUtf8(str);
+}
+
+
+/**
+ * toqstr - convert a UTF8 encoded std::string into a QString
+ *
+ * This should not be used, since all possibly non-ASCII stuff should be
+ * stored in a docstring.
+ */
+inline QString const toqstr(std::string const & str)
+{
+ return toqstr(str.c_str());
+}
+
+
+/**
+ * Convert a QChar into a UCS4 character.
+ * This is a hack (it does only make sense for the common part of the UCS4
+ * and UTF16 encodings) and should not be used.
+ * This does only exist because of performance reasons (a real conversion
+ * using iconv is too slow on windows).
+ */
+inline char_type const qchar_to_ucs4(QChar const & qchar)
+{
+ return static_cast<char_type>(qchar.unicode());
+}
+
+
+/**
+ * Convert a UCS4 character into a QChar.
+ * This is a hack (it does only make sense for the common part of the UCS4
+ * and UTF16 encodings) and should not be used.
+ * This does only exist because of performance reasons (a real conversion
+ * using iconv is too slow on windows).
+ */
+inline QChar const ucs4_to_qchar(char_type const ucs4)
+{
+ // FIXME: The following cast is not a real conversion but it work
+ // for the ucs2 subrange of unicode. Instead of an assertion we should
+ // return some special characters that indicates that its display is
+ // not supported.
+ BOOST_ASSERT(ucs4 < 65536);
+ return QChar(static_cast<unsigned short>(ucs4));
+}
+
+
+/**
+ * toqstr - convert a UCS4 encoded docstring into a QString
+ *
+ * This is the preferred method of converting anything that possibly
+ * contains non-ASCII stuff to QString.
+ */
+#if QT_VERSION >= 0x040200
+inline QString const toqstr(docstring const & ucs4)
+{
+ // If possible we let qt do the work, since this version does not
+ // need to be superfast.
+ return QString::fromUcs4(reinterpret_cast<uint const *>(ucs4.data()), ucs4.length());
+}
+#else
+QString const toqstr(docstring const & ucs4);
+#endif
+
+
+/**
+ * ucs4_to_qstring - convert a UCS4 encoded char_type * into a QString
+ *
+ * This is a hack for the painter and font metrics and should not be used
+ * elsewhere. Since it uses ucs4_to_qchar it has the same limitations.
+ */
+inline void ucs4_to_qstring(char_type const * str, size_t ls, QString & s)
+{
+ int i = static_cast<int>(ls);
+ s.resize(i);
+ for (; --i >= 0;)
+ s[i] = ucs4_to_qchar(str[i]);
+}
+
+
+/**
+ * qstring_to_ucs4 - convert a QString into a UCS4 encoded docstring
+ *
+ * This is the preferred method of converting anything that possibly
+ * contains non-ASCII stuff to docstring.
+ */
+docstring const qstring_to_ucs4(QString const & qstr);
+
+
+/**
+ * fromqstr - convert a QString into a UTF8 encoded std::string
+ *
+ * This should not be used except for output to lyxerr, since all possibly
+ * non-ASCII stuff should be stored in a docstring.
+ */
+std::string const fromqstr(QString const & str);
+
+} // namespace lyx
+
+#endif // QSTRING_HELPERS_H
projects / features.git / commitdiff