QMimeData * ScriptModel::mimeData(const QModelIndexList& indexes) const
{
if (indexes.size() == 2) // both columns
{
int pos = indexToPosition(indexes.at(0));
std::ostringstream oss;
const LogEntry& entry = m_entries.at(pos);
OperationDescriptor_ptr reflective =
entry.reflective;
core::holder holder = reflective->get_holder(entry.req);
json::write(oss, reflective, holder);
QMimeData *mimeData = new QMimeData;
mimeData->setText(oss.str().c_str());
return mimeData;
}
return NULL;
}
void SenderImpl::process()
{
OperationDescriptor_ptr op = m_config->operation();
Holder srcHolder = op->get_holder(m_request);
// preFunc
m_evaluator.pre(m_request);
if (m_evaluator.hasError()) throw m_evaluator.error();
// processors
typedef QList< RequestProcessor_ptr > processors_t;
const processors_t& processors = m_config->processors();
for (processors_t::const_iterator it = processors.begin();
it != processors.end(); ++it)
{
applyProcessor(m_request, *it, srcHolder);
}
// postFunc
m_evaluator.post(m_request);
if (m_evaluator.hasError()) throw m_evaluator.error();
// Clone request
// We can't emit a request we're going to modify
Request_ptr request = op->create_request();
Holder dstHolder = op->get_holder(request);
op->copy(srcHolder, dstHolder);
// emit request
emit sendRequest(request);
m_config->notifyRequestSent(request);
}
void ScriptModel::append(corbasim::core::request_ptr req,
int pos)
{
LogEntry entry;
entry.dateTime = QDateTime::currentDateTime();
OperationDescriptor_ptr op =
m_instance->get_reflective_by_tag(req->get_tag());
if (!op) return;
entry.reflective = op;
beginInsertRows(QModelIndex(), pos, pos);
core::holder hold = op->get_holder(req);
Node_ptr node(new Node(op, hold));
m_nodes.insert(pos, node);
// List
entry.req = req;
entry.text = QString("Outgoing call ") + op->get_name();
entry.icon = &m_outputIcon;
// Background Color
entry.color = QColor(Qt::yellow);
m_entries.insert(pos, entry);
endInsertRows();
}
void AbstractInputTool::deleteAbstractInputItem(const QString& id,
InterfaceDescriptor_ptr reflective,
const QList< int >& path)
{
OperationDescriptor_ptr op =
reflective->get_reflective_by_index(path.front());
const key_t key(id, op->get_tag());
QList< AbstractInputItem * >& list = m_map[key];
for (int i = 0; i < list.size(); i++)
{
AbstractInputItem * item = list[i];
if (item->getPath() == path)
{
list.removeAt(i);
m_inverse_map.erase(item);
// Notify to the processor
item->reset();
m_group->deleteItem(
qobject_cast< qt::SortableGroupItem * >
(item->parent()));
delete item;
break;
}
}
}
AbstractInputItem * AbstractInputTool::createAbstractInputItem(const QString& id,
InterfaceDescriptor_ptr reflective,
const QList< int >& path)
{
Objref_ptr objref = m_instances.find(id);
OperationDescriptor_ptr op =
reflective->get_reflective_by_index(path.front());
AbstractInputItem * item = NULL;
if (op && objref)
{
const key_t key(id, op->get_tag());
QList< AbstractInputItem * >& list = m_map[key];
for (int i = 0; i < list.size(); i++)
{
if (list.at(i)->getPath() == path)
{
return NULL;
}
}
item = createItem(objref, op, path);
list.push_back(item);
m_inverse_map[item] = key;
qt::SortableGroupItem * sitem =
new qt::SortableGroupItem(item, m_group);
sitem->showDetails();
const QString title(getFieldName(op, path));
sitem->setTitle(id + "." + title);
m_group->appendItem(sitem);
// connect with the processor
QObject * inputRequestController =
Application::currentApplication()->inputRequestController();
connect(item,
SIGNAL(addProcessor(RequestProcessor_ptr)),
inputRequestController,
SLOT(addProcessor(RequestProcessor_ptr)));
connect(item,
SIGNAL(removeProcessor(RequestProcessor_ptr)),
inputRequestController,
SLOT(removeProcessor(RequestProcessor_ptr)));
item->start();
}
return item;
}
void FilterModel::load(const QVariant& settings)
{
const QVariantList list = settings.toList();
for (QVariantList::const_iterator it = list.begin();
it != list.end(); ++it)
{
const QVariantMap map = it->toMap();
if (!map.contains("instance") || !map.contains("operations"))
continue;
// Name to ID conversion
const QString instance = map["instance"].toString();
if (instance.isEmpty()) continue;
Objref_ptr objref = m_instances.find(instance);
if (!objref) continue;
FirstLevelItems_t::iterator fit = m_items.find(objref->id());
if (fit == m_items.end()) continue;
// End Name to ID conversion
const QVariantMap operations = map["operations"].toMap();
for (unsigned int j = 0;
j < objref->interface()->operation_count(); j++)
{
OperationDescriptor_ptr op =
objref->interface()->get_reflective_by_index(j);
tag_t tag = op->get_tag();
OperationsMap_t::iterator opit =
fit.value().operations.find(tag);
if(operations.contains(op->get_name()) &&
opit != fit.value().operations.end())
{
bool state = operations[op->get_name()].toBool();
opit.value()->setCheckState((state)?
Qt::Checked: Qt::Unchecked);
}
}
}
}
void SenderImpl::start(Sender_weak weak)
{
Sender_ptr ptr (weak.lock());
if (!ptr)
return;
m_evaluator.evaluate(m_config->code());
bool hasErr = m_evaluator.hasError();
if (!hasErr)
{
OperationDescriptor_ptr op = m_config->operation();
// Clone the original request
// We can't modify an emited request
Holder srcHolder = op->get_holder(m_config->request());
m_request = op->create_request();
Holder dstHolder = op->get_holder(m_request);
op->copy(srcHolder, dstHolder);
// m_request is the working request
m_evaluator.init(m_request);
hasErr = m_evaluator.hasError();
}
if (!hasErr)
{
m_timer.expires_from_now(
boost::posix_time::milliseconds(
m_config->initDelay()));
m_timer.async_wait(
boost::bind(&SenderImpl::handleTimeout,
this, weak, _1));
}
else
{
m_config->notifyFinished();
emit finished(m_config);
emit error(m_evaluator.error());
}
}
void FilterModel::registerInstance(Objref_ptr objref)
{
m_instances.add(objref);
FirstLevelItem item;
item.objref = objref;
FirstLevelItems_t::iterator it =
m_items.insert(objref->id(), item);
OperationsMap_t& operations = it.value().operations;
QStandardItem * ifItem = new QStandardItem(objref->name());
ifItem->setEditable(false);
ifItem->setCheckable(true);
ifItem->setTristate(true);
ifItem->setCheckState(Qt::Checked);
item.item = ifItem;
const unsigned int count = objref->interface()->operation_count();
for (unsigned int i = 0; i < count; i++)
{
OperationDescriptor_ptr op =
objref->interface()->get_reflective_by_index(i);
QStandardItem * opItem = new QStandardItem(op->get_name());
opItem->setEditable(false);
opItem->setCheckable(true);
opItem->setCheckState(Qt::Checked);
ifItem->appendRow(opItem);
operations.insert(op->get_tag(), opItem);
}
appendRow(ifItem);
emit filterChanged();
}
void FilterModel::save(QVariant& settings)
{
QVariantList list;
for (FirstLevelItems_t::iterator it = m_items.begin();
it != m_items.end(); ++it)
{
Objref_ptr objref = it.value().objref;
QVariantMap map;
map["instance"] = objref->name();
QVariantMap ops;
for (unsigned int j = 0;
j < objref->interface()->operation_count(); j++)
{
OperationDescriptor_ptr op =
objref->interface()->get_reflective_by_index(j);
tag_t tag = op->get_tag();
OperationsMap_t::const_iterator opit =
it.value().operations.find(tag);
if (opit != it.value().operations.end())
{
ops[op->get_name()] =
(opit.value()->checkState() == Qt::Checked);
}
}
map["operations"] = ops;
list << map;
}
settings = list;
}
corbasim::gui::RequestDialog * SimpleClient::getRequestDialog(int idx)
{
RequestDialog * dlg = m_dialogs[idx];
if (!dlg)
{
OperationDescriptor_ptr op =
m_objref->interface()->get_reflective_by_index(idx);
const char * name = op->get_name();
dlg = new RequestDialog(op, this);
dlg->setWindowTitle(name);
connect(dlg,
SIGNAL(sendRequest(Request_ptr)),
this,
SIGNAL(sendRequest(Request_ptr)));
m_dialogs[idx] = dlg;
}
return dlg;
}
void SimpleClient::initialize(Objref_ptr objref)
{
m_objref = objref;
// Signals
connect(this, SIGNAL(sendRequest(Request_ptr)),
m_objref.get(), SLOT(sendRequest(Request_ptr)));
m_log_model.registerInstance(m_objref);
connect(m_objref.get(),
SIGNAL(requestSent(ObjectId, const Request_ptr&, const Event_ptr&)),
&m_log_model,
SLOT(outputRequest(ObjectId, Request_ptr, Event_ptr)));
m_filteredLog->registerInstance(m_objref);
if (m_seqTool)
m_seqTool->registerInstance(m_objref);
QGridLayout * grid = NULL;
InterfaceDescriptor_ptr factory = m_objref->interface();
const unsigned int count = factory->operation_count();
// Inicializa los dialogos a nulo
m_dialogs.resize(count, NULL);
for (unsigned int i = 0; i < count; i++)
{
const unsigned int idx = i % _max_btns_per_page;
OperationDescriptor_ptr op =
factory->get_reflective_by_index(i);
const char * name = op->get_name();
if (!idx)
{
QWidget * w = new QWidget;
grid = new QGridLayout;
w->setLayout(grid);
// TODO Page + number or from... to...
QString page("From ");
page += name;
m_tab->addTab(w, page);
}
// Button
QPushButton * btn = new QPushButton(name);
grid->addWidget(btn, idx / _max_btns_per_row,
idx % _max_btns_per_row);
m_buttons.addButton(btn, i);
// Menu Operations
QAction * act = m_operations_menu->addAction(name);
m_actions.addAction(act);
act->setData(i);
}
// Validator for reference updates
m_ref->setObjref(m_objref);
}
