void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == getIdForTargetType(TargetTypeText))
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == getIdForTargetType(TargetTypeMarkup)) {
// Some Linux applications refuse to accept pasted markup unless it is
// prefixed by a content-type meta tag.
CString markup = (gMarkupPrefix + dataObject->markup()).utf8();
gtk_selection_data_set(selectionData, markupAtom, 8,
reinterpret_cast<const guchar*>(markup.data()), markup.length() + 1);
} else if (info == getIdForTargetType(TargetTypeURIList)) {
CString uriList = dataObject->uriList().utf8();
gtk_selection_data_set(selectionData, uriListAtom, 8,
reinterpret_cast<const guchar*>(uriList.data()), uriList.length() + 1);
} else if (info == getIdForTargetType(TargetTypeNetscapeURL) && dataObject->hasURL()) {
String url(dataObject->url());
String result(url);
result.append("\n");
if (dataObject->hasText())
result.append(dataObject->text());
else
result.append(url);
GOwnPtr<gchar> resultData(g_strdup(result.utf8().data()));
gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()) + 1);
} else if (info == getIdForTargetType(TargetTypeImage))
gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
}
void KisConvolutionPainterTest::testSymmConvolution()
{
qreal offset = 0.0;
qreal factor = 1.0;
Eigen::Matrix<qreal, 3, 3> filter = initSymmFilter(offset, factor);
QRect imageRect;
int pixelSize = 0;
QByteArray initialData;
KisPaintDeviceSP dev = initAsymTestDevice(imageRect, pixelSize, initialData);
KisConvolutionKernelSP kernel =
KisConvolutionKernel::fromMatrix(filter, offset, factor);
KisConvolutionPainter gc(dev);
gc.beginTransaction();
QRect filterRect = imageRect.adjusted(1,1,-1,-1);
gc.applyMatrix(kernel, dev, filterRect.topLeft(), filterRect.topLeft(),
filterRect.size());
gc.deleteTransaction();
QByteArray resultData(initialData.size(), 0);
dev->readBytes((quint8*)resultData.data(), imageRect);
QCOMPARE(resultData, initialData);
}
/* public slots */
void NetControlThread::execAction(uint _num, TASK _task)
{
number = _num;
task = _task;
keep_alive = false;
if ( nullptr!=task.srcConnPtr ) {
// for new virConnect usage create the new virConnectRef[erence]
int ret = virConnectRef(*task.srcConnPtr);
if ( ret<0 ) {
task.srcConnPtr = nullptr;
sendConnErrors();
} else
keep_alive = true;
};
if ( keep_alive && !isRunning() ) {
ptr_ConnPtr = task.srcConnPtr;
start();
} else {
Result result;
result.type = "network";
result.number = number;
result.action = _EMPTY_ACTION;
emit resultData(result);
};
}
void StorageVolControlThread::execAction(uint _num, TASK _task)
{
number = _num;
task = _task;
currPoolName = task.args.object;
if ( NULL!=task.srcConnPtr ) {
// for new virConnect usage create the new virConnectRef[erence]
int ret = virConnectRef(*task.srcConnPtr);
if ( ret<0 ) {
task.srcConnPtr = NULL;
sendConnErrors();
keep_alive = false;
} else
keep_alive = true;
};
if ( keep_alive && !isRunning() ) {
ptr_ConnPtr = task.srcConnPtr;
start();
} else {
Result result;
result.type = "volume";
result.number = number;
result.action = _EMPTY_ACTION;
emit resultData(result);
};
}
/* private slots */
void StoragePoolControlThread::run()
{
QStringList result;
switch (action) {
case GET_ALL_StPOOL :
result.append(getAllStoragePoolList());
break;
case CREATE_StPOOL :
result.append(createStoragePool());
break;
case DEFINE_StPOOL :
result.append(defineStoragePool());
break;
case START_StPOOL :
result.append(startStoragePool());
break;
case DESTROY_StPOOL :
result.append(destroyStoragePool());
break;
case UNDEFINE_StPOOL :
result.append(undefineStoragePool());
break;
case CHANGE_StPOOL_AUTOSTART :
result.append(changeAutoStartStoragePool());
break;
case GET_StPOOL_XML_DESC :
result.append(getStoragePoolXMLDesc());
break;
default:
break;
};
emit resultData(action, result);
}
void KisConvolutionPainterTest::testAsymmConvolutionImp(QBitArray channelFlags)
{
qreal offset = 0.0;
qreal factor = 1.0;
Eigen::Matrix<qreal, 3, 3> filter = initAsymmFilter(offset, factor);
QRect imageRect;
int pixelSize = -1;
QByteArray initialData;
KisPaintDeviceSP dev = initAsymTestDevice(imageRect, pixelSize, initialData);
KisConvolutionKernelSP kernel =
KisConvolutionKernel::fromMatrix(filter, offset, factor);
KisConvolutionPainter gc(dev);
gc.beginTransaction();
gc.setChannelFlags(channelFlags);
QRect filterRect = imageRect.adjusted(1,1,-1,-1);
gc.applyMatrix(kernel, dev, filterRect.topLeft(), filterRect.topLeft(),
filterRect.size());
gc.deleteTransaction();
QByteArray resultData(initialData.size(), 0);
dev->readBytes((quint8*)resultData.data(), imageRect);
QRect filteredRect = imageRect.adjusted(1, 1, -1, -1);
quint8 *srcPtr = (quint8*) initialData.data();
quint8 *resPtr = (quint8*) resultData.data();
for(int row = 0; row < imageRect.height(); row++) {
for(int col = 0; col < imageRect.width(); col++) {
bool isFiltered = filteredRect.contains(col, row);
int pixelValue = 8 + row * imageRect.width() + col;
KoColor filteredPixel(QColor(pixelValue, pixelValue, pixelValue, 255), dev->colorSpace());
KoColor resultPixel(dev->colorSpace());
for(int j = 0; j < pixelSize; j++) {
resultPixel.data()[j] = isFiltered && channelFlags[j] ?
filteredPixel.data()[j] : srcPtr[j];
}
if(memcmp(resPtr, resultPixel.data(), pixelSize)) {
printPixel("Actual: ", pixelSize, resPtr);
printPixel("Expected:", pixelSize, resultPixel.data());
QFAIL("Failed to filter area");
}
srcPtr += pixelSize;
resPtr += pixelSize;
}
}
}
SpatialMotionVectorRaw SpatialMotionVectorRaw::inverse(const SpatialMotionVectorRaw& op)
{
SpatialMotionVectorRaw result;
Eigen::Map<const Vector6d> opData(op.data());
Eigen::Map<Vector6d> resultData(result.data());
resultData = -opData;
return result;
}
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == TargetTypeText)
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == TargetTypeMarkup) {
// Some Linux applications refuse to accept pasted markup unless it is
// prefixed by a content-type meta tag.
CString markup = String(gMarkupPrefix + dataObject->markup()).utf8();
gtk_selection_data_set(selectionData, markupAtom, 8,
reinterpret_cast<const guchar*>(markup.data()), markup.length());
} else if (info == TargetTypeURIList) {
CString uriList = dataObject->uriList().utf8();
gtk_selection_data_set(selectionData, uriListAtom, 8,
reinterpret_cast<const guchar*>(uriList.data()), uriList.length());
} else if (info == TargetTypeNetscapeURL && dataObject->hasURL()) {
String url(dataObject->url());
String result(url);
result.append("\n");
if (dataObject->hasText())
result.append(dataObject->text());
else
result.append(url);
GUniquePtr<gchar> resultData(g_strdup(result.utf8().data()));
gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()));
} else if (info == TargetTypeImage)
gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
else if (info == TargetTypeSmartPaste)
gtk_selection_data_set_text(selectionData, "", -1);
else if (info == TargetTypeUnknown) {
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
auto types = dataObject->unknownTypes();
auto end = types.end();
for (auto it = types.begin(); it != end; ++it) {
GUniquePtr<gchar> dictItem(g_strdup_printf("{'%s', '%s'}", it->key.utf8().data(), it->value.utf8().data()));
g_variant_builder_add_parsed(&builder, dictItem.get());
}
GRefPtr<GVariant> variant = g_variant_builder_end(&builder);
GUniquePtr<gchar> serializedVariant(g_variant_print(variant.get(), TRUE));
gtk_selection_data_set(selectionData, unknownAtom, 1, reinterpret_cast<const guchar*>(serializedVariant.get()), strlen(serializedVariant.get()));
}
}
SpatialMotionVectorRaw SpatialMotionVectorRaw::compose(const SpatialMotionVectorRaw& op1, const SpatialMotionVectorRaw& op2)
{
SpatialMotionVectorRaw result;
Eigen::Map<const Vector6d> op1Data(op1.data());
Eigen::Map<const Vector6d> op2Data(op2.data());
Eigen::Map<Vector6d> resultData(result.data());
resultData = op1Data + op2Data;
return result;
}
bool SBMLModelSimulation::SaveResult()
{
string resultFileName(joinPath(mDataOutputFolder, "rr_" + mModelFileName));
resultFileName = changeFileExtensionTo(resultFileName, ".csv");
Log(lInfo)<<"Saving result to file: "<<resultFileName;
RoadRunnerData resultData(mEngine);
ofstream fs(resultFileName.c_str());
fs << resultData;
fs.close();
return true;
}
virtual std::string getOAuth2Bearer(const PasswordUpdateCallback &passwordUpdateCallback)
{
SE_LOG_DEBUG(NULL, "retrieving OAuth2 token");
if (!m_accessToken.empty() && !m_invalidateCache) {
return m_accessToken;
}
// Retry login if even the refreshed token failed.
g_hash_table_insert(m_sessionData, g_strdup("ForceTokenRefresh"),
g_variant_ref_sink(g_variant_new_boolean(m_invalidateCache)));
// We get assigned a plain pointer to an instance that we'll own,
// so we have to use the "steal" variant to enable that assignment.
GVariantStealCXX resultDataVar;
GErrorCXX gerror;
GVariantCXX sessionDataVar(HashTable2Variant(m_sessionData));
PlainGStr buffer(g_variant_print(sessionDataVar, true));
SE_LOG_DEBUG(NULL, "asking for OAuth2 token with method %s, mechanism %s and parameters %s",
signon_auth_session_get_method(m_authSession),
m_mechanism.c_str(),
buffer.get());
#define signon_auth_session_process_async_finish signon_auth_session_process_finish
SYNCEVO_GLIB_CALL_SYNC(resultDataVar, gerror, signon_auth_session_process_async,
m_authSession, sessionDataVar, m_mechanism.c_str(), NULL);
buffer.reset(resultDataVar ? g_variant_print(resultDataVar, true) : NULL);
SE_LOG_DEBUG(NULL, "OAuth2 token result: %s, %s",
buffer.get() ? buffer.get() : "<<null>>",
gerror ? gerror->message : "???");
if (!resultDataVar || gerror) {
SE_THROW_EXCEPTION_STATUS(StatusException,
StringPrintf("could not obtain OAuth2 token: %s", gerror ? gerror->message : "???"),
STATUS_FORBIDDEN);
}
GHashTableCXX resultData(Variant2HashTable(resultDataVar));
GVariant *tokenVar = static_cast<GVariant *>(g_hash_table_lookup(resultData, (gpointer)"AccessToken"));
if (!tokenVar) {
SE_THROW("no AccessToken in OAuth2 response");
}
std::string newToken = g_variant_get_string(tokenVar, NULL);
if (newToken.empty()) {
SE_THROW("AccessToken did not contain a string value");
} else if (m_invalidateCache && newToken == m_accessToken) {
SE_THROW("Got the same invalid AccessToken");
}
m_accessToken = newToken;
return m_accessToken;
}
/* private slots */
void StoragePoolControlThread::run()
{
Result result;
switch (task.action) {
case GET_ALL_ENTITY_STATE :
result = getAllStoragePoolList();
break;
case GET_ALL_ENTITY_DATA :
result = getAllStoragePoolDataList();
break;
case CREATE_ENTITY :
result = createStoragePool();
break;
case DEFINE_ENTITY :
result = defineStoragePool();
break;
case START_ENTITY :
result = startStoragePool();
break;
case DESTROY_ENTITY :
result = destroyStoragePool();
break;
case UNDEFINE_ENTITY :
result = undefineStoragePool();
break;
case CHANGE_ENTITY_AUTOSTART :
result = changeAutoStartStoragePool();
break;
case DELETE_ENTITY :
result = deleteStoragePool();
break;
case GET_XML_DESCRIPTION :
result = getStoragePoolXMLDesc();
break;
default:
break;
};
// task.srcConnPtr reference will closed in destructor as ptr_ConnPtr
//virConnectClose(*task.srcConnPtr);
result.type = "pool";
result.number = number;
result.action = task.action;
emit resultData(result);
}
/* private slots */
void StoragePoolControlThread::run()
{
Result result;
switch (task.action) {
case GET_ALL_ENTITY :
result = getAllStoragePoolList();
break;
case CREATE_ENTITY :
result = createStoragePool();
break;
case DEFINE_ENTITY :
result = defineStoragePool();
break;
case START_ENTITY :
result = startStoragePool();
break;
case DESTROY_ENTITY :
result = destroyStoragePool();
break;
case UNDEFINE_ENTITY :
result = undefineStoragePool();
break;
case CHANGE_ENTITY_AUTOSTART :
result = changeAutoStartStoragePool();
break;
case DELETE_ENTITY :
result = deleteStoragePool();
break;
case GET_XML_DESCRIPTION :
result = getStoragePoolXMLDesc();
break;
default:
break;
};
virConnectClose(task.sourceConn);
result.type = "pool";
result.number = number;
result.action = task.action;
emit resultData(result);
}
/* private slots */
void NetControlThread::run()
{
Result result;
switch (task.action) {
case GET_ALL_ENTITY_STATE :
result = getAllNetworkList();
break;
case CREATE_ENTITY :
result = createNetwork();
break;
case DEFINE_ENTITY :
result = defineNetwork();
break;
case START_ENTITY :
result = startNetwork();
break;
case DESTROY_ENTITY :
result = destroyNetwork();
break;
case UNDEFINE_ENTITY :
result = undefineNetwork();
break;
case CHANGE_ENTITY_AUTOSTART :
result = changeAutoStartNetwork();
break;
case GET_XML_DESCRIPTION :
result = getVirtNetXMLDesc();
break;
default:
break;
};
// task.srcConnPtr reference will closed in destructor as ptr_ConnPtr
//virConnectClose(*task.srcConnPtr);
result.type = "network";
result.number = number;
result.action = task.action;
emit resultData(result);
}
/* private slots */
void StorageVolControlThread::run()
{
Result result;
switch (task.action) {
case GET_ALL_ENTITY_STATE :
result = getAllStorageVolList();
break;
case CREATE_ENTITY:
result = createStorageVol();
break;
case DELETE_ENTITY :
result = deleteStorageVol();
break;
case DOWNLOAD_ENTITY :
result = downloadStorageVol();
break;
case UPLOAD_ENTITY :
result = uploadStorageVol();
break;
case RESIZE_ENTITY :
result = resizeStorageVol();
break;
case WIPE_ENTITY :
result = wipeStorageVol();
break;
case GET_XML_DESCRIPTION :
result = getStorageVolXMLDesc();
break;
default:
break;
};
// task.srcConnPtr reference will closed in destructor as ptr_ConnPtr
//virConnectClose(*task.srcConnPtr);
result.type = "volume";
result.number = number;
result.action = task.action;
emit resultData(result);
}
void StoragePoolControlThread::execAction(uint _num, TASK _task)
{
number = _num;
task = _task;
keep_alive = true;
// for new virConnect usage create the new virConnectRef[erence]
int ret = virConnectRef(task.sourceConn);
if ( ret<0 ) {
task.sourceConn = NULL;
sendConnErrors();
keep_alive = false;
};
if ( keep_alive && !isRunning() ) {
if ( NULL!=task.sourceConn ) start();
else {
Result result;
result.type = "pool";
result.number = number;
result.action = _EMPTY_ACTION;
emit resultData(result);
};
};
}
void TaskWareHouse::addNewTask(TASK task)
{
//qDebug()<<task.sourceConn<<task.srcConName<<task.action\
// <<task.method<<task.object<<task.args.list()\
// <<task.args.destConn<<task.type<<"addNewTask_TASK";
++counter;
QString _number = QString("").sprintf("%08d", counter);
if ( !task.method.startsWith("reload") ) {
QString _name = QString("#%1 %2 <%3> in <%4> connection")
.arg(_number)
.arg(task.method)
.arg(task.object)
.arg(task.srcConName);
QListWidgetItem *_item = new QListWidgetItem();
_item->setText(_name);
_item->setIcon(QIcon::fromTheme("ledlightgreen"));
QTime _time = QTime::currentTime();
QMap<QString, QVariant> itemData;
itemData.insert("Connection", task.srcConName);
itemData.insert("Object", task.object);
itemData.insert("Action", task.method);
itemData.insert("Start", QString("%1:%2:%3:%4")
.arg(QString("").sprintf("%02d", _time.hour()))
.arg(QString("").sprintf("%02d", _time.minute()))
.arg(QString("").sprintf("%02d", _time.second()))
.arg(QString("").sprintf("%03d", _time.msec())));
itemData.insert("End", "-");
itemData.insert("Arguments", task.args.list());
itemData.insert("Result", "Processing");
itemData.insert("Message", "-");
_item->setData(Qt::UserRole, itemData);
setNewTooltip(_item);
taskList->addItem(_item);
};
if ( task.type == "domain" ) {
threadPool->insert(
_number,
new DomControlThread(this));
} else if ( task.type == "network" ) {
threadPool->insert(
_number,
new NetControlThread(this));
} else if ( task.type == "pool" ) {
threadPool->insert(
_number,
new StoragePoolControlThread(this));
} else if ( task.type == "volume" ) {
threadPool->insert(
_number,
new StorageVolControlThread(this));
} else if ( task.type == "secret" ) {
threadPool->insert(
_number,
new SecretControlThread(this));
} else return;
ControlThread *cThread = static_cast<ControlThread*>(
threadPool->value(_number));
if ( NULL!=cThread ) {
connect(cThread, SIGNAL(errorMsg(QString&,uint)),
this, SLOT(msgRepeater(QString&, uint)));
connect(cThread, SIGNAL(resultData(Result)),
this, SLOT(taskResultReceiver(Result)));
cThread->execAction(counter, task);
};
