1019 lines
29 KiB
Python
1019 lines
29 KiB
Python
# -*- coding: utf-8 -*-
|
|
# ***************************************************************************
|
|
# * Copyright (c) 2022 Zheng Lei (realthunder) <realthunder.dev@gmail.com>*
|
|
# * *
|
|
# * This program is free software; you can redistribute it and/or modify *
|
|
# * it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
# * as published by the Free Software Foundation; either version 2 of *
|
|
# * the License, or (at your option) any later version. *
|
|
# * for detail see the LICENCE text file. *
|
|
# * *
|
|
# * This program 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 program; if not, write to the Free Software *
|
|
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
# * USA *
|
|
# * *
|
|
# ***************************************************************************
|
|
'''Utilites for generating C++ code for parameters management using Python Cog
|
|
'''
|
|
import cog
|
|
import inspect, re
|
|
from os import path
|
|
|
|
def quote(txt, indent=0):
|
|
lines = [ ' '*indent + '"' + l.replace('\\', '\\\\').replace('"', '\\"') for l in txt.split('\n')]
|
|
return '\\n"\n'.join(lines) + '"'
|
|
|
|
def init_params(params, namespace, class_name, param_path, header_file=None):
|
|
for param in params:
|
|
param.path = param_path
|
|
if not header_file:
|
|
header_file = [f'{namespace}/{class_name}.h']
|
|
param.header_file = header_file + getattr(param.proxy, 'header_file', [])
|
|
param.namespace = namespace
|
|
param.class_name = class_name
|
|
return params
|
|
|
|
def auto_comment(frame=1, msg=None, count=1):
|
|
trace = []
|
|
for stack in inspect.stack()[frame:frame+count]:
|
|
filename = path.normpath(stack[1]).split('/src/')[-1]
|
|
if filename.find('<') >= 0:
|
|
break
|
|
lineno = stack[2]
|
|
trace.insert(0, f'{filename}:{lineno}')
|
|
return f'{"// Auto generated code" if msg is None else msg} ({" <- ".join(trace)})'
|
|
|
|
def trace_comment():
|
|
return auto_comment(2)
|
|
|
|
def get_module_path(module):
|
|
return path.dirname(module.__file__.split(f'src{path.sep}')[-1])
|
|
|
|
def declare_begin(module, header=True):
|
|
class_name = module.ClassName
|
|
namespace = module.NameSpace
|
|
params = module.Params
|
|
param_path = module.ParamPath
|
|
file_path = getattr(module, 'FilePath', get_module_path(module))
|
|
param_file = getattr(module, 'ParamSource', f'{file_path}/{class_name}.py')
|
|
header_file = getattr(module, 'HeaderFile', f'{file_path}/{class_name}.h')
|
|
source_file = getattr(module, 'SourceFile', f'{file_path}/{class_name}.cpp')
|
|
class_doc = module.ClassDoc
|
|
signal = getattr(module, 'Signal', False)
|
|
|
|
if header:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
#include <Base/Parameter.h>
|
|
{"#include <boost_signals2.hpp>" if signal else ""}
|
|
''')
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
namespace {namespace} {{
|
|
/** {class_doc}
|
|
|
|
* The parameters are under group "{param_path}"
|
|
*
|
|
* This class is auto generated by {param_file}. Modify that file
|
|
* instead of this one, if you want to add any parameter. You need
|
|
* to install Cog Python package for code generation:
|
|
* @code
|
|
* pip install cogapp
|
|
* @endcode
|
|
*
|
|
* Once modified, you can regenerate the header and the source file,
|
|
* @code
|
|
* python3 -m cogapp -r {header_file} {source_file}
|
|
* @endcode
|
|
*
|
|
* You can add a new parameter by adding lines in {param_file}. Available
|
|
* parameter types are 'Int, UInt, String, Bool, Float'. For example, to add
|
|
* a new Int type parameter,
|
|
* @code
|
|
* ParamInt(parameter_name, default_value, documentation, on_change=False)
|
|
* @endcode
|
|
*
|
|
* If there is special handling on parameter change, pass in on_change=True.
|
|
* And you need to provide a function implementation in {source_file} with
|
|
* the following signature.
|
|
* @code
|
|
* void {class_name}:on<parameter_name>Changed()
|
|
* @endcode
|
|
*/
|
|
class {namespace}Export {class_name} {{
|
|
public:
|
|
static ParameterGrp::handle getHandle();
|
|
''')
|
|
if signal:
|
|
cog.out(f'''
|
|
static boost::signals2::signal<void (const char*)> &signalParamChanged();
|
|
static void signalAll();
|
|
''')
|
|
|
|
for param in params:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
//@{{
|
|
/// Accessor for parameter {param.name}''')
|
|
if param._doc:
|
|
cog.out(f'''
|
|
///''')
|
|
for line in param._doc.split('\n'):
|
|
cog.out(f'''
|
|
/// {line}''')
|
|
cog.out(f'''
|
|
static const {param.C_Type} & get{param.name}();
|
|
static const {param.C_Type} & default{param.name}();
|
|
static void remove{param.name}();
|
|
static void set{param.name}(const {param.C_Type} &v);
|
|
static const char *doc{param.name}();''')
|
|
if param.on_change:
|
|
cog.out(f'''
|
|
static void on{param.name}Changed();''')
|
|
cog.out(f'''
|
|
//@}}
|
|
''')
|
|
|
|
|
|
def declare_end(module):
|
|
class_name = module.ClassName
|
|
namespace = module.NameSpace
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
}}; // class {class_name}
|
|
}} // namespace {namespace}
|
|
''')
|
|
|
|
|
|
def define(module, header=True):
|
|
class_name = module.ClassName
|
|
namespace = module.NameSpace
|
|
params = module.Params
|
|
param_path = module.ParamPath
|
|
class_doc = module.ClassDoc
|
|
signal = getattr(module, 'Signal', False)
|
|
|
|
if header:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
#include <unordered_map>
|
|
#include <App/Application.h>
|
|
#include <App/DynamicProperty.h>
|
|
#include "{class_name}.h"
|
|
using namespace {namespace};
|
|
''')
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
namespace {{
|
|
class {class_name}P: public ParameterGrp::ObserverType {{
|
|
public:
|
|
ParameterGrp::handle handle;
|
|
std::unordered_map<const char *,void(*)({class_name}P*),App::CStringHasher,App::CStringHasher> funcs;
|
|
''')
|
|
|
|
if signal:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
boost::signals2::signal<void (const char*)> signalParamChanged;
|
|
void signalAll()
|
|
{{''')
|
|
for param in params:
|
|
cog.out(f'''
|
|
signalParamChanged("{param.name}");''')
|
|
cog.out(f'''
|
|
|
|
{trace_comment()}
|
|
}}''')
|
|
|
|
for param in params:
|
|
cog.out(f'''
|
|
{param.C_Type} {param.name};''')
|
|
|
|
cog.out(f'''
|
|
|
|
{trace_comment()}
|
|
{class_name}P() {{
|
|
handle = App::GetApplication().GetParameterGroupByPath("{param_path}");
|
|
handle->Attach(this);
|
|
''')
|
|
|
|
for param in params:
|
|
cog.out(f'''
|
|
{param.name} = {param.getter('handle')};
|
|
funcs["{param.name}"] = &{class_name}P::update{param.name};''')
|
|
|
|
cog.out(f'''
|
|
}}
|
|
|
|
{trace_comment()}
|
|
~{class_name}P() {{
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
void OnChange(Base::Subject<const char*> &, const char* sReason) {{
|
|
if(!sReason)
|
|
return;
|
|
auto it = funcs.find(sReason);
|
|
if(it == funcs.end())
|
|
return;
|
|
it->second(this);
|
|
{"signalParamChanged(sReason);" if signal else ""}
|
|
}}
|
|
|
|
''')
|
|
|
|
for param in params:
|
|
if not param.on_change:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
static void update{param.name}({class_name}P *self) {{
|
|
self->{param.name} = {param.getter('self->handle')};
|
|
}}''')
|
|
else:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
static void update{param.name}({class_name}P *self) {{
|
|
auto v = {param.getter('self->handle')};
|
|
if (self->{param.name} != v) {{
|
|
self->{param.name} = v;
|
|
{class_name}::on{param.name}Changed();
|
|
}}
|
|
}}''')
|
|
|
|
cog.out(f'''
|
|
}};
|
|
|
|
{trace_comment()}
|
|
{class_name}P *instance() {{
|
|
static {class_name}P *inst = new {class_name}P;
|
|
return inst;
|
|
}}
|
|
|
|
}} // Anonymous namespace
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
ParameterGrp::handle {class_name}::getHandle() {{
|
|
return instance()->handle;
|
|
}}
|
|
''')
|
|
|
|
if signal:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
boost::signals2::signal<void (const char*)> &
|
|
{class_name}::signalParamChanged() {{
|
|
return instance()->signalParamChanged;
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
void signalAll() {{
|
|
instance()->signalAll();
|
|
}}
|
|
''')
|
|
|
|
for param in params:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
const char *{class_name}::doc{param.name}() {{
|
|
return {param.doc(class_name)};
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
const {param.C_Type} & {class_name}::get{param.name}() {{
|
|
return instance()->{param.name};
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
const {param.C_Type} & {class_name}::default{param.name}() {{
|
|
const static {param.C_Type} def = {param.default};
|
|
return def;
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
void {class_name}::set{param.name}(const {param.C_Type} &v) {{
|
|
{param.setter()};
|
|
instance()->{param.name} = v;
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
void {class_name}::remove{param.name}() {{
|
|
instance()->handle->Remove{param.Type}("{param.name}");
|
|
}}
|
|
''')
|
|
|
|
def widgets_declare(param_set):
|
|
param_group = param_set.ParamGroup
|
|
|
|
for title,params in param_group:
|
|
name = _regex.sub('', title)
|
|
cog.out(f'''
|
|
|
|
{trace_comment()}
|
|
QGroupBox * group{name} = nullptr;''')
|
|
for param in params:
|
|
param.declare_widget()
|
|
|
|
def widgets_init(param_set):
|
|
param_group = param_set.ParamGroup
|
|
|
|
cog.out(f'''
|
|
auto layout = new QVBoxLayout(this);''')
|
|
for title, params in param_group:
|
|
name = _regex.sub('', title)
|
|
cog.out(f'''
|
|
|
|
|
|
{trace_comment()}
|
|
group{name} = new QGroupBox(this);
|
|
layout->addWidget(group{name});
|
|
auto layoutHoriz{name} = new QHBoxLayout(group{name});
|
|
auto layout{name} = new QGridLayout();
|
|
layoutHoriz{name}->addLayout(layout{name});
|
|
layoutHoriz{name}->addStretch();''')
|
|
|
|
for row,param in enumerate(params):
|
|
cog.out(f'''
|
|
|
|
{trace_comment()}''')
|
|
param.init_widget(row, name)
|
|
|
|
cog.out('''
|
|
layout->addItem(new QSpacerItem(40, 20, QSizePolicy::Fixed, QSizePolicy::Expanding));
|
|
retranslateUi();''')
|
|
|
|
def widgets_restore(param_set):
|
|
param_group = param_set.ParamGroup
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}''')
|
|
for _,params in param_group:
|
|
for param in params:
|
|
param.widget_restore()
|
|
|
|
def widgets_save(param_set):
|
|
param_group = param_set.ParamGroup
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}''')
|
|
for _,params in param_group:
|
|
for param in params:
|
|
param.widget_save()
|
|
|
|
def preference_dialog_declare_begin(param_set, header=True):
|
|
namespace = param_set.NameSpace
|
|
class_name = param_set.ClassName
|
|
dialog_namespace = getattr(param_set, 'DialogNameSpace', 'Dialog')
|
|
param_group = param_set.ParamGroup
|
|
file_path = getattr(param_set, 'FilePath', get_module_path(param_set))
|
|
param_file = getattr(param_set, 'ParamSource', f'{file_path}/{class_name}.py')
|
|
header_file = getattr(param_set, 'HeaderFile', f'{file_path}/{class_name}.h')
|
|
source_file = getattr(param_set, 'SourceFile', f'{file_path}/{class_name}.cpp')
|
|
class_doc = param_set.ClassDoc
|
|
|
|
if header:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
#include <Gui/PropertyPage.h>
|
|
#include <Gui/PrefWidgets.h>''')
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
class QLabel;
|
|
class QGroupBox;
|
|
|
|
namespace {namespace} {{
|
|
namespace {dialog_namespace} {{
|
|
/** {class_doc}
|
|
|
|
* This class is auto generated by {param_file}. Modify that file
|
|
* instead of this one, if you want to make any change. You need
|
|
* to install Cog Python package for code generation:
|
|
* @code
|
|
* pip install cogapp
|
|
* @endcode
|
|
*
|
|
* Once modified, you can regenerate the header and the source file,
|
|
* @code
|
|
* python3 -m cogapp -r {header_file} {source_file}
|
|
* @endcode
|
|
*/
|
|
class {class_name} : public Gui::Dialog::PreferencePage
|
|
{{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
{class_name}( QWidget* parent = 0 );
|
|
~{class_name}();
|
|
|
|
void saveSettings();
|
|
void loadSettings();
|
|
void retranslateUi();
|
|
|
|
protected:
|
|
void changeEvent(QEvent *e);
|
|
|
|
private:''')
|
|
widgets_declare(param_set)
|
|
|
|
|
|
def preference_dialog_declare_end(param_set):
|
|
class_name = param_set.ClassName
|
|
namespace = param_set.NameSpace
|
|
dialog_namespace = getattr(param_set, 'DialogNameSpace', 'Dialog')
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
}};
|
|
}} // namespace {dialog_namespace}
|
|
}} // namespace {namespace}
|
|
''')
|
|
|
|
def preference_dialog_declare(param_set, header=True):
|
|
preference_dialog_declare_begin(param_set, header)
|
|
preference_dialog_declare_end(param_set)
|
|
|
|
_regex = re.compile(r"[^a-zA-Z_]")
|
|
|
|
def preference_dialog_define(param_set, header=True):
|
|
param_group = param_set.ParamGroup
|
|
class_name = param_set.ClassName
|
|
dialog_namespace = getattr(param_set, 'DialogNameSpace', 'Dialog')
|
|
namespace = f'{param_set.NameSpace}::{dialog_namespace}'
|
|
file_path = getattr(param_set, 'FilePath', get_module_path(param_set))
|
|
param_file = getattr(param_set, 'ParamSource', f'{file_path}/{class_name}.py')
|
|
header_file = getattr(param_set, 'HeaderFile', f'{file_path}/{class_name}.h')
|
|
source_file = getattr(param_set, 'SourceFile', f'{file_path}/{class_name}.cpp')
|
|
user_init = getattr(param_set, 'UserInit', '')
|
|
headers = set()
|
|
|
|
if header:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
#ifndef _PreComp_
|
|
# include <QApplication>
|
|
# include <QLabel>
|
|
# include <QGroupBox>
|
|
# include <QGridLayout>
|
|
# include <QVBoxLayout>
|
|
# include <QHBoxLayout>
|
|
#endif''')
|
|
for _,params in param_group:
|
|
for param in params:
|
|
for header in param.header_file:
|
|
if header not in headers:
|
|
headers.add(header)
|
|
cog.out(f'''
|
|
#include <{header}>''')
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
#include "{header_file}"
|
|
using namespace {namespace};
|
|
/* TRANSLATOR {namespace}::{class_name} */
|
|
''')
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
{class_name}::{class_name}(QWidget* parent)
|
|
: PreferencePage( parent )
|
|
{{
|
|
''')
|
|
widgets_init(param_set)
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
{user_init}
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
{class_name}::~{class_name}()
|
|
{{
|
|
}}
|
|
''')
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
void {class_name}::saveSettings()
|
|
{{''')
|
|
widgets_save(param_set)
|
|
cog.out(f'''
|
|
}}
|
|
|
|
{trace_comment()}
|
|
void {class_name}::loadSettings()
|
|
{{''')
|
|
widgets_restore(param_set)
|
|
cog.out(f'''
|
|
}}
|
|
|
|
{trace_comment()}
|
|
void {class_name}::retranslateUi()
|
|
{{
|
|
setWindowTitle(QObject::tr("{param_set.Title}"));''')
|
|
for title, params in param_group:
|
|
name = _regex.sub('', title)
|
|
cog.out(f'''
|
|
group{name}->setTitle(QObject::tr("{title}"));''')
|
|
for row,param in enumerate(params):
|
|
param.retranslate()
|
|
cog.out(f'''
|
|
}}
|
|
|
|
{trace_comment()}
|
|
void {class_name}::changeEvent(QEvent *e)
|
|
{{
|
|
if (e->type() == QEvent::LanguageChange) {{
|
|
retranslateUi();
|
|
}}
|
|
QWidget::changeEvent(e);
|
|
}}
|
|
''')
|
|
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
#include "moc_{class_name}.cpp"
|
|
''')
|
|
|
|
_ParamPrefix = 'User parameter:BaseApp/Preferences/'
|
|
|
|
class Param:
|
|
WidgetPrefix = ''
|
|
|
|
def __init__(self, name, default, doc='', title='', on_change=False, proxy=None, **kwd):
|
|
self.name = name
|
|
self.title = title if title else name
|
|
self._default = default
|
|
self._doc = doc
|
|
self.on_change = on_change
|
|
self.proxy = proxy
|
|
|
|
def _declare_label(self):
|
|
cog.out(f'''
|
|
QLabel *label{self.name} = nullptr;''')
|
|
|
|
def declare_label(self):
|
|
if self.proxy:
|
|
self.proxy.declare_label(self)
|
|
else:
|
|
self._declare_label()
|
|
|
|
def _init_label(self, row, group_name):
|
|
cog.out(f'''
|
|
label{self.name} = new QLabel(this);
|
|
layout{group_name}->addWidget(label{self.name}, {row}, 0);''')
|
|
|
|
def init_label(self, row, group_name):
|
|
if self.proxy:
|
|
self.proxy.init_label(self, row, group_name)
|
|
else:
|
|
self._init_label(row, group_name)
|
|
|
|
def _declare_widget(self):
|
|
self.declare_label()
|
|
cog.out(f'''
|
|
{self.widget_type} *{self.widget_name} = nullptr;''')
|
|
|
|
def declare_widget(self):
|
|
if self.proxy:
|
|
self.proxy.declare_widget(self)
|
|
else:
|
|
self._declare_widget()
|
|
|
|
def _init_widget(self, row, group_name):
|
|
self.init_label(row, group_name)
|
|
cog.out(f'''
|
|
{self.widget_name} = new {self.widget_type}(this);
|
|
layout{group_name}->addWidget({self.widget_name}, {row}, {self.widget_column});''')
|
|
if self.widget_setter:
|
|
cog.out(f'''
|
|
{self.widget_name}->{self.widget_setter}({self.namespace}::{self.class_name}::default{self.name}());''')
|
|
self._init_pref_widget()
|
|
|
|
def _init_pref_widget(self):
|
|
cog.out(f'''
|
|
{self.widget_name}->setEntryName("{self.name}");''')
|
|
if self.path.startswith(_ParamPrefix):
|
|
cog.out(f'''
|
|
{self.widget_name}->setParamGrpPath("{self.path[len(_ParamPrefix):]}");''')
|
|
else:
|
|
cog.out(f'''
|
|
{self.widget_name}->setParamGrpPath("{self.path}");''')
|
|
|
|
def init_widget(self, row, group_name):
|
|
if self.proxy:
|
|
self.proxy.init_widget(self, row, group_name)
|
|
else:
|
|
self._init_widget(row, group_name)
|
|
|
|
def _widget_save(self):
|
|
cog.out(f'''
|
|
{self.widget_name}->onSave();''')
|
|
|
|
def widget_save(self):
|
|
if self.proxy:
|
|
self.proxy.widget_save(self)
|
|
else:
|
|
self._widget_save()
|
|
|
|
def _widget_restore(self):
|
|
cog.out(f'''
|
|
{self.widget_name}->onRestore();''')
|
|
|
|
def widget_restore(self):
|
|
if self.proxy:
|
|
self.proxy.widget_restore(self)
|
|
else:
|
|
self._widget_restore()
|
|
|
|
def _retranslate_label(self):
|
|
cog.out(f'''
|
|
label{self.name}->setText(QObject::tr("{self.title}"));
|
|
label{self.name}->setToolTip({self.widget_name}->toolTip());''')
|
|
|
|
def retranslate_label(self):
|
|
if self.proxy:
|
|
self.proxy.retranslate_label(self)
|
|
else:
|
|
self._retranslate_label()
|
|
|
|
def _retranslate(self):
|
|
cog.out(f'''
|
|
{self.widget_name}->setToolTip(QApplication::translate("{self.class_name}", {self.namespace}::{self.class_name}::doc{self.name}()));''')
|
|
self.retranslate_label()
|
|
|
|
def retranslate(self):
|
|
if self.proxy:
|
|
self.proxy.retranslate(self)
|
|
else:
|
|
self._retranslate()
|
|
|
|
@property
|
|
def default(self):
|
|
return self._default
|
|
|
|
def doc(self, class_name):
|
|
if not self._doc:
|
|
return '""'
|
|
return f'''QT_TRANSLATE_NOOP("{class_name}",
|
|
{quote(self._doc)})'''
|
|
|
|
@property
|
|
def widget_type(self):
|
|
if self.proxy:
|
|
return self.proxy.widget_type(self)
|
|
return self.WidgetType
|
|
|
|
@property
|
|
def widget_prefix(self):
|
|
if self.proxy:
|
|
return self.proxy.widget_prefix(self)
|
|
return self.WidgetPrefix
|
|
|
|
@property
|
|
def widget_setter(self):
|
|
if self.proxy:
|
|
return self.proxy.widget_setter(self)
|
|
return self.WidgetSetter
|
|
|
|
@property
|
|
def widget_name(self):
|
|
return f'{self.widget_prefix}{self.name}'
|
|
|
|
@property
|
|
def widget_column(self):
|
|
return 1
|
|
|
|
def getter(self, handle):
|
|
return f'{handle}->Get{self.Type}("{self.name}", {self.default})'
|
|
|
|
def setter(self):
|
|
return f'instance()->handle->Set{self.Type}("{self.name}",v)'
|
|
|
|
|
|
class ParamBool(Param):
|
|
Type = 'Bool'
|
|
C_Type = 'bool'
|
|
WidgetType = 'Gui::PrefCheckBox'
|
|
WidgetSetter = 'setChecked'
|
|
|
|
@property
|
|
def default(self):
|
|
if isinstance(self._default, str):
|
|
return self._default
|
|
return 'true' if self._default else 'false'
|
|
|
|
def _declare_label(self):
|
|
pass
|
|
|
|
def _init_label(self, _row, _group_name):
|
|
pass
|
|
|
|
@property
|
|
def widget_column(self):
|
|
return 0
|
|
|
|
def _retranslate_label(self):
|
|
cog.out(f'''
|
|
{self.widget_name}->setText(QObject::tr("{self.title}"));''')
|
|
|
|
class ParamFloat(Param):
|
|
Type = 'Float'
|
|
C_Type = 'double'
|
|
WidgetType = 'Gui::PrefDoubleSpinBox'
|
|
WidgetSetter = 'setValue'
|
|
|
|
class ParamString(Param):
|
|
Type = 'ASCII'
|
|
C_Type = 'std::string'
|
|
WidgetType = 'Gui::PrefLineEdit'
|
|
WidgetSetter = 'setText'
|
|
|
|
@property
|
|
def default(self):
|
|
return f'"{self._default}"'
|
|
|
|
class ParamQString(Param):
|
|
Type = 'ASCII'
|
|
C_Type = 'QString'
|
|
WidgetType = 'Gui::PrefLineEdit'
|
|
WidgetSetter = 'setText'
|
|
|
|
@property
|
|
def default(self):
|
|
return f'QStringLiteral("{self._default}")'
|
|
|
|
def getter(self, handle):
|
|
return f'QString::fromUtf8({handle}->Get{self.Type}("{self.name}", "{self._default}").c_str())'
|
|
|
|
def setter(self):
|
|
return f'instance()->handle->Set{self.Type}("{self.name}",v.toUtf8().constData())'
|
|
|
|
class ParamInt(Param):
|
|
Type = 'Int'
|
|
C_Type = 'long'
|
|
WidgetType = 'Gui::PrefSpinBox'
|
|
WidgetSetter = 'setValue'
|
|
|
|
class ParamUInt(Param):
|
|
Type = 'Unsigned'
|
|
C_Type = 'unsigned long'
|
|
WidgetType = 'Gui::PrefSpinBox'
|
|
WidgetSetter = 'setValue'
|
|
|
|
class ParamHex(ParamUInt):
|
|
@property
|
|
def default(self):
|
|
return '0x%08X' % self._default
|
|
|
|
class ParamProxy:
|
|
WidgetType = None
|
|
WidgetPrefix = ''
|
|
WidgetSetter = None
|
|
|
|
def __init__(self, param_bool=None):
|
|
self.param_bool = param_bool
|
|
|
|
def declare_label(self, param):
|
|
if not self.param_bool:
|
|
param._declare_label()
|
|
|
|
def widget_prefix(self, param):
|
|
return self.WidgetPrefix if self.WidgetPrefix else param.WidgetPrefix
|
|
|
|
def widget_type(self, param):
|
|
return self.WidgetType if self.WidgetType else param.WidgetType
|
|
|
|
def widget_setter(self, param):
|
|
return self.WidgetSetter if self.WidgetSetter else param.WidgetSetter
|
|
|
|
def declare_widget(self, param):
|
|
if self.param_bool:
|
|
self.param_bool.declare_widget()
|
|
param._declare_widget()
|
|
|
|
def init_label(self, param, row, group_name):
|
|
if not self.param_bool:
|
|
param._init_label(row, group_name)
|
|
|
|
def init_widget(self, param, row, group_name):
|
|
param._init_widget(row, group_name)
|
|
if self.param_bool:
|
|
self.param_bool.init_widget(row, group_name)
|
|
cog.out(f'''
|
|
{param.widget_name}->setEnabled({self.param_bool.widget_name}->isChecked());
|
|
connect({self.param_bool.widget_name}, SIGNAL(toggled(bool)), {param.widget_name}, SLOT(setEnabled(bool)));''')
|
|
|
|
def retranslate_label(self, param):
|
|
if not self.param_bool:
|
|
param._retranslate_label()
|
|
|
|
def retranslate(self, param):
|
|
param._retranslate()
|
|
if self.param_bool:
|
|
self.param_bool.retranslate()
|
|
|
|
def widget_save(self, param):
|
|
param._widget_save()
|
|
if self.param_bool:
|
|
self.param_bool.widget_save()
|
|
|
|
def widget_restore(self, param):
|
|
param._widget_restore()
|
|
if self.param_bool:
|
|
self.param_bool.widget_restore()
|
|
|
|
|
|
class ComboBoxItem:
|
|
def __init__(self, text, tooltips=None, data=None):
|
|
self.text = text
|
|
self.tooltips = tooltips
|
|
self._data = data
|
|
|
|
@property
|
|
def data(self):
|
|
if self._data is None:
|
|
return 'QVariant()'
|
|
if isinstance(self._data, str):
|
|
return f'QByteArray("{self._data}")'
|
|
return self._data
|
|
|
|
class ParamComboBox(ParamProxy):
|
|
WidgetType = 'Gui::PrefComboBox'
|
|
|
|
def __init__(self, items, translate=True, param_bool=None):
|
|
super().__init__(param_bool)
|
|
self.translate = translate
|
|
self.items = []
|
|
for item in items:
|
|
if isinstance(item, str):
|
|
item = ComboBoxItem(item);
|
|
elif isinstance(item, tuple):
|
|
item = ComboBoxItem(*item)
|
|
else:
|
|
assert(isinstance(item, ComboBoxItem))
|
|
self.items.append(item)
|
|
|
|
def widget_setter(self, _param):
|
|
return None
|
|
|
|
def init_widget(self, param, row, group_name):
|
|
super().init_widget(param, row, group_name)
|
|
if self.translate:
|
|
cog.out(f'''
|
|
for (int i=0; i<{len(self.items)}; ++i) {trace_comment()}
|
|
{param.widget_name}->addItem(QString());''')
|
|
|
|
for i,item in enumerate(self.items):
|
|
if not self.translate:
|
|
cog.out(f'''
|
|
{param.widget_name}->addItem(QStringLiteral("{item.text}"));''')
|
|
if item._data is not None:
|
|
cog.out(f'''
|
|
{param.widget_name}->setItemData({param.widget_name}->count()-1, {item.data});''')
|
|
|
|
cog.out(f'''
|
|
{param.widget_name}->setCurrentIndex({param.namespace}::{param.class_name}::default{param.name}());''')
|
|
|
|
def retranslate(self, param):
|
|
super().retranslate(param)
|
|
cog.out(f'''
|
|
{trace_comment()}''')
|
|
for i,item in enumerate(self.items):
|
|
if self.translate:
|
|
cog.out(f'''
|
|
{param.widget_name}->setItemText({i}, QObject::tr("{item.text}"));''')
|
|
if item.tooltips:
|
|
cog.out(f'''
|
|
{param.widget_name}->setItemData({i}, QObject::tr("{item.tooltips}"), Qt::ToolTipRole);''')
|
|
|
|
class ParamLinePattern(ParamProxy):
|
|
WidgetType = 'Gui::PrefLinePattern'
|
|
|
|
def widget_setter(self, _param):
|
|
return None
|
|
|
|
def init_widget(self, param, row, group_name):
|
|
super().init_widget(param, row, group_name)
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
for (int i=1; i<{param.widget_name}->count(); ++i) {{
|
|
if ({param.widget_name}->itemData(i).toInt() == {param.default})
|
|
{param.widget_name}->setCurrentIndex(i);
|
|
}}''')
|
|
|
|
class ParamColor(ParamProxy):
|
|
WidgetType = 'Gui::PrefColorButton'
|
|
WidgetSetter = 'setPackedColor'
|
|
|
|
def __init__(self, param_bool=None, transparency=True):
|
|
super().__init__(param_bool)
|
|
self.transparency = transparency
|
|
|
|
def init_widget(self, param, row, group_name):
|
|
super().init_widget(param, row, group_name)
|
|
if self.transparency:
|
|
cog.out(f'''
|
|
{param.widget_name}->setAllowTransparency(true);''')
|
|
|
|
class ParamFile(ParamProxy):
|
|
WidgetType = 'Gui::PrefFileChooser'
|
|
WidgetSetter = 'setFileNameStd'
|
|
|
|
class ParamSpinBox(ParamProxy):
|
|
def __init__(self, value_min, value_max, value_step, decimals=0, param_bool=None):
|
|
super().__init__(param_bool)
|
|
self.value_min = value_min
|
|
self.value_max = value_max
|
|
self.value_step = value_step
|
|
self.decimals = decimals
|
|
|
|
def init_widget(self, param, row, group_name):
|
|
super().init_widget(param, row, group_name)
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
{param.widget_name}->setMinimum({self.value_min});
|
|
{param.widget_name}->setMaximum({self.value_max});
|
|
{param.widget_name}->setSingleStep({self.value_step});''')
|
|
if self.decimals:
|
|
cog.out(f'''
|
|
{param.widget_name}->setDecimals({self.decimals});''')
|
|
|
|
|
|
class ParamShortcutEdit(ParamProxy):
|
|
WidgetType = 'Gui::PrefAccelLineEdit'
|
|
WidgetSetter = 'setDisplayText'
|
|
|
|
|
|
class Property:
|
|
def __init__(self, name, property_type, doc, group=None, prop_flags=None, static=False):
|
|
self.name = name
|
|
self.type_name = property_type
|
|
self.doc = doc
|
|
self.prop_flags = prop_flags if prop_flags else 'App::Prop_None'
|
|
self.static = static
|
|
self.group = group if group else ""
|
|
|
|
def declare(self):
|
|
if self.static:
|
|
cog.out(f'''
|
|
static {self.type_name} *get{self.name}Property(App::DocumentObject *obj, bool force=false);
|
|
inline {self.type_name} *get{self.name}Property(bool force=false) {{
|
|
return get{self.name}Property(this, force);
|
|
}}''')
|
|
else:
|
|
cog.out(f'''
|
|
{self.type_name} *get{self.name}Property(bool force=false);''')
|
|
|
|
def define(self, class_name):
|
|
if self.static:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
{self.type_name} *{class_name}::get{self.name}Property(App::DocumentObject *obj, bool force)
|
|
{{''')
|
|
else:
|
|
cog.out(f'''
|
|
{trace_comment()}
|
|
{self.type_name} *{class_name}::get{self.name}Property(bool force)
|
|
{{
|
|
auto obj = this;''')
|
|
cog.out(f'''
|
|
if (auto prop = Base::freecad_dynamic_cast<{self.type_name}>(
|
|
obj->getPropertyByName("{self.name}")))
|
|
{{
|
|
if (prop->getContainer() == obj)
|
|
return prop;
|
|
}}
|
|
if (!force)
|
|
return nullptr;
|
|
return static_cast<{self.type_name}*>(obj->addDynamicProperty(
|
|
"{self.type_name}", "{self.name}", "{self.group}",
|
|
{quote(self.doc)},
|
|
{self.prop_flags}));
|
|
}}
|
|
''')
|
|
|
|
def declare_properties(properties):
|
|
cog.out(f'''
|
|
{trace_comment()}''')
|
|
for prop in properties:
|
|
prop.declare()
|
|
|
|
def define_properties(properties, class_name):
|
|
for prop in properties:
|
|
prop.define(class_name)
|