Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 567)
+++ lemon/cbc.cc	(revision 576)
@@ -56,10 +56,13 @@
     _osi_solver = 0;
     _cbc_model = 0;
+    messageLevel(MESSAGE_NOTHING);
   }
 
   CbcMip::CbcMip(const CbcMip& other) {
     _prob = new CoinModel(*other._prob);
+    _prob->setProblemName("LEMON");
     _osi_solver = 0;
     _cbc_model = 0;
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -271,22 +274,6 @@
     _cbc_model= new CbcModel(*_osi_solver);
 
-    switch (_message_level) {
-    case MESSAGE_NO_OUTPUT:
-      _osi_solver->messageHandler()->setLogLevel(0);
-      _cbc_model->setLogLevel(0);
-      break;
-    case MESSAGE_ERROR_MESSAGE:
-      _osi_solver->messageHandler()->setLogLevel(1);
-      _cbc_model->setLogLevel(1);
-      break;
-    case MESSAGE_NORMAL_OUTPUT:
-      _osi_solver->messageHandler()->setLogLevel(2);
-      _cbc_model->setLogLevel(2);
-      break;
-    case MESSAGE_FULL_OUTPUT:
-      _osi_solver->messageHandler()->setLogLevel(3);
-      _cbc_model->setLogLevel(3);
-      break;
-    }
+    _osi_solver->messageHandler()->setLogLevel(_message_level);
+    _cbc_model->setLogLevel(_message_level);
 
     _cbc_model->initialSolve();
@@ -454,6 +441,22 @@
   }
 
-  void CbcMip::messageLevel(MessageLevel m) {
-    _message_level = m;
+  void CbcMip::_messageLevel(MessageLevel level) {
+    switch (level) {
+    case MESSAGE_NOTHING:
+      _message_level = 0;
+      break;
+    case MESSAGE_ERROR:
+      _message_level = 1;
+      break;
+    case MESSAGE_WARNING:
+      _message_level = 1;
+      break;
+    case MESSAGE_NORMAL:
+      _message_level = 2;
+      break;
+    case MESSAGE_VERBOSE:
+      _message_level = 3;
+      break;
+    }
   }
 
Index: lemon/cbc.h
===================================================================
--- lemon/cbc.h	(revision 567)
+++ lemon/cbc.h	(revision 576)
@@ -116,31 +116,10 @@
     virtual void _clear();
 
-  public:
+    virtual void _messageLevel(MessageLevel level);
+    void _applyMessageLevel();
 
-    ///Enum for \c messageLevel() parameter
-    enum MessageLevel {
-      /// no output (default value)
-      MESSAGE_NO_OUTPUT = 0,
-      /// error messages only
-      MESSAGE_ERROR_MESSAGE = 1,
-      /// normal output
-      MESSAGE_NORMAL_OUTPUT = 2,
-      /// full output (includes informational messages)
-      MESSAGE_FULL_OUTPUT = 3
-    };
+    int _message_level;
 
-  private:
-
-    MessageLevel _message_level;
-
-  public:
-
-    ///Set the verbosity of the messages
-
-    ///Set the verbosity of the messages
-    ///
-    ///\param m is the level of the messages output by the solver routines.
-    void messageLevel(MessageLevel m);
-
+    
 
   };
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 540)
+++ lemon/clp.cc	(revision 576)
@@ -25,5 +25,5 @@
     _prob = new ClpSimplex();
     _init_temporals();
-    messageLevel(MESSAGE_NO_OUTPUT);
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -33,5 +33,5 @@
     cols = other.cols;
     _init_temporals();
-    messageLevel(MESSAGE_NO_OUTPUT);
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -431,6 +431,22 @@
   }
 
-  void ClpLp::messageLevel(MessageLevel m) {
-    _prob->setLogLevel(static_cast<int>(m));
+  void ClpLp::_messageLevel(MessageLevel level) {
+    switch (level) {
+    case MESSAGE_NOTHING:
+      _prob->setLogLevel(0);
+      break;
+    case MESSAGE_ERROR:
+      _prob->setLogLevel(1);
+      break;
+    case MESSAGE_WARNING:
+      _prob->setLogLevel(2);
+      break;
+    case MESSAGE_NORMAL:
+      _prob->setLogLevel(3);
+      break;
+    case MESSAGE_VERBOSE:
+      _prob->setLogLevel(4);
+      break;
+    }
   }
 
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 540)
+++ lemon/clp.h	(revision 576)
@@ -137,4 +137,6 @@
     virtual void _clear();
 
+    virtual void _messageLevel(MessageLevel);
+    
   public:
 
@@ -154,24 +156,4 @@
     int clpCol(Col c) const { return cols(id(c)); }
 
-    ///Enum for \c messageLevel() parameter
-    enum MessageLevel {
-      /// no output (default value)
-      MESSAGE_NO_OUTPUT = 0,
-      /// print final solution
-      MESSAGE_FINAL_SOLUTION = 1,
-      /// print factorization
-      MESSAGE_FACTORIZATION = 2,
-      /// normal output
-      MESSAGE_NORMAL_OUTPUT = 3,
-      /// verbose output
-      MESSAGE_VERBOSE_OUTPUT = 4
-    };
-    ///Set the verbosity of the messages
-
-    ///Set the verbosity of the messages
-    ///
-    ///\param m is the level of the messages output by the solver routines.
-    void messageLevel(MessageLevel m);
-
   };
 
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 551)
+++ lemon/cplex.cc	(revision 576)
@@ -73,4 +73,5 @@
     int status;
     _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -79,4 +80,5 @@
     int status;
     _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -87,4 +89,5 @@
     rows = cplex.rows;
     cols = cplex.cols;
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -437,4 +440,23 @@
     rows.clear();
     cols.clear();
+  }
+
+  void CplexBase::_messageLevel(MessageLevel level) {
+    switch (level) {
+    case MESSAGE_NOTHING:
+      _message_enabled = false;
+      break;
+    case MESSAGE_ERROR:
+    case MESSAGE_WARNING:
+    case MESSAGE_NORMAL:
+    case MESSAGE_VERBOSE:
+      _message_enabled = true;
+      break;
+    }
+  }
+
+  void CplexBase::_applyMessageLevel() {
+    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, 
+                   _message_enabled ? CPX_ON : CPX_OFF);
   }
 
@@ -508,4 +530,5 @@
   CplexLp::SolveExitStatus CplexLp::_solve() {
     _clear_temporals();
+    _applyMessageLevel();
     return convertStatus(CPXlpopt(cplexEnv(), _prob));
   }
@@ -513,4 +536,5 @@
   CplexLp::SolveExitStatus CplexLp::solvePrimal() {
     _clear_temporals();
+    _applyMessageLevel();
     return convertStatus(CPXprimopt(cplexEnv(), _prob));
   }
@@ -518,4 +542,5 @@
   CplexLp::SolveExitStatus CplexLp::solveDual() {
     _clear_temporals();
+    _applyMessageLevel();
     return convertStatus(CPXdualopt(cplexEnv(), _prob));
   }
@@ -523,4 +548,5 @@
   CplexLp::SolveExitStatus CplexLp::solveBarrier() {
     _clear_temporals();
+    _applyMessageLevel();
     return convertStatus(CPXbaropt(cplexEnv(), _prob));
   }
@@ -601,5 +627,5 @@
   }
 
-  //7.5-os cplex statusai (Vigyazat: a 9.0-asei masok!)
+  // Cplex 7.0 status values
   // This table lists the statuses, returned by the CPXgetstat()
   // routine, for solutions to LP problems or mixed integer problems. If
@@ -648,5 +674,5 @@
   //       User pivot used
   //
-  //     Ezeket hova tegyem:
+  // Pending return values
   // ??case CPX_ABORT_DUAL_INFEAS
   // ??case CPX_ABORT_CROSSOVER
@@ -719,5 +745,4 @@
     statusSwitch(cplexEnv(),stat);
     //CPXgetstat(cplexEnv(), _prob);
-    //printf("A primal status: %d, CPX_OPTIMAL=%d \n",stat,CPX_OPTIMAL);
     switch (stat) {
     case 0:
@@ -752,5 +777,5 @@
   }
 
-  //9.0-as cplex verzio statusai
+  // Cplex 9.0 status values
   // CPX_STAT_ABORT_DUAL_OBJ_LIM
   // CPX_STAT_ABORT_IT_LIM
@@ -865,4 +890,5 @@
   CplexMip::SolveExitStatus CplexMip::_solve() {
     int status;
+    _applyMessageLevel();
     status = CPXmipopt (cplexEnv(), _prob);
     if (status==0)
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 551)
+++ lemon/cplex.h	(revision 576)
@@ -145,12 +145,27 @@
     virtual void _clear();
 
+    virtual void _messageLevel(MessageLevel level);
+    void _applyMessageLevel();
+
+    bool _message_enabled;
+
   public:
 
     /// Returns the used \c CplexEnv instance
     const CplexEnv& env() const { return _env; }
+
+    /// \brief Returns the const cpxenv pointer
     ///
+    /// \note The cpxenv might be destructed with the solver.
     const cpxenv* cplexEnv() const { return _env.cplexEnv(); }
 
+    /// \brief Returns the const cpxenv pointer
+    ///
+    /// \note The cpxenv might be destructed with the solver.
+    cpxenv* cplexEnv() { return _env.cplexEnv(); }
+
+    /// Returns the cplex problem object
     cpxlp* cplexLp() { return _prob; }
+    /// Returns the cplex problem object
     const cpxlp* cplexLp() const { return _prob; }
 
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 566)
+++ lemon/glpk.cc	(revision 576)
@@ -32,4 +32,5 @@
     lp = glp_create_prob();
     glp_create_index(lp);
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -40,4 +41,5 @@
     rows = other.rows;
     cols = other.cols;
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -527,4 +529,24 @@
   }
 
+  void GlpkBase::_messageLevel(MessageLevel level) {
+    switch (level) {
+    case MESSAGE_NOTHING:
+      _message_level = GLP_MSG_OFF;
+      break;
+    case MESSAGE_ERROR:
+      _message_level = GLP_MSG_ERR;
+      break;
+    case MESSAGE_WARNING:
+      _message_level = GLP_MSG_ERR;
+      break;
+    case MESSAGE_NORMAL:
+      _message_level = GLP_MSG_ON;
+      break;
+    case MESSAGE_VERBOSE:
+      _message_level = GLP_MSG_ALL;
+      break;
+    }
+  }
+
   GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;
 
@@ -533,5 +555,4 @@
   GlpkLp::GlpkLp()
     : LpBase(), LpSolver(), GlpkBase() {
-    messageLevel(MESSAGE_NO_OUTPUT);
     presolver(false);
   }
@@ -539,5 +560,4 @@
   GlpkLp::GlpkLp(const GlpkLp& other)
     : LpBase(other), LpSolver(other), GlpkBase(other) {
-    messageLevel(MESSAGE_NO_OUTPUT);
     presolver(false);
   }
@@ -563,18 +583,5 @@
     glp_init_smcp(&smcp);
 
-    switch (_message_level) {
-    case MESSAGE_NO_OUTPUT:
-      smcp.msg_lev = GLP_MSG_OFF;
-      break;
-    case MESSAGE_ERROR_MESSAGE:
-      smcp.msg_lev = GLP_MSG_ERR;
-      break;
-    case MESSAGE_NORMAL_OUTPUT:
-      smcp.msg_lev = GLP_MSG_ON;
-      break;
-    case MESSAGE_FULL_OUTPUT:
-      smcp.msg_lev = GLP_MSG_ALL;
-      break;
-    }
+    smcp.msg_lev = _message_level;
     smcp.presolve = _presolve;
 
@@ -605,18 +612,5 @@
     glp_init_smcp(&smcp);
 
-    switch (_message_level) {
-    case MESSAGE_NO_OUTPUT:
-      smcp.msg_lev = GLP_MSG_OFF;
-      break;
-    case MESSAGE_ERROR_MESSAGE:
-      smcp.msg_lev = GLP_MSG_ERR;
-      break;
-    case MESSAGE_NORMAL_OUTPUT:
-      smcp.msg_lev = GLP_MSG_ON;
-      break;
-    case MESSAGE_FULL_OUTPUT:
-      smcp.msg_lev = GLP_MSG_ALL;
-      break;
-    }
+    smcp.msg_lev = _message_level;
     smcp.meth = GLP_DUAL;
     smcp.presolve = _presolve;
@@ -859,18 +853,12 @@
   }
 
-  void GlpkLp::messageLevel(MessageLevel m) {
-    _message_level = m;
-  }
-
   // GlpkMip members
 
   GlpkMip::GlpkMip()
     : LpBase(), MipSolver(), GlpkBase() {
-    messageLevel(MESSAGE_NO_OUTPUT);
   }
 
   GlpkMip::GlpkMip(const GlpkMip& other)
     : LpBase(), MipSolver(), GlpkBase(other) {
-    messageLevel(MESSAGE_NO_OUTPUT);
   }
 
@@ -901,18 +889,5 @@
     glp_init_smcp(&smcp);
 
-    switch (_message_level) {
-    case MESSAGE_NO_OUTPUT:
-      smcp.msg_lev = GLP_MSG_OFF;
-      break;
-    case MESSAGE_ERROR_MESSAGE:
-      smcp.msg_lev = GLP_MSG_ERR;
-      break;
-    case MESSAGE_NORMAL_OUTPUT:
-      smcp.msg_lev = GLP_MSG_ON;
-      break;
-    case MESSAGE_FULL_OUTPUT:
-      smcp.msg_lev = GLP_MSG_ALL;
-      break;
-    }
+    smcp.msg_lev = _message_level;
     smcp.meth = GLP_DUAL;
 
@@ -939,18 +914,5 @@
     glp_init_iocp(&iocp);
 
-    switch (_message_level) {
-    case MESSAGE_NO_OUTPUT:
-      iocp.msg_lev = GLP_MSG_OFF;
-      break;
-    case MESSAGE_ERROR_MESSAGE:
-      iocp.msg_lev = GLP_MSG_ERR;
-      break;
-    case MESSAGE_NORMAL_OUTPUT:
-      iocp.msg_lev = GLP_MSG_ON;
-      break;
-    case MESSAGE_FULL_OUTPUT:
-      iocp.msg_lev = GLP_MSG_ALL;
-      break;
-    }
+    iocp.msg_lev = _message_level;
 
     if (glp_intopt(lp, &iocp) != 0) return UNSOLVED;
@@ -1003,7 +965,3 @@
   const char* GlpkMip::_solverName() const { return "GlpkMip"; }
 
-  void GlpkMip::messageLevel(MessageLevel m) {
-    _message_level = m;
-  }
-
 } //END OF NAMESPACE LEMON
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 565)
+++ lemon/glpk.h	(revision 576)
@@ -100,4 +100,6 @@
 
     virtual void _clear();
+
+    virtual void _messageLevel(MessageLevel level);
 
   private:
@@ -112,4 +114,8 @@
     
     static FreeEnvHelper freeEnvHelper;
+
+  protected:
+    
+    int _message_level;
     
   public:
@@ -192,28 +198,4 @@
     void presolver(bool presolve);
 
-    ///Enum for \c messageLevel() parameter
-    enum MessageLevel {
-      /// no output (default value)
-      MESSAGE_NO_OUTPUT = 0,
-      /// error messages only
-      MESSAGE_ERROR_MESSAGE = 1,
-      /// normal output
-      MESSAGE_NORMAL_OUTPUT = 2,
-      /// full output (includes informational messages)
-      MESSAGE_FULL_OUTPUT = 3
-    };
-
-  private:
-
-    MessageLevel _message_level;
-
-  public:
-
-    ///Set the verbosity of the messages
-
-    ///Set the verbosity of the messages
-    ///
-    ///\param m is the level of the messages output by the solver routines.
-    void messageLevel(MessageLevel m);
   };
 
@@ -245,28 +227,4 @@
     virtual Value _getSolValue() const;
 
-    ///Enum for \c messageLevel() parameter
-    enum MessageLevel {
-      /// no output (default value)
-      MESSAGE_NO_OUTPUT = 0,
-      /// error messages only
-      MESSAGE_ERROR_MESSAGE = 1,
-      /// normal output
-      MESSAGE_NORMAL_OUTPUT = 2,
-      /// full output (includes informational messages)
-      MESSAGE_FULL_OUTPUT = 3
-    };
-
-  private:
-
-    MessageLevel _message_level;
-
-  public:
-
-    ///Set the verbosity of the messages
-
-    ///Set the verbosity of the messages
-    ///
-    ///\param m is the level of the messages output by the solver routines.
-    void messageLevel(MessageLevel m);
   };
 
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 540)
+++ lemon/lp_base.h	(revision 576)
@@ -69,4 +69,19 @@
       MAX
     };
+
+    ///Enum for \c messageLevel() parameter
+    enum MessageLevel {
+      /// no output (default value)
+      MESSAGE_NOTHING,
+      /// error messages only
+      MESSAGE_ERROR,
+      /// warnings
+      MESSAGE_WARNING,
+      /// normal output
+      MESSAGE_NORMAL,
+      /// verbose output
+      MESSAGE_VERBOSE
+    };
+    
 
     ///The floating point type used by the solver
@@ -974,4 +989,6 @@
     virtual const char* _solverName() const = 0;
 
+    virtual void _messageLevel(MessageLevel level) = 0;
+
     //Own protected stuff
 
@@ -1528,4 +1545,7 @@
     void clear() { _clear(); }
 
+    /// Sets the message level of the solver
+    void messageLevel(MessageLevel level) { _messageLevel(level); }
+
     ///@}
 
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 540)
+++ lemon/lp_skeleton.cc	(revision 576)
@@ -85,4 +85,6 @@
   }
 
+  void SkeletonSolverBase::_messageLevel(MessageLevel) {}
+
   LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }
 
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 541)
+++ lemon/lp_skeleton.h	(revision 576)
@@ -141,4 +141,6 @@
     virtual void _clear();
 
+    ///\e
+    virtual void _messageLevel(MessageLevel);
   };
 
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 540)
+++ lemon/soplex.cc	(revision 576)
@@ -21,4 +21,5 @@
 
 #include <soplex.h>
+#include <spxout.h>
 
 
@@ -29,4 +30,5 @@
   SoplexLp::SoplexLp() {
     soplex = new soplex::SoPlex;
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -48,4 +50,5 @@
     _row_names_ref = lp._row_names_ref;
 
+    messageLevel(MESSAGE_NOTHING);
   }
 
@@ -272,4 +275,6 @@
 
     _clear_temporals();
+    
+    _applyMessageLevel();
 
     soplex::SPxSolver::Status status = soplex->solve();
@@ -420,4 +425,28 @@
   }
 
+  void SoplexLp::_messageLevel(MessageLevel level) {
+    switch (level) {
+    case MESSAGE_NOTHING:
+      _message_level = -1;
+      break;
+    case MESSAGE_ERROR:
+      _message_level = soplex::SPxOut::ERROR;
+      break;
+    case MESSAGE_WARNING:
+      _message_level = soplex::SPxOut::WARNING;
+      break;
+    case MESSAGE_NORMAL:
+      _message_level = soplex::SPxOut::INFO2;
+      break;
+    case MESSAGE_VERBOSE:
+      _message_level = soplex::SPxOut::DEBUG;
+      break;
+    }
+  }
+
+  void SoplexLp::_applyMessageLevel() {
+    soplex::Param::setVerbose(_message_level);
+  }
+
 } //namespace lemon
 
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 540)
+++ lemon/soplex.h	(revision 576)
@@ -145,4 +145,9 @@
     virtual void _clear();
 
+    void _messageLevel(MessageLevel m);
+    void _applyMessageLevel();
+
+    int _message_level;
+
   };
 
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 575)
+++ test/lp_test.cc	(revision 551)
@@ -396,5 +396,10 @@
     cloneTest<CplexLp>();
   } catch (CplexEnv::LicenseError& error) {
+#ifdef LEMON_FORCE_CPLEX_CHECK
     check(false, error.what());
+#else
+    std::cerr << error.what() << std::endl;
+    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
+#endif
   }
 #endif
Index: test/mip_test.cc
===================================================================
--- test/mip_test.cc	(revision 575)
+++ test/mip_test.cc	(revision 567)
@@ -144,5 +144,10 @@
     cloneTest<CplexMip>();
   } catch (CplexEnv::LicenseError& error) {
+#ifdef LEMON_FORCE_CPLEX_CHECK
     check(false, error.what());
+#else
+    std::cerr << error.what() << std::endl;
+    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
+#endif
   }
 #endif