Commit d35fa0c2 authored by Jan Möbius's avatar Jan Möbius

Renamed to remesher, tooltips, scriptinfo, indentation

git-svn-id: http://www.openflipper.org/svnrepo/OpenFlipper/branches/Free@12768 383ad7c9-94d9-4d36-a494-682f7c89f535
parent c04fe637
......@@ -42,9 +42,8 @@
#include <QtGui>
#include "AdvancedRemesherPlugin.hh"
#include "RemesherPlugin.hh"
// Flipper algorithms
#include "Algorithms/AdaptiveRemesherT.hh"
#include "Algorithms/UniformRemesherT.hh"
......@@ -60,41 +59,42 @@
// ----------------------------------------------------------------------------------------
AdvancedRemesherPlugin::AdvancedRemesherPlugin() :
RemesherPlugin::RemesherPlugin() :
progress_(0) {
progress_ = new ProgressEmitter();
progress_ = new ProgressEmitter();
connect(progress_, SIGNAL(signalJobState(QString,int)), this, SIGNAL(setJobState(QString,int)), Qt::QueuedConnection);
connect(progress_, SIGNAL(changeDescription(QString,QString)), this, SIGNAL(setJobDescription(QString,QString)), Qt::QueuedConnection);
connect(progress_, SIGNAL(signalJobState(QString,int)), this, SIGNAL(setJobState(QString,int)), Qt::QueuedConnection);
connect(progress_, SIGNAL(changeDescription(QString,QString)), this, SIGNAL(setJobDescription(QString,QString)), Qt::QueuedConnection);
}
// ----------------------------------------------------------------------------------------
AdvancedRemesherPlugin::~AdvancedRemesherPlugin() {
RemesherPlugin::~RemesherPlugin() {
delete progress_;
delete progress_;
}
// ----------------------------------------------------------------------------------------
/// Initialize the plugin
void AdvancedRemesherPlugin::pluginsInitialized(){
emit setSlotDescription("adaptiveRemeshing(int,double,double,double,int,bool)", "Adaptive Remeshing",
QString("object_id,error,min_edge_length,max_edge_length,iterations,use_projection").split(","),
QString("id of an object,error,minimal target edge length,maximal target edge length,iterations,use projection method").split(","));
emit setSlotDescription("uniformRemeshing(int,double,unsigned int,unsigned int,bool)", "Uniform Remeshing",
QString("object_id,edge_length,iterations,area_iterations,use_projection").split(","),
QString("id of an object,target edge length,iterations,area iterations,use projection method").split(","));
void RemesherPlugin::pluginsInitialized(){
emit setSlotDescription("adaptiveRemeshing(int,double,double,double,int,bool)", "Adaptive Remeshing",
QString("object_id,error,min_edge_length,max_edge_length,iterations,use_projection").split(","),
QString("id of an object,error,minimal target edge length,maximal target edge length,iterations,use projection method").split(","));
emit setSlotDescription("uniformRemeshing(int,double,unsigned int,unsigned int,bool)", "Uniform Remeshing",
QString("object_id,edge_length,iterations,area_iterations,use_projection").split(","),
QString("id of an object,target edge length,iterations,area iterations,use projection method").split(","));
}
// ----------------------------------------------------------------------------------------
/// init the Toolbox
void AdvancedRemesherPlugin::initializePlugin() {
tool_ = new AdvancedRemesherToolBox();
void RemesherPlugin::initializePlugin() {
if ( OpenFlipper::Options::gui() ) {
tool_ = new RemesherToolBox();
// Connect buttons
connect(tool_->adaptive_button, SIGNAL(clicked()), this, SLOT(adaptiveRemeshingButtonClicked()) );
......@@ -108,295 +108,296 @@ void AdvancedRemesherPlugin::initializePlugin() {
toolIcon_ = new QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"remesher.png");
emit addToolbox( tr("Remesher") , tool_ , toolIcon_);
}
}
// ----------------------------------------------------------------------------------------
void AdvancedRemesherPlugin::threadFinished(QString _jobId) {
void RemesherPlugin::threadFinished(QString _jobId) {
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS,DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
emit updatedObject(o_it->id(), UPDATE_GEOMETRY | UPDATE_TOPOLOGY );
emit createBackup(o_it->id(), "Remeshing", UPDATE_GEOMETRY | UPDATE_TOPOLOGY);
}
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS,DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
emit updatedObject(o_it->id(), UPDATE_GEOMETRY | UPDATE_TOPOLOGY );
emit createBackup(o_it->id(), "Remeshing", UPDATE_GEOMETRY | UPDATE_TOPOLOGY);
}
// Detach job from progress emitter
progress_->detachJob();
// Detach job from progress emitter
progress_->detachJob();
}
// ----------------------------------------------------------------------------------------
void AdvancedRemesherPlugin::computeInitValues() {
void RemesherPlugin::computeInitValues() {
if(OpenFlipper::Options::nogui()) return;
if(OpenFlipper::Options::nogui()) return;
double mean_edge = 0.0;
double max_feature_angle = 0.0;
double mean_edge = 0.0;
double max_feature_angle = 0.0;
//read one target objects
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
//read one target objects
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
if(o_it->dataType() == DATA_TRIANGLE_MESH) {
if(o_it->dataType() == DATA_TRIANGLE_MESH) {
TriMesh* mesh = PluginFunctions::triMesh(o_it->id());
if(!mesh) return;
TriMesh* mesh = PluginFunctions::triMesh(o_it->id());
if(!mesh) return;
mesh->update_face_normals();
mesh->update_face_normals();
for(TriMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
for(TriMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
TriMesh::HalfedgeHandle he = mesh->halfedge_handle(e_it, 0);
TriMesh::HalfedgeHandle he = mesh->halfedge_handle(e_it, 0);
ACG::Vec3d vec_e = mesh->point(mesh->to_vertex_handle(he)) - mesh->point(mesh->from_vertex_handle(he));
ACG::Vec3d vec_e = mesh->point(mesh->to_vertex_handle(he)) - mesh->point(mesh->from_vertex_handle(he));
mean_edge += vec_e.length();
mean_edge += vec_e.length();
// Estimate feature angle
TriMesh::FaceHandle fh1 = mesh->face_handle(he);
TriMesh::FaceHandle fh2 = mesh->face_handle(mesh->opposite_halfedge_handle(he));
// Estimate feature angle
TriMesh::FaceHandle fh1 = mesh->face_handle(he);
TriMesh::FaceHandle fh2 = mesh->face_handle(mesh->opposite_halfedge_handle(he));
TriMesh::Normal n1 = mesh->normal(fh1);
TriMesh::Normal n2 = mesh->normal(fh2);
TriMesh::Normal n1 = mesh->normal(fh1);
TriMesh::Normal n2 = mesh->normal(fh2);
double feature_angle = (1.0 - (n1 | n2));
double feature_angle = (1.0 - (n1 | n2));
if(feature_angle > max_feature_angle) max_feature_angle = feature_angle;
}
if(feature_angle > max_feature_angle) max_feature_angle = feature_angle;
}
mean_edge /= (double)mesh->n_edges();
mean_edge /= (double)mesh->n_edges();
} else {
// DATA_POLY_MESH
} else {
// DATA_POLY_MESH
PolyMesh* mesh = PluginFunctions::polyMesh(o_it->id());
if(!mesh) return;
PolyMesh* mesh = PluginFunctions::polyMesh(o_it->id());
if(!mesh) return;
mesh->update_face_normals();
mesh->update_face_normals();
for(PolyMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
for(PolyMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
PolyMesh::HalfedgeHandle he = mesh->halfedge_handle(e_it, 0);
PolyMesh::HalfedgeHandle he = mesh->halfedge_handle(e_it, 0);
ACG::Vec3d vec_e = mesh->point(mesh->to_vertex_handle(he)) - mesh->point(mesh->from_vertex_handle(he));
ACG::Vec3d vec_e = mesh->point(mesh->to_vertex_handle(he)) - mesh->point(mesh->from_vertex_handle(he));
mean_edge += vec_e.length();
mean_edge += vec_e.length();
// Estimate feature angle
PolyMesh::FaceHandle fh1 = mesh->face_handle(he);
PolyMesh::FaceHandle fh2 = mesh->face_handle(mesh->opposite_halfedge_handle(he));
// Estimate feature angle
PolyMesh::FaceHandle fh1 = mesh->face_handle(he);
PolyMesh::FaceHandle fh2 = mesh->face_handle(mesh->opposite_halfedge_handle(he));
PolyMesh::Normal n1 = mesh->normal(fh1);
PolyMesh::Normal n2 = mesh->normal(fh2);
PolyMesh::Normal n1 = mesh->normal(fh1);
PolyMesh::Normal n2 = mesh->normal(fh2);
double feature_angle = (1.0 - (n1 | n2));
double feature_angle = (1.0 - (n1 | n2));
if(feature_angle > max_feature_angle) max_feature_angle = feature_angle;
}
if(feature_angle > max_feature_angle) max_feature_angle = feature_angle;
}
mean_edge /= (double)mesh->n_edges();
}
mean_edge /= (double)mesh->n_edges();
}
// Convert feature angle to radian
max_feature_angle = max_feature_angle * (M_PI / 2.0);
// Convert feature angle to radian
max_feature_angle = max_feature_angle * (M_PI / 2.0);
// Set adaptive values
tool_->adaptive_error->setValue(mean_edge * 0.1); // 10% of mean value
tool_->adaptive_min_edge->setValue(mean_edge - (mean_edge * 0.1)); // mean - 10%
tool_->adaptive_max_edge->setValue(mean_edge + (mean_edge * 0.1)); // mean + 10%
// Set adaptive values
tool_->adaptive_error->setValue(mean_edge * 0.1); // 10% of mean value
tool_->adaptive_min_edge->setValue(mean_edge - (mean_edge * 0.1)); // mean - 10%
tool_->adaptive_max_edge->setValue(mean_edge + (mean_edge * 0.1)); // mean + 10%
// Set uniform values
tool_->uniform_edge_length->setValue(mean_edge);
// Set uniform values
tool_->uniform_edge_length->setValue(mean_edge);
return; // Just take first object
}
return; // Just take first object
}
}
// ----------------------- Adaptive Remeshing ---------------------------------------------
void AdvancedRemesherPlugin::adaptiveRemeshingButtonClicked() {
void RemesherPlugin::adaptiveRemeshingButtonClicked() {
QString jobId = name() + "AdaptiveRemeshing";
OpenFlipperThread* thread = new OpenFlipperThread(jobId);
connect(thread, SIGNAL( finished(QString)), this, SIGNAL(finishJob(QString)));
connect(thread, SIGNAL( function() ), this, SLOT(adaptiveRemeshing()),Qt::DirectConnection);
connect(this, SIGNAL( finishJob(QString)), this, SLOT(threadFinished(QString)), Qt::QueuedConnection);
emit startJob( jobId, "Adaptive remeshing" , 0 , 100 , true);
QString jobId = name() + "AdaptiveRemeshing";
OpenFlipperThread* thread = new OpenFlipperThread(jobId);
connect(thread, SIGNAL( finished(QString)), this, SIGNAL(finishJob(QString)));
connect(thread, SIGNAL( function() ), this, SLOT(adaptiveRemeshing()),Qt::DirectConnection);
connect(this, SIGNAL( finishJob(QString)), this, SLOT(threadFinished(QString)), Qt::QueuedConnection);
// Attach job to progress emitter
progress_->attachJob(jobId);
emit startJob( jobId, "Adaptive remeshing" , 0 , 100 , true);
thread->start();
thread->startProcessing();
// Attach job to progress emitter
progress_->attachJob(jobId);
thread->start();
thread->startProcessing();
}
// ----------------------------------------------------------------------------------------
void AdvancedRemesherPlugin::adaptiveRemeshing() {
void RemesherPlugin::adaptiveRemeshing() {
if(OpenFlipper::Options::nogui()) return;
//read one target objects
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS, DataType(DATA_TRIANGLE_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
if(OpenFlipper::Options::nogui()) return;
// Check data type.
// Note that adaptive remeshing is restricted
// to triangle meshes only since it relies
// on edge flips which are only defined
// for triangle configurations.
//read one target objects
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS, DataType(DATA_TRIANGLE_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
// Get parameters from GUI
double error = tool_->adaptive_error->value();
double min_edge = tool_->adaptive_min_edge->value();
double max_edge = tool_->adaptive_max_edge->value();
unsigned int iters = tool_->adaptive_iters->text().toInt();
bool projection = tool_->adaptive_projection->isChecked();
// Check data type.
// Note that adaptive remeshing is restricted
// to triangle meshes only since it relies
// on edge flips which are only defined
// for triangle configurations.
adaptiveRemeshing(o_it->id(), error, min_edge, max_edge, iters, projection);
// Get parameters from GUI
double error = tool_->adaptive_error->value();
double min_edge = tool_->adaptive_min_edge->value();
double max_edge = tool_->adaptive_max_edge->value();
unsigned int iters = tool_->adaptive_iters->text().toInt();
bool projection = tool_->adaptive_projection->isChecked();
}
adaptiveRemeshing(o_it->id(), error, min_edge, max_edge, iters, projection);
}
}
// ----------------------------------------------------------------------------------------
void AdvancedRemesherPlugin::adaptiveRemeshing(int _objectID,
double _error,
double _min_edge_length,
double _max_edge_length,
unsigned int _iters,
bool _use_projection) {
void RemesherPlugin::adaptiveRemeshing(int _objectID,
double _error,
double _min_edge_length,
double _max_edge_length,
unsigned int _iters,
bool _use_projection) {
BaseObjectData* object = 0;
BaseObjectData* object = 0;
if (PluginFunctions::getObject(_objectID, object)) {
if (PluginFunctions::getObject(_objectID, object)) {
// Check data type
if (object->dataType(DATA_TRIANGLE_MESH)) {
// Check data type
if (object->dataType(DATA_TRIANGLE_MESH)) {
TriMesh* mesh = PluginFunctions::triMesh(object);
TriMesh* mesh = PluginFunctions::triMesh(object);
Remeshing::AdaptiveRemesherT<TriMesh> remesher(*mesh, progress_);
Remeshing::AdaptiveRemesherT<TriMesh> remesher(*mesh, progress_);
remesher.remesh(_error, _min_edge_length, _max_edge_length, _iters, _use_projection);
remesher.remesh(_error, _min_edge_length, _max_edge_length, _iters, _use_projection);
mesh->update_normals();
mesh->update_normals();
QString projectionString = "FALSE";
if (_use_projection)
projectionString = "TRUE";
QString projectionString = "FALSE";
if (_use_projection)
projectionString = "TRUE";
emit scriptInfo("adaptiveRemeshing(" + QString::number(_objectID) + ", "
+ QString::number(_error) + ", "
+ QString::number(_min_edge_length) + ", "
+ QString::number(_max_edge_length) + ", "
+ QString::number(_iters) + ", "
+ projectionString + ")");
emit scriptInfo("adaptiveRemeshing(" + QString::number(_objectID) + ", "
+ QString::number(_error) + ", "
+ QString::number(_min_edge_length) + ", "
+ QString::number(_max_edge_length) + ", "
+ QString::number(_iters) + ", "
+ projectionString + ")");
return;
}
return;
}
}
}
// ----------------------- Uniform Remeshing ---------------------------------------------
void AdvancedRemesherPlugin::uniformRemeshingButtonClicked() {
void RemesherPlugin::uniformRemeshingButtonClicked() {
OpenFlipperThread* thread = new OpenFlipperThread(name() + "UniformRemeshing");
connect(thread, SIGNAL( state(QString, int)), this, SIGNAL(setJobState(QString, int)));
connect(thread, SIGNAL( finished(QString)), this, SIGNAL(finishJob(QString)));
connect(thread, SIGNAL( function() ), this, SLOT(uniformRemeshing()),Qt::DirectConnection);
connect(this, SIGNAL( finishJob(QString)), this, SLOT(threadFinished(QString)), Qt::QueuedConnection);
emit startJob( name() + "UniformRemeshing", "Uniform remeshing" , 0 , 100 , true);
thread->start();
thread->startProcessing();
OpenFlipperThread* thread = new OpenFlipperThread(name() + "UniformRemeshing");
connect(thread, SIGNAL( state(QString, int)), this, SIGNAL(setJobState(QString, int)));
connect(thread, SIGNAL( finished(QString)), this, SIGNAL(finishJob(QString)));
connect(thread, SIGNAL( function() ), this, SLOT(uniformRemeshing()),Qt::DirectConnection);
connect(this, SIGNAL( finishJob(QString)), this, SLOT(threadFinished(QString)), Qt::QueuedConnection);
emit startJob( name() + "UniformRemeshing", "Uniform remeshing" , 0 , 100 , true);
thread->start();
thread->startProcessing();
}
// ----------------------------------------------------------------------------------------
void AdvancedRemesherPlugin::uniformRemeshing(){
void RemesherPlugin::uniformRemeshing(){
if(OpenFlipper::Options::nogui()) return;
// Get parameters from GUI
double edge_length = tool_->uniform_edge_length->value();
unsigned int iters = tool_->uniform_iters->text().toInt();
unsigned int area_iters = tool_->uniform_area_iters->text().toInt();
bool projection = tool_->uniform_projection->isChecked();
//read one target objects
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS, DataType(DATA_TRIANGLE_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
// Set incident vertices to feature edges to be feature vertices
TriMesh* mesh = PluginFunctions::triMesh(o_it->id());
if(!mesh) continue;
for(TriMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
if(mesh->status(e_it).feature()) {
mesh->status(mesh->to_vertex_handle(mesh->halfedge_handle(e_it, 0))).set_feature(true);
mesh->status(mesh->from_vertex_handle(mesh->halfedge_handle(e_it, 0))).set_feature(true);
}
}
// Check data type.
// Note that uniform remeshing is restricted
// to triangle meshes only since it also relies
// on edge flips which are only defined
// for triangle configurations.
uniformRemeshing(o_it->id(), edge_length, iters, area_iters, projection);
if(OpenFlipper::Options::nogui()) return;
// Get parameters from GUI
double edge_length = tool_->uniform_edge_length->value();
unsigned int iters = tool_->uniform_iters->text().toInt();
unsigned int area_iters = tool_->uniform_area_iters->text().toInt();
bool projection = tool_->uniform_projection->isChecked();
//read one target objects
for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS, DataType(DATA_TRIANGLE_MESH)) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
// Set incident vertices to feature edges to be feature vertices
TriMesh* mesh = PluginFunctions::triMesh(o_it->id());
if(!mesh) continue;
for(TriMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
if(mesh->status(e_it).feature()) {
mesh->status(mesh->to_vertex_handle(mesh->halfedge_handle(e_it, 0))).set_feature(true);
mesh->status(mesh->from_vertex_handle(mesh->halfedge_handle(e_it, 0))).set_feature(true);
}
}
// Check data type.
// Note that uniform remeshing is restricted
// to triangle meshes only since it also relies
// on edge flips which are only defined
// for triangle configurations.
uniformRemeshing(o_it->id(), edge_length, iters, area_iters, projection);
}
}
// ----------------------------------------------------------------------------------------
void AdvancedRemesherPlugin::uniformRemeshing(int _objectID,
double _edge_length,
unsigned int _iters,
unsigned int _area_iters,
bool _use_projection) {
void RemesherPlugin::uniformRemeshing(int _objectID,
double _edge_length,
unsigned int _iters,
unsigned int _area_iters,
bool _use_projection) {
BaseObjectData* object = 0;
BaseObjectData* object = 0;
if (PluginFunctions::getObject(_objectID, object)) {
if (PluginFunctions::getObject(_objectID, object)) {
// Check data type
if (object->dataType(DATA_TRIANGLE_MESH)) {
// Check data type
if (object->dataType(DATA_TRIANGLE_MESH)) {
TriMesh* mesh = PluginFunctions::triMesh(object);
TriMesh* mesh = PluginFunctions::triMesh(object);
Remeshing::UniformRemesherT<TriMesh> remesher(*mesh, progress_);
Remeshing::UniformRemesherT<TriMesh> remesher(*mesh, progress_);
remesher.remesh(_edge_length, _iters, _area_iters, _use_projection);
remesher.remesh(_edge_length, _iters, _area_iters, _use_projection);
mesh->update_normals();
mesh->update_normals();
QString projectionString = "FALSE";
if (_use_projection)
projectionString = "TRUE";
QString projectionString = "FALSE";
if (_use_projection)
projectionString = "TRUE";
emit scriptInfo("adaptiveRemeshing(" + QString::number(_objectID) + ", "
+ QString::number(_edge_length) + ", "
+ QString::number(_iters) + ", "
+ QString::number(_area_iters) + ", "
+ QString::number(_iters) + ", "
+ projectionString + ")");
emit scriptInfo("adaptiveRemeshing(" + QString::number(_objectID) + ", "
+ QString::number(_edge_length) + ", "
+ QString::number(_iters) + ", "
+ QString::number(_area_iters) + ", "
+ QString::number(_iters) + ", "
+ projectionString + ")");
return;
}
return;
}
}
}
// ----------------------------------------------------------------------------------------
Q_EXPORT_PLUGIN2( advancedRemesherPlugin, AdvancedRemesherPlugin );
Q_EXPORT_PLUGIN2( remesherplugin, RemesherPlugin );
......@@ -56,10 +56,10 @@
#include <ObjectTypes/TriangleMesh/TriangleMesh.hh>
#include <ObjectTypes/PolyMesh/PolyMesh.hh>
#include "AdvancedRemesherToolbox.hh"
#include "RemesherToolbox.hh"
#include "ProgressEmitter.hh"
class AdvancedRemesherPlugin : public QObject, BaseInterface, BackupInterface, ToolboxInterface, LoggingInterface, RPCInterface, ProcessInterface, ScriptInterface
class RemesherPlugin : public QObject, BaseInterface, BackupInterface, ToolboxInterface, LoggingInterface, RPCInterface, ProcessInterface, ScriptInterface
{
Q_OBJECT
Q_INTERFACES(BaseInterface)
......@@ -73,102 +73,102 @@ Q_INTERFACES(ScriptInterface)
signals:
//BaseInterface
void updateView();
void updatedObject(int _id, const UpdateType _type);
//BaseInterface
void updateView();
void updatedObject(int _id, const UpdateType _type);
void setSlotDescription(QString _slotName, QString _slotDescription,
void setSlotDescription(QString _slotName, QString _slotDescription,
QStringList _parameters, QStringList _descriptions);
//LoggingInterface:
void log( Logtype _type, QString _message );
void log( QString _message );
//LoggingInterface:
void log( Logtype _type, QString _message );
void log( QString _message );
// RPC Interface
void pluginExists( QString _pluginName , bool& _exists ) ;
void functionExists( QString _pluginName , QString _functionName , bool& _exists );
// RPC Interface
void pluginExists( QString _pluginName , bool& _exists ) ;
void functionExists( QString _pluginName , QString _functionName , bool& _exists );
// ToolboxInterface
void addToolbox( QString _name , QWidget* _widget, QIcon* _icon );
// ToolboxInterface
void addToolbox( QString _name , QWidget* _widget, QIcon* _icon );
// ProcessInterface
void startJob( QString _jobId, QString _description, int _min, int _max, bool _blocking = false);
void setJobState(QString _jobId, int _value);
void setJobName(QString _jobId, QString _name);
void finishJob(QString _jobId);
void setJobDescription(QString _jobId, QString _description);
// ProcessInterface
void startJob( QString _jobId, QString _description, int _min, int _max, bool _blocking = false);
void setJobState(QString _jobId, int _value);
void setJobName(QString _jobId, QString _name);
void finishJob(QString _jobId);
void setJobDescription(QString _jobId, QString _description);
// BackupInterface
void createBackup(int _id , QString _name, UpdateType _type = UPDATE_ALL);
// BackupInterface
void createBackup(int _id , QString _name, UpdateType _type = UPDATE_ALL);
// ScriptInterface
void scriptInfo(QString _functionName);
// ScriptInterface
void scriptInfo(QString _functionName);