void Sasl::respond(qpid::SaslServer::Status status, const std::string& chllnge)
{
switch (status) {
case qpid::SaslServer::OK:
connection.setUserid(authenticator->getUserid());
completed(true);
//can't set authenticated & failed until we have actually sent the outcome
state = SUCCESS_PENDING;
securityLayer = authenticator->getSecurityLayer(65535);
if (securityLayer.get()) {
QPID_LOG_CAT(info, security, id << " Security layer installed");
securityLayer->init(&connection);
connection.setSaslSsf(securityLayer->getSsf());
}
QPID_LOG_CAT(info, security, id << " Authenticated as " << authenticator->getUserid());
break;
case qpid::SaslServer::FAIL:
completed(false);
state = FAILURE_PENDING;
QPID_LOG_CAT(info, security, id << " Failed to authenticate");
break;
case qpid::SaslServer::CHALLENGE:
challenge(&chllnge);
QPID_LOG_CAT(info, security, id << " Challenge issued");
break;
}
haveOutput = true;
out.activateOutput();
}
void ImportWorker::run()
{
if (!runCheck(1))
emit completed(getStyledText(tr("Consistency error, "
"import could not be performed with current import configuration"),
"red",true));
else
{
if (runImport(OGRGDALEXT_PRECHECK_STEPS+1))
{
emit completed(getStyledText(tr("Import sucessful"),
"green",true));
}
else
{
emit completed(getStyledText(tr("Import error. "
"Import may be uncompleted or inconsistent"),
"red",true));
}
emit closeRequired();
}
emit finished();
}
void ConnectionDiagnosticThread::run()
{
boost::scoped_ptr<mongo::DBClientConnection> connection;
try {
connection.reset(new mongo::DBClientConnection);
connection->connect(_connection->info());
emit connectionStatus("", true);
}
catch(const mongo::UserException &ex) {
const char *what = ex.what();
emit connectionStatus(QString(what), false);
emit completed();
return;
}
try {
if (_connection->hasEnabledPrimaryCredential())
{
CredentialSettings *credential = _connection->primaryCredential();
std::string database = credential->databaseName();
std::string username = credential->userName();
std::string password = credential->userPassword();
std::string errmsg;
bool ok = connection->auth(database, username, password, errmsg);
emit authStatus("", ok);
}
} catch (const mongo::UserException &) {
emit authStatus("", false);
}
emit completed();
}
void regionEditDialog::refresh(void)
{
disconnect(link, SIGNAL(completed()), 0, 0);
connect(link, SIGNAL(completed()), this, SLOT(getLock()));
if (regionIndex < link->regionListCount())
link->tx("region[" + link->getRegionIdAt(regionIndex) + "].refresh?\n");
}
bool KHTMLReader::filter(const KUrl& url)
{
kDebug(30503) << "KHTMLReader::filter";
QObject::connect(_html, SIGNAL(completed()), this, SLOT(completed()));
_state.clear();
_list_depth = 0;
_html->view()->resize(600, 530);
_html->setAutoloadImages(false);
_html->setJScriptEnabled(false);
_html->setPluginsEnabled(false);
_html->setJavaEnabled(false);
_html->setMetaRefreshEnabled(false);
if (_html->openUrl(url) == false) {
kWarning(30503) << "openUrl returned false";
return false;
}
#ifdef __GNUC__
#warning "kde4: port it"
#endif
#if 0
//FIXME use synchronous IO instead of this hack if possible.
QWidget dummy(0);//,0,WType_Dialog | WShowModal);
qt_enter_modal(&dummy);
qApp->enter_loop();
qt_leave_modal(&dummy);
#endif
return _it_worked;
}
void
MoonInstallerService::UpdaterCompleted ()
{
char *content, *path, *tmp;
char *xap;
int err = 0;
gsize size;
gsize xap_len;
FILE *fp;
path = g_build_filename (GetBaseInstallDir (), app->uid, "Application.xap", NULL);
// check that the xap has changed...
if (g_file_get_contents (path, &content, &size, NULL)) {
if (g_file_get_contents (request->GetFilename (), &xap, &xap_len, NULL)) {
if (xap_len == size && !memcmp (xap, content, size)) {
// no change to the xap
completed (false, NULL, user_data);
CloseDownloader (false);
g_free (content);
g_free (xap);
g_free (path);
return;
}
g_free (xap);
}
g_free (content);
}
tmp = g_strdup_printf ("%s.tmp", path);
if ((fp = fopen (tmp, "wb"))) {
// write to the temporary file
if (CopyFileTo (request->GetFilename (), fileno (fp)))
err = ferror (fp);
fclose (fp);
if (err == 0) {
// rename the temp file to the actual file
if (g_rename (tmp, path) == -1)
err = errno;
}
} else {
err = errno;
}
g_free (path);
g_free (tmp);
if (err == 0) {
// update the app's mtime
// FIXME: get the Last-Modified: header from the downloader?
app->mtime = time (NULL);
db->SyncAppRecord (app);
}
completed (err == 0, err ? g_strerror (err) : NULL, user_data);
CloseDownloader (false);
}
void Link::rx(void)
{
qint32 i;
rxStream+= server.readAll();
QStringList cmds = rxStream.split(QRegExp("[\r\n]"));
for (i=0; i<cmds.size()-1; i++)
{
if (cmds[i] == "ok") {
succeeded = 1;
emit completed();
emit success();
}
else if (cmds[i].contains("error")) {
succeeded = 0;
emit completed();
if (cmds[i].section('=', 1).size())
emit error(cmds[i].section('=', 1));
emit error();
}
else
parseCmd(this, cmds[i]);
}
if (cmds.size() > 1)
{
rxStream.clear();
if (cmds.at(i).size()) // if string size != 0, there is a partial command leftover
rxStream+= cmds.at(i);
}
}
void HasherThread::run()
{
#if DEBUG_TEST_BUFFER_MODE == 1
qint64 size;
qint64 iReadCount=0;
int iProgress=0;
char buffer[pagesize*BEST_BUFFER_SIZE];
int count;
#endif
m_stop = false;
QFile f( fullFileName );
if ( !f.open(QIODevice::ReadOnly) ) {
emit error(treeitem, QString("Unable to open file %1").arg(fullFileName) );
return;
}
#if DEBUG_TEST_BUFFER_MODE == 1
size = f.size();
#endif
hasher->reset();
#if DEBUG_TEST_TIME == 1
QDateTime sT = QDateTime::currentDateTime();
emit msg(treeitem, "Start: " + sT.toString("yyyy-MM-dd_HH:mm:ss zzz"));
#endif
#if DEBUG_TEST_BUFFER_MODE == 1
do {
count = f.read( buffer, sizeof(buffer) );
if ( count == -1 ) {
emit error(treeitem, QString("Read error") );
break;
}
//add hash data by read position
hasher->addData( buffer, count );
iReadCount = iReadCount + count;
//signal how many byte read
iProgress = ((iReadCount *100) / size);
emit fileReadPos(treeitem, iProgress);
} while( !f.atEnd() && (!m_stop));
if (!m_stop) {
emit completed(treeitem, hasher->result().toHex().toUpper() );
}
#else
//add by filename
//connect(&f,SIGNAL(f.),this,filehashPos() );
if (hasher->addData(&f)) {
emit completed(treeitem, hasher->result().toHex().toUpper() );
}
#endif
#if DEBUG_TEST_TIME == 1
QDateTime eT = QDateTime::currentDateTime();
emit msg(treeitem, "Finish: " + eT.toString("yyyy-MM-dd_HH:mm:ss zzz"));
#endif
//*/
f.close();
}
/*
* implementation for context_switch
*/
void context_switch(sc_context * pContext) {
assert(pContext != NULL);
if (pContext->pFiber != NULL && !completed(pContext)) {
if (current_context != NULL) if (!completed(current_context)) current_context->state = FS_DELAYED;
current_context = pContext;
SwitchToFiber(pContext->pFiber);
}
return;
}
Item::Item( QListViewItem *parent, const KURL &url )
: QCheckListItem( parent, url.fileName(), QCheckListItem::CheckBox )
, m_lister( true )
, m_url( url )
, m_listed( false )
{
m_lister.setDirOnlyMode( true );
setExpandable( true );
connect( &m_lister, SIGNAL(newItems( const KFileItemList& )), SLOT(newItems( const KFileItemList& )) );
connect( &m_lister, SIGNAL(completed()), SLOT(completed()) );
connect( &m_lister, SIGNAL(canceled()), SLOT(completed()) );
}
void regionEditDialog::changeRegion(int i)
{
if (uploadChanges()) {
// need to wait for the ok / error signal from uploadChanges() before doing a refresh or get lock
nextRegionIndex = i - 1;
disconnect(link, SIGNAL(completed()), 0, 0);
connect(link, SIGNAL(completed()), this, SLOT(doRegionChange()));
}
else {
nextRegionIndex = i - 1;
doRegionChange();
}
}
void regionEditDialog::getLock(void)
{
GeoRegion *region;
disconnect(link, SIGNAL(completed()), 0, 0);
if (link->lastSucceeded()) {
connect(link, SIGNAL(completed()), this, SLOT(updateYears()));
region = link->getRegionAt(regionIndex);
if (!region)
return;
link->tx("region[" + link->getRegionIdAt(regionIndex) + "].lock=" + QString::number(region->getVersion()) + "\n");
}
}
/*
* implementation for context_recall
*/
void * context_recall(sc_context * pContext) {
void * r;
assert(pContext != NULL);
if (top_context == current_context) /*especially for PM realization*/
context_switch(pContext);
r = (pContext->pFiber != NULL)?
completed(pContext)? *(pContext->pParameter): NULL:
NULL;
if (completed(pContext)) context_complete(pContext);
return r;
}
void QDeclarativeTimeLine::updateCurrentTime(int v)
{
if (d->syncAdj == -1)
d->syncAdj = v;
v -= d->syncAdj;
int timeChanged = v - d->prevTime;
#if 0
if (!timeChanged)
return;
#endif
d->prevTime = v;
d->advance(timeChanged);
emit updated();
// Do we need to stop the clock?
if (d->ops.isEmpty()) {
stop();
d->prevTime = 0;
d->clockRunning = false;
emit completed();
} /*else if (pauseTime > 0) {
GfxClock::cancelClock();
d->prevTime = 0;
GfxClock::pauseFor(pauseTime);
d->syncAdj = 0;
d->clockRunning = false;
}*/ else if (/*!GfxClock::isActive()*/ state() != Running) {
stop();
d->prevTime = 0;
d->clockRunning = true;
d->syncAdj = 0;
start();
}
}
void OGRGDALImportExtension::proceedToImport()
{
if (mp_PrecheckImportDlg != NULL)
delete mp_PrecheckImportDlg;
mp_PrecheckImportDlg = new PrecheckImportDialog(OGRGDALEXT_PRECHECK_STEPS+m_SourcesInfos.size()+2,this);
mp_PrecheckImportDlg->open();
QThread* WThread = new QThread;
ImportWorker* Worker = new ImportWorker(m_SourcesInfos,mp_AdvancedDesc,m_InputDir);
Worker->moveToThread(WThread);
connect(Worker, SIGNAL(stepEntered(QString)), mp_PrecheckImportDlg, SLOT(handleStepEntered(QString)));
connect(Worker, SIGNAL(stepCompleted(int,QString)), mp_PrecheckImportDlg, SLOT(handleStepCompleted(int,QString)));
connect(Worker, SIGNAL(completed(QString)), mp_PrecheckImportDlg, SLOT(handleCompleted(QString)));
connect(Worker, SIGNAL(finished()), mp_PrecheckImportDlg, SLOT(handleFinished()));
// for automatic closing on successful import
connect(Worker, SIGNAL(closeRequired()), mp_PrecheckImportDlg, SLOT(handleCloseRequired()));
connect(mp_PrecheckImportDlg, SIGNAL(closeRequired()), this, SLOT(handleCloseRequired()));
connect(WThread, SIGNAL(started()), Worker, SLOT(run()));
connect(Worker, SIGNAL(finished()), WThread, SLOT(quit()));
connect(Worker, SIGNAL(finished()), Worker, SLOT(deleteLater()));
connect(WThread, SIGNAL(finished()), WThread, SLOT(deleteLater()));
WThread->start();
}
MenuMedia::MenuMedia()
: KPanelMenu( QString::null, 0, "Media" ),
mMenuId(0)
{
disableAutoClear();
setCaption(i18n("Media Menu"));
m_DirLister = new KDirLister();
connect( m_DirLister, SIGNAL( clear() ), this, SLOT( slotClear() ) );
connect( m_DirLister, SIGNAL( started(const KURL&) ),
this, SLOT( slotStarted(const KURL&) ) );
connect( m_DirLister, SIGNAL( completed() ),
this, SLOT( slotCompleted() ) );
connect( m_DirLister, SIGNAL( newItems( const KFileItemList & ) ),
this, SLOT( slotNewItems( const KFileItemList & ) ) );
connect( m_DirLister, SIGNAL( deleteItem( KFileItem * ) ),
this, SLOT( slotDeleteItem( KFileItem * ) ) );
connect( m_DirLister, SIGNAL( refreshItems( const KFileItemList & ) ),
this, SLOT( slotRefreshItems( const KFileItemList & ) ) );
m_ExcludedTypesList.clear();
m_ExcludedTypesList << "media/hdd_mounted";
m_ExcludedTypesList << "media/hdd_unmounted";
m_ExcludedTypesList << "media/nfs_mounted";
m_ExcludedTypesList << "media/nfs_unmounted";
m_ExcludedTypesList << "media/smb_mounted";
m_ExcludedTypesList << "media/smb_unmounted";
}
TupExportWizardPage *TupExportWizard::addPage(TupExportWizardPage *newPage)
{
QString tag = newPage->getTag();
newPage->setParent(k->history);
newPage->show();
k->history->addWidget(newPage);
if (k->history->count() == 1) { // First Page
newPage->setFocus();
k->backButton->setEnabled(false);
k->nextButton->setDefault(true);
}
// k->nextButton->setEnabled(newPage->isComplete());
connect(newPage, SIGNAL(completed()), this, SLOT(pageCompleted()));
connect(newPage, SIGNAL(emptyField()), this, SLOT(disableButton()));
if (tag.compare("PLUGIN") == 0) {
// connect(newPage, SIGNAL(formatSelected(int, const QString &)), this, SLOT(setFormat(int, const QString &)));
connect(newPage, SIGNAL(animatedImageFormatSelected(int, const QString &)), this, SLOT(setFormat(int, const QString &)));
connect(newPage, SIGNAL(imagesArrayFormatSelected(int, const QString &)), this, SLOT(setFormat(int, const QString &)));
connect(newPage, SIGNAL(animationFormatSelected(int, const QString &)), this, SLOT(setFormat(int, const QString &)));
}
void spi_dw_isr(void *arg)
{
struct device *dev = (struct device *)arg;
const struct spi_dw_config *info = dev->config->config_info;
u32_t error = 0;
u32_t int_status;
int_status = read_isr(info->regs);
SYS_LOG_DBG("SPI int_status 0x%x - (tx: %d, rx: %d)",
int_status, read_txflr(info->regs), read_rxflr(info->regs));
if (int_status & DW_SPI_ISR_ERRORS_MASK) {
error = 1;
goto out;
}
if (int_status & DW_SPI_ISR_RXFIS) {
pull_data(dev);
}
if (int_status & DW_SPI_ISR_TXEIS) {
push_data(dev);
}
out:
clear_interrupts(info->regs);
completed(dev, error);
}
// This can happen after openUrl returns, or directly from m_image->ref()
void KHTMLImage::notifyFinished( khtml::CachedObject *o )
{
if ( !m_image || o != m_image )
return;
//const QPixmap &pix = m_image->pixmap();
QString caption;
KMimeType::Ptr mimeType;
if ( !m_mimeType.isEmpty() )
mimeType = KMimeType::mimeType(m_mimeType, KMimeType::ResolveAliases);
if ( mimeType ) {
if ( !m_image->suggestedTitle().isEmpty() ) {
caption = i18n( "%1 (%2 - %3x%4 Pixels)", m_image->suggestedTitle(), mimeType->comment(), m_image->pixmap_size().width(), m_image->pixmap_size().height() );
} else {
caption = i18n( "%1 - %2x%3 Pixels" , mimeType->comment() ,
m_image->pixmap_size().width() , m_image->pixmap_size().height() );
}
} else {
if ( !m_image->suggestedTitle().isEmpty() ) {
caption = i18n( "%1 (%2x%3 Pixels)" , m_image->suggestedTitle(), m_image->pixmap_size().width() , m_image->pixmap_size().height() );
} else {
caption = i18n( "Image - %1x%2 Pixels" , m_image->pixmap_size().width() , m_image->pixmap_size().height() );
}
}
emit setWindowCaption( caption );
emit completed();
emit setStatusBarText(i18n("Done."));
}
void HasherThread::run()
{
QFile f( filename );
if ( !f.open(QIODevice::ReadOnly) )
{
emit error( QString("Unable to open file %1").arg(filename) );
return;
}
hasher->reset();
char buffer[16*1024];
qint64 count;
qint64 summator = 0;
int _progress = 0;
do {
count = f.read( buffer, sizeof(buffer) );
summator += count;
_progress = (int)((float(summator)/f.size()) * 1000);
//qDebug() << "HasherThread::run " << count;
// qDebug() << "HasherThread::run " << f.size() << " - " << summator << " - " << float(summator)/f.size();
// qDebug() << "HasherThread::progress " << _progress;
emit progress(_progress);
if ( count == -1 )
{
emit error( QString("Read error") );
break;
}
hasher->addData( buffer, count );
} while( !f.atEnd() );
emit completed( hasher->result().toHex() );
}
void POSTRequestGenerator::onResponseReceived(SimulatorResult result,
SimulatorResourceModelSP repModel)
{
OC_LOG_V(INFO, TAG, "Response recieved result:%d", result);
m_responseCnt++;
completed();
}
void OGRGDALImportExtension::runPrecheck()
{
if (mp_PrecheckImportDlg != NULL)
delete mp_PrecheckImportDlg;
mp_PrecheckImportDlg = new PrecheckImportDialog(OGRGDALEXT_PRECHECK_STEPS,this);
mp_PrecheckImportDlg->open();
QThread* WThread = new QThread;
PrecheckWorker* Worker = new PrecheckWorker(m_SourcesInfos,mp_AdvancedDesc);
Worker->moveToThread(WThread);
connect(Worker, SIGNAL(stepEntered(QString)), mp_PrecheckImportDlg, SLOT(handleStepEntered(QString)));
connect(Worker, SIGNAL(stepCompleted(int,QString)), mp_PrecheckImportDlg, SLOT(handleStepCompleted(int,QString)));
connect(Worker, SIGNAL(completed(QString)), mp_PrecheckImportDlg, SLOT(handleCompleted(QString)));
connect(Worker, SIGNAL(finished()), mp_PrecheckImportDlg, SLOT(handleFinished()));
connect(WThread, SIGNAL(started()), Worker, SLOT(run()));
connect(Worker, SIGNAL(finished()), WThread, SLOT(quit()));
connect(Worker, SIGNAL(finished()), Worker, SLOT(deleteLater()));
connect(WThread, SIGNAL(finished()), WThread, SLOT(deleteLater()));
WThread->start();
}
void QgsTask::start()
{
mStartCount++;
Q_ASSERT( mStartCount == 1 );
if ( mStatus != Queued )
return;
mStatus = Running;
mOverallStatus = Running;
emit statusChanged( Running );
emit begun();
// force initial emission of progressChanged, but respect if task has had initial progress manually set
setProgress( mProgress );
if ( run() )
{
completed();
}
else
{
terminated();
}
}
void regionEditDialog::doRegionChange(void)
{
if (nextRegionIndex < 0) {
regionEntry.setEnabled(1);
addRegionButton.setEnabled(1);
yearEntry.setEnabled(0);
addYearButton.setEnabled(0);
}
else {
regionEntry.setEnabled(0);
addRegionButton.setEnabled(0);
yearEntry.setEnabled(1);
addYearButton.setEnabled(1);
}
if (nextRegionIndex != regionIndex) {
yearSelector.clear();
yearEntry.clear();
stats.clear();
if (regionIndex >= 0) {
if (nextRegionIndex >= 0)
connect(link, SIGNAL(completed()), this, SLOT(refresh())); // valid -> valid
if (regionIndex < link->regionListCount())
link->tx("region[" + link->getRegionIdAt(regionIndex) + "].unlock\n");
regionIndex = nextRegionIndex;
}
else if (nextRegionIndex >= 0) { // (-1) -> valid
regionIndex = nextRegionIndex;
refresh();
}
}
}
void FullMessageCombiner::slotDataChanged(const QModelIndex &left, const QModelIndex &right)
{
Q_UNUSED(left);
Q_UNUSED(right);
if (!indexesValid()) {
emit failed(tr("Message is gone"));
return;
}
if (m_headerPartIndex.data(Imap::Mailbox::RoleIsFetched).toBool() && m_bodyPartIndex.data(Imap::Mailbox::RoleIsFetched).toBool()) {
emit completed();
disconnect(m_dataChanged);
}
bool headerOffline = m_headerPartIndex.data(Imap::Mailbox::RoleIsUnavailable).toBool();
bool bodyOffline = m_bodyPartIndex.data(Imap::Mailbox::RoleIsUnavailable).toBool();
if (headerOffline && bodyOffline) {
emit failed(tr("Offline mode: uncached message data not available"));
} else if (headerOffline) {
emit failed(tr("Offline mode: uncached header data not available"));
} else if (bodyOffline) {
emit failed(tr("Offline mode: uncached body data not available"));
}
}
FileStoreUploadDialog::FileStoreUploadDialog(QWidget *parent, FileStore *store, RideItem *item) : QDialog(parent), store(store), item(item)
{
// get a compressed version
store->compressRide(item->ride(), data, QFileInfo(item->fileName).baseName() + ".json");
// setup the gui!
QVBoxLayout *layout = new QVBoxLayout(this);
info = new QLabel(QString(tr("Uploading %1 bytes...")).arg(data.size()));
layout->addWidget(info);
progress = new QProgressBar(this);
progress->setMaximum(0);
progress->setValue(0);
layout->addWidget(progress);
okcancel = new QPushButton(tr("Cancel"));
QHBoxLayout *buttons = new QHBoxLayout;
buttons->addStretch();
buttons->addWidget(okcancel);
layout->addLayout(buttons);
// get notification when done
connect(store, SIGNAL(writeComplete(QString,QString)), this, SLOT(completed(QString,QString)));
// ok, so now we can kickoff the upload
store->writeFile(data, QFileInfo(item->fileName).baseName() + ".json.zip");
}
NetworkResult NetworkFactory::performNetworkOperation(const QString &url, int timeout, const QByteArray &input_data,
const QString &input_content_type, QByteArray &output,
QNetworkAccessManager::Operation operation, bool protected_contents,
const QString &username, const QString &password, bool set_basic_header) {
Downloader downloader;
QEventLoop loop;
NetworkResult result;
QString str(input_data);
downloader.appendRawHeader("Content-Type", input_content_type.toLocal8Bit());
if (set_basic_header) {
QString basic_value = username + ":" + password;
QString header_value = QString("Basic ") + QString(basic_value.toUtf8().toBase64());
downloader.appendRawHeader("Authorization", header_value.toLocal8Bit());
}
// We need to quit event loop when the download finishes.
QObject::connect(&downloader, SIGNAL(completed(QNetworkReply::NetworkError)), &loop, SLOT(quit()));
downloader.manipulateData(url, operation, input_data, timeout, protected_contents, username, password);
loop.exec();
output = downloader.lastOutputData();
result.first = downloader.lastOutputError();
result.second = downloader.lastContentType();
return result;
}
GenericMediaDevice::GenericMediaDevice()
: MediaDevice()
, m_kBSize( 0 )
, m_kBAvail( 0 )
, m_connected( false )
{
DEBUG_BLOCK
m_name = i18n("Generic Audio Player");
m_dirLister = new KDirLister();
m_dirLister->setNameFilter( "*.mp3 *.wav *.asf *.flac *.wma *.ogg *.aac *.m4a *.mp4 *.mp2 *.ac3" );
m_dirLister->setAutoUpdate( false );
m_spacesToUnderscores = false;
m_ignoreThePrefix = false;
m_asciiTextOnly = false;
m_songLocation = QString::null;
m_podcastLocation = QString::null;
m_supportedFileTypes.clear();
m_configDialog = 0;
connect( m_dirLister, SIGNAL( newItems(const KFileItemList &) ), this, SLOT( newItems(const KFileItemList &) ) );
connect( m_dirLister, SIGNAL( completed() ), this, SLOT( dirListerCompleted() ) );
connect( m_dirLister, SIGNAL( clear() ), this, SLOT( dirListerClear() ) );
connect( m_dirLister, SIGNAL( clear(const KURL &) ), this, SLOT( dirListerClear(const KURL &) ) );
connect( m_dirLister, SIGNAL( deleteItem(KFileItem *) ), this, SLOT( dirListerDeleteItem(KFileItem *) ) );
}
DirFilterPlugin::DirFilterPlugin (QObject* parent, const QVariantList &)
:KParts::Plugin (parent)
{
m_part = qobject_cast<KParts::ReadOnlyPart*>(parent);
if (m_part) {
connect(m_part, SIGNAL(aboutToOpenURL()), this, SLOT(slotOpenURL()));
connect(m_part, SIGNAL(completed()), this, SLOT(slotOpenURLCompleted()));
connect(m_part, SIGNAL(completed(bool)), this, SLOT(slotOpenURLCompleted()));
}
KParts::ListingNotificationExtension* notifyExt = KParts::ListingNotificationExtension::childObject(m_part);
if (notifyExt && notifyExt->supportedNotificationEventTypes() != KParts::ListingNotificationExtension::None) {
m_listingExt = KParts::ListingFilterExtension::childObject(m_part);
connect(notifyExt, SIGNAL(listingEvent(KParts::ListingNotificationExtension::NotificationEventType,KFileItemList)),
this, SLOT(slotListingEvent(KParts::ListingNotificationExtension::NotificationEventType,KFileItemList)));
m_pFilterMenu = new KActionMenu (KIcon("view-filter"), i18n("View F&ilter"), actionCollection());
actionCollection()->addAction("filterdir", m_pFilterMenu);
m_pFilterMenu->setDelayed(false);
m_pFilterMenu->setDisabled(true);
m_pFilterMenu->setWhatsThis(i18n("Allow to filter the currently displayed items by filetype."));
connect(m_pFilterMenu->menu(), SIGNAL(aboutToShow()),
this, SLOT(slotShowPopup()));
connect(m_pFilterMenu->menu(), SIGNAL(triggered(QAction*)),
this, SLOT(slotItemSelected(QAction*)));
}
void
MoonInstallerService::UpdaterFailed (const char *msg)
{
completed (false, msg, user_data);
CloseDownloader (false);
}
