FreeCAD / src /Gui /Selection /SelectionFilter.cpp

Upload folder using huggingface_hub

985c397 verified 10 months ago

10.8 kB

// SPDX-License-Identifier: LGPL-2.1-or-later
/***************************************************************************
 *   Copyright (c) 2009 Jürgen Riegel <FreeCAD@juergen-riegel.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                                *
 *                                                                         *
 ***************************************************************************/


#ifdef __GNUC__
# include <unistd.h>
#endif

#include <sstream>

#include <App/Document.h>
#include <App/DocumentObjectPy.h>
#include <App/DocumentObject.h>
#include <Base/Interpreter.h>
#include <Base/Tools.h>
#include "Selection.h"
#include "SelectionFilter.h"
#include "SelectionFilterPy.h"
#include "SelectionObject.h"


using namespace Gui;

// suppress annoying warnings from generated source files
#ifdef _MSC_VER
# pragma warning(disable : 4003)
# pragma warning(disable : 4018)
# pragma warning(disable : 4065)
# pragma warning(disable : 4335)  // disable MAC file format warning on VC
#endif


SelectionFilterGate::SelectionFilterGate(const char* filter)
{
    Filter = new SelectionFilter(filter);
}

SelectionFilterGate::SelectionFilterGate(SelectionFilter* filter)
{
    Filter = filter;
}

SelectionFilterGate::SelectionFilterGate()
{
    Filter = nullptr;
}

SelectionFilterGate::~SelectionFilterGate()
{
    delete Filter;
}

bool SelectionFilterGate::allow(App::Document* /*pDoc*/, App::DocumentObject* pObj, const char* sSubName)
{
    return Filter->test(pObj, sSubName);
}

// ----------------------------------------------------------------------------

SelectionGatePython::SelectionGatePython(const Py::Object& obj)
    : gate(obj)
{}

SelectionGatePython::~SelectionGatePython() = default;

bool SelectionGatePython::allow(App::Document* doc, App::DocumentObject* obj, const char* sub)
{
    Base::PyGILStateLocker lock;
    try {
        if (this->gate.hasAttr(std::string("allow"))) {
            Py::Callable method(this->gate.getAttr(std::string("allow")));
            Py::Object pyDoc = Py::asObject(doc->getPyObject());
            Py::Object pyObj = Py::asObject(obj->getPyObject());
            Py::Object pySub = Py::None();
            if (sub) {
                pySub = Py::String(sub);
            }
            Py::Tuple args(3);
            args.setItem(0, pyDoc);
            args.setItem(1, pyObj);
            args.setItem(2, pySub);
            Py::Boolean ok(method.apply(args));
            return (bool)ok;
        }
    }
    catch (Py::Exception&) {
        Base::PyException e;  // extract the Python error text
        e.reportException();
    }

    return true;
}

// ----------------------------------------------------------------------------

SelectionFilterGatePython::SelectionFilterGatePython(SelectionFilterPy* obj)
    : filter(obj)
{
    Base::PyGILStateLocker lock;
    Py_INCREF(filter);
}

SelectionFilterGatePython::~SelectionFilterGatePython()
{
    Base::PyGILStateLocker lock;
    Py_DECREF(filter);
}

bool SelectionFilterGatePython::allow(App::Document*, App::DocumentObject* obj, const char* sub)
{
    return filter->filter.test(obj, sub);
}

// ----------------------------------------------------------------------------

SelectionFilter::SelectionFilter(const char* filter, App::DocumentObject* container)
    : container(container)
{
    setFilter(filter);
}

SelectionFilter::SelectionFilter(const std::string& filter, App::DocumentObject* container)
    : container(container)
{
    setFilter(filter.c_str());
}

void SelectionFilter::setFilter(const char* filter)
{
    if (Base::Tools::isNullOrEmpty(filter)) {
        Ast.reset();
        Filter.clear();
    }
    else {
        Filter = filter;
        if (!parse()) {
            throw Base::ParserError(Errors.c_str());
        }
    }
}

SelectionFilter::~SelectionFilter() = default;

bool SelectionFilter::match()
{
    if (!Ast) {
        return false;
    }
    Result.clear();

    for (const auto& it : Ast->Objects) {
        std::size_t min = 1;
        std::size_t max = 1;

        if (it->Slice) {
            min = it->Slice->Min;
            max = it->Slice->Max;
        }
        std::vector<Gui::SelectionObject> temp = container
            ? Gui::Selection().getSelectionIn(container, it->ObjectType)
            : Gui::Selection().getSelectionEx(nullptr, it->ObjectType);

        // test if subnames present
        if (it->SubName.empty()) {
            // if no subnames the count of the object get tested
            if (temp.size() < min || temp.size() > max) {
                return false;
            }
        }
        else {
            // if subnames present count all subs over the selected object of type
            std::size_t subCount = 0;
            for (const auto& it2 : temp) {
                const std::vector<std::string>& subNames = it2.getSubNames();
                if (subNames.empty()) {
                    return false;
                }
                for (const auto& subName : subNames) {
                    if (subName.find(it->SubName) != 0) {
                        return false;
                    }
                }
                subCount += subNames.size();
            }

            if (subCount < min || subCount > max) {
                return false;
            }
        }

        Result.push_back(temp);
    }
    return true;
}

bool SelectionFilter::test(App::DocumentObject* pObj, const char* sSubName)
{
    if (!Ast) {
        return false;
    }

    for (const auto& it : Ast->Objects) {
        if (pObj->isDerivedFrom(it->ObjectType)) {
            if (!sSubName) {
                return true;
            }
            if (it->SubName.empty()) {
                return true;
            }
            if (std::string(sSubName).find(it->SubName) == 0) {
                return true;
            }
        }
    }
    return false;
}

void SelectionFilter::addError(const char* e)
{
    Errors += e;
    Errors += '\n';
}

// === Parser & Scanner stuff ===============================================

// include the Scanner and the Parser for the filter language

SelectionFilter* ActFilter = nullptr;
Node_Block* TopBlock = nullptr;

// error func
void yyerror(const char* errorinfo)
{
    ActFilter->addError(errorinfo);
}


// for VC9 (isatty and fileno not supported anymore)
#ifdef _MSC_VER
int isatty(int i)
{
    return _isatty(i);
}
int fileno(FILE* stream)
{
    return _fileno(stream);
}
#endif

namespace SelectionParser
{

/*!
 * \brief The StringFactory class
 * Helper class to record the created strings used by the parser.
 */
class StringFactory
{
    std::list<std::unique_ptr<std::string>> data;
    std::size_t max_elements = 20;

public:
    static StringFactory* instance()
    {
        static auto inst = new StringFactory();
        return inst;
    }
    std::string* make(const std::string& str)
    {
        data.push_back(std::make_unique<std::string>(str));
        return data.back().get();
    }
    static std::string* New(const std::string& str)
    {
        return StringFactory::instance()->make(str);
    }
    void clear()
    {
        if (data.size() > max_elements) {
            data.clear();
        }
    }
};

// show the parser the lexer method
#define yylex SelectionFilterlex
int SelectionFilterlex();

// Parser, defined in SelectionFilter.y
#include "SelectionFilter.tab.c"

#ifndef DOXYGEN_SHOULD_SKIP_THIS
// Scanner, defined in SelectionFilter.l
# if defined(__clang__)
#  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Wsign-compare"
#  pragma clang diagnostic ignored "-Wunneeded-internal-declaration"
# elif defined(__GNUC__)
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wsign-compare"
# endif
# include "SelectionFilter.lex.cpp"
# if defined(__clang__)
#  pragma clang diagnostic pop
# elif defined(__GNUC__)
#  pragma GCC diagnostic pop
# endif
#endif  // DOXYGEN_SHOULD_SKIP_THIS

class StringBufferCleaner
{
public:
    explicit StringBufferCleaner(YY_BUFFER_STATE buffer)
        : my_string_buffer {buffer}
    {}
    ~StringBufferCleaner()
    {
        // free the scan buffer
        yy_delete_buffer(my_string_buffer);
    }

    StringBufferCleaner(const StringBufferCleaner&) = delete;
    StringBufferCleaner(StringBufferCleaner&&) = delete;
    StringBufferCleaner& operator=(const StringBufferCleaner&) = delete;
    StringBufferCleaner& operator=(StringBufferCleaner&&) = delete;

private:
    YY_BUFFER_STATE my_string_buffer;
};

}  // namespace SelectionParser

bool SelectionFilter::parse()
{
    Errors = "";
    SelectionParser::YY_BUFFER_STATE my_string_buffer = SelectionParser::SelectionFilter_scan_string(
        Filter.c_str()
    );
    SelectionParser::StringBufferCleaner cleaner(my_string_buffer);
    // be aware that this parser is not reentrant! Don't use with Threats!!!
    assert(!ActFilter);
    ActFilter = this;
    /*int my_parse_result =*/SelectionParser::yyparse();
    ActFilter = nullptr;
    Ast.reset(TopBlock);
    TopBlock = nullptr;
    SelectionParser::StringFactory::instance()->clear();

    if (Errors.empty()) {
        return true;
    }
    else {
        return false;
    }
}

	// SPDX-License-Identifier: LGPL-2.1-or-later
	/***************************************************************************
	* Copyright (c) 2009 Jürgen Riegel <FreeCAD@juergen-riegel.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 *
	* *
	***************************************************************************/


	#ifdef __GNUC__
	# include <unistd.h>
	#endif

	#include <sstream>

	#include <App/Document.h>
	#include <App/DocumentObjectPy.h>
	#include <App/DocumentObject.h>
	#include <Base/Interpreter.h>
	#include <Base/Tools.h>
	#include "Selection.h"
	#include "SelectionFilter.h"
	#include "SelectionFilterPy.h"
	#include "SelectionObject.h"


	using namespace Gui;

	// suppress annoying warnings from generated source files
	#ifdef _MSC_VER
	# pragma warning(disable : 4003)
	# pragma warning(disable : 4018)
	# pragma warning(disable : 4065)
	# pragma warning(disable : 4335) // disable MAC file format warning on VC
	#endif


	SelectionFilterGate::SelectionFilterGate(const char* filter)
	{
	Filter = new SelectionFilter(filter);
	}

	SelectionFilterGate::SelectionFilterGate(SelectionFilter* filter)
	{
	Filter = filter;
	}

	SelectionFilterGate::SelectionFilterGate()
	{
	Filter = nullptr;
	}

	SelectionFilterGate::~SelectionFilterGate()
	{
	delete Filter;
	}

	bool SelectionFilterGate::allow(App::Document* /pDoc/, App::DocumentObject* pObj, const char* sSubName)
	{
	return Filter->test(pObj, sSubName);
	}

	// ----------------------------------------------------------------------------

	SelectionGatePython::SelectionGatePython(const Py::Object& obj)
	: gate(obj)
	{}

	SelectionGatePython::~SelectionGatePython() = default;

	bool SelectionGatePython::allow(App::Document* doc, App::DocumentObject* obj, const char* sub)
	{
	Base::PyGILStateLocker lock;
	try {
	if (this->gate.hasAttr(std::string("allow"))) {
	Py::Callable method(this->gate.getAttr(std::string("allow")));
	Py::Object pyDoc = Py::asObject(doc->getPyObject());
	Py::Object pyObj = Py::asObject(obj->getPyObject());
	Py::Object pySub = Py::None();
	if (sub) {
	pySub = Py::String(sub);
	}
	Py::Tuple args(3);
	args.setItem(0, pyDoc);
	args.setItem(1, pyObj);
	args.setItem(2, pySub);
	Py::Boolean ok(method.apply(args));
	return (bool)ok;
	}
	}
	catch (Py::Exception&) {
	Base::PyException e; // extract the Python error text
	e.reportException();
	}

	return true;
	}

	// ----------------------------------------------------------------------------

	SelectionFilterGatePython::SelectionFilterGatePython(SelectionFilterPy* obj)
	: filter(obj)
	{
	Base::PyGILStateLocker lock;
	Py_INCREF(filter);
	}

	SelectionFilterGatePython::~SelectionFilterGatePython()
	{
	Base::PyGILStateLocker lock;
	Py_DECREF(filter);
	}

	bool SelectionFilterGatePython::allow(App::Document, App::DocumentObject obj, const char* sub)
	{
	return filter->filter.test(obj, sub);
	}

	// ----------------------------------------------------------------------------

	SelectionFilter::SelectionFilter(const char* filter, App::DocumentObject* container)
	: container(container)
	{
	setFilter(filter);
	}

	SelectionFilter::SelectionFilter(const std::string& filter, App::DocumentObject* container)
	: container(container)
	{
	setFilter(filter.c_str());
	}

	void SelectionFilter::setFilter(const char* filter)
	{
	if (Base::Tools::isNullOrEmpty(filter)) {
	Ast.reset();
	Filter.clear();
	}
	else {
	Filter = filter;
	if (!parse()) {
	throw Base::ParserError(Errors.c_str());
	}
	}
	}

	SelectionFilter::~SelectionFilter() = default;

	bool SelectionFilter::match()
	{
	if (!Ast) {
	return false;
	}
	Result.clear();

	for (const auto& it : Ast->Objects) {
	std::size_t min = 1;
	std::size_t max = 1;

	if (it->Slice) {
	min = it->Slice->Min;
	max = it->Slice->Max;
	}
	std::vector<Gui::SelectionObject> temp = container
	? Gui::Selection().getSelectionIn(container, it->ObjectType)
	: Gui::Selection().getSelectionEx(nullptr, it->ObjectType);

	// test if subnames present
	if (it->SubName.empty()) {
	// if no subnames the count of the object get tested
	if (temp.size() < min \|\| temp.size() > max) {
	return false;
	}
	}
	else {
	// if subnames present count all subs over the selected object of type
	std::size_t subCount = 0;
	for (const auto& it2 : temp) {
	const std::vector<std::string>& subNames = it2.getSubNames();
	if (subNames.empty()) {
	return false;
	}
	for (const auto& subName : subNames) {
	if (subName.find(it->SubName) != 0) {
	return false;
	}
	}
	subCount += subNames.size();
	}

	if (subCount < min \|\| subCount > max) {
	return false;
	}
	}

	Result.push_back(temp);
	}
	return true;
	}

	bool SelectionFilter::test(App::DocumentObject* pObj, const char* sSubName)
	{
	if (!Ast) {
	return false;
	}

	for (const auto& it : Ast->Objects) {
	if (pObj->isDerivedFrom(it->ObjectType)) {
	if (!sSubName) {
	return true;
	}
	if (it->SubName.empty()) {
	return true;
	}
	if (std::string(sSubName).find(it->SubName) == 0) {
	return true;
	}
	}
	}
	return false;
	}

	void SelectionFilter::addError(const char* e)
	{
	Errors += e;
	Errors += '\n';
	}

	// === Parser & Scanner stuff ===============================================

	// include the Scanner and the Parser for the filter language

	SelectionFilter* ActFilter = nullptr;
	Node_Block* TopBlock = nullptr;

	// error func
	void yyerror(const char* errorinfo)
	{
	ActFilter->addError(errorinfo);
	}


	// for VC9 (isatty and fileno not supported anymore)
	#ifdef _MSC_VER
	int isatty(int i)
	{
	return _isatty(i);
	}
	int fileno(FILE* stream)
	{
	return _fileno(stream);
	}
	#endif

	namespace SelectionParser
	{

	/*!
	* \brief The StringFactory class
	* Helper class to record the created strings used by the parser.
	*/
	class StringFactory
	{
	std::list<std::unique_ptr<std::string>> data;
	std::size_t max_elements = 20;

	public:
	static StringFactory* instance()
	{
	static auto inst = new StringFactory();
	return inst;
	}
	std::string* make(const std::string& str)
	{
	data.push_back(std::make_unique<std::string>(str));
	return data.back().get();
	}
	static std::string* New(const std::string& str)
	{
	return StringFactory::instance()->make(str);
	}
	void clear()
	{
	if (data.size() > max_elements) {
	data.clear();
	}
	}
	};

	// show the parser the lexer method
	#define yylex SelectionFilterlex
	int SelectionFilterlex();

	// Parser, defined in SelectionFilter.y
	#include "SelectionFilter.tab.c"

	#ifndef DOXYGEN_SHOULD_SKIP_THIS
	// Scanner, defined in SelectionFilter.l
	# if defined(__clang__)
	# pragma clang diagnostic push
	# pragma clang diagnostic ignored "-Wsign-compare"
	# pragma clang diagnostic ignored "-Wunneeded-internal-declaration"
	# elif defined(__GNUC__)
	# pragma GCC diagnostic push
	# pragma GCC diagnostic ignored "-Wsign-compare"
	# endif
	# include "SelectionFilter.lex.cpp"
	# if defined(__clang__)
	# pragma clang diagnostic pop
	# elif defined(__GNUC__)
	# pragma GCC diagnostic pop
	# endif
	#endif // DOXYGEN_SHOULD_SKIP_THIS

	class StringBufferCleaner
	{
	public:
	explicit StringBufferCleaner(YY_BUFFER_STATE buffer)
	: my_string_buffer {buffer}
	{}
	~StringBufferCleaner()
	{
	// free the scan buffer
	yy_delete_buffer(my_string_buffer);
	}

	StringBufferCleaner(const StringBufferCleaner&) = delete;
	StringBufferCleaner(StringBufferCleaner&&) = delete;
	StringBufferCleaner& operator=(const StringBufferCleaner&) = delete;
	StringBufferCleaner& operator=(StringBufferCleaner&&) = delete;

	private:
	YY_BUFFER_STATE my_string_buffer;
	};

	} // namespace SelectionParser

	bool SelectionFilter::parse()
	{
	Errors = "";
	SelectionParser::YY_BUFFER_STATE my_string_buffer = SelectionParser::SelectionFilter_scan_string(
	Filter.c_str()
	);
	SelectionParser::StringBufferCleaner cleaner(my_string_buffer);
	// be aware that this parser is not reentrant! Don't use with Threats!!!
	assert(!ActFilter);
	ActFilter = this;
	/int my_parse_result =/SelectionParser::yyparse();
	ActFilter = nullptr;
	Ast.reset(TopBlock);
	TopBlock = nullptr;
	SelectionParser::StringFactory::instance()->clear();

	if (Errors.empty()) {
	return true;
	}
	else {
	return false;
	}
	}