cosmetics.

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@20319 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/Server.cpp b/src/Server.cpp
index f6b3821dbd35ca967e63bbddd1e61042a5b51ecf..1c6cf9f2b014e88d8aadeb486bfd4d849ee20708 100644 (file)
--- a/src/Server.cpp
+++ b/src/Server.cpp
@@ -71,9 +71,18 @@ using std::endl;
 using std::string;
 
 
+/////////////////////////////////////////////////////////////////////
+//
+// LyXComm
+//
+/////////////////////////////////////////////////////////////////////
+
 #if !defined (HAVE_MKFIFO)
 // We provide a stub class that disables the lyxserver.
 
+LyXComm(std::string const &, Server *, ClientCallbackfct)
+{}
+
 void LyXComm::openConnection()
 {}
 
@@ -106,41 +115,51 @@ void LyXComm::send(string const & msg)
 #else // defined (HAVE_MKFIFO)
 
 
+LyXComm::LyXComm(std::string const & pip, Server * cli, ClientCallbackfct ccb)
+       : pipename_(pip), client_(cli), clientcb_(ccb)
+{
+       ready_ = false;
+       openConnection();
+}
+
+
 void LyXComm::openConnection()
 {
        LYXERR(Debug::LYXSERVER) << "LyXComm: Opening connection" << endl;
 
        // If we are up, that's an error
-       if (ready) {
+       if (ready_) {
                lyxerr << "LyXComm: Already connected" << endl;
                return;
        }
        // We assume that we don't make it
-       ready = false;
+       ready_ = false;
 
-       if (pipename.empty()) {
+       if (pipename_.empty()) {
                LYXERR(Debug::LYXSERVER)
                        << "LyXComm: server is disabled, nothing to do"
                        << endl;
                return;
        }
 
-       if ((infd = startPipe(inPipeName(), false)) == -1)
+       infd_ = startPipe(inPipeName(), false);
+       if (infd_ == -1)
                return;
 
-       if ((outfd = startPipe(outPipeName(), true)) == -1) {
-               endPipe(infd, inPipeName(), false);
+       outfd_ = startPipe(outPipeName(), true);
+       if (outfd_ == -1) {
+               endPipe(infd_, inPipeName(), false);
                return;
        }
 
-       if (fcntl(outfd, F_SETFL, O_NONBLOCK) < 0) {
+       if (fcntl(outfd_, F_SETFL, O_NONBLOCK) < 0) {
                lyxerr << "LyXComm: Could not set flags on pipe " << outPipeName()
                       << '\n' << strerror(errno) << endl;
                return;
        }
 
        // We made it!
-       ready = true;
+       ready_ = true;
        LYXERR(Debug::LYXSERVER) << "LyXComm: Connection established" << endl;
 }
 
@@ -150,22 +169,22 @@ void LyXComm::closeConnection()
 {
        LYXERR(Debug::LYXSERVER) << "LyXComm: Closing connection" << endl;
 
-       if (pipename.empty()) {
+       if (pipename_.empty()) {
                LYXERR(Debug::LYXSERVER)
                        << "LyXComm: server is disabled, nothing to do"
                        << endl;
                return;
        }
 
-       if (!ready) {
+       if (!ready_) {
                lyxerr << "LyXComm: Already disconnected" << endl;
                return;
        }
 
-       endPipe(infd, inPipeName(), false);
-       endPipe(outfd, outPipeName(), true);
+       endPipe(infd_, inPipeName(), false);
+       endPipe(outfd_, outPipeName(), true);
 
-       ready = false;
+       ready_ = false;
 }
 
 
@@ -176,7 +195,7 @@ int LyXComm::startPipe(string const & file, bool write)
                lyxerr << "LyXComm: Pipe " << filename << " already exists.\n"
                       << "If no other LyX program is active, please delete"
                        " the pipe by hand and try again." << endl;
-               pipename.erase();
+               pipename_.erase();
                return -1;
        }
 
@@ -184,7 +203,7 @@ int LyXComm::startPipe(string const & file, bool write)
                lyxerr << "LyXComm: Could not create pipe " << filename << '\n'
                       << strerror(errno) << endl;
                return -1;
-       };
+       }
        int const fd = ::open(filename.toFilesystemEncoding().c_str(),
                              write ? (O_RDWR) : (O_RDONLY|O_NONBLOCK));
 
@@ -209,9 +228,8 @@ void LyXComm::endPipe(int & fd, string const & filename, bool write)
        if (fd < 0)
                return;
 
-       if (!write) {
+       if (!write)
                theApp()->unregisterSocketCallback(fd);
-       }
 
        if (::close(fd) < 0) {
                lyxerr << "LyXComm: Could not close pipe " << filename
@@ -221,7 +239,7 @@ void LyXComm::endPipe(int & fd, string const & filename, bool write)
        if (unlink(FileName(filename)) < 0) {
                lyxerr << "LyXComm: Could not remove pipe " << filename
                       << '\n' << strerror(errno) << endl;
-       };
+       }
 
        fd = -1;
 }
@@ -229,9 +247,9 @@ void LyXComm::endPipe(int & fd, string const & filename, bool write)
 
 void LyXComm::emergencyCleanup()
 {
-       if (!pipename.empty()) {
-               endPipe(infd, inPipeName(), false);
-               endPipe(outfd, outPipeName(), true);
+       if (!pipename_.empty()) {
+               endPipe(infd_, inPipeName(), false);
+               endPipe(outfd_, outPipeName(), true);
        }
 }
 
@@ -239,7 +257,7 @@ void LyXComm::emergencyCleanup()
 // Receives messages and sends then to client
 void LyXComm::read_ready()
 {
-       // nb! make read_buffer_ a class-member for multiple sessions
+       // FIXME: make read_buffer_ a class-member for multiple sessions
        static string read_buffer_;
        read_buffer_.erase();
 
@@ -249,7 +267,7 @@ void LyXComm::read_ready()
        errno = 0;
        int status;
        // the single = is intended here.
-       while ((status = ::read(infd, charbuf, charbuf_size - 1))) {
+       while ((status = ::read(infd_, charbuf, charbuf_size - 1))) {
 
                if (status > 0) {
                        charbuf[status] = '\0'; // turn it into a c string
@@ -265,7 +283,7 @@ void LyXComm::read_ready()
                                        << ", read_buffer_:" << read_buffer_
                                        << ", cmd:" << cmd << endl;
                                if (!cmd.empty())
-                                       clientcb(client, cmd);
+                                       clientcb_(client_, cmd);
                                        //\n or not \n?
                        }
                }
@@ -302,12 +320,12 @@ void LyXComm::send(string const & msg)
 
        LYXERR(Debug::LYXSERVER) << "LyXComm: Sending '" << msg << '\'' << endl;
 
-       if (pipename.empty()) return;
+       if (pipename_.empty()) return;
 
-       if (!ready) {
+       if (!ready_) {
                lyxerr << "LyXComm: Pipes are closed. Could not send "
                       << msg << endl;
-       } else if (::write(outfd, msg.c_str(), msg.length()) < 0) {
+       } else if (::write(outfd_, msg.c_str(), msg.length()) < 0) {
                lyxerr << "LyXComm: Error sending message: " << msg
                       << '\n' << strerror(errno)
                       << "\nLyXComm: Resetting connection" << endl;
@@ -321,38 +339,47 @@ void LyXComm::send(string const & msg)
 
 string const LyXComm::inPipeName() const
 {
-       return pipename + string(".in");
+       return pipename_ + ".in";
 }
 
 
 string const LyXComm::outPipeName() const
 {
-       return pipename + string(".out");
+       return pipename_ + ".out";
 }
 
 
-// Server class
+/////////////////////////////////////////////////////////////////////
+//
+// Server
+//
+/////////////////////////////////////////////////////////////////////
+
+void ServerCallback(Server * server, string const & msg)
+{
+       server->callback(msg);
+}
+
+Server::Server(LyXFunc * f, std::string const & pipes)
+       : numclients_(0), func_(f), pipes_(pipes, this, &ServerCallback)
+{}
+
 
 Server::~Server()
 {
        // say goodbye to clients so they stop sending messages
-       // modified june 1999 by stefano@zool.su.se to send as many bye
-       // messages as there are clients, each with client's name.
+       // send as many bye messages as there are clients,
+       // each with client's name.
        string message;
-       for (int i= 0; i<numclients; ++i) {
-               message = "LYXSRV:" + clients[i] + ":bye\n";
-               pipes.send(message);
+       for (int i = 0; i != numclients_; ++i) {
+               message = "LYXSRV:" + clients_[i] + ":bye\n";
+               pipes_.send(message);
        }
 }
 
 
-/* ---F+------------------------------------------------------------------ *\
-   Function  : ServerCallback
-    Called by : LyXComm
-    Purpose   : handle data gotten from communication
-\* ---F------------------------------------------------------------------- */
-
-void Server::callback(Server * serv, string const & msg)
+// Handle data gotten from communication, called by LyXComm
+void Server::callback(string const & msg)
 {
        LYXERR(Debug::LYXSERVER) << "Server: Received: '"
                                 << msg << '\'' << endl;
@@ -380,8 +407,10 @@ void Server::callback(Server * serv, string const & msg)
                string client;
                while (*p && *p != ':')
                        client += char(*p++);
-               if (*p == ':') ++p;
-               if (!*p) return;
+               if (*p == ':')
+                       ++p;
+               if (!*p)
+                       return;
 
                // --- 3. get function name ---
                string cmd;
@@ -409,33 +438,33 @@ void Server::callback(Server * serv, string const & msg)
                        // we are listening.
                        if (cmd == "hello") {
                                // One more client
-                               if (serv->numclients == MAX_CLIENTS) { //paranoid check
+                               if (numclients_ == MAX_CLIENTS) { //paranoid check
                                        LYXERR(Debug::LYXSERVER)
                                                << "Server: too many clients..."
                                                << endl;
                                        return;
                                }
-                               int i= 0; //find place in clients[]
-                               while (!serv->clients[i].empty()
-                                      && i<serv->numclients)
+                               int i = 0;
+                               while (!clients_[i].empty() && i < numclients_)
                                        ++i;
-                               serv->clients[i] = client;
-                               serv->numclients++;
+                               clients_[i] = client;
+                               ++numclients_;
                                buf = "LYXSRV:" + client + ":hello\n";
                                LYXERR(Debug::LYXSERVER)
                                        << "Server: Greeting "
                                        << client << endl;
-                               serv->pipes.send(buf);
+                               pipes_.send(buf);
                        } else if (cmd == "bye") {
-                               // If clients == 0 maybe we should reset the pipes
+                               // If clients_ == 0 maybe we should reset the pipes
                                // to prevent fake callbacks
                                int i = 0; //look if client is registered
-                               for (; i < serv->numclients; ++i) {
-                                       if (serv->clients[i] == client) break;
+                               for (; i < numclients_; ++i) {
+                                       if (clients_[i] == client)
+                                               break;
                                }
-                               if (i < serv->numclients) {
-                                       serv->numclients--;
-                                       serv->clients[i].erase();
+                               if (i < numclients_) {
+                                       --numclients_;
+                                       clients_[i].erase();
                                        LYXERR(Debug::LYXSERVER)
                                                << "Server: Client "
                                                << client << " said goodbye"
@@ -460,21 +489,19 @@ void Server::callback(Server * serv, string const & msg)
                        // connect to the lyxfunc in the single LyXView we
                        // support currently. (Lgb)
 
+                       func_->dispatch(FuncRequest(lyxaction.lookupFunc(cmd), arg));
+                       string const rval = to_utf8(func_->getMessage());
 
-                       serv->func->dispatch(FuncRequest(lyxaction.lookupFunc(cmd), arg));
-                       string const rval = to_utf8(serv->func->getMessage());
-
-                       //modified june 1999 stefano@zool.su.se:
-                       //all commands produce an INFO or ERROR message
-                       //in the output pipe, even if they do not return
-                       //anything. See chapter 4 of Customization doc.
+                       // all commands produce an INFO or ERROR message
+                       // in the output pipe, even if they do not return
+                       // anything. See chapter 4 of Customization doc.
                        string buf;
-                       if (serv->func->errorStat())
+                       if (func_->errorStat())
                                buf = "ERROR:";
                        else
                                buf = "INFO:";
                        buf += client + ':' + cmd + ':' +  rval + '\n';
-                       serv->pipes.send(buf);
+                       pipes_.send(buf);
 
                        // !!! we don't do any error checking -
                        //  if the client won't listen, the
@@ -484,22 +511,14 @@ void Server::callback(Server * serv, string const & msg)
 
                        // not found
                }
-       }  /* while *p */
+       }  // while *p
 }
 
 
-/* ---F+------------------------------------------------------------------ *\
-   Function  : LyXNotifyClient
-   Called by : WorkAreaKeyPress
-   Purpose   : send a notify messge to a client
-   Parameters: s - string to send
-   Returns   : nothing
-   \* ---F------------------------------------------------------------------- */
-
+// Send a notify messge to a client, called by WorkAreaKeyPress
 void Server::notifyClient(string const & s)
 {
-       string buf = string("NOTIFY:") + s + "\n";
-       pipes.send(buf);
+       pipes_.send("NOTIFY:" + s + "\n");
 }
 
 

diff --git a/src/Server.h b/src/Server.h
index eed1ce01293cbe7de3842658611766a9e6339a16..7acee1a5c5f61f88020802a6d7b7b37bb15ecd56 100644 (file)
--- a/src/Server.h
+++ b/src/Server.h
@@ -38,12 +38,7 @@ public:
        typedef void (*ClientCallbackfct)(Server *, std::string const &);
 
        /// Construct with pipe-basename and callback to receive messages
-       LyXComm(std::string const & pip, Server * cli, ClientCallbackfct ccb = 0)
-               : pipename(pip), client(cli), clientcb(ccb)
-       {
-               ready = false;
-               openConnection();
-       }
+       LyXComm(std::string const & pip, Server * cli, ClientCallbackfct ccb = 0);
 
        ///
        ~LyXComm() { closeConnection(); }
@@ -77,26 +72,25 @@ private:
        void endPipe(int &, std::string const &, bool);
 
        /// This is -1 if not open
-       int infd;
+       int infd_;
 
        /// This is -1 if not open
-       int outfd;
+       int outfd_;
 
        /// Are we up and running?
-       bool ready;
+       bool ready_;
 
        /// Base of pipename including path
-       std::string pipename;
+       std::string pipename_;
 
        /// The client
-       Server * client;
+       Server * client_;
 
        /// The client callback function
-       ClientCallbackfct clientcb;
+       ClientCallbackfct clientcb_;
 };
 
 
-
 ///
 class Server {
 public:
@@ -111,32 +105,28 @@ public:
        // lyxserver is using a buffer that is being edited with a bufferview.
        // With a common buffer list this is not a problem, maybe. (Alejandro)
        ///
-       Server(LyXFunc * f, std::string const & pip)
-               : numclients(0), func(f), pipes(pip, (this), callback) {}
+       Server(LyXFunc * f, std::string const & pip);
        ///
        ~Server();
        ///
        void notifyClient(std::string const &);
 
        /// whilst crashing etc.
-       void emergencyCleanup() { pipes.emergencyCleanup(); }
+       void emergencyCleanup() { pipes_.emergencyCleanup(); }
+       ///
+       void callback(std::string const & msg);
 
 private:
-       ///
-       static void callback(Server *, std::string const & msg);
        /// Names and number of current clients
-       enum {
-               ///
-               MAX_CLIENTS = 10
-       };
+       enum { MAX_CLIENTS = 10 };
        ///
-       std::string clients[MAX_CLIENTS];
+       std::string clients_[MAX_CLIENTS];
        ///
-       int numclients;
+       int numclients_;
        ///
-       LyXFunc * func;
+       LyXFunc * func_;
        ///
-       LyXComm pipes;
+       LyXComm pipes_;
 };
 
 /// Implementation is in LyX.cpp

diff --git a/src/frontends/qt4/GuiKeySymbol.cpp b/src/frontends/qt4/GuiKeySymbol.cpp
index a14c55426a3a695d57fa703a9ff0118c697a08a1..1fb8ba6850832ea741fc625c7ec7c9716ed5da20 100644 (file)
--- a/src/frontends/qt4/GuiKeySymbol.cpp
+++ b/src/frontends/qt4/GuiKeySymbol.cpp
@@ -114,7 +114,7 @@ void GuiKeySymbol::init(string const & symbolname)
 
 bool GuiKeySymbol::isOK() const
 {
-       bool const ok(!(text_.isEmpty() && key_ == Qt::Key_unknown));
+       bool const ok = !(text_.isEmpty() && key_ == Qt::Key_unknown);
        LYXERR(Debug::KEY) << "isOK is " << ok << endl;
        return ok;
 }
@@ -122,7 +122,7 @@ bool GuiKeySymbol::isOK() const
 
 bool GuiKeySymbol::isModifier() const
 {
-       bool const mod(q_is_modifier(key_));
+       bool const mod = q_is_modifier(key_);
        LYXERR(Debug::KEY) << "isMod is " << mod << endl;
        return mod;
 }
@@ -130,7 +130,7 @@ bool GuiKeySymbol::isModifier() const
 
 string GuiKeySymbol::getSymbolName() const
 {
-       string sym(qkey_to_string(key_));
+       string sym = qkey_to_string(key_);
 
        // e.g. A-Za-z, and others
        if (sym.empty())

diff --git a/src/frontends/qt4/GuiView.cpp b/src/frontends/qt4/GuiView.cpp
index be92ee198fc1704bd3cffd8688c4fa1176169430..7c7ef387e0bca46d70afa8bf8216bc4fbb8485e4 100644 (file)
--- a/src/frontends/qt4/GuiView.cpp
+++ b/src/frontends/qt4/GuiView.cpp
@@ -63,9 +63,7 @@
 #include <QTabWidget>
 #include <QUrl>
 
-#include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
-#include <boost/current_function.hpp>
 
 using std::endl;
 using std::string;