QObject(parent),
mp_dBusWindowManagerProxy(0),
mp_dBusPopupProxy(0),
- m_visibleApps(),
- m_invisibleApps(),
- m_requestsToBeVisibleApps()
+ m_visibleSurfaces(),
+ m_invisibleSurfaces(),
+ m_requestsToBeVisibleSurfaces()
{
qDBusRegisterMetaType<SimplePoint>();
qDBusRegisterMetaType<QList<SimplePoint> >();
- qDBusRegisterMetaType<SimpleRect>();
- qDBusRegisterMetaType<QList<SimpleRect> >();
+ qDBusRegisterMetaType<LayoutArea>();
+ qDBusRegisterMetaType<QList<LayoutArea> >();
+ qDBusRegisterMetaType<Layout>();
+ qDBusRegisterMetaType<QList<Layout> >();
qDebug("D-Bus: connect to org.agl.windowmanager /windowmanager");
mp_dBusWindowManagerProxy = new org::agl::windowmanager("org.agl.windowmanager",
void LayoutHandler::setUpLayouts()
{
qDebug("setUpLayouts");
- QList<SimpleRect> surfaceAreas;
- SimpleRect surfaceArea;
- bool isFullScreen;
- int associatedFullScreenLayout;
+ QList<LayoutArea> surfaceAreas;
+ LayoutArea surfaceArea;
const int SCREEN_WIDTH = 1080;
const int SCREEN_HEIGHT = 1920;
surfaceAreas.append(surfaceArea);
- isFullScreen = false;
- associatedFullScreenLayout = 4;
-
- mp_dBusWindowManagerProxy->addLayout(1, "one app", isFullScreen, associatedFullScreenLayout, surfaceAreas);
+ mp_dBusWindowManagerProxy->addLayout(1, "one app", surfaceAreas);
surfaceAreas.clear();
surfaceAreas.append(surfaceArea);
- isFullScreen = false;
- associatedFullScreenLayout = -1;
-
- mp_dBusWindowManagerProxy->addLayout(2, "top on bottom", isFullScreen, associatedFullScreenLayout, surfaceAreas);
+ mp_dBusWindowManagerProxy->addLayout(2, "top on bottom", surfaceAreas);
surfaceAreas.clear();
surfaceAreas.append(surfaceArea);
- isFullScreen = false;
- associatedFullScreenLayout = -1;
-
- mp_dBusWindowManagerProxy->addLayout(3, "side by side", isFullScreen, associatedFullScreenLayout, surfaceAreas);
-
-
- surfaceAreas.clear();
-
- // layout 4:
- // one app surface full screen, no statusbar, no control bar
- surfaceArea.x = 0;
- surfaceArea.y = 0;
- surfaceArea.width = SCREEN_WIDTH;
- surfaceArea.height = SCREEN_HEIGHT;
-
- surfaceAreas.append(surfaceArea);
-
- isFullScreen = true;
- associatedFullScreenLayout = 1;
-
- mp_dBusWindowManagerProxy->addLayout(4, "one app full screen", isFullScreen, associatedFullScreenLayout, surfaceAreas);
-
-
- surfaceAreas.clear();
-
+ mp_dBusWindowManagerProxy->addLayout(3, "side by side", surfaceAreas);
}
-void LayoutHandler::makeMeVisible(int pid)
+void LayoutHandler::makeMeVisible(int surfaceId)
{
- qDebug("makeMeVisible %d", pid);
- m_requestsToBeVisibleApps.append(pid);
+ qDebug("makeMeVisible %d", surfaceId);
+ m_requestsToBeVisibleSurfaces.append(surfaceId);
- qDebug("m_visibleApps %d", m_visibleApps.size());
- qDebug("m_invisibleApps %d", m_invisibleApps.size());
- qDebug("m_requestsToBeVisibleApps %d", m_requestsToBeVisibleApps.size());
+ qDebug("m_visibleSurfaces %d", m_visibleSurfaces.size());
+ qDebug("m_invisibleSurfaces %d", m_invisibleSurfaces.size());
+ qDebug("m_requestsToBeVisibleSurfaces %d", m_requestsToBeVisibleSurfaces.size());
- QList<int> availableLayouts = mp_dBusWindowManagerProxy->getAvailableLayouts(m_visibleApps.size() + m_requestsToBeVisibleApps.size());
+ QList<int> availableLayouts = mp_dBusWindowManagerProxy->getAvailableLayouts(m_visibleSurfaces.size() + m_requestsToBeVisibleSurfaces.size());
if (0 == availableLayouts.size())
{
// no layout fits the need!
// replace the last app
qDebug("no layout fits the need!");
- qDebug("replace the last app");
+ qDebug("replace the last surface");
- m_invisibleApps.append(m_visibleApps.last());
- m_visibleApps.removeLast();
+ m_invisibleSurfaces.append(m_visibleSurfaces.last());
+ m_visibleSurfaces.removeLast();
- m_visibleApps.append(m_requestsToBeVisibleApps);
- m_requestsToBeVisibleApps.clear();
+ m_visibleSurfaces.append(m_requestsToBeVisibleSurfaces);
+ m_requestsToBeVisibleSurfaces.clear();
- for (int i = 0; i < m_visibleApps.size(); ++i)
+ for (int i = 0; i < m_visibleSurfaces.size(); ++i)
{
- mp_dBusWindowManagerProxy->setPidToLayoutArea(m_visibleApps.at(i), i);
+ mp_dBusWindowManagerProxy->setSurfaceToLayoutArea(m_visibleSurfaces.at(i), i);
}
}
if (1 == availableLayouts.size())
{
// switch to new layout
qDebug("switch to new layout %d", availableLayouts.at(0));
- m_visibleApps.append(m_requestsToBeVisibleApps);
- m_requestsToBeVisibleApps.clear();
+ m_visibleSurfaces.append(m_requestsToBeVisibleSurfaces);
+ m_requestsToBeVisibleSurfaces.clear();
mp_dBusWindowManagerProxy->setLayoutById(availableLayouts.at(0));
- for (int i = 0; i < m_visibleApps.size(); ++i)
+ for (int i = 0; i < m_visibleSurfaces.size(); ++i)
{
- mp_dBusWindowManagerProxy->setPidToLayoutArea(m_visibleApps.at(i), i);
+ mp_dBusWindowManagerProxy->setSurfaceToLayoutArea(m_visibleSurfaces.at(i), i);
}
}
if (1 < availableLayouts.size())
void LayoutHandler::toggleFullscreen()
{
qDebug("toggleFullscreen");
- int currentLayout = mp_dBusWindowManagerProxy->getLayout();
- int associatedFullScreenLayout = mp_dBusWindowManagerProxy->getAssociatedFullScreenLayout(currentLayout);
- if (-1 != associatedFullScreenLayout)
- {
- mp_dBusWindowManagerProxy->setLayoutById(associatedFullScreenLayout);
- for (int i = 0; i < m_visibleApps.size(); ++i)
- {
- mp_dBusWindowManagerProxy->setPidToLayoutArea(m_visibleApps.at(i), i);
- }
- }
- else
- {
- qDebug("no associatedFullScreenLayout. Cannot switch to full screen.");
- }
}
void LayoutHandler::setLayoutByName(QString layoutName)
{
// switch to new layout
qDebug("setLayout: switch to new layout %s", layoutName.toStdString().c_str());
- m_visibleApps.append(m_requestsToBeVisibleApps);
- m_requestsToBeVisibleApps.clear();
+ m_visibleSurfaces.append(m_requestsToBeVisibleSurfaces);
+ m_requestsToBeVisibleSurfaces.clear();
mp_dBusWindowManagerProxy->setLayoutByName(layoutName);
- for (int i = 0; i < m_visibleApps.size(); ++i)
+ for (int i = 0; i < m_visibleSurfaces.size(); ++i)
{
- mp_dBusWindowManagerProxy->setPidToLayoutArea(i, i);
+ mp_dBusWindowManagerProxy->setSurfaceToLayoutArea(i, i);
}
}
// DO NOT JUDGE THE SOURCE CODE :)
//////////////////////////////////////////
+// three layers will be defined. The HomeScreen will be placed
+// full screen in the background.
+// On top all applications in one layer.
+// On top of that, the popup layer.
+#define WINDOWMANAGER_LAYER_POPUP 100
+#define WINDOWMANAGER_LAYER_APPLICATIONS 101
+#define WINDOWMANAGER_LAYER_HOMESCREEN 102
+
+#define WINDOWMANAGER_LAYER_NUM 3
+
void* WindowManager::myThis = 0;
WindowManager::WindowManager(QObject *parent) :
QObject(parent),
m_layouts(),
- m_layoutNames(),
- m_layoutFullScreen(),
- m_layoutFullScreenAssociated(),
+ m_surfaces(),
+ mp_layoutAreaToSurfaceIdAssignment(0),
m_currentLayout(-1),
- m_homeScreenPid(-1),
-#ifdef __arm__
- mp_surfaces(0),
- mp_processLayers(0),
-#endif
- mp_layoutAreaToPidAssignment(0)
+ m_homeScreenPid(-1)
{
qDebug("-=[WindowManager]=-");
- qDebug("WindowManager");
// publish windowmanager interface
mp_windowManagerAdaptor = new WindowmanagerAdaptor((QObject*)this);
void WindowManager::start()
{
qDebug("-=[start]=-");
- mp_layoutAreaToPidAssignment = new QMap<int, unsigned int>;
+ mp_layoutAreaToSurfaceIdAssignment = new QMap<int, unsigned int>;
#ifdef __arm__
- mp_processLayers = new QList<int>;
- mp_surfaces = new QMap<t_ilm_uint, SurfaceInfo>;
-
ilmErrorTypes err;
err = ilm_init();
myThis = this;
err = ilm_registerNotification(WindowManager::notificationFunc_static, this);
+
+ createNewLayer(WINDOWMANAGER_LAYER_POPUP);
+ createNewLayer(WINDOWMANAGER_LAYER_APPLICATIONS);
+ createNewLayer(WINDOWMANAGER_LAYER_HOMESCREEN);
#endif
}
qDebug("-=[~WindowManager]=-");
delete mp_windowManagerAdaptor;
#ifdef __arm__
- delete mp_surfaces;
- delete mp_processLayers;
-
ilm_destroy();
#endif
- delete mp_layoutAreaToPidAssignment;
+ delete mp_layoutAreaToSurfaceIdAssignment;
}
void WindowManager::dumpScene()
qDebug("\n");
qDebug("current layout : %d", m_currentLayout);
qDebug("available layouts: %d", m_layouts.size());
- QMap<int, QList<SimpleRect> >::iterator i = m_layouts.begin();
+ QList<Layout>::const_iterator i = m_layouts.begin();
- QList<int> result;
while (i != m_layouts.constEnd())
{
- qDebug("--[id: %d]--[%s]--", i.key(), m_layoutNames.find(i.key()).value().toStdString().c_str());
- qDebug(" %d surface areas", i.value().size());
- for (int j = 0; j < i.value().size(); ++j)
+ qDebug("--[id: %d]--[%s]--", i->id, i->name.toStdString().c_str());
+ qDebug(" %d surface areas", i->layoutAreas.size());
+ for (int j = 0; j < i->layoutAreas.size(); ++j)
{
qDebug(" -area %d", j);
- qDebug(" -x : %d", i.value().at(j).x);
- qDebug(" -y : %d", i.value().at(j).y);
- qDebug(" -width : %d", i.value().at(j).width);
- qDebug(" -height: %d", i.value().at(j).height);
+ qDebug(" -x : %d", i->layoutAreas.at(j).x);
+ qDebug(" -y : %d", i->layoutAreas.at(j).y);
+ qDebug(" -width : %d", i->layoutAreas.at(j).width);
+ qDebug(" -height: %d", i->layoutAreas.at(j).height);
}
++i;
{
qDebug("-=[createNewLayer]=-");
qDebug("layerId %d", layerId);
- ilmErrorTypes err;
t_ilm_uint screenID = 0;
t_ilm_uint width;
t_ilm_uint height;
- err = ilm_getScreenResolution(screenID, &width, &height);
+ ilm_getScreenResolution(screenID, &width, &height);
t_ilm_layer newLayerId = layerId;
- err = ilm_layerCreateWithDimension(&newLayerId, width, height);
-
- t_ilm_float opacity = 0.0;
- err = ilm_layerSetOpacity(newLayerId, opacity);
-
- ilm_layerSetVisibility(newLayerId, ILM_FALSE);
+ ilm_layerCreateWithDimension(&newLayerId, width, height);
+ ilm_layerSetOpacity(newLayerId, 1.0);
+ ilm_layerSetVisibility(newLayerId, ILM_TRUE);
+ ilm_layerSetSourceRectangle(newLayerId,
+ 0,
+ 0,
+ width,
+ height);
+ ilm_layerSetDestinationRectangle(newLayerId,
+ 0,
+ 0,
+ width,
+ height);
ilm_commitChanges();
}
qDebug("-=[addSurfaceToLayer]=-");
qDebug("surfaceId %d", surfaceId);
qDebug("layerId %d", layerId);
- t_ilm_int length;
- t_ilm_layer* pArray;
- ilm_getLayerIDs(&length, &pArray);
- bool layerFound(false);
- for (int i = 0; i < length; ++i)
+ if (layerId == WINDOWMANAGER_LAYER_HOMESCREEN)
{
- if (layerId == pArray[i])
- {
- layerFound = true;
- }
+ struct ilmSurfaceProperties surfaceProperties;
+ ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
+
+ // homescreen app always fullscreen in the back
+ t_ilm_uint screenID = 0;
+ t_ilm_uint width;
+ t_ilm_uint height;
+
+ ilm_getScreenResolution(screenID, &width, &height);
+
+ ilm_surfaceSetDestinationRectangle(surfaceId, 0, 0, width, height);
+ ilm_surfaceSetSourceRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
+ ilm_surfaceSetOpacity(surfaceId, 1.0);
+ ilm_surfaceSetVisibility(surfaceId, ILM_TRUE);
+
+ ilm_layerAddSurface(layerId, surfaceId);
}
- if (!layerFound)
+ if (layerId == WINDOWMANAGER_LAYER_APPLICATIONS)
{
- createNewLayer(layerId);
+ struct ilmSurfaceProperties surfaceProperties;
+ ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
+
+ ilm_surfaceSetDestinationRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
+ ilm_surfaceSetSourceRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
+ ilm_surfaceSetOpacity(surfaceId, 0.0);
+ ilm_surfaceSetVisibility(surfaceId, ILM_FALSE);
+
+ ilm_layerAddSurface(layerId, surfaceId);
}
- struct ilmSurfaceProperties surfaceProperties;
- ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
- //qDebug(" origSourceWidth : %d", surfaceProperties.origSourceWidth);
- //qDebug(" origSourceHeight: %d", surfaceProperties.origSourceHeight);
-
- ilm_layerSetSourceRectangle(layerId,
- 0,
- 0,
- surfaceProperties.origSourceWidth,
- surfaceProperties.origSourceHeight);
- ilm_commitChanges();
+ if (layerId == WINDOWMANAGER_LAYER_POPUP)
+ {
+ struct ilmSurfaceProperties surfaceProperties;
+ ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
- ilm_surfaceSetDestinationRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
- ilm_surfaceSetSourceRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
- ilm_surfaceSetOpacity(surfaceId, 1.0);
- ilm_surfaceSetVisibility(surfaceId, true);
+ ilm_surfaceSetDestinationRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
+ ilm_surfaceSetSourceRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
+ ilm_surfaceSetOpacity(surfaceId, 0.0);
+ ilm_surfaceSetVisibility(surfaceId, ILM_FALSE);
- ilm_layerAddSurface(layerId, surfaceId);
+ ilm_layerAddSurface(layerId, surfaceId);
+ }
ilm_commitChanges();
}
+#endif
+
void WindowManager::updateScreen()
{
qDebug("-=[updateScreen]=-");
- int numberOfLayersToShow = 0;
-
- QMap<int, QList<SimpleRect> >::iterator i = m_layouts.find(m_currentLayout);
- if (m_layouts.end() != i)
- {
- numberOfLayersToShow += i.value().size();
- qDebug("the current layout provides %d render areas", i.value().size());
- }
- else
- {
- qDebug("the current layout provides no render areas!");
- }
-
- t_ilm_layer renderOrder[numberOfLayersToShow];
- int renderOrderCounter = 0;
-
- qDebug("show home screen app");
- if (-1 != m_homeScreenPid)
+ if (-1 != m_currentLayout)
{
- renderOrder[renderOrderCounter] = m_homeScreenPid;
- ++renderOrderCounter;
+#ifdef __arm__
- ilm_layerSetVisibility(m_homeScreenPid, ILM_TRUE);
- t_ilm_float opacity = 1.0;
- ilm_layerSetOpacity(m_homeScreenPid, opacity);
+ t_ilm_layer renderOrder[WINDOWMANAGER_LAYER_NUM];
+ renderOrder[0] = WINDOWMANAGER_LAYER_HOMESCREEN;
+ renderOrder[1] = WINDOWMANAGER_LAYER_APPLICATIONS;
+ renderOrder[2] = WINDOWMANAGER_LAYER_POPUP;
- // homescreen app always fullscreen in the back
- t_ilm_uint screenID = 0;
- t_ilm_uint width;
- t_ilm_uint height;
+ // hide all surfaces
+ for (int i = 0; i < m_surfaces.size(); ++i)
+ {
+ ilm_surfaceSetVisibility(m_surfaces.at(i), ILM_FALSE);
+ ilm_surfaceSetOpacity(m_surfaces.at(i), 0.0);
+ }
- ilm_getScreenResolution(screenID, &width, &height);
+ // find the current used layout
+ QList<Layout>::const_iterator ci = m_layouts.begin();
- ilm_layerSetDestinationRectangle(m_homeScreenPid,
- 0,
- 0,
- width,
- height);
- }
+ Layout currentLayout;
+ while (ci != m_layouts.constEnd())
+ {
+ if (ci->id == m_currentLayout)
+ {
+ currentLayout = *ci;
+ }
+ ++ci;
+ }
- qDebug("show %d apps", numberOfLayersToShow);
- for (int j = 0; j < numberOfLayersToShow; ++j)
- {
- int layerToShow = mp_layoutAreaToPidAssignment->find(j).value();
- if (layerToShow != m_homeScreenPid)
+ qDebug("show %d apps", mp_layoutAreaToSurfaceIdAssignment->size());
+ for (int j = 0; j < mp_layoutAreaToSurfaceIdAssignment->size(); ++j)
{
- qDebug(" app no. %d: %d", j, layerToShow);
- renderOrder[renderOrderCounter] = layerToShow;
- ++renderOrderCounter;
+ int surfaceToShow = mp_layoutAreaToSurfaceIdAssignment->find(j).value();
+ qDebug(" surface no. %d: %d", j, surfaceToShow);
- ilm_layerSetVisibility(layerToShow, ILM_TRUE);
- t_ilm_float opacity = 1.0;
- ilm_layerSetOpacity(layerToShow, opacity);
+ ilm_surfaceSetVisibility(surfaceToShow, ILM_TRUE);
+ ilm_surfaceSetOpacity(surfaceToShow, 1.0);
qDebug(" layout area %d", j);
- qDebug(" x: %d", m_layouts.find(m_currentLayout).value()[j].x);
- qDebug(" x: %d", m_layouts.find(m_currentLayout).value()[j].y);
- qDebug(" w: %d", m_layouts.find(m_currentLayout).value()[j].width);
- qDebug(" h: %d", m_layouts.find(m_currentLayout).value()[j].height);
-
- ilm_layerSetDestinationRectangle(layerToShow,
- m_layouts.find(m_currentLayout).value()[j].x,
- m_layouts.find(m_currentLayout).value()[j].y,
- m_layouts.find(m_currentLayout).value()[j].width,
- m_layouts.find(m_currentLayout).value()[j].height);
+ qDebug(" x: %d", currentLayout.layoutAreas[j].x);
+ qDebug(" y: %d", currentLayout.layoutAreas[j].y);
+ qDebug(" w: %d", currentLayout.layoutAreas[j].width);
+ qDebug(" h: %d", currentLayout.layoutAreas[j].height);
+
+ ilm_surfaceSetDestinationRectangle(surfaceToShow,
+ currentLayout.layoutAreas[j].x,
+ currentLayout.layoutAreas[j].y,
+ currentLayout.layoutAreas[j].width,
+ currentLayout.layoutAreas[j].height);
}
- }
- qDebug("renderOrder");
- for (int j = 0; j < renderOrderCounter; ++j)
- {
- qDebug(" %d: %d", j, renderOrder[j]);
- }
+ ilm_displaySetRenderOrder(0, renderOrder, WINDOWMANAGER_LAYER_NUM);
- ilm_displaySetRenderOrder(0, renderOrder, renderOrderCounter);
-
- ilm_commitChanges();
+ ilm_commitChanges();
+#endif
+ }
}
+#ifdef __arm__
void WindowManager::notificationFunc_non_static(ilmObjectType object,
t_ilm_uint id,
t_ilm_bool created)
if (created)
{
qDebug("Surface created, ID: %d", id);
- //qDebug("Surface created, ID: 0x%s", QString(QByteArray::number(id,16)).toStdString().c_str());
ilm_getPropertiesOfSurface(id, &surfaceProperties);
qDebug(" origSourceWidth : %d", surfaceProperties.origSourceWidth);
qDebug(" origSourceHeight: %d", surfaceProperties.origSourceHeight);
- SurfaceInfo surfaceInfo;
- surfaceInfo.pid = surfaceProperties.creatorPid;
- QString procInfoFileName = QString("/proc/") + QString::number(surfaceInfo.pid) + QString("/comm");
- QFile procInfo(procInfoFileName);
- if (procInfo.open(QIODevice::ReadOnly))
- {
- QTextStream in(&procInfo);
- surfaceInfo.processName = in.readLine();
- qDebug(" creator pid %d %s", surfaceInfo.pid, surfaceInfo.processName.toStdString().c_str());
- addSurfaceToLayer(id, surfaceProperties.creatorPid);
- mp_surfaces->insert(id, surfaceInfo);
- ilm_surfaceAddNotification(id, surfaceCallbackFunction_static);
-
- ilm_commitChanges();
-
- if (0 == QString::compare("weston-fullscre", surfaceInfo.processName))
+ if (m_homeScreenPid == surfaceProperties.creatorPid)
+ {
+ if (m_homeScreenSurfaceId != id)
{
qDebug("HomeScreen app detected");
- m_homeScreenPid = surfaceInfo.pid;
+ m_homeScreenSurfaceId = id;
+ addSurfaceToLayer(id, WINDOWMANAGER_LAYER_HOMESCREEN);
updateScreen();
}
}
else
{
- qDebug("no creator pid found. Ignoring surface!");
+ addSurfaceToLayer(id, WINDOWMANAGER_LAYER_APPLICATIONS);
+
+ m_surfaces.append(id);
}
+ ilm_surfaceAddNotification(id, surfaceCallbackFunction_static);
+
+ ilm_commitChanges();
}
else
{
qDebug("Surface destroyed, ID: %d", id);
- mp_surfaces->erase(mp_surfaces->find(id));
+ m_surfaces.removeAt(m_surfaces.indexOf(id));
ilm_surfaceRemoveNotification(id);
ilm_commitChanges();
static_cast<WindowManager*>(WindowManager::myThis)->notificationFunc_non_static(object, id, created);
}
-
-
-
void WindowManager::surfaceCallbackFunction_non_static(t_ilm_surface surface,
struct ilmSurfaceProperties* surfaceProperties,
t_ilm_notification_mask mask)
}
#endif
-int WindowManager::addLayout(int layoutId, const QString &layoutName, bool isFullScreen, int associatedFullScreenLayout, const QList<SimpleRect> &surfaceAreas)
+
+int WindowManager::homeScreenPid() const
+{
+ return m_homeScreenPid;
+}
+
+void WindowManager::setHomeScreenPid(int value)
+{
+ m_homeScreenPid = value;
+#ifdef __arm__
+ // maybe the HomeSceen app has already provided its surface.
+ // if so, shift it to the correct layer
+ // find the current used layout
+ QList<int>::iterator ci = m_surfaces.begin();
+
+ struct ilmSurfaceProperties surfaceProperties;
+ bool found = false;
+ while ((!found) && (ci != m_surfaces.constEnd()))
+ {
+ ilm_getPropertiesOfSurface(*ci, &surfaceProperties);
+ if (m_homeScreenPid == surfaceProperties.creatorPid)
+ {
+ qDebug("HomeScreen app detected");
+ m_homeScreenSurfaceId = *ci;
+ addSurfaceToLayer(*ci, WINDOWMANAGER_LAYER_HOMESCREEN);
+ m_surfaces.erase(ci);
+ found = true;
+ updateScreen();
+ }
+
+ ++ci;
+ }
+#endif
+
+ updateScreen();
+ dumpScene();
+}
+
+int WindowManager::layoutId() const
+{
+ return m_currentLayout;
+}
+
+QString WindowManager::layoutName() const
+{
+ QList<Layout>::const_iterator i = m_layouts.begin();
+
+ QString result = "not found";
+ while (i != m_layouts.constEnd())
+ {
+ if (i->id == m_currentLayout)
+ {
+ result = i->name;
+ }
+
+ ++i;
+ }
+
+ return result;
+}
+
+
+int WindowManager::addLayout(int layoutId, const QString &layoutName, const QList<LayoutArea> &surfaceAreas)
{
qDebug("-=[addLayout]=-");
- m_layouts.insert(layoutId, surfaceAreas);
- m_layoutNames.insert(layoutId, layoutName);
- m_layoutFullScreen.insert(layoutId, isFullScreen);
- m_layoutFullScreenAssociated.insert(layoutId, associatedFullScreenLayout);
- qDebug("addLayout %d %s %s, %d, size %d",
+ m_layouts.append(Layout(layoutId, layoutName, surfaceAreas));
+
+ qDebug("addLayout %d %s, size %d",
layoutId,
layoutName.toStdString().c_str(),
- isFullScreen ? "true" : "false",
- associatedFullScreenLayout,
surfaceAreas.size());
dumpScene();
- return true;
+ return WINDOWMANAGER_NO_ERROR;
}
-int WindowManager::getAssociatedFullScreenLayout(int layoutId)
+QList<Layout> WindowManager::getAllLayouts()
{
- qDebug("-=[getAssociatedFullScreenLayout]=-");
- return m_layoutFullScreenAssociated.find(layoutId).value();
+ qDebug("-=[getAllLayouts]=-");
+
+ return m_layouts;
}
QList<int> WindowManager::getAvailableLayouts(int numberOfAppSurfaces)
{
qDebug("-=[getAvailableLayouts]=-");
- QMap<int, QList<SimpleRect> >::iterator i = m_layouts.begin();
+ QList<Layout>::const_iterator i = m_layouts.begin();
QList<int> result;
while (i != m_layouts.constEnd())
{
- if (i.value().size() == numberOfAppSurfaces)
+ if (i->layoutAreas.size() == numberOfAppSurfaces)
{
- result.append(i.key());
+ result.append(i->id);
}
++i;
return result;
}
-// maybe not needed anymore
-QList<SimplePoint> WindowManager::getAvailableSurfaces()
+QList<int> WindowManager::getAvailableSurfaces()
{
qDebug("-=[getAvailableSurfaces]=-");
- QList<SimplePoint> points;
- SimplePoint point;
- point.x = 1;
- point.y = 2;
- points.append(point);
- point.x = 11;
- point.y = 22;
- points.append(point);
- point.x = 111;
- point.y = 222;
- points.append(point);
-
- return points;
-}
-int WindowManager::getLayout()
-{
- qDebug("-=[getLayout]=-");
- return m_currentLayout;
+ return m_surfaces;
}
QString WindowManager::getLayoutName(int layoutId)
{
qDebug("-=[getLayoutName]=-");
- return m_layoutNames.find(layoutId).value();
-}
+ QList<Layout>::const_iterator i = m_layouts.begin();
-bool WindowManager::isLayoutFullScreen(int layoutId)
-{
- qDebug("-=[isLayoutFullScreen]=-");
- return m_layoutFullScreen.find(layoutId).value();
+ QString result = "not found";
+ while (i != m_layouts.constEnd())
+ {
+ if (i->id == layoutId)
+ {
+ result = i->name;
+ }
+
+ ++i;
+ }
+
+ return result;
}
-void WindowManager::setLayoutById(int layoutId)
+
+int WindowManager::setLayoutById(int layoutId)
{
qDebug("-=[setLayoutById]=-");
+ int result = WINDOWMANAGER_NO_ERROR;
m_currentLayout = layoutId;
- mp_layoutAreaToPidAssignment->clear();
+ mp_layoutAreaToSurfaceIdAssignment->clear();
dumpScene();
+
+ return result;
}
-void WindowManager::setLayoutByName(const QString &layoutName)
+int WindowManager::setLayoutByName(const QString &layoutName)
{
qDebug("-=[setLayoutByName]=-");
- QMap<int, QString>::iterator i = m_layoutNames.begin();
- while (i != m_layoutNames.constEnd())
+ int result = WINDOWMANAGER_NO_ERROR;
+
+ QList<Layout>::const_iterator i = m_layouts.begin();
+
+ while (i != m_layouts.constEnd())
{
- if (i.value() == layoutName)
+ if (i->name == layoutName)
{
- m_currentLayout = i.key();
+ m_currentLayout = i->id;
+
+ mp_layoutAreaToSurfaceIdAssignment->clear();
+
+ dumpScene();
}
+
++i;
}
- mp_layoutAreaToPidAssignment->clear();
-
- dumpScene();
+ return result;
}
-void WindowManager::setPidToLayoutArea(int pid, int layoutAreaId)
+int WindowManager::setSurfaceToLayoutArea(int surfaceId, int layoutAreaId)
{
- qDebug("-=[setPidToLayoutArea]=-");
- qDebug("pid %d", pid);
+ qDebug("-=[setSurfaceToLayoutArea]=-");
+ int result = WINDOWMANAGER_NO_ERROR;
+
+ qDebug("surfaceId %d", surfaceId);
qDebug("layoutAreaId %d", layoutAreaId);
- mp_layoutAreaToPidAssignment->insert(layoutAreaId, pid);
+ mp_layoutAreaToSurfaceIdAssignment->insert(layoutAreaId, surfaceId);
-#ifdef __arm__
updateScreen();
-#endif
dumpScene();
+
+ return result;
}
See the License for the specific language governing permissions and
limitations under the License. -->
<node>
- <interface name="org.agl.windowmanager">
- <method name="addLayout">
- <arg name="layoutId" type="i" direction="in"/>
- <arg name="layoutName" type="s" direction="in"/>
- <arg name="isFullScreen" type="b" direction="in"/>
- <arg name="associatedFullScreenLayout" type="i" direction="in"/>
- <arg name="surfaceAreas" type="a(iiii)" direction="in"/>
- <annotation name="org.qtproject.QtDBus.QtTypeName.In4" value="QList<SimpleRect>"/>
- <arg name="error" type="i" direction="out"/>
- </method>
- <method name="getAvailableLayouts">
- <arg name="numberOfAppSurfaces" type="i" direction="in"/>
- <arg name="layoutIds" type="ai" direction="out"/>
- <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList<int>"/>
- </method>
- <method name="isLayoutFullScreen">
- <arg name="layoutId" type="i" direction="in"/>
- <arg name="fullScreen" type="b" direction="out"/>
- </method>
- <method name="getAssociatedFullScreenLayout">
- <arg name="layoutId" type="i" direction="in"/>
- <arg name="associatedFullScreenLayout" type="i" direction="out"/>
- </method>
- <method name="setLayoutById">
- <arg name="layoutId" type="i" direction="in"/>
- </method>
- <method name="setLayoutByName">
- <arg name="layoutName" type="s" direction="in"/>
- </method>
- <method name="getLayout">
- <arg name="layoutId" type="i" direction="out"/>
- </method>
- <method name="setPidToLayoutArea">
- <arg name="pid" type="i" direction="in"/>
- <arg name="layoutAreaId" type="i" direction="in"/>
- </method>
- <method name="getAvailableSurfaces">
- <arg name="surfacesAndPids" type="a(ii)" direction="out"/>
- <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList<SimplePoint>"/>
- </method>
- <method name="getLayoutName">
- <arg name="layoutId" type="i" direction="in"/>
- <arg name="layoutName" type="s" direction="out"/>
- </method>
- </interface>
+ <!--
+ org.agl.windowmanager:
+ @short_description: A Layout-based interface for the WindowManager.
+
+ A Layout defines a list of surfaces areas.
+ -->
+ <interface name="org.agl.windowmanager">
+ <!--
+ addLayout:
+ @layoutId: A unique ID that represents this layout. If the ID is already in use WINDOWMANAGER_ERROR_ID_ALREADY_DEFINED will be returned.
+ @layoutName: A user readable string for the layout. If the string is already in use WINDOWMANAGER_ERROR_NAME_ALREADY_DEFINED will be returned.
+ @surfaceAreas: A list of surface areas.
+ @error: WINDOWMANAGER_NO_ERROR or the first error that occurred.
+
+ Add a layout definition to the WindowManayer layout database.
+ The layout database is temoprary and not stored persistently. It has to be recreated by the client after
+ a WindowManager restart.
+ -->
+ <method name="addLayout">
+ <arg name="layoutId" type="i" direction="in"/>
+ <arg name="layoutName" type="s" direction="in"/>
+ <arg name="surfaceAreas" type="a(iiii)" direction="in"/>
+ <annotation name="org.qtproject.QtDBus.QtTypeName.In2" value="QList<LayoutArea>"/>
+ <arg name="error" type="i" direction="out"/>
+ </method>
+
+ <!--
+ setLayoutById:
+ @layoutId: The ID of the layout to activate.
+ @error: WINDOWMANAGER_NO_ERROR or the first error that occurred.
+
+ Switch to the layout with the given ID.
+ -->
+ <method name="setLayoutById">
+ <arg name="layoutId" type="i" direction="in"/>
+ <arg name="error" type="i" direction="out"/>
+ </method>
+ <!--
+ setLayoutByName:
+ @layoutName: The name of the layout to activate.
+ @error: WINDOWMANAGER_NO_ERROR or the first error that occurred.
+
+ Switch to the layout with the given name.
+ -->
+ <method name="setLayoutByName">
+ <arg name="layoutName" type="s" direction="in"/>
+ <arg name="error" type="i" direction="out"/>
+ </method>
+
+ <!--
+ getLayoutName:
+ @layoutId: The ID of the requested layout name.
+ @layoutName: The name of the layout with the given ID.
+
+ Request the name of the layout with the given ID. This does not set or activate a layout.
+ It is just returning the name of the given layout.
+ -->
+ <method name="getLayoutName">
+ <arg name="layoutId" type="i" direction="in"/>
+ <arg name="layoutName" type="s" direction="out"/>
+ </method>
+
+ <!--
+ layout:
+ The current active layout with all its information.
+ -->
+ <property>
+ <arg name="layout" type="(isa(iiii))" access="read"/>
+ <annotation name="org.qtproject.QtDBus.QtTypeName" value="Layout"/>
+ </property>
+ <!--
+ layoutId:
+ The current active layout id. This property is redundant, since its info is already available
+ in the property layout. But this property is more lightweight.
+ -->
+ <property name="layoutId" type="i" access="read"/>
+ <!--
+ layoutName:
+ The name of the current active layout. This property is redundant, since its info is already available
+ in the property layout. But this property is more lightweight.
+ -->
+ <property name="layoutName" type="s" access="read"/>
+
+ <!--
+ getAllLayouts:
+ @layouts: A list of all layouts.
+
+ Returns a list of all layouts that were added to the WindowManager.
+ -->
+ <method name="getAllLayouts">
+ <arg name="layoutIds" type="a(isa(iiii))" direction="out"/>
+ <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList<Layout>"/>
+ </method>
+
+ <!--
+ getAvailableLayouts:
+ @numberOfAppSurfaces: The ID of the requested layout name.
+ @layoutIds: A list of layouts that offer the exact requested ammount of surface render areas.
+
+ Returns a list of layouts that offer the exact requested ammount of surface render areas.
+ If the list is empty, no layout fits the exact ammount.
+ -->
+ <method name="getAvailableLayouts">
+ <arg name="numberOfAppSurfaces" type="i" direction="in"/>
+ <arg name="layoutIds" type="ai" direction="out"/>
+ <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList<int>"/>
+ </method>
+
+ <!--
+ setSurfaceToLayoutArea:
+ @surfaceId: The ID of the surface that shall be positioned.
+ @layoutAreaId: The ID of the layout area where the surface shall be rendered.
+ @error: WINDOWMANAGER_NO_ERROR or the first error that occurred.
+
+ The surface will be scaled to the size of the layout area.
+ The surface will be made visible with this call.
+ -->
+ <method name="setSurfaceToLayoutArea">
+ <arg name="surfaceId" type="i" direction="in"/>
+ <arg name="layoutAreaId" type="i" direction="in"/>
+ <arg name="error" type="i" direction="out"/>
+ </method>
+
+ <!--
+ getAvailableSurfaces:
+ @surfaceIds: A list of all known surfaceIds except for the surfaces created by the Home Screen app.
+
+ If no surfaces are available, the returned list is empty.
+ -->
+ <method name="getAvailableSurfaces">
+ <arg name="surfaceIds" type="a(i)" direction="out"/>
+ <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QList<int>"/>
+ </method>
+
+ <!--
+ homeScreenPid:
+ The PID of the Home Screen app. The Home Screen app requires a special handling.
+ It will always be visible in the background. So it will be placed in a special layer at the lowest z-order.
+ -->
+ <property name="homeScreenPid" type="i" access="readwrite"/>
+ </interface>
</node>