hopefully fix tex2lyx linking.

[lyx.git] / src / lyxsocket.C

diff --git a/src/lyxsocket.C b/src/lyxsocket.C
index 73f8b210694e6467c7a7075bc31c6750bf1f6c7c..0de947676401945c424931c139dfea79178b6e3b 100644 (file)
--- a/src/lyxsocket.C
+++ b/src/lyxsocket.C
@@ -14,72 +14,14 @@
 
 #include <config.h>
 
-#include <config.h>
-
 #include "lyxsocket.h"
 
-
-#if !(defined(HAVE_READ) && defined(HAVE_WRITE) && defined(HAVE_CLOSE))
-// We provide stub classes to disables the sockets.
-
-LyXServerSocket::LyXServerSocket(LyXFunc *, std::string const &)
-{}
-
-
-LyXServerSocket::~LyXServerSocket()
-{}
-
-
-std::string const & LyXServerSocket::address() const
-{
-       return address_;
-}
-
-
-void LyXServerSocket::serverCallback()
-{}
-
-
-void LyXServerSocket::dataCallback(int)
-{}
-
-
-void LyXServerSocket::writeln(std::string const &)
-{}
-
-
-LyXDataSocket::LyXDataSocket(int)
-{}
-
-
-LyXDataSocket::~LyXDataSocket()
-{}
-
-
-bool LyXDataSocket::connected() const
-{
-       return false;
-}
-
-
-bool LyXDataSocket::readln(std::string &)
-{
-       return false;
-}
-
-
-void LyXDataSocket::writeln(std::string const &)
-{}
-
-#else // defined(HAVE_READ) && defined(HAVE_WRITE) && defined(HAVE_CLOSE)
-
-
 #include "debug.h"
 #include "funcrequest.h"
 #include "LyXAction.h"
 #include "lyxfunc.h"
 
-#include "frontends/lyx_gui.h"
+#include "frontends/Application.h"
 
 #include "support/environment.h"
 #include "support/lyxlib.h"
@@ -89,6 +31,10 @@ void LyXDataSocket::writeln(std::string const &)
 
 #include <cerrno>
 
+#if defined (_WIN32)
+# include <io.h>
+#endif
+
 using boost::shared_ptr;
 
 using std::auto_ptr;
@@ -96,12 +42,14 @@ using std::endl;
 using std::string;
 
 
+namespace lyx {
+
 // Address is the unix address for the socket.
 // MAX_CLIENTS is the maximum number of clients
 // that can connect at the same time.
 LyXServerSocket::LyXServerSocket(LyXFunc * f, string const & addr)
        : func(f),
-         fd_(lyx::support::socktools::listen(addr, 3)),
+         fd_(support::socktools::listen(addr, 3)),
          address_(addr)
 {
        if (fd_ == -1) {
@@ -111,11 +59,11 @@ LyXServerSocket::LyXServerSocket(LyXFunc * f, string const & addr)
 
        // These env vars are used by DVI inverse search
        // Needed by xdvi
-       lyx::support::setEnv("XEDITOR", "lyxclient -g %f %l");
+       support::setEnv("XEDITOR", "lyxclient -g %f %l");
        // Needed by lyxclient
-       lyx::support::setEnv("LYXSOCKET", address_);
+       support::setEnv("LYXSOCKET", address_);
 
-       lyx_gui::register_socket_callback(
+       theApp->registerSocketCallback(
                fd_,
                boost::bind(&LyXServerSocket::serverCallback, this)
                );
@@ -128,9 +76,13 @@ LyXServerSocket::LyXServerSocket(LyXFunc * f, string const & addr)
 // Close the socket and remove the address of the filesystem.
 LyXServerSocket::~LyXServerSocket()
 {
-       lyx_gui::unregister_socket_callback(fd_);
-       ::close(fd_);
-       lyx::support::unlink(address_);
+       if (fd_ != -1) {
+               theApp->unregisterSocketCallback(fd_);
+               if (::close(fd_) != 0)
+                       lyxerr << "lyx: Server socket " << fd_
+                              << " IO error on closing: " << strerror(errno);
+       }
+       support::unlink(address_);
        lyxerr[Debug::LYXSERVER] << "lyx: Server socket quitting" << endl;
 }
 
@@ -145,7 +97,7 @@ string const & LyXServerSocket::address() const
 // is OK and if the number of clients does not exceed MAX_CLIENTS
 void LyXServerSocket::serverCallback()
 {
-       int const client_fd = lyx::support::socktools::accept(fd_);
+       int const client_fd = support::socktools::accept(fd_);
 
        if (fd_ == -1) {
                lyxerr[Debug::LYXSERVER] << "lyx: Failed to accept new client"
@@ -161,7 +113,7 @@ void LyXServerSocket::serverCallback()
        // Register the new client.
        clients[client_fd] =
                shared_ptr<LyXDataSocket>(new LyXDataSocket(client_fd));
-       lyx_gui::register_socket_callback(
+       theApp->registerSocketCallback(
                client_fd,
                boost::bind(&LyXServerSocket::dataCallback,
                            this, client_fd)
@@ -190,7 +142,7 @@ void LyXServerSocket::dataCallback(int fd)
                if (key == "LYXCMD") {
                        string const cmd = line.substr(pos + 1);
                        func->dispatch(lyxaction.lookupFunc(cmd));
-                       string const rval = func->getMessage();
+                       string const rval = to_utf8(func->getMessage());
                        if (func->errorStat()) {
                                client->writeln("ERROR:" + cmd + ':' + rval);
                        } else {
@@ -217,7 +169,7 @@ void LyXServerSocket::writeln(string const & line)
        string const linen(line + '\n');
        int const size = linen.size();
        int const written = ::write(fd_, linen.c_str(), size);
-       if (written < size) { // Allways mean end of connection.
+       if (written < size) { // Always mean end of connection.
                if ((written == -1) && (errno == EPIPE)) {
                        // The program will also receive a SIGPIPE
                        // that must be caught
@@ -255,9 +207,11 @@ LyXDataSocket::LyXDataSocket(int fd)
 
 LyXDataSocket::~LyXDataSocket()
 {
-       ::close(fd_);
+       if (::close(fd_) != 0)
+               lyxerr << "lyx: Data socket " << fd_
+                      << " IO error on closing: " << strerror(errno);
 
-       lyx_gui::unregister_socket_callback(fd_);
+       theApp->unregisterSocketCallback(fd_);
        lyxerr[Debug::LYXSERVER] << "lyx: Data socket " << fd_ << " quitting."
                                 << endl;
 }
@@ -273,7 +227,7 @@ bool LyXDataSocket::connected() const
 bool LyXDataSocket::readln(string & line)
 {
        int const charbuf_size = 100;
-        char charbuf[charbuf_size]; // buffer for the ::read() system call
+       char charbuf[charbuf_size]; // buffer for the ::read() system call
        int count;
 
        // read and store characters in buffer
@@ -312,7 +266,7 @@ void LyXDataSocket::writeln(string const & line)
        string const linen(line + '\n');
        int const size = linen.size();
        int const written = ::write(fd_, linen.c_str(), size);
-       if (written < size) { // Allways mean end of connection.
+       if (written < size) { // Always mean end of connection.
                if ((written == -1) && (errno == EPIPE)) {
                        // The program will also receive a SIGPIPE
                        // that must be catched
@@ -329,4 +283,5 @@ void LyXDataSocket::writeln(string const & line)
        }
 }
 
-#endif // defined(HAVE_READ) && defined(HAVE_WRITE) && defined(HAVE_CLOSE)
+
+} // namespace lyx