FreeCAD/src/Gui/PythonConsolePy.cpp
Mateusz Skowroński d5c074f80d QString::toAscii() is obsolete in Qt5. Replace it with toLatin1().
This change is Qt4/Qt5 neutral.
2016-01-05 16:06:48 +01:00

349 lines
9.8 KiB
C++

/***************************************************************************
* Copyright (c) 2004 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QByteArray>
# include <QInputDialog>
# include <QEventLoop>
# include <QTimer>
#endif
#include "PythonConsolePy.h"
#include "PythonConsole.h"
#include "MainWindow.h"
#include <Base/Console.h>
#include <Base/Exception.h>
using namespace Gui;
void PythonStdout::init_type()
{
behaviors().name("PythonStdout");
behaviors().doc("Redirection of stdout to FreeCAD's Python console window");
// you must have overwritten the virtual functions
behaviors().supportRepr();
add_varargs_method("write",&PythonStdout::write,"write()");
add_varargs_method("flush",&PythonStdout::flush,"flush()");
}
PythonStdout::PythonStdout(PythonConsole *pc)
: pyConsole(pc)
{
}
PythonStdout::~PythonStdout()
{
}
Py::Object PythonStdout::getattr(const char *name)
{
if (strcmp(name, "softspace") == 0) {
int i=0;
return Py::Int(i);
}
return getattr_methods(name);
}
Py::Object PythonStdout::repr()
{
std::string s;
std::ostringstream s_out;
s_out << "PythonStdout";
return Py::String(s_out.str());
}
Py::Object PythonStdout::write(const Py::Tuple& args)
{
try {
Py::Object output(args[0]);
if (PyUnicode_Check(output.ptr())) {
PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
if (unicode) {
const char* string = PyString_AsString(unicode);
int maxlen = qstrlen(string) > 10000 ? 10000 : -1;
pyConsole->insertPythonOutput(QString::fromUtf8(string, maxlen));
Py_DECREF(unicode);
}
}
else {
Py::String text(args[0]);
std::string string = (std::string)text;
int maxlen = string.size() > 10000 ? 10000 : -1;
pyConsole->insertPythonOutput(QString::fromUtf8(string.c_str(), maxlen));
}
}
catch (Py::Exception& e) {
// Do not provoke error messages
e.clear();
}
return Py::None();
}
Py::Object PythonStdout::flush(const Py::Tuple&)
{
return Py::None();
}
// -------------------------------------------------------------------------
void PythonStderr::init_type()
{
behaviors().name("PythonStderr");
behaviors().doc("Redirection of stdout to FreeCAD's Python console window");
// you must have overwritten the virtual functions
behaviors().supportRepr();
add_varargs_method("write",&PythonStderr::write,"write()");
add_varargs_method("flush",&PythonStderr::flush,"flush()");
}
PythonStderr::PythonStderr(PythonConsole *pc)
: pyConsole(pc)
{
}
PythonStderr::~PythonStderr()
{
}
Py::Object PythonStderr::getattr(const char *name)
{
if (strcmp(name, "softspace") == 0) {
int i=0;
return Py::Int(i);
}
return getattr_methods(name);
}
Py::Object PythonStderr::repr()
{
std::string s;
std::ostringstream s_out;
s_out << "PythonStderr";
return Py::String(s_out.str());
}
Py::Object PythonStderr::write(const Py::Tuple& args)
{
try {
Py::Object output(args[0]);
if (PyUnicode_Check(output.ptr())) {
PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
if (unicode) {
const char* string = PyString_AsString(unicode);
int maxlen = qstrlen(string) > 10000 ? 10000 : -1;
pyConsole->insertPythonError(QString::fromUtf8(string, maxlen));
Py_DECREF(unicode);
}
}
else {
Py::String text(args[0]);
std::string string = (std::string)text;
int maxlen = string.size() > 10000 ? 10000 : -1;
pyConsole->insertPythonError(QString::fromUtf8(string.c_str(), maxlen));
}
}
catch (Py::Exception& e) {
// Do not provoke error messages
e.clear();
}
return Py::None();
}
Py::Object PythonStderr::flush(const Py::Tuple&)
{
return Py::None();
}
// -------------------------------------------------------------------------
void OutputStdout::init_type()
{
behaviors().name("OutputStdout");
behaviors().doc("Redirection of stdout to FreeCAD's output window");
// you must have overwritten the virtual functions
behaviors().supportRepr();
add_varargs_method("write",&OutputStdout::write,"write()");
add_varargs_method("flush",&OutputStdout::flush,"flush()");
}
OutputStdout::OutputStdout()
{
}
OutputStdout::~OutputStdout()
{
}
Py::Object OutputStdout::getattr(const char *name)
{
if (strcmp(name, "softspace") == 0) {
int i=0;
return Py::Int(i);
}
return getattr_methods(name);
}
Py::Object OutputStdout::repr()
{
std::string s;
std::ostringstream s_out;
s_out << "OutputStdout";
return Py::String(s_out.str());
}
Py::Object OutputStdout::write(const Py::Tuple& args)
{
try {
Py::Object output(args[0]);
if (PyUnicode_Check(output.ptr())) {
PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
if (unicode) {
const char* string = PyString_AsString(unicode);
Base::Console().Message("%s",string);
Py_DECREF(unicode);
}
}
else {
Py::String text(args[0]);
std::string string = (std::string)text;
Base::Console().Message("%s",string.c_str());
}
}
catch (Py::Exception& e) {
// Do not provoke error messages
e.clear();
}
return Py::None();
}
Py::Object OutputStdout::flush(const Py::Tuple&)
{
return Py::None();
}
// -------------------------------------------------------------------------
void OutputStderr::init_type()
{
behaviors().name("OutputStderr");
behaviors().doc("Redirection of stdout to FreeCAD's output window");
// you must have overwritten the virtual functions
behaviors().supportRepr();
add_varargs_method("write",&OutputStderr::write,"write()");
add_varargs_method("flush",&OutputStderr::flush,"flush()");
}
OutputStderr::OutputStderr()
{
}
OutputStderr::~OutputStderr()
{
}
Py::Object OutputStderr::getattr(const char *name)
{
if (strcmp(name, "softspace") == 0) {
int i=0;
return Py::Int(i);
}
return getattr_methods(name);
}
Py::Object OutputStderr::repr()
{
std::string s;
std::ostringstream s_out;
s_out << "OutputStderr";
return Py::String(s_out.str());
}
Py::Object OutputStderr::write(const Py::Tuple& args)
{
try {
Py::Object output(args[0]);
if (PyUnicode_Check(output.ptr())) {
PyObject* unicode = PyUnicode_AsEncodedObject(output.ptr(), "utf-8", "strict");
if (unicode) {
const char* string = PyString_AsString(unicode);
Base::Console().Error("%s",string);
Py_DECREF(unicode);
}
}
else {
Py::String text(args[0]);
std::string string = (std::string)text;
Base::Console().Error("%s",string.c_str());
}
}
catch (Py::Exception& e) {
// Do not provoke error messages
e.clear();
}
return Py::None();
}
Py::Object OutputStderr::flush(const Py::Tuple&)
{
return Py::None();
}
// -------------------------------------------------------------------------
void PythonStdin::init_type()
{
behaviors().name("PythonStdin");
behaviors().doc("Redirection of stdin to FreeCAD to open an input dialog");
// you must have overwritten the virtual functions
behaviors().supportRepr();
add_varargs_method("readline",&PythonStdin::readline,"readline()");
}
PythonStdin::PythonStdin(PythonConsole *pc)
: pyConsole(pc)
{
}
PythonStdin::~PythonStdin()
{
}
Py::Object PythonStdin::repr()
{
std::string s;
std::ostringstream s_out;
s_out << "PythonStdin";
return Py::String(s_out.str());
}
Py::Object PythonStdin::readline(const Py::Tuple& args)
{
return Py::String( (const char *)pyConsole->readline().toLatin1() );
}