QmDisplayState::QmDisplayState(QObject *parent)
: QObject(parent) {
MEEGO_INITIALIZE(QmDisplayState);
connect(priv, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)),
this, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)));
}
QmDisplayState::~QmDisplayState() {
MEEGO_PRIVATE(QmDisplayState)
disconnect(priv, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)),
this, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)));
MEEGO_UNINITIALIZE(QmDisplayState);
}
DisplayState::DisplayState(QObject *parent) :
QObject(parent),
m_state(new MeeGo::QmDisplayState(this)),
m_dpy(MeeGo::QmDisplayState::Unknown),
m_timer(new QTimer(this)) {
m_timer->setSingleShot(false);
m_timer->setInterval(50 * 1000);
QObject::connect(m_timer, SIGNAL(timeout()), this, SLOT(timeout()));
QObject::connect(m_state, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)),
this, SLOT(displayStateChanged(MeeGo::QmDisplayState::DisplayState)));
}
LipstickCompositor::LipstickCompositor()
: QWaylandCompositor(this), m_totalWindowCount(0), m_nextWindowId(1), m_homeActive(true), m_shaderEffect(0),
m_fullscreenSurface(0), m_directRenderingActive(false), m_topmostWindowId(0), m_screenOrientation(Qt::PrimaryOrientation), m_displayState(new MeeGo::QmDisplayState(this)), m_retainedSelection(0)
{
setColor(Qt::black);
setRetainedSelectionEnabled(true);
if (m_instance) qFatal("LipstickCompositor: Only one compositor instance per process is supported");
m_instance = this;
QObject::connect(this, SIGNAL(frameSwapped()), this, SLOT(windowSwapped()));
QObject::connect(this, SIGNAL(beforeSynchronizing()), this, SLOT(clearUpdateRequest()));
connect(m_displayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(reactOnDisplayStateChanges(MeeGo::QmDisplayState::DisplayState)));
QObject::connect(HomeApplication::instance(), SIGNAL(aboutToDestroy()), this, SLOT(homeApplicationAboutToDestroy()));
m_orientationSensor = new QOrientationSensor(this);
QObject::connect(m_orientationSensor, SIGNAL(readingChanged()), this, SLOT(setScreenOrientationFromSensor()));
if (!m_orientationSensor->connectToBackend()) {
qWarning() << "Could not connect to the orientation sensor backend";
} else {
if (!m_orientationSensor->start())
qWarning() << "Could not start the orientation sensor";
}
emit HomeApplication::instance()->homeActiveChanged();
QDesktopServices::setUrlHandler("http", this, "openUrl");
QDesktopServices::setUrlHandler("https", this, "openUrl");
QDesktopServices::setUrlHandler("mailto", this, "openUrl");
connect(QGuiApplication::clipboard(), SIGNAL(dataChanged()), SLOT(clipboardDataChanged()));
}
void Ut_DeviceLock::testSignalConnections()
{
QCOMPARE(disconnect(deviceLock->lockTimer, SIGNAL(timeout()), deviceLock, SLOT(lock())), true);
QCOMPARE(disconnect(deviceLock->qmActivity, SIGNAL(activityChanged(MeeGo::QmActivity::Activity)), deviceLock, SLOT(setStateAndSetupLockTimer())), true);
QCOMPARE(disconnect(deviceLock->qmLocks, SIGNAL(stateChanged(MeeGo::QmLocks::Lock,MeeGo::QmLocks::State)), deviceLock, SLOT(setStateAndSetupLockTimer())), true);
QCOMPARE(disconnect(deviceLock->qmDisplayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), deviceLock, SLOT(checkDisplayState(MeeGo::QmDisplayState::DisplayState))), true);
}
ThermalNotifier::ThermalNotifier(QObject *parent) :
QObject(parent),
thermalState(new MeeGo::QmThermal(this)),
displayState(new MeeGo::QmDisplayState(this)),
thermalStateNotifiedWhileScreenIsOn(MeeGo::QmThermal::Normal)
{
connect(thermalState, SIGNAL(thermalChanged(MeeGo::QmThermal::ThermalState)), this, SLOT(applyThermalState(MeeGo::QmThermal::ThermalState)));
connect(displayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(applyDisplayState(MeeGo::QmDisplayState::DisplayState)));
}
NotifierNotificationSink::NotifierNotificationSink(QObject *parent) :
NotificationSink(parent),
ngfAdapter(new NGFAdapter),
additionsDisabled(false),
ngfEventId(0),
notifierEnabled(false)
{
#ifdef HAVE_QMSYSTEM
connect(&displayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)),
this, SLOT(updateStatusOfLedFeedback()));
#endif
}
LEDNotificationSink::LEDNotificationSink(QObject *parent) : NotificationSink(parent),
notifierEnabled(false)
{
m_interface = new QDBusInterface(MCE_SERVICE, MCE_REQUEST_PATH, MCE_REQUEST_IF,
QDBusConnection::systemBus(), this);
configItem = new MGConfItem(GCONF_LED_KEY);
#ifdef HAVE_QMSYSTEM
connect(&displayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)),
this, SLOT(updateStatusOfLedFeedback()));
#endif
}
NS_IMETHODIMP
nsNativeAppSupportQt::Start(bool* aRetVal)
{
NS_ASSERTION(gAppData, "gAppData must not be null.");
#ifdef MOZ_ENABLE_QMSYSTEM2
connect(&mActivity, SIGNAL(activityChanged(MeeGo::QmActivity::Activity)), this, SLOT(activityChanged(MeeGo::QmActivity::Activity)));
connect(&mDeviceMode, SIGNAL(deviceModeChanged(MeeGo::QmDeviceMode::DeviceMode)), this, SLOT(deviceModeChanged(MeeGo::QmDeviceMode::DeviceMode)));
connect(&mDisplayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(displayStateChanged(MeeGo::QmDisplayState::DisplayState)));
// Init states withing next event loop iteration
QTimer::singleShot(0, this, SLOT(RefreshStates()));
#endif
*aRetVal = true;
#ifdef MOZ_ENABLE_LIBCONIC
g_type_init();
#endif
#if (MOZ_PLATFORM_MAEMO == 5)
/* Initialize maemo application
The initalization name will be of the form "Vendor.Name".
If a Vendor isn't given, then we will just use "Name".
Note that this value must match your X-Osso-Service name
defined in your desktop file. If it doesn't, the OSSO
system will happily kill your process.
*/
nsCAutoString applicationName;
if (gAppData->vendor) {
applicationName.Append(gAppData->vendor);
applicationName.Append(".");
}
applicationName.Append(gAppData->name);
ToLowerCase(applicationName);
m_osso_context = osso_initialize(applicationName.get(),
gAppData->version ? gAppData->version : "1.0",
true,
nsnull);
/* Check that initilialization was ok */
if (m_osso_context == nsnull) {
return NS_ERROR_FAILURE;
}
#endif
return NS_OK;
}
DeviceLock::DeviceLock(QObject * parent) :
QObject(parent),
lockingGConfItem(new MGConfItem("/desktop/nemo/devicelock/automatic_locking", this)),
lockTimer(new QTimer(this)),
qmActivity(new MeeGo::QmActivity(this)),
qmLocks(new MeeGo::QmLocks(this)),
qmDisplayState(new MeeGo::QmDisplayState(this)),
deviceLockState(Undefined)
{
monoTime.tv_sec = 0;
connect(lockingGConfItem, SIGNAL(valueChanged()), this, SLOT(setStateAndSetupLockTimer()));
connect(lockTimer, SIGNAL(timeout()), this, SLOT(lock()));
connect(qmActivity, SIGNAL(activityChanged(MeeGo::QmActivity::Activity)), this, SLOT(setStateAndSetupLockTimer()));
connect(qmLocks, SIGNAL(stateChanged(MeeGo::QmLocks::Lock,MeeGo::QmLocks::State)), this, SLOT(setStateAndSetupLockTimer()));
connect(qmDisplayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(checkDisplayState(MeeGo::QmDisplayState::DisplayState)));
connect(qApp, SIGNAL(homeReady()), this, SLOT(init()));
}
LipstickCompositor::LipstickCompositor()
: QWaylandCompositor(this), m_totalWindowCount(0), m_nextWindowId(1), m_homeActive(true), m_shaderEffect(0),
m_fullscreenSurface(0), m_directRenderingActive(false), m_topmostWindowId(0), m_screenOrientation(Qt::PrimaryOrientation), m_displayState(new MeeGo::QmDisplayState(this))
{
setColor(Qt::black);
if (m_instance) qFatal("LipstickCompositor: Only one compositor instance per process is supported");
m_instance = this;
QObject::connect(this, SIGNAL(frameSwapped()), this, SLOT(windowSwapped()));
QObject::connect(this, SIGNAL(beforeSynchronizing()), this, SLOT(clearUpdateRequest()));
connect(m_displayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(reactOnDisplayStateChanges(MeeGo::QmDisplayState::DisplayState)));
emit HomeApplication::instance()->homeActiveChanged();
QDesktopServices::setUrlHandler("http", this, "openUrl");
QDesktopServices::setUrlHandler("https", this, "openUrl");
QDesktopServices::setUrlHandler("mailto", this, "openUrl");
}
MCompositorNotificationSink::MCompositorNotificationSink() :
sinkDisabled(false),
allPreviewsDisabled(false),
window(NULL),
currentBanner(NULL),
touchScreenLockActive(false)
{
notificationPreviewMode = new MGConfItem(NOTIFICATION_PREVIEW_ENABLED, this);
changeNotificationPreviewMode();
connect(notificationPreviewMode, SIGNAL(valueChanged()), this, SLOT(changeNotificationPreviewMode()));
#ifdef HAVE_QMSYSTEM
connect(&displayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(changeNotificationPreviewMode()));
#endif
// Setup the timer which makes the banner disappear
connect(&bannerTimer, SIGNAL(timeout()), this, SLOT(disappearCurrentBanner()));
bannerTimer.setSingleShot(true);
currentAppWindowAtom = X11Wrapper::XInternAtom(QX11Info::display(), "_MEEGOTOUCH_CURRENT_APP_WINDOW", False);
notificationPreviewsDisabledAtom = X11Wrapper::XInternAtom(QX11Info::display(), "_MEEGOTOUCH_NOTIFICATION_PREVIEWS_DISABLED", False);
}
DeviceLock::DeviceLock(QObject * parent) :
QObject(parent),
QDBusContext(),
lockingDelay(-1),
lockTimer(new QTimer(this)),
qmActivity(new MeeGo::QmActivity(this)),
qmLocks(new MeeGo::QmLocks(this)),
qmDisplayState(new MeeGo::QmDisplayState(this)),
deviceLockState(Undefined),
m_activity(MeeGo::QmActivity::Active),
m_displayState(MeeGo::QmDisplayState::Unknown),
isCallActive(false),
m_blankingPause(false),
m_blankingInhibit(false)
{
monoTime.tv_sec = 0;
connect(lockTimer, SIGNAL(timeout()), this, SLOT(lock()));
connect(qmActivity, SIGNAL(activityChanged(MeeGo::QmActivity::Activity)), this, SLOT(handleActivityChanged(MeeGo::QmActivity::Activity)));
connect(qmLocks, SIGNAL(stateChanged(MeeGo::QmLocks::Lock,MeeGo::QmLocks::State)), this, SLOT(setStateAndSetupLockTimer()));
connect(qmDisplayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(handleDisplayStateChanged(MeeGo::QmDisplayState::DisplayState)));
connect(static_cast<HomeApplication *>(qApp), &HomeApplication::homeReady, this, &DeviceLock::init);
QDBusConnection::systemBus().connect(QString(), "/com/nokia/mce/signal", "com.nokia.mce.signal", "sig_call_state_ind", this, SLOT(handleCallStateChange(QString, QString)));
QDBusConnection::systemBus().connect(QString(), "/com/nokia/mce/signal", "com.nokia.mce.signal", "display_blanking_pause_ind", this, SLOT(handleBlankingPauseChange(QString)));
QDBusConnection::systemBus().connect(QString(), "/com/nokia/mce/signal", "com.nokia.mce.signal", "display_blanking_inhibit_ind", this, SLOT(handleBlankingInhibitChange(QString)));
QDBusMessage call = QDBusMessage::createMethodCall("com.nokia.mce", "/", "com.nokia.mce.request", "get_display_blanking_inhibit");
QDBusPendingCall reply = QDBusConnection::systemBus().asyncCall(call);
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this);
connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), SLOT(sendInhibitFinished(QDBusPendingCallWatcher*)));
QDBusMessage pauseCall = QDBusMessage::createMethodCall("com.nokia.mce", "/", "com.nokia.mce.request", "get_display_blanking_pause");
QDBusPendingCall pauseReply = QDBusConnection::systemBus().asyncCall(pauseCall);
QDBusPendingCallWatcher *pauseWatcher = new QDBusPendingCallWatcher(pauseReply, this);
connect(pauseWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)), SLOT(sendPauseFinished(QDBusPendingCallWatcher*)));
handleActivityChanged(qmActivity->get());
handleDisplayStateChanged(qmDisplayState->get());
}
void QmDisplayState::disconnectNotify(const QMetaMethod &signal) {
#else
void QmDisplayState::disconnectNotify(const char *signal) {
#endif
MEEGO_PRIVATE(QmDisplayState)
/* QObject::disconnect() needs to be thread-safe */
QMutexLocker locker(&priv->connectMutex);
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
if (signal == QMetaMethod::fromSignal(&QmDisplayState::displayStateChanged)) {
#else
if (QLatin1String(signal) == QLatin1String(QMetaObject::normalizedSignature(SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState))))) {
#endif
priv->connectCount[SIGNAL_DISPLAY_STATE]--;
if (0 == priv->connectCount[SIGNAL_DISPLAY_STATE]) {
#if HAVE_MCE
QDBusConnection::systemBus().disconnect(MCE_SERVICE,
MCE_SIGNAL_PATH,
MCE_SIGNAL_IF,
MCE_DISPLAY_SIG,
priv,
SLOT(slotDisplayStateChanged(const QString&)));
#endif
}
}
StatusAreaRenderer::StatusAreaRenderer(QObject *parent) :
QObject(parent),
scene(new QGraphicsScene),
statusArea(new StatusArea),
statusAreaLivePixmap(NULL),
statusAreaPropertyWindow(0),
windowManagerWindow(0),
windowManagerWindowWidget(NULL),
statusBarVisible(false),
#ifdef HAVE_QMSYSTEM
displayState(new MeeGo::QmDisplayState()),
#endif
renderScene(true),
previousRootWindowEventMask(0)
{
scene->setParent(this);
scene->setObjectName("statusareascene");
scene->addItem(statusArea);
statusArea->setObjectName("statusarea");
// Get signaled when the scene changes
connect(scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(accumulateSceneChanges(QList<QRectF>)));
#ifdef HAVE_QMSYSTEM
// Switch rendering on and off based on the display state
connect(displayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(setSceneRender(MeeGo::QmDisplayState::DisplayState)));
// The following part is important so that widgets will know from the very beginning whether they are on display or not
MeeGo::QmDisplayState::DisplayState state = displayState->get();
if (state != MeeGo::QmDisplayState::Off) {
// Set rendering state off to make all widgets think they are not on display
setSceneRender(MeeGo::QmDisplayState::Off);
}
// Let the widgets know whether they are actually on display or not
setSceneRender(state);
#endif
// Get the required X atoms
Display *display = QX11Info::display();
statusBarVisibleAtom = X11Wrapper::XInternAtom(display, "_MEEGOTOUCH_STATUSBAR_VISIBLE", False);
windowManagerWindowAtom = X11Wrapper::XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
netSupportedAtom = X11Wrapper::XInternAtom(display, "_NET_SUPPORTED", False);
shareDrawableAtom = X11Wrapper::XInternAtom(display, "XSERVER_SECURITY_POLICY_SHARE_DRAWABLE", True);
setSizeFromStyle();
if(!createSharedPixmapHandle() || !createBackPixmap()) {
qWarning("Shared Pixmap was not created. Status area will not render");
} else {
createStatusAreaPropertyWindow();
setSharedPixmapHandleToWindowProperty();
setStatusAreaPropertyWindowIdToRootWindowProperty();
if(setupStatusBarVisibleListener()) {
updateStatusBarVisibleProperty();
} else {
wmWindowUnavailable();
}
// Work around bug 285985 - When mcompositor restarts and sets the
// _NET_SUPPORTED atom on the root window, Qt will kill our
// ProprtyChangeMask bit. Let the X event loop handler finish
// and restart out quest for WM availability
connect(this, SIGNAL(netSupportedPropertyChanged()),
this, SLOT(wmWindowUnavailable()),
Qt::QueuedConnection);
}
connect(&accumulationTimer, SIGNAL(timeout()), this, SLOT(renderAccumulatedRegion()));
}
QConnectionManager::QConnectionManager(QObject *parent) :
QObject(parent),
netman(NetworkManagerFactory::createInstance()),
currentNetworkState(QString()),
currentType(QString()),
currentNotification(0),
askForRoaming(false),
isEthernet(false),
connmanAvailable(false),
handoverInProgress(false),
oContext(0),
tetheringWifiTech(0),
tetheringEnabled(false),
flightModeSuppression(false)
{
qDebug() << Q_FUNC_INFO;
manualConnnectionTimer.invalidate();
connect(netman,SIGNAL(availabilityChanged(bool)),this,SLOT(connmanAvailabilityChanged(bool)));
connectionAdaptor = new ConnAdaptor(this);
QDBusConnection dbus = QDBusConnection::sessionBus();
if (!dbus.registerService(CONND_SERVICE)) {
qDebug() << "XXXXXXXXXXX could not register service XXXXXXXXXXXXXXXXXX";
}
if (!dbus.registerObject(CONND_PATH, this)) {
qDebug() << "XXXXXXXXXXX could not register object XXXXXXXXXXXXXXXXXX";
}
askForRoaming = askRoaming();
connect(&clockModel,SIGNAL(timeUpdatesChanged()),this,SLOT(timeUpdatesChanged()));
ua = new UserAgent(this);
connect(ua,SIGNAL(userInputRequested(QString,QVariantMap)),
this,SLOT(onUserInputRequested(QString,QVariantMap)));
connect(ua,SIGNAL(connectionRequest()),this,SLOT(onConnectionRequest()));
connect(ua,SIGNAL(errorReported(QString, QString)),this,SLOT(onErrorReported(QString, QString)));
connect(ua,SIGNAL(userInputCanceled()),this,SLOT(onUserInputCanceled()));
connect(ua,SIGNAL(userInputRequested(QString,QVariantMap)),
this,SLOT(onUserInputRequested(QString,QVariantMap)), Qt::UniqueConnection);
connect(ua,SIGNAL(browserRequested(QString,QString)),
this,SLOT(browserRequest(QString,QString)), Qt::UniqueConnection);
connect(netman,SIGNAL(servicesListChanged(QStringList)),this,SLOT(servicesListChanged(QStringList)));
connect(netman,SIGNAL(stateChanged(QString)),this,SLOT(networkStateChanged(QString)));
connect(netman,SIGNAL(servicesChanged()),this,SLOT(setup()));
connect(netman,SIGNAL(offlineModeChanged(bool)),this,SLOT(offlineModeChanged(bool)));
QFile connmanConf("/etc/connman/main.conf");
if (connmanConf.open(QIODevice::ReadOnly | QIODevice::Text)) {
while (!connmanConf.atEnd()) {
QString line = connmanConf.readLine();
if (line.startsWith("DefaultAutoConnectTechnologies")) {
QString token = line.section(" = ",1,1).simplified();
techPreferenceList = token.split(",");
break;
}
}
connmanConf.close();
}
if (techPreferenceList.isEmpty())
//ethernet,bluetooth,cellular,wifi is default
techPreferenceList << "wifi" << "cellular" << "bluetooth" << "ethernet";
mceWatch = new WakeupWatcher(this);
connect(mceWatch,SIGNAL(displayStateChanged(QString)),this,SLOT(displayStateChanged(QString)));
connect(mceWatch,SIGNAL(sleepStateChanged(bool)),this,SLOT(sleepStateChanged(bool)));
connmanAvailable = QDBusConnection::systemBus().interface()->isServiceRegistered("net.connman");
if (connmanAvailable)
setup();
goodConnectTimer = new QTimer(this);
goodConnectTimer->setSingleShot(true);
goodConnectTimer->setInterval(12 * 1000);
connect(goodConnectTimer,SIGNAL(timeout()),this,SLOT(connectionTimeout()));
}
void nsNativeAppSupportQt::RefreshStates()
{
activityChanged(mActivity.get());
displayStateChanged(mDisplayState.get());
deviceModeChanged(mDeviceMode.getMode());
}
MainWindow::MainWindow(QString url, int quality, int listen_port, bool view_only):
QMainWindow(0),
vnc_view(0),
scroll_area(new ScrollArea(this)),
input_toolbuttons(new QActionGroup(this)),
key_menu(0)
{
setWindowTitle("Presence VNC");
#ifdef Q_WS_MAEMO_5
setContextMenuPolicy(Qt::NoContextMenu);
setAttribute(Qt::WA_Maemo5StackedWindow);
#endif
migrateConfiguration();
//set up toolbar
toolbar = new QToolBar(0);
key_menu_button = input_toolbuttons->addAction(toolbar->addAction(QChar(0x2026), this, SLOT(showKeyMenu()))); //"..." button
key_menu_button->setCheckable(true); //used to indicate wether a modifier key is still pressed
input_toolbuttons->addAction(toolbar->addAction(tr("Tab"), this, SLOT(sendTab())));
input_toolbuttons->addAction(toolbar->addAction(tr("Esc"), this, SLOT(sendEsc())));
input_toolbuttons->addAction(toolbar->addAction(tr("PgUp"), this, SLOT(sendPgUp())));
input_toolbuttons->addAction(toolbar->addAction(tr("PgDn"), this, SLOT(sendPgDn())));
#ifdef Q_WS_MAEMO_5
input_toolbuttons->addAction(toolbar->addAction(QIcon("/usr/share/icons/hicolor/48x48/hildon/chat_enter.png"), "", this, SLOT(sendReturn())));
input_toolbuttons->addAction(toolbar->addAction(QIcon("/usr/share/icons/hicolor/48x48/hildon/control_keyboard.png"), "", this, SLOT(showInputPanel())));
#endif
QSettings settings;
zoom_slider = new QSlider(Qt::Horizontal, 0);
zoom_slider->setRange(0, 100);
connect(zoom_slider, SIGNAL(valueChanged(int)),
this, SLOT(setZoomLevel(int)));
connect(zoom_slider, SIGNAL(sliderReleased()),
this, SLOT(zoomSliderReleased()));
zoom_slider->setValue(settings.value("zoomlevel", 95).toInt());
toolbar->addWidget(zoom_slider);
#ifdef Q_WS_MAEMO_5
toolbar->addAction(QIcon("/usr/share/icons/hicolor/48x48/hildon/general_fullsize.png"), "", this, SLOT(toggleFullscreen()));
#else
toolbar->addAction(tr("Toggle Fullscreen"), this, SLOT(toggleFullscreen()));
#endif
addToolBar(toolbar);
toolbar->setVisible(settings.value("show_toolbar", true).toBool());
toolbar->setEnabled(false);
//set up menu
QAction *connect_action = new QAction(tr("Connect"), this);
disconnect_action = new QAction(tr("Disconnect"), this);
show_toolbar = new QAction(tr("Show toolbar"), this);
show_toolbar->setCheckable(true);
show_toolbar->setChecked(settings.value("show_toolbar", true).toBool());
QAction *pref_action = new QAction(tr("Preferences"), this);
QAction *about_action = new QAction(tr("About"), this);
#ifdef Q_WS_MAEMO_5
menuBar()->addAction(connect_action);
menuBar()->addAction(disconnect_action);
menuBar()->addAction(show_toolbar);
menuBar()->addAction(pref_action);
menuBar()->addAction(about_action);
#else
QMenu* session_menu = menuBar()->addMenu(tr("&Session"));
session_menu->addAction(connect_action);
session_menu->addAction(disconnect_action);
session_menu->addSeparator();
session_menu->addAction(pref_action);
session_menu->addSeparator();
session_menu->addAction(tr("&Quit"), this, SLOT(close()));
QMenu* view_menu = menuBar()->addMenu(tr("&View"));
view_menu->addAction(show_toolbar);
QMenu* help_menu = menuBar()->addMenu(tr("&Help"));
help_menu->addAction(about_action);
#endif
connect(about_action, SIGNAL(triggered()),
this, SLOT(about()));
connect(pref_action, SIGNAL(triggered()),
this, SLOT(showPreferences()));
connect(connect_action, SIGNAL(triggered()),
this, SLOT(showConnectDialog()));
connect(disconnect_action, SIGNAL(triggered()),
this, SLOT(disconnectFromHost()));
connect(show_toolbar, SIGNAL(toggled(bool)),
toolbar, SLOT(setVisible(bool)));
connect(show_toolbar, SIGNAL(toggled(bool)),
this, SLOT(updateScreenSpaceDelayed()));
#ifdef Q_WS_MAEMO_5
QDBusConnection::systemBus().connect("", MCE_SIGNAL_PATH, MCE_SIGNAL_IF, MCE_DISPLAY_SIG,
this, SLOT(displayStateChanged(QString)));
#endif
setCentralWidget(scroll_area);
connect(scroll_area, SIGNAL(fullscreenButtonClicked()),
this, SLOT(toggleFullscreen()));
grabZoomKeys(true);
reloadSettings();
if(url.isEmpty() and listen_port == 0) {
disconnect_action->setEnabled(false);
showConnectDialog();
} else {
connectToHost(url, quality, listen_port, view_only);
}
}
void Wifi::setInformation(const android::WifiInformation& info)
{
// fprintf(stderr, "Wifi::setInformation)\n");
QMutexLocker _l(&sWifiMutex);
QString ipaddr = QString::fromLocal8Bit(info.ipaddr.string());
if (ipaddr != mIPAddress) {
mIPAddress = ipaddr;
emit ipaddrChanged();
}
QString macaddr = QString::fromLocal8Bit(info.macaddr.string());
if (macaddr != mMacAddress) {
mMacAddress = macaddr;
emit macaddrChanged();
}
QString bssid = QString::fromLocal8Bit(info.bssid.string());
if (bssid != mBssid) {
mBssid = bssid;
emit bssidChanged();
}
QString ssid = QString::fromLocal8Bit(info.ssid.string());
if (ssid != mSsid) {
mSsid = ssid;
emit ssidChanged();
}
DisplayState s = _infoToDisplayState(info);
if (mDisplayState != s) {
mDisplayState = s;
emit displayStateChanged();
}
if (mNetworkId != info.network_id) {
mNetworkId = info.network_id;
emit networkIdChanged();
}
if (info.link_speed != mLinkSpeed) {
mLinkSpeed = info.link_speed;
emit linkSpeedChanged();
}
if (mRssi != info.rssi) {
int signal_level = rssiToLevel(info.rssi);
if (signal_level != mSignalLevel) {
mSignalLevel = signal_level;
emit signalLevelChanged();
}
mRssi = info.rssi;
emit rssiChanged();
}
bool active = (mDisplayState == Wifi::FULLY_CONFIGURED);
if (active != mActive) {
mActive = active;
emit activeChanged();
}
}