void ExecutionDomain::Deactivate(bool sync_dispatch) {
    // Flag ourselves as deactivated.  This will prevent any new event sources
    // from being added to the sources_ list.  We can then swap the contents of
    // the sources_ list with a temp list, leave the lock and deactivate all of
    // the sources at our leisure.
    fbl::DoublyLinkedList<fbl::RefPtr<EventSource>, EventSource::SourcesListTraits> to_deactivate;
    bool sync_needed = false;

    {
        fbl::AutoLock sources_lock(&sources_lock_);
        if (deactivated()) {
            ZX_DEBUG_ASSERT(sources_.is_empty());
        } else {
            deactivated_.store(1u);
            to_deactivate.swap(sources_);
        }

        // If there are dispatch operations currently in flight, clear the
        // dispatch idle event and set the flag indicating to the dispatch
        // operation that it needs to set the event when it finishes.
        if (dispatch_in_progress_) {
            sync_needed = true;
            if (!dispatch_sync_in_progress_) {
                __UNUSED zx_status_t res;
                dispatch_sync_in_progress_ = true;
                res = dispatch_idle_evt_.signal(ZX_USER_SIGNAL_0, 0u);
                ZX_DEBUG_ASSERT(res == ZX_OK);
            }
        }
    }

    // Now deactivate all of our event sources and release all of our references.
    if (!to_deactivate.is_empty()) {
        for (auto& source : to_deactivate) {
            source.Deactivate();
        }
        to_deactivate.clear();
    }

    // Synchronize if needed
    if (sync_needed && sync_dispatch) {
        __UNUSED zx_status_t res;
        zx_signals_t pending;

        res = dispatch_idle_evt_.wait_one(ZX_USER_SIGNAL_0, zx::deadline_after(zx::sec(5)), &pending);

        ZX_DEBUG_ASSERT(res == ZX_OK);
        ZX_DEBUG_ASSERT((pending & ZX_USER_SIGNAL_0) != 0);
    }

    // Finally, exit our thread pool and release our reference to it.
    decltype(thread_pool_) pool;
    {
        fbl::AutoLock sources_lock(&sources_lock_);
        pool = std::move(thread_pool_);
    }

    if (pool != nullptr)
        pool->RemoveDomainFromPool(this);
}
bool ExecutionDomain::AddPendingWork(EventSource* event_source) {
    ZX_DEBUG_ASSERT(event_source != nullptr);
    ZX_DEBUG_ASSERT(!event_source->InPendingList());
    ZX_DEBUG_ASSERT(event_source->dispatch_state() == DispatchState::WaitingOnPort);

    // If this ExecutionDomain has become deactivated, then it is not accepting
    // any new pending work.   Do not add the source to the pending work queue,
    // and do not tell the caller that it should be processing the queue when we
    // return.  The event source is now in the Idle state.
    fbl::AutoLock sources_lock(&sources_lock_);
    if (deactivated()) {
        event_source->dispatch_state_ = DispatchState::Idle;
        return false;
    }

    // Add this event source to the back of the pending work queue, and tell the
    // caller whether or not it is responsible for processing the queue.
    bool ret = !dispatch_in_progress_;
    if (ret) {
        ZX_DEBUG_ASSERT(pending_work_.is_empty());
        dispatch_in_progress_ = true;
    }

    event_source->dispatch_state_ = DispatchState::DispatchPending;
    pending_work_.push_back(fbl::WrapRefPtr(event_source));

    return ret;
}
Beispiel #3
0
bool LXQtWorldClockPopup::event(QEvent *event)
{
    if (event->type() == QEvent::Close)
        emit deactivated();

    return QDialog::event(event);
}
ExecutionDomain::~ExecutionDomain() {
    // Assert that the Owner implementation properly deactivated itself
    // before destructing.
    ZX_DEBUG_ASSERT(deactivated());
    ZX_DEBUG_ASSERT(sources_.is_empty());
    ZX_DEBUG_ASSERT(!thread_pool_node_state_.InContainer());
}
void sJarvisNodeComponent::parseEvent(QString component, jarvisEvents event, QStringList args)
{
    if(component != m_id) return;
    if      (event == E_DISABLED)
    {
        emit disabled();
    }else if(event == E_ENABLED)
    {
        emit enabled();
    }else if(event == E_ACTIVATED)
    {
        emit activated();
    }else if(event == E_DEACTIVATED)
    {
        emit deactivated();
    }else if(event == E_RAW_READ)
    {
        emit rawRead();
        emit rawRead(args);
    }else if(event == E_DATA_READ)
    {
        emit dataRead();
        emit dataRead(args);
    }else if(event == E_COFFEE_MAKING)
    {
        emit coffeeMaking();
    }else if(event == E_COFFEE_MADE)
    {
        emit coffeeMade();
    }
}
Beispiel #6
0
void AnalysisWidget::startEngine()
{
    int index = ui.engineList->currentIndex();
    stopEngine();
    if(index != -1)
    {
        if(parentWidget() && !parentWidget()->isVisible())
        {
            parentWidget()->show();
        }
        ui.variationText->clear();
        m_engine = Engine::newEngine(index);
        ui.vpcount->setEnabled(m_engine->providesMvp());
        ui.label->setEnabled(m_engine->providesMvp());
        if(!m_engine->providesMvp())
        {
            ui.vpcount->setValue(1);
        }

        connect(m_engine, SIGNAL(activated()), SLOT(engineActivated()));
        connect(m_engine, SIGNAL(error(QProcess::ProcessError)), SLOT(engineError(QProcess::ProcessError)));
        connect(m_engine, SIGNAL(deactivated()), SLOT(engineDeactivated()));
        connect(m_engine, SIGNAL(analysisUpdated(const Analysis&)),
                SLOT(showAnalysis(const Analysis&)));
        m_engine->setMoveTime(m_moveTime);
        m_engine->activate();
        QString key = QString("/") + objectName() + "/Engine";
        AppSettings->setValue(key, ui.engineList->itemText(index));
    }
}
Beispiel #7
0
FrameEditor::FrameEditor(MediaManager *media, QWidget *parent) :
    FrameObject(parent),
    ui(new Ui::FrameEditor)
{
    ui->setupUi(this);

    // Hidden in current version. It's not there yet.
    ui->button_atmosphere_library_refresh->hide();
    ui->button_sfx_library_refresh->hide();
    ui->button_singleshot_library_refresh->hide();
    ui->button_music_library_refresh->hide();

    QSettings settings;

    ui->tabs_ambienceeditor->setCurrentIndex(settings.value("EditorWindow/tab_active", 0).toInt());

    // Splitters
    ui->splitter_atmosphere->restoreState(settings.value("EditorFrame/atmosphere_splitter").toByteArray());
    ui->splitter_sfx->restoreState(settings.value("EditorFrame/sfx_splitter").toByteArray());
    ui->splitter_singleshots->restoreState(settings.value("EditorFrame/singleshots_splitter").toByteArray());
    ui->splitter_music->restoreState(settings.value("EditorFrame/music_splitter").toByteArray());
    ui->splitter_hotkeys->restoreState(settings.value("EditorFrame/hotkeys_splitter").toByteArray());
    ui->hotkeys_libraries_toolBox->setCurrentIndex(settings.value("EditorFrame/hotkeys_toolbox", 0).toInt());

    // Preview
    //media_preview = new MediaContainer(media->system, this);
    media_preview = media->createContainer();
    connect(ui->preview_play_pause, SIGNAL(toggled(bool)), this, SLOT(previewPlayPause(bool)));
    connect(ui->preview_play_pause, SIGNAL(fileDropped(QString,int)), this, SLOT(previewEnqueue(QString,int)));
    connect(media_preview, SIGNAL(finished(int)), this, SLOT(previewStop()));
    connect(media_preview, SIGNAL(trackPosition(int,int)), this, SLOT(previewSetSeek(int,int)));
    connect(this, SIGNAL(deactivated()), this, SLOT(previewStop()));
}
Beispiel #8
0
void Task::setActive(bool a)
{
    _active = a;
    emit changed();
    if ( a )
      emit activated();
    else
      emit deactivated();
}
Beispiel #9
0
void QgsMapTool::deactivate()
{
  if ( mAction )
    mAction->setChecked( false );
  if ( mButton )
    mButton->setChecked( false );

  emit deactivated();
}
Beispiel #10
0
void YaEventNotifierInformer::notifierVisibilityChanged()
{
	bool enabled = notifier_->shouldBeVisible();
	button()->setEnabled(enabled);
	if (enabled)
		emit activated();
	else
		emit deactivated();
	updateButton();
}
Beispiel #11
0
void LXQtWorldClock::activated(ActivationReason reason)
{
    switch (reason)
    {
    case ILXQtPanelPlugin::Trigger:
    case ILXQtPanelPlugin::MiddleClick:
        break;

    default:
        return;
    }

    if (!mPopup)
    {
        mPopup = new LXQtWorldClockPopup(mContent);
        connect(mPopup, SIGNAL(deactivated()), SLOT(deletePopup()));

        if (reason == ILXQtPanelPlugin::Trigger)
        {
            mPopup->setObjectName(QLatin1String("WorldClockCalendar"));

            mPopup->layout()->setContentsMargins(0, 0, 0, 0);
            QCalendarWidget *calendarWidget = new QCalendarWidget(mPopup);
            mPopup->layout()->addWidget(calendarWidget);

            QString timeZoneName = mActiveTimeZone;
            if (timeZoneName == QLatin1String("local"))
                timeZoneName = QString::fromLatin1(QTimeZone::systemTimeZoneId());

            QTimeZone timeZone(timeZoneName.toLatin1());
            calendarWidget->setFirstDayOfWeek(QLocale(QLocale::AnyLanguage, timeZone.country()).firstDayOfWeek());
            calendarWidget->setSelectedDate(QDateTime::currentDateTime().toTimeZone(timeZone).date());
        }
        else
        {
            mPopup->setObjectName(QLatin1String("WorldClockPopup"));

            mPopupContent = new QLabel(mPopup);
            mPopup->layout()->addWidget(mPopupContent);
            mPopupContent->setAlignment(mContent->alignment());

            updatePopupContent();
        }

        mPopup->adjustSize();
        mPopup->setGeometry(calculatePopupWindowPos(mPopup->size()));

        willShowWindow(mPopup);
        mPopup->show();
    }
    else
    {
        deletePopup();
    }
}
Beispiel #12
0
Module::Module(QWidget *parent, const QVariantList &args)
    : KCModule(parent, args)
    , ui(new Ui::Module)
    , m_manager(new DriverManager(this))
{
    KAboutData *aboutData = new KAboutData("kcm-driver-manager",
                                    i18n("Driver Manager"),
                                    global_s_versionStringFull,
                                    QStringLiteral(""),
                                    KAboutLicense::LicenseKey::GPL_V3,
                                    i18n("Copyright 2013 Rohan Garg"));

    aboutData->addAuthor(i18n("Rohan Garg"), i18n("Author"), QStringLiteral("*****@*****.**"));
    aboutData->addAuthor(i18n("Harald Sitter"), i18n("Qt 5 port"), QStringLiteral("*****@*****.**"));

    setAboutData(aboutData);

    // We have no help so remove the button from the buttons.
    setButtons(buttons() ^ KCModule::Help);

    ui->setupUi(this);
    ui->progressBar->setVisible(false);
    connect(ui->reloadButton, SIGNAL(clicked(bool)), SLOT(load()));

    m_overlay = new KPixmapSequenceOverlayPainter(this);
    m_overlay->setWidget(this);

#warning variable name
    QString label = xi18nc("@title/rich", "<title>Your computer requires no proprietary drivers</title>");
    m_label = new QLabel(label, this);
    m_label->hide();
    ui->driverOptionsVLayout->addWidget(m_label);

    //Debconf handling
    QString uuid = QUuid::createUuid().toString();
    uuid.remove('{').remove('}').remove('-');
    m_pipe = QDir::tempPath() % QLatin1String("/qapt-sock-") % uuid;
    m_debconfGui = new DebconfKde::DebconfGui(m_pipe, this);
    m_debconfGui->connect(m_debconfGui, SIGNAL(activated()), this, SLOT(showDebconf()));
    m_debconfGui->connect(m_debconfGui, SIGNAL(deactivated()), this, SLOT(hideDebconf()));
    m_debconfGui->hide();

    connect(m_manager, SIGNAL(refreshFailed()),
            this, SLOT(onRefreshFailed()));
    connect(m_manager, SIGNAL(devicesReady(DeviceList)),
            this, SLOT(onDevicesReady(DeviceList)));

    connect(m_manager, SIGNAL(changeProgressChanged(int)),
            this, SLOT(progressChanged(int)));
    connect(m_manager, SIGNAL(changeFinished()),
            this, SLOT(finished()));
    connect(m_manager, SIGNAL(changeFailed(QString)),
            this, SLOT(failed(QString)));
}
Beispiel #13
0
/*!
    \reimp
*/
void QUsbStorageGadgetProvider::deactivate()
{
    if (value("active", false).toBool()) {
        if (QProcess::execute("/sbin/rmmod g_file_storage") == 0) {
            setValue("active", false);
            emit deactivated();
        } else {
            emit deactivateFailed();
        }
    }
}
Beispiel #14
0
void UsbGadgetTask::activateEthernet()
{
    QUsbEthernetGadget *ethernetGadget = new QUsbEthernetGadget;
    if (ethernetGadget && ethernetGadget->available()) {
        connect(ethernetGadget, SIGNAL(activated()), this, SLOT(ethernetActivated()));
        connect(ethernetGadget, SIGNAL(activateFailed()), this, SLOT(ethernetDeactivated()));
        connect(ethernetGadget, SIGNAL(deactivated()), this, SLOT(ethernetDeactivated()));

        ethernetGadget->activate();

        m_gadget = ethernetGadget;
    }
}
Beispiel #15
0
void TabbableWidget::changeEvent(QEvent* event)
{
	AdvancedWidget<QWidget>::changeEvent(event);

	if (event->type() == QEvent::ActivationChange ||
	    event->type() == QEvent::WindowStateChange)
	{
		if (isActiveTab()) {
			activated();
		}
		else {
			deactivated();
		}
	}
}
int EventFilter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: activated(); break;
        case 1: deactivated(); break;
        default: ;
        }
        _id -= 2;
    }
    return _id;
}
Beispiel #17
0
bool PlayGameEngine::createEngine_()
{
    SB_PLAY_DEBUG("PlayGameEngine::createEngine_()");

    stopBetweenMoves_ = AppSettings->getValue("/PlayGame/restartEngineBetweenMoves").toBool();

    if (engine_)
        destroyEngine_();

    EngineList elist;
    elist.restore();

    int i = elist.names().indexOf(name_);
    if (i >= 0)
    {
        engine_ = Engine::newEngine(i);

        connect(engine_, SIGNAL(activated()), SLOT(engineActivated_()));
        connect(engine_, SIGNAL(readyOk()), SLOT(engineReadyOk_()));
        connect(engine_, SIGNAL(error(QProcess::ProcessError)),
                        SLOT(engineError_(QProcess::ProcessError)));
        connect(engine_, SIGNAL(deactivated()), SLOT(engineDeactivated_()));
        connect(engine_, SIGNAL(analysisUpdated(Analysis)),
                                    SLOT(engineAnalysis_(const Analysis&)));
        connect(engine_, SIGNAL(bestMoveSend(SHATRA::Move)),
                        SLOT(engineBestMove_(SHATRA::Move)));

        // debug
        if (engineDebug_)
        {
            connect(engine_, SIGNAL(engineDebug(Engine*,Engine::DebugType,QString)),
                    engineDebug_, SLOT(slotEngineDebug(Engine*,Engine::DebugType,QString)));
        }
        connect(engine_, SIGNAL(engineDebug(Engine*,Engine::DebugType,QString)),
                         SIGNAL(engineDebug(Engine*,Engine::DebugType,QString)));

        //if (!stopBetweenMoves_)
            engine_->activate();

        SB_PLAY_DEBUG("PlayGameEngine::createEngine_(): created Engine " << name_);
        return true;
    }
    else
    {
        SB_PLAY_DEBUG("PlayGameEngine::createEngine_(): unknown Engine name " << name_);
        return false;
    }
}
Beispiel #18
0
KMdiDockContainer::~KMdiDockContainer()
{
	TQMap<KDockWidget*, int>::iterator it;
	while ( m_map.count() )
	{
		it = m_map.begin();
		KDockWidget *w = it.key();
		if ( m_overlapButtons.contains( w ) )
		{
			( ::tqqt_cast<KDockWidgetHeader*>( w->getHeader() ) )->removeButton( m_overlapButtons[w] );
			m_overlapButtons.remove( w );
		}
		m_map.remove( w );
		w->undock();
	}
	deactivated( this );
}
void ExecutionDomain::RemoveEventSource(EventSource* event_source) {
    fbl::AutoLock sources_lock(&sources_lock_);

    // Has this ExecutionDomain become deactivated?  If so, then this
    // event_source may still be on a list (the local 'to_deactivate' list in
    // Deactivate), but it is not in the ExecutionDomain's sources_ list, so
    // there is nothing to do here.
    if (deactivated()) {
        ZX_DEBUG_ASSERT(sources_.is_empty());
        return;
    }

    // If the event_source has not already been removed from the domain's list, do
    // so now.
    if (event_source->InExecutionDomain())
        sources_.erase(*event_source);
}
void KPrViewModePresentation::deactivate()
{
    emit deactivated();

    m_animationDirector->deactivate();
    KoPAPageBase * page = m_view->activePage();
    if ( m_endOfSlideShowPage ) {
        if ( page == m_endOfSlideShowPage ) {
            KPrDocument *document = static_cast<KPrDocument *>( m_view->kopaDocument() );
            page = document->slideShow().last();
        }
    }
    m_tool->deactivate();

    if (!m_baseCanvas) return;

    m_baseCanvas->setParent( m_savedParent, Qt::Widget );
    m_baseCanvas->setFocus();
    m_baseCanvas->setWindowState( m_baseCanvas->windowState() & ~Qt::WindowFullScreen ); // reset
    m_baseCanvas->show();
    KoCursor::setAutoHideCursor( m_baseCanvas, false );
    m_baseCanvas->setMouseTracking( true );
    m_view->setActivePage( page );

    // only delete after the new page has been set
    delete m_endOfSlideShowPage;
    m_endOfSlideShowPage = 0;

    delete m_animationDirector;
    m_animationDirector = 0;

    if ( m_presenterViewWidget ) {
        m_presenterViewWidget->setWindowState(
            m_presenterViewWidget->windowState() & ~Qt::WindowFullScreen );
        delete m_pvAnimationDirector;
        m_pvAnimationDirector = 0;

        delete m_presenterViewWidget;
        m_presenterViewWidget = 0;
        m_presenterViewCanvas = 0;
    }
    // make sure the page does not have an offset after finishing a presentation
    m_baseCanvas->setDocumentOffset(QPoint(0, 0));
}
void ExecutionDomain::DispatchPendingWork() {
    // While we have work waiting in the pending queue, dispatch it.
    //
    // TODO(johngro) : To prevent starvation issues, we should probably only
    // perform a finite amount of work, and unwind out into the port wait
    // operation to give other event source owners a chance if this ends up
    // going on for too long.
    while (true) {
        // Enter the sources lock and take a reference to the front of the
        // pending queue.  If the pending work queue is empty, or we have been
        // deactivated, we are finished.
        fbl::RefPtr<EventSource> source;
        {
            fbl::AutoLock sources_lock(&sources_lock_);
            ZX_DEBUG_ASSERT(dispatch_in_progress_);
            if (deactivated() || pending_work_.is_empty()) {
                // Clear the pending work queue and the dispatch in progress
                // flag.  If someone is attempting to synchronize with dispatch
                // operations in flight, set the event indicating that we are
                // now idle.
                pending_work_.clear();
                dispatch_in_progress_ = false;
                if (dispatch_sync_in_progress_) {
                    __UNUSED zx_status_t res;
                    res = dispatch_idle_evt_.signal(0u, ZX_USER_SIGNAL_0);
                    ZX_DEBUG_ASSERT(res == ZX_OK);
                }
                return;
            }

            source = pending_work_.begin().CopyPointer();
        }

        // Attempt to transition to the Dispatching state.  If this fails, it
        // means that we were canceled after we left the sources_lock_ but
        // before we managed to re-enter both the EventSource's object lock and
        // the execution domain's sources lock.  If this is the case, just move
        // on to the next pending source.
        ZX_DEBUG_ASSERT(source != nullptr);
        if (source->BeginDispatching())
            source->Dispatch(this);
    }
}
Beispiel #22
0
KasTaskItem::KasTaskItem( KasTasker *parent, Task::Ptr task )
    : KasItem( parent ),
      task_(task),
      thumbTimer(0),
      attentionTimer(0)
{
    setIcon( icon() );
    setAttention( task->demandsAttention() );
    updateTask(false);

    connect( task, SIGNAL( changed(bool) ), this, SLOT( updateTask(bool) ) );
    connect( task, SIGNAL( activated() ), this, SLOT( startAutoThumbnail() ) );
    connect( task, SIGNAL( deactivated() ), this, SLOT( stopAutoThumbnail() ) );
    connect( task, SIGNAL( iconChanged() ), this, SLOT( iconChanged() ) );
    connect( task, SIGNAL( thumbnailChanged() ), this, SLOT( iconChanged() ) );

    connect( this, SIGNAL(leftButtonClicked(QMouseEvent *)), SLOT(toggleActivateAction()) );
    connect( this, SIGNAL(rightButtonClicked(QMouseEvent *)), SLOT(showWindowMenuAt(QMouseEvent *) ) );

    attentionTimer = new QTimer( this, "attentionTimer" );
    connect( attentionTimer, SIGNAL( timeout() ), SLOT( checkAttention() ) );
    attentionTimer->start( CHECK_ATTENTION_DELAY );
}
zx_status_t ExecutionDomain::AddEventSource(
        fbl::RefPtr<EventSource>&& event_source) {
    if (event_source == nullptr)
        return ZX_ERR_INVALID_ARGS;

    // This check is a bit sketchy...  This event_source should *never* be in
    // any ExecutionDomain's event_source list at this point in time, however if
    // it is, we don't really know what lock we need to obtain to make this
    // observation atomically.  That said, the check will not mutate any state,
    // so it should be safe.  It just might not catch a bad situation which
    // should never happen.
    ZX_DEBUG_ASSERT(!event_source->InExecutionDomain());

    // If this ExecutionDomain has become deactivated, then it is not accepting
    // any new event sources.  Fail the request to add this event_source.
    fbl::AutoLock sources_lock(&sources_lock_);
    if (deactivated())
        return ZX_ERR_BAD_STATE;

    // We are still active.  Transfer the reference to this event_source to our set
    // of sources.
    sources_.push_front(std::move(event_source));
    return ZX_OK;
}
Beispiel #24
0
void DockContainer::tabClicked(int t)
{
    kdDebug(760) << "DockContainer::tabClicked()" << endl;
    bool call_makeVisible = !m_tabSwitching;
    m_tabSwitching = true;
    if((t != -1) && m_tb->isTabRaised(t))
    {
        if(m_ws->isHidden())
        {
            m_ws->show();
            parentDockWidget()->restoreFromForcedFixedSize();
        }
        if(!m_ws->widget(t))
        {
            m_revMap[t]->manualDock(parentDockWidget(), KDockWidget::DockCenter, 20);
            if(call_makeVisible)
                m_revMap[t]->makeDockVisible(); // manualDock(parentDockWidget(),KDockWidget::DockCenter,20);
            m_tabSwitching = false;
            emit activated(this);
            return;
        }
        m_ws->raiseWidget(t);
        if(m_ws->widget(t))
        {
            KDockWidget *tmpDw = static_cast< KDockWidget * >(m_ws->widget(t)->qt_cast("KDockWidget"));
            if(tmpDw)
            {
                if(tmpDw->getWidget())
                    tmpDw->getWidget()->setFocus();
            }
            else
                kdDebug(760) << "Something really weird is going on" << endl;
        }
        else
            kdDebug(760) << "DockContainer::tabClicked(int): m_ws->widget(t)==0 " << endl;

        if(oldtab != t)
            m_tb->setTab(oldtab, false);
        m_tabSwitching = true;
        oldtab = t;
        emit activated(this);
    }
    else
    {
        // try save splitter position
        if(parentDockWidget() && parentDockWidget()->parent())
        {
            KDockSplitter *sp = static_cast< KDockSplitter * >(parentDockWidget()->parent()->qt_cast("KDockSplitter"));
            if(sp)
                m_separatorPos = sp->separatorPos();
        }
        m_previousTab = t;
        //    oldtab=-1;
        if(m_block)
            return;
        emit deactivated(this);
        m_block = true;
        if(m_ws->widget(t))
        {
            //    ((KDockWidget*)m_ws->widget(t))->undock();
        }
        m_block = false;
        m_ws->hide();


        kdDebug(760) << "Fixed Width:" << m_tb->width() << endl;
        if(m_vertical)
            parentDockWidget()->setForcedFixedWidth(m_tb->width()); // strange why it worked before at all
        else
            parentDockWidget()->setForcedFixedHeight(m_tb->height()); // strange why it worked before at all
    }
    m_tabSwitching = false;
}
Beispiel #25
0
QX::QX(QWidget *parent, Qt::WFlags f)
        : QWidget(parent)
{
    Q_UNUSED(f);

    BuildMenu();
    favouritesAction->setChecked(true);

    lineEdit = new QLineEdit("xterm", this);

    bOk = new QPushButton(this);
    bOk->setMinimumWidth(100);
    bOk->setText("Run");
    connect(bOk, SIGNAL(clicked()), this, SLOT(okClicked()));

    lw = new QListWidget(this);
    connect(lw, SIGNAL(clicked(QModelIndex)), this, SLOT(listClicked()));

    lAppname = new QLabel(this);
    bResume = new QPushButton(this);
    bTerminate = new QPushButton(this);
    lAppname->setVisible(false);
    lAppname->setAlignment(Qt::AlignCenter);
    bResume->setVisible(false);
    bTerminate->setVisible(false);
    connect(bResume, SIGNAL(clicked()), this, SLOT(resumeClicked()));
    connect(bTerminate, SIGNAL(clicked()), this, SLOT(terminateClicked()));

    //------------------------------------------

    grid=new QGridLayout(this);
    grid->addWidget(lineEdit,0,0);
    grid->addWidget(bOk,0,1);
    grid->addWidget(lw,1,0,1,2);
    grid->addWidget(lAppname,2,0,1,2);
    grid->addWidget(bResume,3,0,1,2);
    grid->addWidget(bTerminate,4,0,1,2);

    LoadFavourites();
    scanner = new DesktopScanner();
    FillApps(favouritesAction->isChecked());

    //==========================================

    appRunScr = new AppRunningScreen();
    connect(appRunScr, SIGNAL(deactivated()), this, SLOT(pauseApp()));
    connect(appRunScr, SIGNAL(keyPress(QKeyEvent *)), this, SLOT(keyPress(QKeyEvent *)));
    connect(appRunScr, SIGNAL(keyRelease(QKeyEvent *)), this, SLOT(keyRelease(QKeyEvent *)));

    process = NULL;
    xprocess = NULL;
    rotHelper = new RotateHelper(this, 0);
    wmTimer = new QTimer(this);
    connect(wmTimer, SIGNAL(timeout()), this, SLOT(processWmEvents()));
    screen = QX::ScreenMain;

    if(getenv("DISPLAY") == NULL)
        setenv("DISPLAY", "0:0", true);

#if QTOPIA
    powerConstraint = QtopiaApplication::Disable;

    // Start the "QX" service that handles application switching.
    new QxService(this);
#endif

    showScreen(QX::ScreenMain);
}
/*?
    Test function for QUsbStorageGadgetProvider.
    This test:
        * Creates a QUsbStorageGadgetProvider.
        * Does simple set-get tests on QUsbStorageGadgetProvider attributes.
        * Activates and deactivates the gadget and ensures that the
          required signals are emitted.
*/
void tst_QUsbStorageGadget::providerTests()
{
    QUsbManager *manager = new QUsbManager(this);

    // Test that there is no current usb gadget
    QList<QUsbGadget *> activeGadgets = manager->activeGadgets();
    QVERIFY(activeGadgets.count() == 0);
    foreach (QUsbGadget *gadget, activeGadgets)
        delete gadget;

    // Test that the provider works as expected
    {
        QUsbStorageGadgetProvider *provider = new QUsbStorageGadgetProvider("Qt Extended");

        // Set and test various attributes
        {
            if (provider->supportsProduct()) {
                provider->setProduct("Qt Extended Product");
                QVERIFY(provider->product() == "Qt Extended Product");
            }

            if (provider->supportsProductId()) {
                provider->setProductId(0x5454);
                QVERIFY(provider->productId() == 0x5454);
            }

            if (provider->supportsVendor()) {
                provider->setVendor("Qt Extended Vendor");
                QVERIFY(provider->vendor() == "Qt Extended Vendor");
            }

            if (provider->supportsVendorId()) {
                provider->setVendorId(0x5454);
                QVERIFY(provider->vendorId() == 0x5454);
            }

            QVERIFY(provider->backingStore().isEmpty());

            provider->addBackingStore("/dev/partition1");
            QVERIFY(provider->backingStore().count() == 1);
            QVERIFY(provider->backingStore().contains("/dev/partition1"));

            provider->addBackingStore("/dev/partition2");
            QVERIFY(provider->backingStore().count() == 2);
            QVERIFY(provider->backingStore().contains("/dev/partition1"));
            QVERIFY(provider->backingStore().contains("/dev/partition2"));

            provider->removeBackingStore("/dev/partition1");
            QVERIFY(provider->backingStore().count() == 1);
            QVERIFY(!provider->backingStore().contains("/dev/partition1"));
            QVERIFY(provider->backingStore().contains("/dev/partition2"));

            QStringList partitions;
            partitions << "/dev/partition3" << "/dev/partition4";
            provider->setBackingStore(partitions);
            QVERIFY(provider->backingStore() == partitions);

            provider->setBackingStore(QStringList());
            QVERIFY(provider->backingStore().isEmpty());
        }

        // Activate and deactivate gadget
        if (QProcess::execute("/sbin/modinfo g_file_storage")) {
            QSKIP("This test requires the g_file_storage usb gadget driver", SkipSingle);
        } else {
            QVERIFY(manager->canActivate("Storage"));

            QSignalSpy activateSpy(provider, SIGNAL(activated()));
            QSignalSpy deactivateSpy(provider, SIGNAL(deactivated()));

            QTemporaryFile backingStore;
            backingStore.open();
            backingStore.resize(5*1024*1024);

            provider->addBackingStore(backingStore.fileName());

            provider->activate();

            //QTRY_VERIFY(activateSpy.count() + deactivateSpy.count() == 1);
            activateSpy.clear();
            deactivateSpy.clear();

            QVERIFY(provider->active());

            QList<QUsbGadget *> activeGadgets = manager->activeGadgets();
            bool activated = false;
            foreach (QUsbGadget *gadget, activeGadgets) {
                if (gadget->gadget() == provider->gadget())
                    activated = true;

                delete gadget;
            }
            QVERIFY(activated);

            provider->deactivate();
            //QTRY_VERIFY(activateSpy.count() + deactivateSpy.count() == 1);

            QVERIFY(!provider->active());

            activeGadgets = manager->activeGadgets();
            bool deactivated = true;
            foreach (QUsbGadget *gadget, activeGadgets) {
                if (gadget->gadget() == provider->gadget())
                    deactivated = false;

                delete gadget;
            }
            QVERIFY(deactivated);
        }

        delete provider;
    }

    delete manager;

    QValueSpaceObject::sync();
}
Beispiel #27
0
/**
 * @brief ConcertWidget::ConcertWidget
 * @param parent
 */
ConcertWidget::ConcertWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::ConcertWidget)
{
    ui->setupUi(this);
    ui->concertName->clear();
    ui->artStackedWidget->setAnimation(QEasingCurve::OutCubic);
    ui->artStackedWidget->setSpeed(300);

    QFont font = ui->concertName->font();
    font.setPointSize(font.pointSize()+4);
    ui->concertName->setFont(font);

    m_concert = 0;
    m_posterDownloadManager = new DownloadManager(this);

    connect(ui->poster, SIGNAL(clicked()), this, SLOT(chooseConcertPoster()));
    connect(ui->backdrop, SIGNAL(clicked()), this, SLOT(chooseConcertBackdrop()));
    connect(ui->logo, SIGNAL(clicked()), this, SLOT(chooseConcertLogo()));
    connect(ui->clearArt, SIGNAL(clicked()), this, SLOT(chooseConcertClearArt()));
    connect(ui->cdArt, SIGNAL(clicked()), this, SLOT(chooseConcertCdArt()));
    connect(ui->poster, SIGNAL(sigClose()), this, SLOT(deleteConcertPoster()));
    connect(ui->backdrop, SIGNAL(sigClose()), this, SLOT(deleteConcertBackdrop()));
    connect(ui->logo, SIGNAL(sigClose()), this, SLOT(deleteConcertLogo()));
    connect(ui->clearArt, SIGNAL(sigClose()), this, SLOT(deleteConcertClearArt()));
    connect(ui->cdArt, SIGNAL(sigClose()), this, SLOT(deleteConcertCdArt()));
    connect(m_posterDownloadManager, SIGNAL(downloadFinished(DownloadManagerElement)), this, SLOT(posterDownloadFinished(DownloadManagerElement)));
    connect(ui->name, SIGNAL(textChanged(QString)), this, SLOT(concertNameChanged(QString)));
    connect(ui->buttonRevert, SIGNAL(clicked()), this, SLOT(onRevertChanges()));
    connect(ui->buttonReloadStreamDetails, SIGNAL(clicked()), this, SLOT(onReloadStreamDetails()));

    ui->genreCloud->setText(tr("Genres"));
    ui->genreCloud->setPlaceholder(tr("Add Genre"));
    connect(ui->genreCloud, SIGNAL(activated(QString)), this, SLOT(addGenre(QString)));
    connect(ui->genreCloud, SIGNAL(deactivated(QString)), this, SLOT(removeGenre(QString)));

    ui->tagCloud->setText(tr("Tags"));
    ui->tagCloud->setPlaceholder(tr("Add Tag"));
    connect(ui->tagCloud, SIGNAL(activated(QString)), this, SLOT(addTag(QString)));
    connect(ui->tagCloud, SIGNAL(deactivated(QString)), this, SLOT(removeTag(QString)));

    ui->poster->setDefaultPixmap(QPixmap(":/img/film_reel.png"));
    ui->backdrop->setDefaultPixmap(QPixmap(":/img/pictures_alt.png").scaled(64, 64, Qt::KeepAspectRatio, Qt::SmoothTransformation));
    ui->logo->setDefaultPixmap(QPixmap(":/img/pictures_alt.png").scaled(64, 64, Qt::KeepAspectRatio, Qt::SmoothTransformation));
    ui->clearArt->setDefaultPixmap(QPixmap(":/img/pictures_alt.png").scaled(64, 64, Qt::KeepAspectRatio, Qt::SmoothTransformation));
    ui->cdArt->setDefaultPixmap(QPixmap(":/img/pictures_alt.png").scaled(64, 64, Qt::KeepAspectRatio, Qt::SmoothTransformation));

    m_loadingMovie = new QMovie(":/img/spinner.gif");
    m_loadingMovie->start();

    setDisabledTrue();
    clear();

    m_savingWidget = new QLabel(this);
    m_savingWidget->setMovie(m_loadingMovie);
    m_savingWidget->hide();

    connect(ui->fanarts, SIGNAL(sigRemoveImage(QByteArray)), this, SLOT(onRemoveExtraFanart(QByteArray)));
    connect(ui->fanarts, SIGNAL(sigRemoveImage(QString)), this, SLOT(onRemoveExtraFanart(QString)));
    connect(ui->btnAddExtraFanart, SIGNAL(clicked()), this, SLOT(onAddExtraFanart()));

    // Connect GUI change events to concert object
    connect(ui->name, SIGNAL(textEdited(QString)), this, SLOT(onNameChange(QString)));
    connect(ui->artist, SIGNAL(textEdited(QString)), this, SLOT(onArtistChange(QString)));
    connect(ui->album, SIGNAL(textEdited(QString)), this, SLOT(onAlbumChange(QString)));
    connect(ui->tagline, SIGNAL(textEdited(QString)), this, SLOT(onTaglineChange(QString)));
    connect(ui->rating, SIGNAL(valueChanged(double)), this, SLOT(onRatingChange(double)));
    connect(ui->trailer, SIGNAL(textEdited(QString)), this, SLOT(onTrailerChange(QString)));
    connect(ui->runtime, SIGNAL(valueChanged(int)), this, SLOT(onRuntimeChange(int)));
    connect(ui->playcount, SIGNAL(valueChanged(int)), this, SLOT(onPlayCountChange(int)));
    connect(ui->certification, SIGNAL(editTextChanged(QString)), this, SLOT(onCertificationChange(QString)));
    connect(ui->watched, SIGNAL(stateChanged(int)), this, SLOT(onWatchedChange(int)));
    connect(ui->released, SIGNAL(dateChanged(QDate)), this, SLOT(onReleasedChange(QDate)));
    connect(ui->lastPlayed, SIGNAL(dateTimeChanged(QDateTime)), this, SLOT(onLastWatchedChange(QDateTime)));
    connect(ui->overview, SIGNAL(textChanged()), this, SLOT(onOverviewChange()));
    connect(ui->videoAspectRatio, SIGNAL(valueChanged(double)), this, SLOT(onStreamDetailsEdited()));
    connect(ui->videoCodec, SIGNAL(textEdited(QString)), this, SLOT(onStreamDetailsEdited()));
    connect(ui->videoDuration, SIGNAL(timeChanged(QTime)), this, SLOT(onStreamDetailsEdited()));
    connect(ui->videoHeight, SIGNAL(valueChanged(int)), this, SLOT(onStreamDetailsEdited()));
    connect(ui->videoWidth, SIGNAL(valueChanged(int)), this, SLOT(onStreamDetailsEdited()));
    connect(ui->videoScantype, SIGNAL(textEdited(QString)), this, SLOT(onStreamDetailsEdited()));

    QPainter p;
    QPixmap revert(":/img/arrow_circle_left.png");
    p.begin(&revert);
    p.setCompositionMode(QPainter::CompositionMode_SourceIn);
    p.fillRect(revert.rect(), QColor(0, 0, 0, 200));
    p.end();
    ui->buttonRevert->setIcon(QIcon(revert));
    ui->buttonRevert->setVisible(false);
}
Beispiel #28
0
void KMdiDockContainer::tabClicked( int t )
{
	bool call_makeVisible = !m_tabSwitching;
	m_tabSwitching = true;
	if ( m_tb->isTabRaised( t ) )
	{
		kdDebug( 760 ) << k_funcinfo << "Tab " << t << " was just activated" << endl;
		if ( m_ws->isHidden() )
		{
			kdDebug( 760 ) << k_funcinfo << "Showing widgetstack for tab just clicked" << endl;
			m_ws->show();
			parentDockWidget()->restoreFromForcedFixedSize();
		}

		if ( !m_ws->widget( t ) )
		{
			kdDebug( 760 ) << k_funcinfo << "Widget tab was clicked for is not in our stack" << endl;
			kdDebug( 760 ) << k_funcinfo << "Docking it back in" << endl;
			m_revMap[t]->manualDock( parentDockWidget(), KDockWidget::DockCenter, 20 );
			if ( call_makeVisible )
				m_revMap[t]->makeDockVisible();
			m_tabSwitching = false;
			emit activated( this );
			return ;
		}

		if ( m_ws->widget( t ) )
		{
			m_ws->raiseWidget( t );
			KDockWidget * tmpDw = ::tqqt_cast<KDockWidget*>( m_ws->widget( t ) );
			if ( tmpDw )
			{
				if ( tmpDw->getWidget() )
					tmpDw->getWidget()->setFocus();
			}
			else
				kdDebug( 760 ) << k_funcinfo << "Something really weird is going on" << endl;
		}
		else
			kdDebug( 760 ) << k_funcinfo << "We have no widget to handle in our stack." << endl;

		if ( oldtab != t )
			m_tb->setTab( oldtab, false );

		m_tabSwitching = true;
		oldtab = t;
		emit activated( this );
	}
	else
	{
		kdDebug( 760 ) << k_funcinfo << "Tab " << t << " was just deactiviated" << endl;
		// try save splitter position
		if ( parentDockWidget() && parentDockWidget()->parent() )
		{
			KDockSplitter * sp = ::tqqt_cast<KDockSplitter*>( parentDockWidget()->parent() );
			if ( sp )
				m_separatorPos = sp->separatorPos();
		}
		m_previousTab = t;
		//    oldtab=-1;
		if ( m_block )
			return ;
		emit deactivated( this );
		m_block = true;
		if ( m_ws->widget( t ) )
		{
			//    ((KDockWidget*)m_ws->widget(t))->undock();
		}
		m_block = false;
		m_ws->hide ();


		kdDebug( 760 ) << k_funcinfo << "Fixed Width:" << m_tb->width() << endl;
		if ( !m_horizontal )
			parentDockWidget()->setForcedFixedWidth( m_tb->width() ); // strange why it worked before at all
		else
			parentDockWidget()->setForcedFixedHeight( m_tb->height() ); // strange why it worked before at all
	}
	m_tabSwitching = false;
}
Beispiel #29
0
	void setActive(T *active)
	{
		m_active = active;
		if(active) activated();
		else deactivated();
	}