X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=WindowManager%2Fsrc%2Fwindowmanager.cpp;h=26d650fc114be744c16ae560c9f38c7c8b0e6113;hb=f1de82b82538e143bd46fd216ccc62e1f1b0f983;hp=dcab2f4affc2e2ad173af286faae19ff7cb6a421;hpb=0a468d9b5ae7b3e5ba106facf17698d89b1ce200;p=staging%2FHomeScreen.git diff --git a/WindowManager/src/windowmanager.cpp b/WindowManager/src/windowmanager.cpp index dcab2f4..26d650f 100644 --- a/WindowManager/src/windowmanager.cpp +++ b/WindowManager/src/windowmanager.cpp @@ -15,169 +15,252 @@ */ #include "windowmanager.hpp" +#include +#include ////////////////////////////////////////// // THIS IS STILL UNDER HEAVY DEVELOPMENT! // 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) + QObject(parent), + m_layouts(), + m_surfaces(), + mp_layoutAreaToSurfaceIdAssignment(0), + m_currentLayout(-1), + m_homeScreenPid(-1) { - qDebug("WindowManager"); + qDebug("-=[WindowManager]=-"); + // publish windowmanager interface + mp_windowManagerAdaptor = new WindowmanagerAdaptor((QObject*)this); + + QDBusConnection dbus = QDBusConnection::sessionBus(); + dbus.registerObject("/windowmanager", this); + dbus.registerService("org.agl.windowmanager"); +} + +void WindowManager::start() +{ + qDebug("-=[start]=-"); + mp_layoutAreaToSurfaceIdAssignment = new QMap; #ifdef __arm__ ilmErrorTypes err; - if (true)//!ilm_isInitialized()) ...crashes... - { - err = ilm_init(); - qDebug("ilm_init = %d", err); - } + err = ilm_init(); + qDebug("ilm_init = %d", err); - t_ilm_uint screenID = 0; - t_ilm_uint width; - t_ilm_uint height; + myThis = this; + err = ilm_registerNotification(WindowManager::notificationFunc_static, this); - err = ilm_getScreenResolution(screenID, &width, &height); - qDebug("ilm_getScreenResolution = %d", err); - qDebug("pWidth %d, pHeight %d", width, height); + createNewLayer(WINDOWMANAGER_LAYER_POPUP); + createNewLayer(WINDOWMANAGER_LAYER_APPLICATIONS); + createNewLayer(WINDOWMANAGER_LAYER_HOMESCREEN); +#endif +} +WindowManager::~WindowManager() +{ + qDebug("-=[~WindowManager]=-"); + delete mp_windowManagerAdaptor; +#ifdef __arm__ + ilm_destroy(); +#endif + delete mp_layoutAreaToSurfaceIdAssignment; +} - t_ilm_layer layerId = 42; // does not matter - err = ilm_layerCreateWithDimension(&layerId, width, height); - qDebug("ilm_layerCreateWithDimension = %d", err); - qDebug("layerId = %d", layerId); +void WindowManager::dumpScene() +{ + qDebug("\n"); + qDebug("current layout : %d", m_currentLayout); + qDebug("available layouts: %d", m_layouts.size()); + QList::const_iterator i = m_layouts.begin(); - err = ilm_layerSetVisibility(layerId, true); - qDebug("ilm_layerSetVisibility = %d", err); + while (i != m_layouts.constEnd()) + { + 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->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); + } - ilm_commitChanges(); + ++i; + } +} - err = ilm_displaySetRenderOrder(screenID, &layerId, 1); - qDebug("ilm_displaySetRenderOrder = %d", err); +#ifdef __arm__ - ilm_commitChanges(); +void WindowManager::createNewLayer(int layerId) +{ + qDebug("-=[createNewLayer]=-"); + qDebug("layerId %d", layerId); - err = ilm_layerSetSourceRectangle(layerId, 0, 0, width, height); - qDebug("ilm_layerSetSourceRectangle = %d", err); - err = ilm_layerSetDestinationRectangle(layerId, 0, 0, width, height); - qDebug("layerSetDestinationRectangle = %d", err); + t_ilm_uint screenID = 0; + t_ilm_uint width; + t_ilm_uint height; + + ilm_getScreenResolution(screenID, &width, &height); + + t_ilm_layer newLayerId = layerId; + 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(); +} - t_ilm_float opacity = 1.0; +void WindowManager::addSurfaceToLayer(int surfaceId, int layerId) +{ + qDebug("-=[addSurfaceToLayer]=-"); + qDebug("surfaceId %d", surfaceId); + qDebug("layerId %d", layerId); - err = ilm_layerSetOpacity(layerId, opacity); - qDebug("ilm_layerSetOpacity = %d", err); + if (layerId == WINDOWMANAGER_LAYER_HOMESCREEN) + { + struct ilmSurfaceProperties surfaceProperties; + ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties); + qDebug("sourceX %d", surfaceProperties.sourceX); + qDebug("sourceY %d", surfaceProperties.sourceY); + qDebug("sourceWidth %d", surfaceProperties.sourceWidth); + qDebug("sourceHeight %d", surfaceProperties.sourceHeight); - t_ilm_int length; - t_ilm_surface* pArray; + // homescreen app always fullscreen in the back + t_ilm_uint screenID = 0; + t_ilm_uint width; + t_ilm_uint height; - err = ilm_getSurfaceIDs(&length, &pArray); - qDebug("ilm_getSurfaceIDs = %d", err); - qDebug("length %d pArray[0] %d", length, pArray[0]); + ilm_getScreenResolution(screenID, &width, &height); - if (length > 0) - { - t_ilm_surface surfaceId = pArray[0]; + 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); - err = ilm_layerAddSurface(layerId, surfaceId); - qDebug("ilm_layerAddSurface = %d", err); + ilm_layerAddSurface(layerId, surfaceId); + } - t_ilm_bool visibility; - err = ilm_surfaceGetVisibility(surfaceId, &visibility); - qDebug("ilm_surfaceGetVisibility = %d", err); - qDebug("visibility %d", visibility); + if (layerId == WINDOWMANAGER_LAYER_APPLICATIONS) + { + struct ilmSurfaceProperties surfaceProperties; + ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties); - err = ilm_surfaceSetVisibility(surfaceId, true); - qDebug("ilm_surfaceSetVisibility = %d", err); + 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); - err = ilm_surfaceSetOpacity(surfaceId, opacity); - qDebug("ilm_surfaceSetOpacity = %d", err); + ilm_layerAddSurface(layerId, surfaceId); + } - err = ilm_surfaceSetSourceRectangle(surfaceId, 0, 0, 200, 200); - qDebug("ilm_surfaceSetSourceRectangle = %d", err); - err = ilm_surfaceSetDestinationRectangle(surfaceId, 0, 0, 200, 200); - qDebug("surfaceSetDestinationRectangle = %d", err); + 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, 0.0); + ilm_surfaceSetVisibility(surfaceId, ILM_FALSE); + ilm_layerAddSurface(layerId, surfaceId); } ilm_commitChanges(); +} - struct ilmScreenProperties screenProperties; - struct ilmLayerProperties layerProperties; - struct ilmSurfaceProperties surfaceProperties; - - err = ilm_getPropertiesOfScreen(0, &screenProperties); - qDebug("ilm_getPropertiesOfScreen = %d", err); - err = ilm_getPropertiesOfLayer(layerId, &layerProperties); - qDebug("ilm_getPropertiesOfLayer = %d", err); - err = ilm_getPropertiesOfSurface(pArray[0], &surfaceProperties); - qDebug("ilm_getPropertiesOfSurface = %d", err); - - - qDebug("screen"); - qDebug("t_ilm_uint %d", screenProperties.layerCount); /*!< number of layers displayed on the screen */ - //qDebug("t_ilm_layer* %d", screenProperties.layerIds[0]); /*!< array of layer ids */ - qDebug("t_ilm_uint %d", screenProperties.harwareLayerCount); /*!< number of hardware layers */ - qDebug("t_ilm_uint %d", screenProperties.screenWidth); /*!< width value of screen in pixels */ - qDebug("t_ilm_uint %d", screenProperties.screenHeight); /*!< height value of screen in pixels */ - - qDebug("layer"); - qDebug("t_ilm_float %f", layerProperties.opacity); /*!< opacity value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.sourceX); /*!< x source position value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.sourceY); /*!< y source position value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.sourceWidth); /*!< source width value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.sourceHeight); /*!< source height value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.origSourceWidth); /*!< original source width value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.origSourceHeight); /*!< original source height value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.destX); /*!< x destination position value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.destY); /*!< y desitination position value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.destWidth); /*!< destination width value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.destHeight); /*!< destination height value of the layer */ - qDebug("ilmOrientation%d", layerProperties.orientation); /*!< orientation value of the layer */ - qDebug("t_ilm_bool %d", layerProperties.visibility); /*!< visibility value of the layer */ - qDebug("t_ilm_uint %d", layerProperties.type); /*!< type of layer */ - qDebug("t_ilm_int %d", layerProperties.creatorPid); /*!< process id of application that created this layer */ - - qDebug("surface"); - qDebug("t_ilm_float %f", surfaceProperties.opacity); /*!< opacity value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.sourceX); /*!< x source position value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.sourceY); /*!< y source position value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.sourceWidth); /*!< source width value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.sourceHeight); /*!< source height value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.origSourceWidth); /*!< original source width value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.origSourceHeight); /*!< original source height value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.destX); /*!< x destination position value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.destY); /*!< y desitination position value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.destWidth); /*!< destination width value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.destHeight); /*!< destination height value of the surface */ - qDebug("ilmOrientation %d", surfaceProperties.orientation); /*!< orientation value of the surface */ - qDebug("t_ilm_bool %d", surfaceProperties.visibility); /*!< visibility value of the surface */ - qDebug("t_ilm_uint %d", surfaceProperties.frameCounter); /*!< already rendered frames of surface */ - qDebug("t_ilm_uint %d", surfaceProperties.drawCounter); /*!< content updates of surface */ - qDebug("t_ilm_uint %d", surfaceProperties.updateCounter); /*!< content updates of surface */ - qDebug("t_ilm_uint %d", surfaceProperties.pixelformat); /*!< pixel format of surface */ - qDebug("t_ilm_uint %d", surfaceProperties.nativeSurface); /*!< native surface handle of surface */ - qDebug("t_ilm_int %d", surfaceProperties.creatorPid); /*!< process id of application that created this surface */ - qDebug("ilmInputDevice %d", surfaceProperties.focus); /*!< bitmask of every type of device that this surface has focus in */ - - err = ilm_registerNotification(WindowManager::notificationFunc_static, this); #endif -} -WindowManager::~WindowManager() +void WindowManager::updateScreen() { + qDebug("-=[updateScreen]=-"); + #ifdef __arm__ - ilmErrorTypes err; - if (ilm_isInitialized()) + if (-1 != m_currentLayout) { - err = ilm_destroy(); - qDebug("ilm_destroy = %d", err); + + // 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); + } + + // find the current used layout + QList::const_iterator ci = m_layouts.begin(); + + Layout currentLayout; + while (ci != m_layouts.constEnd()) + { + if (ci->id == m_currentLayout) + { + currentLayout = *ci; + } + + ++ci; + } + + qDebug("show %d apps", mp_layoutAreaToSurfaceIdAssignment->size()); + for (int j = 0; j < mp_layoutAreaToSurfaceIdAssignment->size(); ++j) + { + int surfaceToShow = mp_layoutAreaToSurfaceIdAssignment->find(j).value(); + qDebug(" surface no. %d: %d", j, surfaceToShow); + + ilm_surfaceSetVisibility(surfaceToShow, ILM_TRUE); + ilm_surfaceSetOpacity(surfaceToShow, 1.0); + + qDebug(" layout area %d", j); + 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); + } + + ilm_commitChanges(); } + + t_ilm_layer renderOrder[WINDOWMANAGER_LAYER_NUM]; + renderOrder[0] = WINDOWMANAGER_LAYER_HOMESCREEN; + renderOrder[1] = WINDOWMANAGER_LAYER_APPLICATIONS; + renderOrder[2] = WINDOWMANAGER_LAYER_POPUP; + + ilm_displaySetRenderOrder(0, renderOrder, WINDOWMANAGER_LAYER_NUM); + + ilm_commitChanges(); + #endif } @@ -186,7 +269,8 @@ void WindowManager::notificationFunc_non_static(ilmObjectType object, t_ilm_uint id, t_ilm_bool created) { - qDebug("notificationFunc_non_static"); + qDebug("-=[notificationFunc_non_static]=-"); + qDebug("Notification from weston!"); if (ILM_SURFACE == object) { struct ilmSurfaceProperties surfaceProperties; @@ -194,62 +278,273 @@ void WindowManager::notificationFunc_non_static(ilmObjectType object, if (created) { qDebug("Surface created, ID: %d", id); - - ilm_layerAddSurface(42 /*always use layer 42 for now*/, id); - ilm_surfaceSetOpacity(id, 1.0); - ilm_surfaceSetVisibility(id, true); ilm_getPropertiesOfSurface(id, &surfaceProperties); - ilm_surfaceSetSourceRectangle(id, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight); + qDebug(" origSourceWidth : %d", surfaceProperties.origSourceWidth); + qDebug(" origSourceHeight: %d", surfaceProperties.origSourceHeight); + + if (m_homeScreenPid == surfaceProperties.creatorPid) + { + if (m_homeScreenSurfaceId != id) + { + qDebug("HomeScreen app detected"); + m_homeScreenSurfaceId = id; + addSurfaceToLayer(id, WINDOWMANAGER_LAYER_HOMESCREEN); + updateScreen(); + } + } + else + { + addSurfaceToLayer(id, WINDOWMANAGER_LAYER_APPLICATIONS); + + m_surfaces.append(id); + } + ilm_surfaceAddNotification(id, surfaceCallbackFunction_static); ilm_commitChanges(); } else { qDebug("Surface destroyed, ID: %d", id); + m_surfaces.removeAt(m_surfaces.indexOf(id)); + ilm_surfaceRemoveNotification(id); + + ilm_commitChanges(); } + } + if (ILM_LAYER == object) + { + //qDebug("Layer.. we don't care..."); + } +} - t_ilm_uint screenID = 0; - t_ilm_uint width; - t_ilm_uint height; - ilm_getScreenResolution(screenID, &width, &height); +void WindowManager::notificationFunc_static(ilmObjectType object, + t_ilm_uint id, + t_ilm_bool created, + void* user_data) +{ + static_cast(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) +{ + qDebug("-=[surfaceCallbackFunction_non_static]=-"); + qDebug("surfaceCallbackFunction_non_static changes for surface %d", surface); + if (ILM_NOTIFICATION_VISIBILITY & mask) + { + qDebug("ILM_NOTIFICATION_VISIBILITY"); + } + + if (ILM_NOTIFICATION_OPACITY & mask) + { + qDebug("ILM_NOTIFICATION_OPACITY"); + } - t_ilm_int length; - t_ilm_surface* pArray; + if (ILM_NOTIFICATION_ORIENTATION & mask) + { + qDebug("ILM_NOTIFICATION_ORIENTATION"); + } - ilm_getSurfaceIDs(&length, &pArray); - qDebug("length %d", length); + if (ILM_NOTIFICATION_SOURCE_RECT & mask) + { + qDebug("ILM_NOTIFICATION_SOURCE_RECT"); + } + + if (ILM_NOTIFICATION_DEST_RECT & mask) + { + qDebug("ILM_NOTIFICATION_DEST_RECT"); + } +} + +void WindowManager::surfaceCallbackFunction_static(t_ilm_surface surface, + struct ilmSurfaceProperties* surfaceProperties, + t_ilm_notification_mask mask) + +{ + static_cast(WindowManager::myThis)->surfaceCallbackFunction_non_static(surface, surfaceProperties, mask); +} +#endif - for (int i = 0; i < length; ++i) +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::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) { - //ilm_getPropertiesOfSurface(pArray[i], &surfaceProperties); - qDebug("place surface %d at x: %f, y: %f, width: %f, height: %f", - pArray[i], - i * (width / (1.0 * length)), - 0, - width / (1.0 * length), - height); - ilm_surfaceSetDestinationRectangle(pArray[(int)i], - i * (width / (1.0 * length)), - 0, - width / (1.0 * length), - height); + qDebug("HomeScreen app detected"); + m_homeScreenSurfaceId = *ci; + addSurfaceToLayer(*ci, WINDOWMANAGER_LAYER_HOMESCREEN); + m_surfaces.erase(ci); + found = true; + updateScreen(); } - ilm_commitChanges(); + ++ci; } - if (ILM_LAYER == object) +#endif + + updateScreen(); + dumpScene(); +} + +int WindowManager::layoutId() const +{ + return m_currentLayout; +} + +QString WindowManager::layoutName() const +{ + QList::const_iterator i = m_layouts.begin(); + + QString result = "not found"; + while (i != m_layouts.constEnd()) { - qDebug("Layer.. we don't care..."); + if (i->id == m_currentLayout) + { + result = i->name; + } + + ++i; } + + return result; } -void WindowManager::notificationFunc_static(ilmObjectType object, - t_ilm_uint id, - t_ilm_bool created, - void* user_data) + +int WindowManager::addLayout(int layoutId, const QString &layoutName, const QList &surfaceAreas) +{ + qDebug("-=[addLayout]=-"); + m_layouts.append(Layout(layoutId, layoutName, surfaceAreas)); + + qDebug("addLayout %d %s, size %d", + layoutId, + layoutName.toStdString().c_str(), + surfaceAreas.size()); + + dumpScene(); + + return WINDOWMANAGER_NO_ERROR; +} + +QList WindowManager::getAllLayouts() { - qDebug("notificationFunc_static"); - static_cast(user_data)->notificationFunc_non_static(object, id, created); + qDebug("-=[getAllLayouts]=-"); + + return m_layouts; +} + +QList WindowManager::getAvailableLayouts(int numberOfAppSurfaces) +{ + qDebug("-=[getAvailableLayouts]=-"); + QList::const_iterator i = m_layouts.begin(); + + QList result; + while (i != m_layouts.constEnd()) + { + if (i->layoutAreas.size() == numberOfAppSurfaces) + { + result.append(i->id); + } + + ++i; + } + + return result; +} + +QList WindowManager::getAvailableSurfaces() +{ + qDebug("-=[getAvailableSurfaces]=-"); + + return m_surfaces; +} + +QString WindowManager::getLayoutName(int layoutId) +{ + qDebug("-=[getLayoutName]=-"); + QList::const_iterator i = m_layouts.begin(); + + QString result = "not found"; + while (i != m_layouts.constEnd()) + { + if (i->id == layoutId) + { + result = i->name; + } + + ++i; + } + + return result; +} + + +int WindowManager::setLayoutById(int layoutId) +{ + qDebug("-=[setLayoutById]=-"); + int result = WINDOWMANAGER_NO_ERROR; + m_currentLayout = layoutId; + + mp_layoutAreaToSurfaceIdAssignment->clear(); + + dumpScene(); + + return result; +} + +int WindowManager::setLayoutByName(const QString &layoutName) +{ + qDebug("-=[setLayoutByName]=-"); + int result = WINDOWMANAGER_NO_ERROR; + + QList::const_iterator i = m_layouts.begin(); + + while (i != m_layouts.constEnd()) + { + if (i->name == layoutName) + { + m_currentLayout = i->id; + + mp_layoutAreaToSurfaceIdAssignment->clear(); + + dumpScene(); + } + + ++i; + } + + return result; +} + +int WindowManager::setSurfaceToLayoutArea(int surfaceId, int layoutAreaId) +{ + qDebug("-=[setSurfaceToLayoutArea]=-"); + int result = WINDOWMANAGER_NO_ERROR; + + qDebug("surfaceId %d", surfaceId); + qDebug("layoutAreaId %d", layoutAreaId); + mp_layoutAreaToSurfaceIdAssignment->insert(layoutAreaId, surfaceId); + + updateScreen(); + + dumpScene(); + + return result; } -#endif