void SearchWidget::slotMoveSelectedImagesToThisResult()
{
const QModelIndex currentIndex = d->searchResultsSelectionModel->currentIndex();
const SearchResultModel::SearchResultItem currentItem = d->searchResultsModel->resultItem(currentIndex);
const KMap::GeoCoordinates& targetCoordinates = currentItem.result.coordinates;
const QModelIndexList selectedImageIndices = d->kipiImageSelectionModel->selectedRows();
if (selectedImageIndices.isEmpty())
return;
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
for (int i=0; i<selectedImageIndices.count(); ++i)
{
const QPersistentModelIndex itemIndex = selectedImageIndices.at(i);
KipiImageItem* const item = d->kipiImageModel->itemFromIndex(itemIndex);
GPSUndoCommand::UndoInfo undoInfo(itemIndex);
undoInfo.readOldDataFromItem(item);
GPSDataContainer newData;
newData.setCoordinates(targetCoordinates);
item->setGPSData(newData);
undoInfo.readNewDataFromItem(item);
undoCommand->addUndoInfo(undoInfo);
}
undoCommand->setText(i18np("1 image moved to '%2'",
"%1 images moved to '%2'", selectedImageIndices.count(), currentItem.result.name));
emit(signalUndoCommand(undoCommand));
}
void SearchResultModelHelper::snapItemsTo(const QModelIndex& targetIndex, const QList<QModelIndex>& snappedIndices)
{
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
SearchResultModel::SearchResultItem targetItem = d->model->resultItem(targetIndex);
const KMap::GeoCoordinates& targetCoordinates = targetItem.result.coordinates;
for (int i=0; i<snappedIndices.count(); ++i)
{
const QPersistentModelIndex itemIndex = snappedIndices.at(i);
KipiImageItem* const item = d->imageModel->itemFromIndex(itemIndex);
GPSUndoCommand::UndoInfo undoInfo(itemIndex);
undoInfo.readOldDataFromItem(item);
GPSDataContainer newData;
newData.setCoordinates(targetCoordinates);
item->setGPSData(newData);
undoInfo.readNewDataFromItem(item);
undoCommand->addUndoInfo(undoInfo);
}
undoCommand->setText(i18np("1 image snapped to '%2'",
"%1 images snapped to '%2'", snappedIndices.count(), targetItem.result.name));
emit(signalUndoCommand(undoCommand));
}
void GPSCorrelatorWidget::slotAllItemsCorrelated()
{
if (d->correlationCorrelatedCount == 0)
{
QMessageBox::warning(this, i18n("Correlation failed"),
i18n("Could not correlate any image - please make sure the timezone and gap settings are correct."));
}
else if (d->correlationCorrelatedCount == d->correlationTotalCount)
{
QMessageBox::information(this, i18n("Correlation succeeded"),
i18n("All images have been correlated. You can now check their position on the map."));
}
else
{
// note: no need for i18np here, because the case of correlationTotalCount==1 is covered in the other two cases.
QMessageBox::warning(this, i18n("Correlation finished"),
i18n("%1 out of %2 images have been correlated. Please check the timezone and gap settings if you think that more images should have been correlated.",
d->correlationCorrelatedCount, d->correlationTotalCount));
}
if (d->correlationCorrelatedCount == 0)
{
delete d->correlationUndoCommand;
}
else
{
d->correlationUndoCommand->setText(i18np("1 image correlated",
"%1 images correlated",
d->correlationCorrelatedCount));
emit(signalUndoCommand(d->correlationUndoCommand));
}
// enable the UI:
emit(signalSetUIEnabled(true));
}
void GPSImageDetails::slotApply()
{
GPSDataContainer newData;
if (d->cbCoordinates->isChecked())
{
const double lat = d->leLatitude->text().toDouble();
const double lon = d->leLongitude->text().toDouble();
newData.setCoordinates(GeoIface::GeoCoordinates(lat, lon));
if (d->cbAltitude->isChecked())
{
const qreal alt = static_cast<qreal>(d->leAltitude->text().toDouble());
newData.setAltitude(alt);
}
if (d->cbSpeed->isChecked())
{
const qreal speed = static_cast<qreal>(d->leSpeed->text().toDouble());
newData.setSpeed(speed);
}
if (d->cbNSatellites->isChecked())
{
const int nSatellites = d->leNSatellites->text().toInt();
newData.setNSatellites(nSatellites);
}
if (d->cbFixType->isChecked())
{
const int fixType = d->comboFixType->itemData(d->comboFixType->currentIndex()).toInt();
newData.setFixType(fixType);
}
if (d->cbDop->isChecked())
{
const qreal dop = static_cast<qreal>(d->leDop->text().toDouble());
newData.setDop(dop);
}
}
GPSImageItem* const gpsItem = d->imageModel->itemFromIndex(d->imageIndex);
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
GPSUndoCommand::UndoInfo undoInfo(d->imageIndex);
undoInfo.readOldDataFromItem(gpsItem);
gpsItem->setGPSData(newData);
undoInfo.readNewDataFromItem(gpsItem);
undoCommand->addUndoInfo(undoInfo);
undoCommand->setText(i18n("Details changed"));
emit(signalUndoCommand(undoCommand));
}
void GPSSyncKGeoMapModelHelper::onIndicesMoved(const QList<QPersistentModelIndex>& movedMarkers,
const GeoCoordinates& targetCoordinates,
const QPersistentModelIndex& targetSnapIndex)
{
if (targetSnapIndex.isValid())
{
const QAbstractItemModel* const targetModel = targetSnapIndex.model();
for (int i=0; i<d->ungroupedModelHelpers.count(); ++i)
{
ModelHelper* const ungroupedHelper = d->ungroupedModelHelpers.at(i);
if (ungroupedHelper->model()==targetModel)
{
QList<QModelIndex> iMovedMarkers;
for (int i=0; i<movedMarkers.count(); ++i)
{
iMovedMarkers << movedMarkers.at(i);
}
ungroupedHelper->snapItemsTo(targetSnapIndex, iMovedMarkers);
return;
}
}
}
GPSUndoCommand* const undoCommand = new GPSUndoCommand();
for (int i=0; i<movedMarkers.count(); ++i)
{
const QPersistentModelIndex itemIndex = movedMarkers.at(i);
KipiImageItem* const item = static_cast<KipiImageItem*>(d->model->itemFromIndex(itemIndex));
GPSUndoCommand::UndoInfo undoInfo(itemIndex);
undoInfo.readOldDataFromItem(item);
GPSDataContainer newData;
newData.setCoordinates(targetCoordinates);
item->setGPSData(newData);
undoInfo.readNewDataFromItem(item);
undoCommand->addUndoInfo(undoInfo);
}
undoCommand->setText(i18np("1 image moved",
"%1 images moved", movedMarkers.count()));
emit(signalUndoCommand(undoCommand));
}
void GPSReverseGeocodingWidget::slotRGCanceled()
{
if (!d->undoCommand)
{
// the undo command object is not available, therefore
// RG has probably been finished already
return;
}
if (d->receivedRGCount>0)
{
// Before we abort, ask the user whether he wants to discard
// the information obtained so far.
// ATTENTION: While we ask the question, the RG backend continues running
// and sends information about new images to this widget.
// This means that RG might finish while we ask the question!!!
d->currentlyAskingCancelQuestion = true;
const QString question = i18n("%1 out of %2 images have been reverse geocoded. Would you like to keep the tags which were already obtained or discard them?", d->receivedRGCount, d->requestedRGCount);
const int result = KMessageBox::questionYesNoCancel(
this,
question,
i18n("Abort reverse geocoding?"),
KGuiItem(i18n("Keep tags")),
KGuiItem(i18n("Discard tags")),
KGuiItem(i18n("Continue"))
);
d->currentlyAskingCancelQuestion = false;
if (result==KMessageBox::Cancel)
{
// continue
// did RG finish while we asked the question?
if (d->receivedRGCount==d->requestedRGCount)
{
// the undo data was delayed, now send it
if (d->undoCommand)
{
emit(signalUndoCommand(d->undoCommand));
d->undoCommand = 0;
}
// unlock the UI
emit(signalSetUIEnabled(true));
}
return;
}
if (result==KMessageBox::No)
{
// discard the tags
d->undoCommand->undo();
}
if (result==KMessageBox::Yes)
{
if (d->undoCommand)
{
emit(signalUndoCommand(d->undoCommand));
d->undoCommand = 0;
}
}
}
// clean up the RG request:
d->currentBackend->cancelRequests();
if (d->undoCommand)
{
delete d->undoCommand;
d->undoCommand = 0;
}
emit(signalSetUIEnabled(true));
}
