void DataPlot::closeEvent ( QCloseEvent * event ){
    deleteLater();
}
	void RecEventsFetcher::handleFinished ()
	{
		auto reply = qobject_cast<QNetworkReply*> (sender ());
		if (!reply)
			return;

		reply->deleteLater ();
		deleteLater ();

		const auto& data = reply->readAll ();

		QDomDocument doc;
		if (!doc.setContent (data))
		{
			qWarning () << Q_FUNC_INFO
					<< "error parsing reply";
			return;
		}

		Media::EventInfos_t result;

		auto eventElem = doc
				.documentElement ()
				.firstChildElement ("events")
				.firstChildElement ("event");
		while (!eventElem.isNull ())
		{
			auto artistsElem = eventElem.firstChildElement ("artists");
			auto venueElem = eventElem.firstChildElement ("venue");
			auto locationElem = venueElem.firstChildElement ("location");
			auto pointElem = locationElem.firstChildElement ("point");

			Media::EventInfo info =
			{
				eventElem.firstChildElement ("id").text ().toInt (),
				eventElem.firstChildElement ("title").text (),
				QString (),
				QLocale ("en_US").toDateTime (eventElem.firstChildElement ("startDate").text (),
							"ddd, dd MMM yyyy hh:mm:ss"),
				eventElem.firstChildElement ("url").text (),
				GetImage (eventElem, "medium"),
				GetImage (eventElem, "extralarge"),
				GetElemsList (artistsElem, "artist"),
				artistsElem.firstChildElement ("headliner").text (),
				GetElemsList (eventElem.firstChildElement ("tags"), "tag"),
				eventElem.firstChildElement ("attendance").text ().toInt (),
				venueElem.firstChildElement ("name").text (),
				pointElem.firstChildElement ("lat").text ().toDouble (),
				pointElem.firstChildElement ("long").text ().toDouble (),
				locationElem.firstChildElement ("city").text (),
				locationElem.firstChildElement ("street").text (),
				true,
				Type_ == Type::Attending ?
						Media::EventAttendType::Surely :
						Media::EventAttendType::None
			};
			result << info;

			eventElem = eventElem.nextSiblingElement ("event");
		}

		emit gotRecommendedEvents (result);
	}
Exemple #3
0
void CSVWorld::SceneSubView::closeRequest()
{
    deleteLater();
}
Exemple #4
0
 void deleteObject(QObject *object, int msec)
 {
     QTimer::singleShot( msec, object, SLOT( deleteLater() ) );
 }
Exemple #5
0
void ObjectHelper::Invoked() {
  closure_->Invoke();
  deleteLater();
}
void FullScreenPlayer::stop()
{
    deleteLater();
}
CaptureFilterEdit::CaptureFilterEdit(QWidget *parent, bool plain) :
    SyntaxLineEdit(parent),
    plain_(plain),
    field_name_only_(false),
    apply_button_(NULL)
{
    setAccessibleName(tr("Capture filter entry"));

    completion_model_ = new QStringListModel(this);
    setCompleter(new QCompleter(completion_model_, this));
    setCompletionTokenChars(libpcap_primitive_chars_);

    placeholder_text_ = QString(tr("Enter a capture filter %1")).arg(UTF8_HORIZONTAL_ELLIPSIS);
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
    setPlaceholderText(placeholder_text_);
#endif

    //   DFCombo
    //     Bookmark (star)
    //     DispalyFilterEdit
    //     Clear button
    //     Apply (right arrow) + Cancel (x) + Reload (arrowed circle)
    //     Combo drop-down

    // XXX - Move bookmark and apply buttons to the toolbar a la Firefox, Chrome & Safari?
    // XXX - Use native buttons on OS X?

    bookmark_button_ = new QToolButton(this);
    bookmark_button_->setCursor(Qt::ArrowCursor);
    bookmark_button_->setStyleSheet(QString(
            "QToolButton { /* all types of tool button */"
            "  border 0 0 0 0;"
#ifdef Q_OS_MAC
            "  border-right: %1px solid gray;"
#else
            "  border-right: %1px solid palette(shadow);"
#endif
            "  border-top-left-radius: 3px;"
            "  border-bottom-left-radius: 3px;"
            "  padding-left: 1px;"
            "  image: url(:/dfilter/dfilter_bookmark_normal.png) center;"
            "}"

            "QToolButton:hover {"
            "  image: url(:/dfilter/dfilter_bookmark_hover.png) center;"
            "}"
            "QToolButton:pressed {"
            "  image: url(:/dfilter/dfilter_bookmark_pressed.png) center;"
            "}"
            "QToolButton:disabled {"
            "  image: url(:/dfilter/dfilter_bookmark_disabled.png) center;"
            "}"


            ).arg(plain_ ? 0 : 1)
            );
    connect(bookmark_button_, SIGNAL(clicked()), this, SLOT(bookmarkClicked()));

    clear_button_ = new QToolButton(this);
    clear_button_->setCursor(Qt::ArrowCursor);
    clear_button_->setStyleSheet(
            "QToolButton {"
            "  image: url(:/dfilter/dfilter_erase_normal.png) center;"
            "  border: none;"
            "  width: 16px;"
            "}"
            "QToolButton:hover {"
            "  image: url(:/dfilter/dfilter_erase_active.png) center;"
            "}"
            "QToolButton:pressed {"
            "  image: url(:/dfilter/dfilter_erase_selected.png) center;"
            "}"
            );
    clear_button_->hide();
    connect(clear_button_, SIGNAL(clicked()), this, SLOT(clear()));
    connect(this, SIGNAL(textChanged(const QString&)), this, SLOT(checkFilter(const QString&)));

    if (!plain_) {
        apply_button_ = new QToolButton(this);
        apply_button_->setCursor(Qt::ArrowCursor);
        apply_button_->setEnabled(false);
        apply_button_->setStyleSheet(
                "QToolButton { /* all types of tool button */"
                "  border 0 0 0 0;"
                "  border-top-right-radius: 3px;"
                "  border-bottom-right-radius: 3px;"
                "  padding-right: 1px;"
                "  image: url(:/dfilter/dfilter_apply_normal.png) center;"
                "}"

                "QToolButton:hover {"
                "  image: url(:/dfilter/dfilter_apply_hover.png) center;"
                "}"
                "QToolButton:pressed {"
                "  image: url(:/dfilter/dfilter_apply_pressed.png) center;"
                "}"
                "QToolButton:disabled {"
                "  image: url(:/dfilter/dfilter_apply_disabled.png) center;"
                "}"
                );
        connect(apply_button_, SIGNAL(clicked()), this, SLOT(applyCaptureFilter()));
        connect(this, SIGNAL(returnPressed()), this, SLOT(applyCaptureFilter()));
    }

    int frameWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
    QSize bksz = bookmark_button_->sizeHint();
    QSize cbsz = clear_button_->sizeHint();
    QSize apsz;
    if (apply_button_) {
        apsz = apply_button_->sizeHint();
    } else {
        apsz.setHeight(0); apsz.setWidth(0);
    }
    setStyleSheet(QString(
            "CaptureFilterEdit {"
            "  padding-left: %1px;"
            "  margin-left: %2px;"
            "  margin-right: %3px;"
            "}"
            )
            .arg(frameWidth + 1)
            .arg(bksz.width())
            .arg(cbsz.width() + apsz.width() + frameWidth + 1)
            );

    QThread *syntax_thread = new QThread;
    syntax_worker_ = new CaptureFilterSyntaxWorker;
    syntax_worker_->moveToThread(syntax_thread);
    connect(wsApp, SIGNAL(appInitialized()), this, SLOT(initCaptureFilter()));
    connect(syntax_thread, SIGNAL(started()), syntax_worker_, SLOT(start()));
    connect(syntax_thread, SIGNAL(started()), this, SLOT(checkFilter()));
    connect(syntax_worker_, SIGNAL(syntaxResult(QString,bool,QString)),
            this, SLOT(setFilterSyntaxState(QString,bool,QString)));
    connect(syntax_thread, SIGNAL(finished()), syntax_worker_, SLOT(deleteLater()));
    syntax_thread->start();
}
Exemple #8
0
void Element::destroyElement()
{
    deleteLater();
}
Exemple #9
0
Sidebar_Widget::Sidebar_Widget(QWidget *parent, KParts::ReadOnlyPart *par, const char *name,bool universalMode, const QString &currentProfile)
	:QWidget(parent,name),m_universalMode(universalMode),m_partParent(par),m_currentProfile(currentProfile)
{
	m_somethingVisible = false;
	m_initial = true;
	m_noUpdate = false;
	m_layout = 0;
	m_currentButton = 0;
	m_activeModule = 0;
	m_userMovedSplitter = false;
        //kdDebug() << "**** Sidebar_Widget:SidebarWidget()"<<endl;
	if (universalMode)
	{
		m_relPath = "konqsidebartng/kicker_entries/";
	}
	else
	{
		m_relPath = "konqsidebartng/" + currentProfile + "/entries/";
	}
	m_path = KGlobal::dirs()->saveLocation("data", m_relPath, true);
	m_buttons.setAutoDelete(true);
	m_hasStoredUrl = false;
	m_latestViewed = -1;
	setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

	QSplitter *splitterWidget = splitter();
	if (splitterWidget) {
		splitterWidget->setResizeMode(parent, QSplitter::FollowSizeHint);
		splitterWidget->setOpaqueResize( false );
		connect(splitterWidget,SIGNAL(setRubberbandCalled()),SLOT(userMovedSplitter()));
	}
		
	m_area = new KDockArea(this);
	m_area->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
	m_mainDockWidget = m_area->createDockWidget("free", 0);
	m_mainDockWidget->setWidget(new QWidget(m_mainDockWidget));
	m_area->setMainDockWidget(m_mainDockWidget);
	m_area->setMinimumWidth(0);
	m_mainDockWidget->setDockSite(KDockWidget::DockTop);
	m_mainDockWidget->setEnableDocking(KDockWidget::DockNone);

	m_buttonBar = new KMultiTabBar(KMultiTabBar::Vertical,this);
	m_buttonBar->showActiveTabTexts(true);

	m_menu = new QPopupMenu(this, "Sidebar_Widget::Menu");
	QPopupMenu *addMenu = new QPopupMenu(this, "Sidebar_Widget::addPopup");
	m_menu->insertItem(i18n("Add New"), addMenu, 0);
	m_menu->insertItem(i18n("Multiple Views"), 1);
	m_menu->insertItem(i18n("Show Tabs Left"), 2);
	m_menu->insertItem(i18n("Show Configuration Button"), 3);
	if (!m_universalMode) {
		m_menu->insertItem(SmallIconSet("remove"),
                                   i18n("Close Navigation Panel"),
				par, SLOT(deleteLater()));
	}
        connect(m_menu, SIGNAL(aboutToShow()),
		this, SLOT(aboutToShowConfigMenu()));
	connect(m_menu, SIGNAL(activated(int)),
		this, SLOT(activatedMenu(int)));

	m_buttonPopup = 0;
	addBackEnd *ab = new addBackEnd(this, addMenu, universalMode,
                                        currentProfile,
                                        "Sidebar_Widget-addBackEnd");

	connect(ab, SIGNAL(updateNeeded()),
		this, SLOT(updateButtons()));
	connect(ab, SIGNAL(initialCopyNeeded()),
		this, SLOT(finishRollBack()));

	initialCopy();

        if (universalMode)
        {
                m_config = new KConfig("konqsidebartng_kicker.rc");
        }
        else
        {
                m_config = new KConfig("konqsidebartng.rc");
                m_config->setGroup(currentProfile);
        }
        readConfig();

        // Disable stuff (useful for Kiosk mode)!
        m_menu->setItemVisible(1, !m_immutableSingleWidgetMode);
        m_menu->setItemVisible(2, !m_immutableShowTabsLeft);
        m_menu->setItemVisible(3, !m_immutableShowExtraButtons);

	connect(&m_configTimer, SIGNAL(timeout()),
		this, SLOT(saveConfig()));
	m_somethingVisible = !m_openViews.isEmpty();
	doLayout();
	QTimer::singleShot(0,this,SLOT(createButtons()));
	connect(m_area, SIGNAL(dockWidgetHasUndocked(KDockWidget*)),
		this, SLOT(dockWidgetHasUndocked(KDockWidget*)));
}
Exemple #10
0
void SplashScreen::Close()
{
    close();
    deleteLater();
}
	void AccountsTab::Remove ()
	{
		emit removeTab (this);
		deleteLater ();
	}
void Variable::die()
{
    removeSelf();
    deleteLater();
}
bool cRenderer::RenderImage()
{
	WriteLog("cRenderer::RenderImage()", 2);

	if (image->IsAllocated())
	{
		image->SetImageParameters(params->imageAdjustments);

		int progressiveSteps;
		if (data->configuration.UseProgressive())
			progressiveSteps =
				(int)(log((double)max(image->GetWidth(), image->GetHeight())) / log(2.0)) - 3;
		else
			progressiveSteps = 0;

		if (progressiveSteps < 0) progressiveSteps = 0;
		int progressive = pow(2.0, (double)progressiveSteps - 1);
		if (progressive == 0) progressive = 1;

		// prepare multiple threads
		QThread **thread = new QThread *[data->configuration.GetNumberOfThreads()];
		cRenderWorker::sThreadData *threadData =
			new cRenderWorker::sThreadData[data->configuration.GetNumberOfThreads()];
		cRenderWorker **worker = new cRenderWorker *[data->configuration.GetNumberOfThreads()];

		if (scheduler) delete scheduler;
		scheduler = new cScheduler(image->GetHeight(), progressive);

		cProgressText progressText;
		progressText.ResetTimer();

		for (int i = 0; i < data->configuration.GetNumberOfThreads(); i++)
		{
			threadData[i].id = i + 1;
			if (data->configuration.UseNetRender())
			{
				if (i < data->netRenderStartingPositions.size())
				{
					threadData[i].startLine = data->netRenderStartingPositions.at(i);
				}
				else
				{
					threadData[i].startLine = 0;
					qCritical() << "NetRender - Mising starting positions data";
				}
			}
			else
			{
				threadData[i].startLine = (image->GetHeight() / data->configuration.GetNumberOfThreads())
																	* i / scheduler->GetProgressiveStep()
																	* scheduler->GetProgressiveStep();
			}
			threadData[i].scheduler = scheduler;
		}

		QString statusText;
		QString progressTxt;

		QElapsedTimer timerRefresh;
		timerRefresh.start();
		qint64 lastRefreshTime = 0;
		QList<int> listToRefresh;
		QList<int> listToSend;

		QElapsedTimer timerProgressRefresh;
		timerProgressRefresh.start();

		WriteLog("Start rendering", 2);
		do
		{
			WriteLogDouble("Progressive loop", scheduler->GetProgressiveStep(), 2);
			for (int i = 0; i < data->configuration.GetNumberOfThreads(); i++)
			{
				WriteLog(QString("Thread ") + QString::number(i) + " create", 3);
				thread[i] = new QThread;
				worker[i] = new cRenderWorker(
					params, fractal, &threadData[i], data, image); // Warning! not needed to delete object
				worker[i]->moveToThread(thread[i]);
				QObject::connect(thread[i], SIGNAL(started()), worker[i], SLOT(doWork()));
				QObject::connect(worker[i], SIGNAL(finished()), thread[i], SLOT(quit()));
				QObject::connect(worker[i], SIGNAL(finished()), worker[i], SLOT(deleteLater()));
				thread[i]->setObjectName("RenderWorker #" + QString::number(i));
				thread[i]->start();
				WriteLog(QString("Thread ") + QString::number(i) + " started", 3);
			}

			while (!scheduler->AllLinesDone())
			{
				gApplication->processEvents();

				if (*data->stopRequest || progressText.getTime() > data->configuration.GetMaxRenderTime()
						|| systemData.globalStopRequest)
				{
					scheduler->Stop();
				}

				Wait(10); // wait 10ms

				if (data->configuration.UseRefreshRenderedList())
				{
					// get list of last rendered lines
					QList<int> list = scheduler->GetLastRenderedLines();
					// create list of lines for image refresh
					listToRefresh += list;
				}

				// status bar and progress bar
				double percentDone = scheduler->PercentDone();
				data->lastPercentage = percentDone;
				statusText = QObject::tr("Rendering image");
				progressTxt = progressText.getText(percentDone);
				data->statistics.time = progressText.getTime();

				if (timerProgressRefresh.elapsed() > 1000)
				{
					emit updateProgressAndStatus(statusText, progressTxt, percentDone);
					emit updateStatistics(data->statistics);
					timerProgressRefresh.restart();
				}

				// refresh image
				if (listToRefresh.size() > 0)
				{
					if (timerRefresh.elapsed() > lastRefreshTime
							&& (scheduler->GetProgressivePass() > 1 || !data->configuration.UseProgressive()))
					{
						timerRefresh.restart();

						emit updateProgressAndStatus(statusText, progressTxt, percentDone);
						emit updateStatistics(data->statistics);

						QSet<int> set_listToRefresh = listToRefresh.toSet(); // removing duplicates
						listToRefresh = set_listToRefresh.toList();
						qSort(listToRefresh);
						listToSend += listToRefresh;

						image->CompileImage(&listToRefresh);

						if (data->configuration.UseRenderTimeEffects())
						{
							if (params->ambientOcclusionEnabled
									&& params->ambientOcclusionMode == params::AOmodeScreenSpace)
							{
								cRenderSSAO rendererSSAO(params, data, image);
								rendererSSAO.setProgressive(scheduler->GetProgressiveStep());
								rendererSSAO.RenderSSAO(&listToRefresh);
							}
						}

						image->ConvertTo8bit();

						if (data->configuration.UseImageRefresh())
						{
							image->UpdatePreview(&listToRefresh);
							image->GetImageWidget()->update();
						}

						// sending rendered lines to NetRender server
						if (data->configuration.UseNetRender() && gNetRender->IsClient()
								&& gNetRender->GetStatus() == CNetRender::netRender_WORKING)
						{
							// If ACK was already received, then server is ready to take new data.
							if (netRenderAckReceived)
							{
								QList<QByteArray> renderedLinesData;
								for (int i = 0; i < listToSend.size(); i++)
								{
									// avoid sending already rendered lines
									if (scheduler->IsLineDoneByServer(listToSend.at(i)))
									{
										listToSend.removeAt(i);
										i--;
										continue;
									}
									// creating data set to send
									QByteArray lineData;
									CreateLineData(listToSend.at(i), &lineData);
									renderedLinesData.append(lineData);
								}
								// sending data
								if (listToSend.size() > 0)
								{
									emit sendRenderedLines(listToSend, renderedLinesData);
									emit NotifyClientStatus();
									netRenderAckReceived = false;
									listToSend.clear();
								}
							}
						}

						if (data->configuration.UseNetRender() && gNetRender->IsServer())
						{
							QList<int> toDoList = scheduler->CreateDoneList();
							if (toDoList.size() > data->configuration.GetNumberOfThreads())
							{
								for (int c = 0; c < gNetRender->GetClientCount(); c++)
								{
									emit SendToDoList(c, toDoList);
								}
							}
						}

						lastRefreshTime = timerRefresh.elapsed() * data->configuration.GetRefreshRate()
															/ (listToRefresh.size());

						if (lastRefreshTime < 100)
							lastRefreshTime = 100; // the shortest refresh time can be 100ms

						// do not refresh and send data too often
						if (data->configuration.UseNetRender())
						{
							if (lastRefreshTime < 500) lastRefreshTime = 500;
						}

						timerRefresh.restart();
						listToRefresh.clear();
					} // timerRefresh
				}		// isPreview
			}			// while scheduler

			for (int i = 0; i < data->configuration.GetNumberOfThreads(); i++)
			{
				while (thread[i]->isRunning())
				{
					gApplication->processEvents();
				};
				WriteLog(QString("Thread ") + QString::number(i) + " finished", 2);
				delete thread[i];
			}
		} while (scheduler->ProgressiveNextStep());

		// send last rendered lines
		if (data->configuration.UseNetRender() && gNetRender->IsClient()
				&& gNetRender->GetStatus() == CNetRender::netRender_WORKING)
		{
			if (netRenderAckReceived)
			{
				QList<QByteArray> renderedLinesData;
				for (int i = 0; i < listToSend.size(); i++)
				{
					// avoid sending already rendered lines
					if (scheduler->IsLineDoneByServer(listToSend.at(i)))
					{
						listToSend.removeAt(i);
						i--;
						continue;
					}
					QByteArray lineData;
					CreateLineData(listToSend.at(i), &lineData);
					renderedLinesData.append(lineData);
				}

				if (listToSend.size() > 0)
				{
					emit sendRenderedLines(listToSend, renderedLinesData);
					emit NotifyClientStatus();
					netRenderAckReceived = false;
					listToSend.clear();
				}
			}
		}

		if (data->configuration.UseNetRender())
		{
			if (gNetRender->IsClient())
			{
				gNetRender->SetStatus(CNetRender::netRender_READY);
				emit NotifyClientStatus();
			}

			if (gNetRender->IsServer())
			{
				emit StopAllClients();
			}
		}
		// refresh image at end
		WriteLog("image->CompileImage()", 2);
		image->CompileImage();

		if (!(gNetRender->IsClient() && data->configuration.UseNetRender()))
		{
			bool ssaoUsed = false;
			if (params->ambientOcclusionEnabled
					&& params->ambientOcclusionMode == params::AOmodeScreenSpace)
			{
				cRenderSSAO rendererSSAO(params, data, image);
				connect(&rendererSSAO,
					SIGNAL(updateProgressAndStatus(const QString &, const QString &, double)), this,
					SIGNAL(updateProgressAndStatus(const QString &, const QString &, double)));
				rendererSSAO.RenderSSAO();
				ssaoUsed = true;
			}
void GaduDrivePutTransfer::requestFinished()
{
    emit finished();
    deleteLater();
}
Exemple #15
0
void SyncEngine::startSync()
{
    if (_journal->exists()) {
        QVector< SyncJournalDb::PollInfo > pollInfos = _journal->getPollInfos();
        if (!pollInfos.isEmpty()) {
            qDebug() << "Finish Poll jobs before starting a sync";
            CleanupPollsJob *job = new CleanupPollsJob(pollInfos, _account,
                    _journal, _localPath, this);
            connect(job, SIGNAL(finished()), this, SLOT(startSync()));
            connect(job, SIGNAL(aborted(QString)), this, SLOT(slotCleanPollsJobAborted(QString)));
            job->start();
            return;
        }
    }

    Q_ASSERT(!_syncRunning);
    _syncRunning = true;

    Q_ASSERT(_csync_ctx);

    if (!QDir(_localPath).exists()) {
        // No _tr, it should only occur in non-mirall
        emit csyncError("Unable to find local sync folder.");
        finalize();
        return;
    }

    // Check free size on disk first.
    const qint64 minFree = criticalFreeSpaceLimit();
    const qint64 freeBytes = Utility::freeDiskSpace(_localPath);
    if (freeBytes >= 0) {
        qDebug() << "There are" << freeBytes << "bytes available at" << _localPath
                 << "and at least" << minFree << "are required";
        if (freeBytes < minFree) {
            emit csyncError(tr("Only %1 are available, need at least %2 to start").arg(
                                Utility::octetsToString(freeBytes),
                                Utility::octetsToString(minFree)));
            finalize();
            return;
        }
    } else {
        qDebug() << "Could not determine free space available at" << _localPath;
    }

    _syncedItems.clear();
    _syncItemMap.clear();
    _needsUpdate = false;

    csync_resume(_csync_ctx);

    int fileRecordCount = -1;
    if (!_journal->exists()) {
        qDebug() << "=====sync looks new (no DB exists)";
    } else {
        qDebug() << "=====sync with existing DB";
    }

    qDebug() <<  "=====Using Qt" << qVersion();
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
    qDebug() <<  "=====Using SSL library version"
             <<  QSslSocket::sslLibraryVersionString().toUtf8().data();
#endif

    fileRecordCount = _journal->getFileRecordCount(); // this creates the DB if it does not exist yet

    if( fileRecordCount == -1 ) {
        qDebug() << "No way to create a sync journal!";
        emit csyncError(tr("Unable to initialize a sync journal."));
        finalize();
        return;
        // database creation error!
    }

    _csync_ctx->read_remote_from_db = true;

    // This tells csync to never read from the DB if it is empty
    // thereby speeding up the initial discovery significantly.
    _csync_ctx->db_is_empty = (fileRecordCount == 0);

    auto selectiveSyncBlackList = _journal->getSelectiveSyncList(SyncJournalDb::SelectiveSyncBlackList);
    bool usingSelectiveSync = (!selectiveSyncBlackList.isEmpty());
    qDebug() << (usingSelectiveSync ? "====Using Selective Sync" : "====NOT Using Selective Sync");

    csync_set_userdata(_csync_ctx, this);
    _account->credentials()->syncContextPreStart(_csync_ctx);

    // csync_set_auth_callback( _csync_ctx, getauth );
    //csync_set_log_level( 11 ); don't set the loglevel here, it shall be done by folder.cpp or owncloudcmd.cpp
    int timeout = OwncloudPropagator::httpTimeout();
    csync_set_module_property(_csync_ctx, "timeout", &timeout);

    _stopWatch.start();

    qDebug() << "#### Discovery start #################################################### >>";

    _discoveryMainThread = new DiscoveryMainThread(account());
    _discoveryMainThread->setParent(this);
    connect(this, SIGNAL(finished()), _discoveryMainThread, SLOT(deleteLater()));
    connect(_discoveryMainThread, SIGNAL(etagConcatenation(QString)), this, SLOT(slotRootEtagReceived(QString)));


    DiscoveryJob *discoveryJob = new DiscoveryJob(_csync_ctx);
    discoveryJob->_selectiveSyncBlackList = selectiveSyncBlackList;
    discoveryJob->_selectiveSyncWhiteList =
        _journal->getSelectiveSyncList(SyncJournalDb::SelectiveSyncWhiteList);
    discoveryJob->_newBigFolderSizeLimit = _newBigFolderSizeLimit;
    discoveryJob->moveToThread(&_thread);
    connect(discoveryJob, SIGNAL(finished(int)), this, SLOT(slotDiscoveryJobFinished(int)));
    connect(discoveryJob, SIGNAL(folderDiscovered(bool,QString)),
            this, SIGNAL(folderDiscovered(bool,QString)));

    connect(discoveryJob, SIGNAL(newBigFolder(QString)),
            this, SIGNAL(newBigFolder(QString)));


    // This is used for the DiscoveryJob to be able to request the main thread/
    // to read in directory contents.
    qDebug() << Q_FUNC_INFO << _remotePath << _remoteUrl;
    _discoveryMainThread->setupHooks( discoveryJob, _remotePath);

    // Starts the update in a seperate thread
    QMetaObject::invokeMethod(discoveryJob, "start", Qt::QueuedConnection);
}
Exemple #16
0
QgsBookmarks::QgsBookmarks( QWidget *parent )
    : QgsDockWidget( parent )
    , mQgisModel( nullptr )
    , mProjectModel( nullptr )
{
  setupUi( this );
  restorePosition();

  bookmarksDockContents->layout()->setMargin( 0 );
  bookmarksDockContents->layout()->setContentsMargins( 0, 0, 0, 0 );
  static_cast< QGridLayout* >( bookmarksDockContents->layout() )->setVerticalSpacing( 0 );

  QToolButton* btnImpExp = new QToolButton;
  btnImpExp->setAutoRaise( true );
  btnImpExp->setToolTip( tr( "Import/Export Bookmarks" ) );
  btnImpExp->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSharing.svg" ) ) );
  btnImpExp->setPopupMode( QToolButton::InstantPopup );

  QMenu *share = new QMenu( this );
  QAction *btnExport = share->addAction( tr( "&Export" ) );
  QAction *btnImport = share->addAction( tr( "&Import" ) );
  btnExport->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSharingExport.svg" ) ) );
  btnImport->setIcon( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSharingImport.svg" ) ) );
  connect( btnExport, SIGNAL( triggered() ), this, SLOT( exportToXml() ) );
  connect( btnImport, SIGNAL( triggered() ), this, SLOT( importFromXml() ) );
  btnImpExp->setMenu( share );

  connect( actionAdd, SIGNAL( triggered() ), this, SLOT( addClicked() ) );
  connect( actionDelete, SIGNAL( triggered() ), this, SLOT( deleteClicked() ) );
  connect( actionZoomTo, SIGNAL( triggered() ), this, SLOT( zoomToBookmark() ) );

  mBookmarkToolbar->addWidget( btnImpExp );

  // open the database
  QSqlDatabase db = QSqlDatabase::addDatabase( QStringLiteral( "QSQLITE" ), QStringLiteral( "bookmarks" ) );
  db.setDatabaseName( QgsApplication::qgisUserDbFilePath() );
  if ( !db.open() )
  {
    QMessageBox::warning( this, tr( "Error" ),
                          tr( "Unable to open bookmarks database.\nDatabase: %1\nDriver: %2\nDatabase: %3" )
                          .arg( QgsApplication::qgisUserDbFilePath(),
                                db.lastError().driverText(),
                                db.lastError().databaseText() )
                        );
    deleteLater();
    return;
  }

  mQgisModel = new QSqlTableModel( this, db );
  mQgisModel->setTable( QStringLiteral( "tbl_bookmarks" ) );
  mQgisModel->setSort( 0, Qt::AscendingOrder );
  mQgisModel->select();
  mQgisModel->setEditStrategy( QSqlTableModel::OnFieldChange );

  // set better headers then column names from table
  mQgisModel->setHeaderData( 0, Qt::Horizontal, tr( "ID" ) );
  mQgisModel->setHeaderData( 1, Qt::Horizontal, tr( "Name" ) );
  mQgisModel->setHeaderData( 2, Qt::Horizontal, tr( "Project" ) );
  mQgisModel->setHeaderData( 3, Qt::Horizontal, tr( "xMin" ) );
  mQgisModel->setHeaderData( 4, Qt::Horizontal, tr( "yMin" ) );
  mQgisModel->setHeaderData( 5, Qt::Horizontal, tr( "xMax" ) );
  mQgisModel->setHeaderData( 6, Qt::Horizontal, tr( "yMax" ) );
  mQgisModel->setHeaderData( 7, Qt::Horizontal, tr( "SRID" ) );

  mProjectModel = new QgsProjectBookmarksTableModel();
  mModel.reset( new QgsMergedBookmarksTableModel( *mQgisModel, *mProjectModel, lstBookmarks ) );

  lstBookmarks->setModel( mModel.data() );

  QSettings settings;
  lstBookmarks->header()->restoreState( settings.value( QStringLiteral( "/Windows/Bookmarks/headerstate" ) ).toByteArray() );

#ifndef QGISDEBUG
  lstBookmarks->setColumnHidden( 0, true );
#endif
}
/**
 * @brief KGuardiantServer::run
 */
void KGuardiantServer::run()
{
    //Bloque de código principal.
    qDebug() << "KGuardiantServer.Run is executing";
    log->log("KGuardiantServer.Run is executing");



    cam = new DeviceMgr(this);
    clock = new QTimer(this);
    clock->setInterval(300);
    clock->setSingleShot(false);

    connect(cam,
            SIGNAL(finished()),
            cam,
            SLOT(deleteLater()));

    connect(clock,
            SIGNAL(timeout()),
            cam,
            SLOT(requestImage()));

    detector = new MovementDetector(this);

    connect(cam,
            SIGNAL(newImage(cv::Mat&)),
            detector,
            SLOT(processImg(cv::Mat&)),
                 Qt::DirectConnection);
    connect(cam,
            SIGNAL(newImage(cv::Mat&,cv::Mat&)),
            detector,
            SLOT(processImg(cv::Mat&,cv::Mat&))
            ,Qt::DirectConnection);

    connect(detector,
            SIGNAL(processedImg(QByteArray)),
            &server,
            SLOT(sendImg(QByteArray)));

    connect(detector,
            SIGNAL(finished()),
            detector,
            SLOT(deleteLater()));


    console = new Console(this);

    connect(console,SIGNAL(finished()),console,SLOT(deleteLater()));
    connect(console,SIGNAL(startServer()),&server,SLOT(startServer()));
    connect(console,SIGNAL(stopServer()),&server,SLOT(stopServer()));
    connect(console,SIGNAL(checkClients()),&server,SLOT(requestClients()));
    connect(&server,
            SIGNAL(clientList(QHash<qintptr,TCPConnection*>*)),
            console,
            SLOT(printClients(QHash<qintptr,TCPConnection*>*)));
    connect(console,SIGNAL(finish()),this,SLOT(quit()));




    cam->start();
    detector->start();
    clock->start();
    server.startServer();
    //console->start();
    //QTimer::singleShot(10,console,SLOT(startC()));
    //Débese chamar a quit() para finalizar o bucle de eventos do sistema.
    //quit();
}
void TabDeckEditor::closeRequest()
{
    if (confirmClose())
        deleteLater();
}
void FullScreenPlayer::mousePressEvent(QMouseEvent *event)
{
    Q_UNUSED(event)
    m_mediaObject->stop();
    deleteLater();
}
Exemple #20
0
	void GlanceShower::Finalize ()
	{
		emit finished (true);
		deleteLater ();
	}
Exemple #21
0
mainWindow::mainWindow(QMainWindow *parent) : QMainWindow(parent), mainWindow_ui(new Ui::MainWindow)
{
    mainWindow_ui->setupUi(this);

    // Setup toolbar items
    mainWindow_ui->mainToolBar->addSeparator();
    actionQuit = mainWindow_ui->mainToolBar->addAction("Quit");
    mainWindow_ui->mainToolBar->addSeparator();
    actionNormalCapture = mainWindow_ui->mainToolBar->addAction("Normal");
    actionEdgeDetection = mainWindow_ui->mainToolBar->addAction("Edge");
    actionCircleDetection = mainWindow_ui->mainToolBar->addAction("Circle");
    actionSquareDetection = mainWindow_ui->mainToolBar->addAction("Square");
    actionLineDetection = mainWindow_ui->mainToolBar->addAction("Line");
    mainWindow_ui->mainToolBar->addSeparator();

    // Setup delay menu
    selectDelayMenu = new QMenu(this);
    actionDelay50ms = new QAction("50ms", this);
    actionDelay250ms = new QAction("250ms", this);
    actionDelay500ms = new QAction("500ms", this);
    actionDelay1s = new QAction("1s", this);
    selectDelayMenu->addAction(actionDelay50ms);
    selectDelayMenu->addAction(actionDelay250ms);
    selectDelayMenu->addAction(actionDelay500ms);
    selectDelayMenu->addAction(actionDelay1s);
    setDelayButton = new QToolButton(this);
    setDelayButton->setText("Delay");
    setDelayButton->setMenu(selectDelayMenu);
    setDelayButton->setPopupMode(QToolButton::InstantPopup);
    setDelayButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
    mainWindow_ui->mainToolBar->addWidget(setDelayButton);

    // Setup mode menu
    selectModeMenu = new QMenu(this);
    actionModeVideo = new QAction("Video", this);
    actionModeImage = new QAction("Image", this);
    selectModeMenu->addAction(actionModeVideo);
    selectModeMenu->addAction(actionModeImage);
    setModeButton = new QToolButton(this);
    setModeButton->setText("Mode");
    setModeButton->setMenu(selectModeMenu);
    setModeButton->setPopupMode(QToolButton::InstantPopup);
    setModeButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
    mainWindow_ui->mainToolBar->addWidget(setModeButton);
    actionCaptureOneFrame = mainWindow_ui->mainToolBar->addAction("Capture");

    // Create a new ImageCpature class for image cpature.
    imageCapture = new ImageCapture(parent);
    imageCapture->captureFromCamera(-1);

    // Create a new ImageProcess class for image process.
    // This is a new separate thread.
    imageProcess = new ImageProcess(parent);
    imageProcess->start();

    // Connect signals to slots.
    connect(imageCapture, SIGNAL(imageCaptured(QImage &)), this, SLOT(displayImage(QImage &)));
    connect(imageCapture, SIGNAL(processImage(cv::Mat &)), imageProcess, SLOT(processImage(cv::Mat &)));
    connect(actionQuit, SIGNAL(triggered()), this, SLOT(deleteLater()));
    connect(actionNormalCapture, SIGNAL(triggered()), imageProcess, SLOT(changeToNormal()));
    connect(actionEdgeDetection, SIGNAL(triggered()), imageProcess, SLOT(changeToEdgeDetection()));
    connect(actionCircleDetection, SIGNAL(triggered()), imageProcess, SLOT(changeToCircleDetection()));
    connect(actionSquareDetection, SIGNAL(triggered()), imageProcess, SLOT(changeToSquareDetection()));
    connect(actionLineDetection, SIGNAL(triggered()), imageProcess, SLOT(changeToLineDetection()));
    connect(actionDelay50ms, SIGNAL(triggered()), imageCapture, SLOT(setDelayTo50ms()));
    connect(actionDelay250ms, SIGNAL(triggered()), imageCapture, SLOT(setDelayTo250ms()));
    connect(actionDelay500ms, SIGNAL(triggered()), imageCapture, SLOT(setDelayTo500ms()));
    connect(actionDelay1s, SIGNAL(triggered()), imageCapture, SLOT(setDelayTo1s()));
    connect(actionModeVideo, SIGNAL(triggered()), imageCapture, SLOT(setModeToVideo()));
    connect(actionModeImage, SIGNAL(triggered()), imageCapture, SLOT(setModeToImage()));
    connect(actionCaptureOneFrame, SIGNAL(triggered()), imageCapture, SLOT(captureOneFrame()));

    xbee = new Xbee("/dev/ttyUSB0");

}
Exemple #22
0
void paramform::on_qMdPushButton_clicked()
{
    paramadata->updataAll();
    patterndata->wrk_updataAll();
    deleteLater();
}
Exemple #23
0
bool SASLAuthFeature::xmppStanzaIn(IXmppStream *AXmppStream, Stanza &AStanza, int AOrder)
{
	if (AXmppStream==FXmppStream && AOrder==XSHO_XMPP_FEATURE)
	{
		if (AStanza.kind() == "challenge")
		{
			QByteArray challengeData = QByteArray::fromBase64(AStanza.element().text().toLatin1());
			LOG_STRM_DEBUG(FXmppStream->streamJid(),QString("SASL auth challenge received: %1").arg(QString::fromUtf8(challengeData)));
			
			QMap<QByteArray, QByteArray> responseMap;
			QMap<QByteArray, QByteArray> challengeMap = parseChallenge(challengeData);
			if (challengeMap.value("qop") == "auth")
			{
				QByteArray randBytes(32,' ');
				for (int i=0; i<randBytes.size(); i++)
					randBytes[i] = (char) (256.0 * qrand() / (RAND_MAX + 1.0));

				responseMap["cnonce"] = randBytes.toHex();
				if (challengeMap.contains("realm"))
					responseMap["realm"] = challengeMap.value("realm");
				else
					responseMap["realm"] = FXmppStream->streamJid().pDomain().toUtf8();
				responseMap["username"] = FXmppStream->streamJid().pNode().toUtf8();
				responseMap["nonce"] = challengeMap.value("nonce");
				responseMap["nc"] = "00000001";
				responseMap["qop"] = "auth";
				responseMap["digest-uri"] = QString("xmpp/%1").arg(FXmppStream->streamJid().pDomain()).toUtf8();
				responseMap["charset"] = "utf-8";
				responseMap["response"] = getResponseValue(responseMap,FXmppStream->password());
			}
			QByteArray responseData = serializeResponse(responseMap);

			Stanza response("response",NS_FEATURE_SASL);
			response.element().appendChild(response.createTextNode(responseData.toBase64()));
			FXmppStream->sendStanza(response);

			LOG_STRM_DEBUG(FXmppStream->streamJid(),QString("SASL auth response sent: %1").arg(QString::fromUtf8(responseData)));
		}
		else
		{
			FXmppStream->removeXmppStanzaHandler(XSHO_XMPP_FEATURE,this);
			if (AStanza.kind() == "success")
			{
				LOG_STRM_INFO(FXmppStream->streamJid(),"Authorization successes");
				deleteLater();
				emit finished(true);
			}
			else if (AStanza.kind() == "failure")
			{
				XmppSaslError err(AStanza.element());
				LOG_STRM_WARNING(FXmppStream->streamJid(),QString("Authorization failed: %1").arg(err.condition()));
				emit error(err);
			}
			else
			{
				XmppError err(IERR_SASL_AUTH_INVALID_RESPONSE);
				LOG_STRM_WARNING(FXmppStream->streamJid(),QString("Authorization error: Invalid stanza kind=%1").arg(AStanza.kind()));
				emit error(err);
			}
		}
		return true;
	}
	return false;
}
	void Thymio2Interface::Free()
	{
		deleteLater();
	}
void TimeServer::incomingConnection(int socketDescriptor)
{
  ConnectionThread *thread = new ConnectionThread(socketDescriptor);
  connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
  thread->start();
}
	void PhysicalObjectInterface::Free()
	{
		deleteLater();
	}
Exemple #27
0
QgsBookmarks::QgsBookmarks( QWidget *parent, Qt::WindowFlags fl )
    : QDialog( parent, fl )
{
  setupUi( this );
  restorePosition();

  //
  // Create the zoomto and delete buttons and add them to the
  // toolbar
  //
  QPushButton *btnAdd    = new QPushButton( tr( "&Add" ) );
  QPushButton *btnDelete = new QPushButton( tr( "&Delete" ) );
  QPushButton *btnZoomTo = new QPushButton( tr( "&Zoom to" ) );
  QPushButton *btnImpExp = new QPushButton( tr( "&Share" ) );

  btnZoomTo->setDefault( true );
  buttonBox->addButton( btnAdd, QDialogButtonBox::ActionRole );
  buttonBox->addButton( btnDelete, QDialogButtonBox::ActionRole );
  buttonBox->addButton( btnZoomTo, QDialogButtonBox::ActionRole );
  buttonBox->addButton( btnImpExp, QDialogButtonBox::ActionRole );

  QMenu *share = new QMenu();
  QAction *btnExport = share->addAction( tr( "&Export" ) );
  QAction *btnImport = share->addAction( tr( "&Import" ) );
  connect( btnExport, SIGNAL( triggered() ), this, SLOT( exportToXML() ) );
  connect( btnImport, SIGNAL( triggered() ), this, SLOT( importFromXML() ) );
  btnImpExp->setMenu( share );

  connect( btnAdd, SIGNAL( clicked() ), this, SLOT( addClicked() ) );
  connect( btnDelete, SIGNAL( clicked() ), this, SLOT( deleteClicked() ) );
  connect( btnZoomTo, SIGNAL( clicked() ), this, SLOT( zoomToBookmark() ) );

  // open the database
  QSqlDatabase db = QSqlDatabase::addDatabase( "QSQLITE", "bookmarks" );
  db.setDatabaseName( QgsApplication::qgisUserDbFilePath() );
  if ( !db.open() )
  {
    QMessageBox::warning( this, tr( "Error" ),
                          tr( "Unable to open bookmarks database.\nDatabase: %1\nDriver: %2\nDatabase: %3" )
                          .arg( QgsApplication::qgisUserDbFilePath() )
                          .arg( db.lastError().driverText() )
                          .arg( db.lastError().databaseText() )
                        );
    deleteLater();
    return;
  }

  QSqlTableModel *model = new QSqlTableModel( this, db );
  model->setTable( "tbl_bookmarks" );
  model->setSort( 0, Qt::AscendingOrder );
  model->setEditStrategy( QSqlTableModel::OnFieldChange );
  model->select();

  // set better headers then column names from table
  model->setHeaderData( 0, Qt::Horizontal, tr( "ID" ) );
  model->setHeaderData( 1, Qt::Horizontal, tr( "Name" ) );
  model->setHeaderData( 2, Qt::Horizontal, tr( "Project" ) );
  model->setHeaderData( 3, Qt::Horizontal, tr( "xMin" ) );
  model->setHeaderData( 4, Qt::Horizontal, tr( "yMin" ) );
  model->setHeaderData( 5, Qt::Horizontal, tr( "xMax" ) );
  model->setHeaderData( 6, Qt::Horizontal, tr( "yMax" ) );
  model->setHeaderData( 7, Qt::Horizontal, tr( "SRID" ) );

  lstBookmarks->setModel( model );

  QSettings settings;
  lstBookmarks->header()->restoreState( settings.value( "/Windows/Bookmarks/headerstate" ).toByteArray() );

#ifndef QGISDEBUG
  lstBookmarks->setColumnHidden( 0, true );
#endif
}
Exemple #28
0
void Smtp::readyRead()
{

    //qDebug() <<"readyRead";
    // SMTP is line-oriented

    QString responseLine;
    do
    {
        responseLine = socket->readLine();
        response += responseLine;
    }
    while ( socket->canReadLine() && responseLine[3] != ' ' );
    //qDebug()<<response;
    responseLine.truncate( 3 );


    if ( state == Init && responseLine[0] == '2' )
    {
        // banner was okay, let's go on

        *t << "HELO there\r\n";
        t->flush();

        state = Mail;
    }
    else if ( state == Mail && responseLine[0] == '2' )
    {
        // HELO response was okay (well, it has to be)

        *t << "MAIL FROM: " << from << "\r\n";
        t->flush();
        state = Rcpt;
    }
    else if ( state == Rcpt && responseLine[0] == '2' )
    {

        *t << "RCPT TO: " << rcpt << "\r\n"; //r
        t->flush();
        state = Data;
    }
    else if ( state == Data && responseLine[0] == '2' )
    {

        *t << "DATA\r\n";
        t->flush();
        state = Body;
    }
    else if ( state == Body && responseLine[0] == '3' )
    {

        *t << message << "\r\n.\r\n";
        t->flush();
        state = Quit;
    }
    else if ( state == Quit && responseLine[0] == '2' )
    {

        *t << "QUIT\r\n";
        t->flush();
        // here, we just close.
        state = Close;
        emit status( tr( "Message sent" ) );
    }
    else if ( state == Close )
    {
        deleteLater();
        //exit(1);
        return;
    }
    else
    {
        // something broke.
        qDebug() << response;
        //QMessageBox::warning( 0, tr( "Qt Mail Example" ), tr( "Unexpected reply from SMTP server:\n\n" ) + response );
        state = Close;
    }
    response = "";
}
void KstDebugNotifier::close() {
  _animationStage = 999;
  deleteLater();
}
 virtual void closeEvent( QCloseEvent *e )
 {
   Q_UNUSED( e );
   deleteLater();
 }