void MainWindow::displayDestroyed()
{
Queue* q = getCurrentQueue();
//QModelIndex i = treeTransfers->currentIndex();
QList<int> sel = getSelection();
Transfer* d = 0;
if(q != 0 && sel.size() == 1)
d = q->at(sel[0]);
if(QWidget* w = stackedDetails->currentWidget())
{
//disconnect(w, SIGNAL(destroyed()), this, SLOT(displayDestroyed()));
stackedDetails->removeWidget(w);
delete w;
}
m_pDetailsDisplay = 0;
if(d != 0)
{
QWidget* widgetDisplay = new QWidget(stackedDetails);
m_pDetailsDisplay = d->createDetailsWidget(widgetDisplay);
if(m_pDetailsDisplay)
{
stackedDetails->insertWidget(0,widgetDisplay);
stackedDetails->setCurrentIndex(0);
connect(m_pDetailsDisplay, SIGNAL(destroyed()), this, SLOT(displayDestroyed()));
}
else
delete widgetDisplay;
}
doneQueue(q);
}
bool LibusbSoundplaneDriver::processThreadScheduleTransfer(Transfer &transfer)
{
if (processThreadShouldStopTransfers())
{
return false;
}
libusb_fill_iso_transfer(
transfer.transfer,
transfer.device,
transfer.endpointAddress,
reinterpret_cast<unsigned char *>(transfer.packets),
sizeof(transfer.packets),
transfer.numPackets(),
processThreadTransferCallbackStatic,
&transfer,
1000);
libusb_set_iso_packet_lengths(
transfer.transfer,
sizeof(transfer.packets) / transfer.numPackets());
const auto result = libusb_submit_transfer(transfer.transfer);
if (result < 0)
{
fprintf(stderr, "Failed to submit USB transfer: %s\n", libusb_error_name(result));
return false;
}
else
{
mOutstandingTransfers++;
return true;
}
}
Transfer * Client::registerTransfer (const QString& name, TransferType type,
const QString& clientId) {
Transfer * transfer = 0;
if (d_ptr->interface == 0) {
if (d_ptr->initDbusInterface() == false) {
qCritical() << "Failed to create dbus interface";
return transfer;
}
}
QDBusReply<QString> reply =
d_ptr->interface->registerTransientTransfer(name, type, clientId);
if (reply.isValid()) {
transfer = new TransientTransfer (d_ptr->interface, reply.value(), name,
type, this);
if (transfer != 0) {
d_ptr->transfers[transfer->transferId()] = transfer;
connect(d_ptr,SIGNAL(sendLastProgress()),transfer,
SLOT(sendLastProgress()));
} else {
qCritical() << "Failed to create transfer";
}
} else {
qWarning() << "Transfer UI returned error.";
}
return transfer;
}
cairo_surface_t *
GalliumSurface::Cairo ()
{
static cairo_user_data_key_t key;
struct pipe_resource *texture = sampler_view->texture;
Transfer *transfer;
unsigned char *data;
if (!pipe) {
g_warning ("GalliumSurface::Cairo called with invalid "
"surface instance.");
return NULL;
}
if (mapped)
return cairo_surface_reference (mapped);
transfer = new Transfer (pipe, texture);
data = (unsigned char *) transfer->Map ();
mapped = cairo_image_surface_create_for_data (data,
CAIRO_FORMAT_ARGB32,
texture->width0,
texture->height0,
texture->width0 * 4);
cairo_surface_set_user_data (mapped,
&key,
(void *) transfer,
CairoDestroy);
return cairo_surface_reference (mapped);
}
void JavaExtractor::finishedExtraction(QList<QString> list)
{
if (list.isEmpty())
{
setMessage(tr("Empty or invalid link list"));
setState(Failed);
return;
}
QString clsName = m_engines[m_strClass].targetClass;
if (clsName.isEmpty())
{
BestEngine e = bestEngine(list[0], Download);
if (!e.engine)
{
setMessage(tr("Failed to detect URL class: %1").arg(list[0]));
setState(Failed);
return;
}
clsName = e.engine->shortName;
}
QList<Transfer*> ts;
TransferFactory* f = TransferFactory::instance();
foreach (QString url, list)
{
Transfer *t = f->createInstance(clsName);
t->init(url, m_strTarget);
t->setState(Waiting);
ts << t;
}
bool checkWork() {
int flag;
MPI_Iprobe(reqRank, WORK_TRANSMIT, MPI_COMM_WORLD, &flag, &status);
if (flag) {
file << "Process " << rank << " Prijma praci\n";
// kontrola velkosti
int testTransferSize;
MPI_Get_count(&status, MPI_SHORT, &testTransferSize);
file << "\nTransfer Size: " << testTransferSize << "\n";
// prijmanie predoslej ziadosti
Transfer * transfer = new Transfer(testTransferSize);
MPI_Recv(transfer->transfer, testTransferSize, MPI_SHORT, reqRank, WORK_TRANSMIT, MPI_COMM_WORLD, &status);
// pokial 1 == NO_WORK
if (testTransferSize == 1)return false;
file << "Process " << rank << " Prijal spravu o velkosti:" << testTransferSize << "\n";
stack->add(transfer->unpack());
delete transfer;
}
return flag == 0;
}
void checkSolution() {
LinkedStack<Kostra> tempStack;
int flag, testTransferSize;
for (int i = 0; i < worldSize; i++) {
if (i == rank)continue;
MPI_Iprobe(i, SOLUTION_TRANSMIT, MPI_COMM_WORLD, &flag, &status);
file << "\nProcess " << rank << " : Checking Solutions from: " << i << "flag:" << flag << "\n";
if (flag) {
MPI_Get_count(&status, MPI_SHORT, &testTransferSize);
Transfer * t = new Transfer(testTransferSize);
file << "Prijmam solution o velkosti: " << testTransferSize << "\n";
MPI_Recv(t->transfer, testTransferSize, MPI_SHORT, i, SOLUTION_TRANSMIT, MPI_COMM_WORLD, &status);
file << "Prijal sem solution o velkosti: " << testTransferSize << "\n";
tempStack = *t->unpack();
if (solution == NULL || tempStack.front->k->krok < solution->krok)
setSolution(tempStack.front->k);
delete t;
}
}
file << "\nProcess " << rank << " : Exiting Solutions: ";
}
void TextFileDataSource::ConstructAndAddTransferTransaction(std::string line)
{
enum
{
ID,
AMOUNT,
CUSTOMER_ID,
DATE,
TO_ACCOUNT_ID,
FROM_ACCOUNT_ID,
NUM_FIELDS
};
vector<std::string> lineSplit = stringUtils::splitstring(line, ',');
date dt;
Transfer t
(
TypeConverter(lineSplit[ID]),
TypeConverter(lineSplit[AMOUNT]),
TypeConverter(lineSplit[CUSTOMER_ID]),
dt,
TypeConverter(lineSplit[TO_ACCOUNT_ID]),
TypeConverter(lineSplit[FROM_ACCOUNT_ID])
);
_transactions.add(t.getId(), &t);
}
bool DeviceHandleLibUSB::write(const Transfer& transfer_, uint8_t endpoint_)
{
int nBytesWritten = 0;
if (static_cast<bool>(transfer_) == true)
{
int result = libusb_bulk_transfer(m_pCurrentDevice, // Device handle
endpoint_, // Endpoint
const_cast<uint8_t*>(transfer_.data().data()), // Data pointer
transfer_.size(), // Size of data
&nBytesWritten, // N. of bytes actually written
kLibUSBWriteTimeout // Timeout
);
if ((LIBUSB_SUCCESS != result) || (nBytesWritten != transfer_.size()))
{
M_LOG(
"[DeviceHandleLibUSB] write: error=" << result << " - transfer size: " << transfer_.size()
<< " written: "
<< nBytesWritten);
return false;
}
return true;
}
return false;
}
dbinterface::dbinterface()
{
this->dbm=new dbmeth;
if(dbm->Transfer(dbm->do_nothing)){//!
Transfer *tr = new Transfer(this,dbm->transferMes());
tr->exec();
}
}
void
GalliumSurface::CairoDestroy (void *data)
{
Transfer *transfer = (Transfer *) data;
transfer->Unmap ();
delete transfer;
}
void TraktorF1MK2::processButtons(const Transfer& input_)
{
bool shiftPressed(isButtonPressed(input_, Button::Shift));
Device::Button changedButton(Device::Button::Unknown);
bool buttonPressed(false);
for (int i = 0; i < kF1MK2_buttonsDataSize - 1; i++) // Skip the last byte (encoder value)
{
for (int k = 0; k < 8; k++)
{
uint8_t btn = (i * 8) + k;
Button currentButton(static_cast<Button>(btn));
if (currentButton == Button::Shift)
{
continue;
}
buttonPressed = isButtonPressed(input_, currentButton);
if (buttonPressed != m_buttonStates[btn])
{
m_buttonStates[btn] = buttonPressed;
changedButton = deviceButton(currentButton);
if (changedButton != Device::Button::Unknown)
{
if (currentButton >= Button::Pad8 && currentButton <= Button::Pad9)
{
keyChanged(btn, buttonPressed ? 1.0 : 0.0, shiftPressed);
}
else
{
buttonChanged(changedButton, buttonPressed, shiftPressed);
}
}
}
}
}
// encoder
uint8_t currentValue = input_.data()[kF1MK2_buttonsDataSize];
if (currentValue != m_encoderValue)
{
bool valueIncreased = ((static_cast<uint8_t>(m_encoderValue) < currentValue)
|| ((m_encoderValue == 0xff) && (currentValue == 0x00)))
&& (!((m_encoderValue == 0x0) && (currentValue == 0xff)));
m_encoderValue = currentValue;
encoderChanged(0, valueIncreased, shiftPressed);
}
// pots/faders
for (uint8_t potIndex = 0, i = kF1MK2_buttonsDataSize + 1; potIndex < 8; i += 2, potIndex++)
{
unsigned value = (input_.data()[i]) | (input_.data()[i + 1] << 8);
if (m_potentiometersValues[potIndex] != value)
{
m_potentiometersValues[potIndex] = value;
controlChanged(potIndex, value / 1024.0, shiftPressed);
}
}
}
void ClientPrivate::startSlot (const QString & id) {
if (transfers.contains (id)) {
Transfer * transfer = transfers[id];
transfer->startSlot ();
Q_EMIT(startTransfer (transfer));
} else {
qDebug() << "Ignore start signal for" << id;
}
}
void ClientPrivate::pauseSlot (const QString & id) {
if (transfers.contains (id)) {
Transfer * transfer = transfers[id];
transfer->pauseSlot ();
Q_EMIT(pauseTransfer (transfer));
} else {
qDebug() << "Ignore pause signal for" << id;
}
}
void TransfersContentsWidget::openTransfer(const QModelIndex &index)
{
Transfer *transfer = getTransfer(index.isValid() ? index : m_ui->transfersViewWidget->currentIndex());
if (transfer)
{
transfer->openTarget();
}
}
void TransfersContentsWidget::openTransfer(QAction *action)
{
Transfer *transfer = getTransfer(m_ui->transfersViewWidget->currentIndex());
if (transfer && action && !action->data().isNull())
{
Utils::runApplication(action->data().toString(), QUrl::fromLocalFile(transfer->getTarget()));
}
}
void TransfersContentsWidget::openTransferFolder(const QModelIndex &index)
{
Transfer *transfer = getTransfer(index.isValid() ? index : m_ui->transfersViewWidget->currentIndex());
if (transfer)
{
Utils::runApplication(QString(), QUrl::fromLocalFile(QFileInfo(transfer->getTarget()).dir().canonicalPath()));
}
}
void TransfersContentsWidget::redownloadTransfer()
{
Transfer *transfer = getTransfer(m_ui->transfersViewWidget->selectionModel()->hasSelection() ? m_ui->transfersViewWidget->selectionModel()->currentIndex() : QModelIndex());
if (transfer)
{
transfer->restart();
}
}
void ClientPrivate::cancelSlot (const QString & id) {
qDebug() << "Transfer id " << id;
if (transfers.contains (id)) {
Transfer * transfer = transfers[id];
transfer->cancelSlot ();
Q_EMIT(cancelTransfer (transfer));
} else {
qDebug() << "Ignore cancel signal for" << id;
}
}
Transfer *TransferManager::FindTransferByName( const String &sName )
{
for ( Transfer *pCur = (Transfer *)m_transferList.GetFirst(); pCur; pCur = (Transfer *)m_transferList.GetNext( pCur ) )
{
if ( sName == pCur->GetName() )
return pCur;
}
return (NULL);
}
void ClientPrivate::errorRepairSlot (const QString& id) {
qDebug()<<transfers.contains(id);
if (transfers.contains (id)) {
Transfer * transfer = transfers[id];
transfer->errorRepairSlot ();
Q_EMIT(repairErrorTransfer (transfer));
} else {
qDebug() << "Ignore repair signal for" << id;
}
}
bool DeviceHandleHIDAPI::write(const Transfer& transfer_, uint8_t)
{
if (transfer_)
{
int nBytesWritten = hid_write(m_pCurrentDevice, transfer_.data().data(), transfer_.size());
return (nBytesWritten >= static_cast<int>(transfer_.size()));
}
return false;
}
void TransferListWidget::torrentDoubleClicked(const QModelIndex& index) {
const QString hash = index.model()->data(index.model()->index(index.row(), TorrentModelItem::TR_HASH)).toString();//mapToSource(index).row();
Transfer h = BTSession->getTransfer(hash);
if (!h.is_valid()) return;
int action;
if (h.is_seed()) {
action = Preferences().getActionOnDblClOnTorrentFn();
} else {
action = Preferences().getActionOnDblClOnTorrentDl();
}
switch(action) {
case TOGGLE_PAUSE:
if (h.is_paused()) {
h.resume();
} else {
h.pause();
}
break;
case OPEN_DEST:
QString link = h.num_files() == 1 ? h.absolute_files_path().at(0) : h.save_path();
QDesktopServices::openUrl(QUrl::fromLocalFile(link));
break;
}
}
void TransfersManager::transferStarted()
{
Transfer *transfer = qobject_cast<Transfer*>(sender());
if (transfer && transfer->getState() != Transfer::CancelledState)
{
emit transferStarted(transfer);
scheduleSave();
}
}
void Updater::transferFinished()
{
Transfer *transfer = qobject_cast<Transfer*>(sender());
if (transfer)
{
const QString path = transfer->getTarget();
if ((transfer->getState() == Transfer::FinishedState) && QFile::exists(path))
{
if (QFileInfo(path).suffix() == QLatin1String("xml"))
{
QFile file(SessionsManager::getWritableDataPath(QLatin1String("update.txt")));
if (file.open(QIODevice::ReadWrite | QIODevice::Text))
{
QTextStream stream(&file);
stream << path;
file.close();
}
}
}
else
{
Console::addMessage(QCoreApplication::translate("main", "Unable to download update: %1\nError: %2").arg(transfer->getSource().url()).arg(transfer->getState()), OtherMessageCategory, ErrorMessageLevel);
m_transfersSuccessful = false;
}
transfer->deleteLater();
}
else
{
m_transfersSuccessful = false;
}
++m_transfersCount;
if (m_transfersCount == 2)
{
if (!m_transfersSuccessful)
{
clearUpdate();
}
emit finished(m_transfersSuccessful);
deleteLater();
}
}
void ClientPrivate::tuiLaunched () {
qDebug () << "ClientPrivate::tuiLaunched";
QMapIterator<QString, Transfer *> iter (transfers);
if (transfers.count() == 0) {
// There are no transfers
return;
}
while (iter.hasNext()) {
iter.next();
Transfer *transfer = iter.value ();
if (iter.key() != transfer->transferId ()) {
qCritical () <<
"Client::tuiLaunched -> Key does not match transfer id";
}
QDBusReply<bool> exists =
interface->transferExists (transfer->transferId ());
if (exists.isValid ()) {
if (exists.value () == true) {
qDebug() << transfer->transferId () << "exists in TUI"
<< "- not registering this. Moving to next";
// Transfer exists in TUI - go to next transfer
continue;
}
} else {
qCritical() << "Got invalid reply when checking if transfer "
<< transfer->transferId () << " exists in TUI";
continue;
}
QDBusReply<QString> reply =
interface->registerTransientTransfer (transfer->transferId ());
if (reply.isValid()) {
if (reply.value () == transfer->transferId ()) {
transfer->tuiLaunched ();
} else {
qCritical() << "Got " << reply.value () <<
" as reply from registerPersistentTransfer instead of "
<< "expected value of " << transfer->transferId ();
}
} else {
qWarning() << "Transfer with tracker uri" << transfer->transferId ()
<< "not found.";
}
}
}
void
Transfers::load(const YAML::Node & node)
{
// xfers are optional...
const YAML::Node *transfers = node.FindValue("transfers");
if (transfers) {
for ( size_t itransfer = 0; itransfer < transfers->size(); ++itransfer ) {
const YAML::Node & transferNode = (*transfers)[itransfer];
Transfer *transferInfo = new Transfer(*this);
transferInfo->load(transferNode);
this->push_back(transferInfo);
}
}
}
void sendSolution() {
file << "Process 0 : Sending Solutions\n";
LinkedStack<Kostra> tempStack;
tempStack.add(solution);
solution->toString();
Transfer * t = new Transfer(&tempStack);
for (int i = 0; i < worldSize; i++) {
//neposilej zpravu sam sobe
if (i == rank) continue;
MPI_Send(t->transfer, t->size, MPI_SHORT, i, SOLUTION_TRANSMIT, MPI_COMM_WORLD);
}
t->print();
delete t;
}
Transfer* TransfersManager::startTransfer(QNetworkReply *reply, const QString &target, Transfer::TransferOptions options)
{
Transfer *transfer = new Transfer(reply, target, options, m_instance);
if (transfer->getState() == Transfer::CancelledState)
{
transfer->deleteLater();
return NULL;
}
addTransfer(transfer);
return transfer;
}
Transfer* TransfersManager::startTransfer(const QUrl &source, const QString &target, Transfer::TransferOptions options)
{
Transfer *transfer = new Transfer(source, target, options, m_instance);
if (transfer->getState() == Transfer::CancelledState)
{
transfer->deleteLater();
return NULL;
}
addTransfer(transfer);
return transfer;
}
