LayerManagerPlugins/Communicators/GenericCommunicator/src/GenericCommunicator.cpp

   1 /***************************************************************************
   2  * Copyright 2012 BMW Car IT GmbH
   3  * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
   4  *
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  ****************************************************************************/
  19
  20 #include "GenericCommunicator.h"
  21 #include "ilm_types.h"
  22 #include "Log.h"
  23 #include "Configuration.h"
  24
  25 #include "ICommandExecutor.h"
  26 #include "CommitCommand.h"
  27 #include "LayerCreateCommand.h"
  28 #include "LayergroupCreateCommand.h"
  29 #include "SurfaceCreateCommand.h"
  30 #include "SurfacegroupCreateCommand.h"
  31 #include "SurfaceGetDimensionCommand.h"
  32 #include "LayerGetDimensionCommand.h"
  33 #include "SurfaceGetOpacityCommand.h"
  34 #include "LayerGetOpacityCommand.h"
  35 #include "SurfaceGetPixelformatCommand.h"
  36 #include "LayerGetVisibilityCommand.h"
  37 #include "SurfaceGetVisibilityCommand.h"
  38 #include "LayerAddSurfaceCommand.h"
  39 #include "LayerRemoveSurfaceCommand.h"
  40 #include "LayerRemoveCommand.h"
  41 #include "SurfaceRemoveCommand.h"
  42 #include "LayergroupRemoveCommand.h"
  43 #include "SurfacegroupRemoveCommand.h"
  44 #include "SurfaceGetOrientationCommand.h"
  45 #include "LayerGetOrientationCommand.h"
  46 #include "LayergroupAddLayerCommand.h"
  47 #include "LayergroupRemoveLayerCommand.h"
  48 #include "LayerSetDestinationRectangleCommand.h"
  49 #include "SurfaceSetDestinationRectangleCommand.h"
  50 #include "LayerSetOpacityCommand.h"
  51 #include "LayergroupSetOpacityCommand.h"
  52 #include "SurfaceSetOpacityCommand.h"
  53 #include "SurfacegroupSetOpacityCommand.h"
  54 #include "LayerSetSourceRectangleCommand.h"
  55 #include "SurfaceSetSourceRectangleCommand.h"
  56 #include "LayerSetOrientationCommand.h"
  57 #include "SurfaceSetOrientationCommand.h"
  58 #include "SurfacegroupAddSurfaceCommand.h"
  59 #include "SurfacegroupRemoveSurfaceCommand.h"
  60 #include "LayerSetVisibilityCommand.h"
  61 #include "SurfaceSetVisibilityCommand.h"
  62 #include "LayergroupSetVisibilityCommand.h"
  63 #include "SurfacegroupSetVisibilityCommand.h"
  64 #include "DebugCommand.h"
  65 #include "ExitCommand.h"
  66 #include "ScreenSetRenderOrderCommand.h"
  67 #include "LayerSetRenderOrderCommand.h"
  68 #include "LayerSetDimensionCommand.h"
  69 #include "SurfaceSetDimensionCommand.h"
  70 #include "LayerSetPositionCommand.h"
  71 #include "SurfaceSetPositionCommand.h"
  72 #include "LayerGetPositionCommand.h"
  73 #include "SurfaceGetPositionCommand.h"
  74 #include "ShaderCreateCommand.h"
  75 #include "ShaderDestroyCommand.h"
  76 #include "SurfaceSetShaderCommand.h"
  77 #include "ShaderSetUniformsCommand.h"
  78 #include "ScreenDumpCommand.h"
  79 #include "LayerDumpCommand.h"
  80 #include "SurfaceDumpCommand.h"
  81 #include "SurfaceSetNativeContentCommand.h"
  82 #include "SurfaceRemoveNativeContentCommand.h"
  83 #include "SurfaceSetKeyboardFocusCommand.h"
  84 #include "SurfaceGetKeyboardFocusCommand.h"
  85 #include "SurfaceUpdateInputEventAcceptance.h"
  86 #include "SurfaceSetChromaKeyCommand.h"
  87 #include "LayerSetChromaKeyCommand.h"
  88 #include "SetOptimizationModeCommand.h"
  89 #include "GetOptimizationModeCommand.h"
  90 #include <stdbool.h>
  91 #include <unistd.h>
  92 #include <stdio.h>
  93 #include <string.h>
  94 #include <stdlib.h>
  95 #include <string>
  96 #include <pthread.h>
  97 #include <signal.h>
  98
  99 #define DEFAULT_SCREEN 0
 100
 101 const char* RESOURCE_ALREADY_INUSE = "Ressource already in use";
 102 const char* INVALID_ARGUMENT = "Invalid argument";
 103 const char* RESOURCE_NOT_FOUND = "Ressource not found";
 104 const char* NOT_IMPLEMENTED = "Feature not implemented";
 105
 106
 107 GenericCommunicator::GenericCommunicator(ICommandExecutor& executor, Configuration& config)
 108 : ICommunicator(&executor)
 109 , PluginBase(executor, config, Communicator_Api_v1)
 110 , m_running(ILM_FALSE)
 111 {
 112     MethodTable manager_methods[] =
 113     {
 114         { "ServiceConnect",                   &GenericCommunicator::ServiceConnect },
 115         { "ServiceDisconnect",                &GenericCommunicator::ServiceDisconnect },
 116         { "Debug",                            &GenericCommunicator::Debug },
 117         { "ScreenShot",                       &GenericCommunicator::ScreenShot },
 118         { "ScreenShotOfLayer",                &GenericCommunicator::ScreenShotOfLayer },
 119         { "ScreenShotOfSurface",              &GenericCommunicator::ScreenShotOfSurface },
 120         { "GetScreenResolution",              &GenericCommunicator::GetScreenResolution },
 121         { "GetNumberOfHardwareLayers",        &GenericCommunicator::GetNumberOfHardwareLayers },
 122         { "GetScreenIDs",                     &GenericCommunicator::GetScreenIDs },
 123         { "ListAllLayerIDS",                  &GenericCommunicator::ListAllLayerIDS },
 124         { "ListAllLayerIDsOnScreen",          &GenericCommunicator::ListAllLayerIDsOnScreen },
 125         { "ListAllSurfaceIDS",                &GenericCommunicator::ListAllSurfaceIDS },
 126         { "ListAllLayerGroupIDS",             &GenericCommunicator::ListAllLayerGroupIDS },
 127         { "ListAllSurfaceGroupIDS",           &GenericCommunicator::ListAllSurfaceGroupIDS },
 128         { "ListSurfacesOfSurfacegroup",       &GenericCommunicator::ListSurfacesOfSurfacegroup },
 129         { "ListLayersOfLayergroup",           &GenericCommunicator::ListLayersOfLayergroup },
 130         { "ListSurfaceofLayer",               &GenericCommunicator::ListSurfaceofLayer },
 131         { "GetPropertiesOfSurface",           &GenericCommunicator::GetPropertiesOfSurface },
 132         { "GetPropertiesOfLayer",             &GenericCommunicator::GetPropertiesOfLayer },
 133         { "CreateSurface",                    &GenericCommunicator::CreateSurface },
 134         { "CreateSurfaceFromId",              &GenericCommunicator::CreateSurfaceFromId },
 135         { "InitializeSurface",                &GenericCommunicator::InitializeSurface },
 136         { "InitializeSurfaceFromId",          &GenericCommunicator::InitializeSurfaceFromId },
 137         { "SetSurfaceNativeContent",          &GenericCommunicator::SetSurfaceNativeContent },
 138         { "RemoveSurfaceNativeContent",       &GenericCommunicator::RemoveSurfaceNativeContent },
 139         { "RemoveSurface",                    &GenericCommunicator::RemoveSurface },
 140         { "CreateLayer",                      &GenericCommunicator::CreateLayer },
 141         { "CreateLayerFromId",                &GenericCommunicator::CreateLayerFromId },
 142         { "CreateLayerWithDimension",         &GenericCommunicator::CreateLayerWithDimension },
 143         { "CreateLayerFromIdWithDimension",   &GenericCommunicator::CreateLayerFromIdWithDimension },
 144         { "RemoveLayer",                      &GenericCommunicator::RemoveLayer },
 145         { "AddSurfaceToSurfaceGroup",         &GenericCommunicator::AddSurfaceToSurfaceGroup },
 146         { "RemoveSurfaceFromSurfaceGroup",    &GenericCommunicator::RemoveSurfaceFromSurfaceGroup },
 147         { "AddLayerToLayerGroup",             &GenericCommunicator::AddLayerToLayerGroup },
 148         { "RemoveLayerFromLayerGroup",        &GenericCommunicator::RemoveLayerFromLayerGroup },
 149         { "AddSurfaceToLayer",                &GenericCommunicator::AddSurfaceToLayer },
 150         { "RemoveSurfaceFromLayer",           &GenericCommunicator::RemoveSurfaceFromLayer },
 151         { "CreateSurfaceGroup",               &GenericCommunicator::CreateSurfaceGroup },
 152         { "CreateSurfaceGroupFromId",         &GenericCommunicator::CreateSurfaceGroupFromId },
 153         { "RemoveSurfaceGroup",               &GenericCommunicator::RemoveSurfaceGroup },
 154         { "CreateLayerGroup",                 &GenericCommunicator::CreateLayerGroup },
 155         { "CreateLayerGroupFromId",           &GenericCommunicator::CreateLayerGroupFromId },
 156         { "RemoveLayerGroup",                 &GenericCommunicator::RemoveLayerGroup },
 157         { "SetSurfaceSourceRegion",           &GenericCommunicator::SetSurfaceSourceRegion },
 158         { "SetLayerSourceRegion",             &GenericCommunicator::SetLayerSourceRegion },
 159         { "SetSurfaceDestinationRegion",      &GenericCommunicator::SetSurfaceDestinationRegion },
 160         { "SetSurfacePosition",               &GenericCommunicator::SetSurfacePosition },
 161         { "GetSurfacePosition",               &GenericCommunicator::GetSurfacePosition },
 162         { "SetSurfaceDimension",              &GenericCommunicator::SetSurfaceDimension },
 163         { "SetLayerDestinationRegion",        &GenericCommunicator::SetLayerDestinationRegion },
 164         { "SetLayerPosition",                 &GenericCommunicator::SetLayerPosition },
 165         { "GetLayerPosition",                 &GenericCommunicator::GetLayerPosition },
 166         { "SetLayerDimension",                &GenericCommunicator::SetLayerDimension },
 167         { "GetLayerDimension",                &GenericCommunicator::GetLayerDimension },
 168         { "GetSurfaceDimension",              &GenericCommunicator::GetSurfaceDimension },
 169         { "SetSurfaceOpacity",                &GenericCommunicator::SetSurfaceOpacity },
 170         { "SetLayerOpacity",                  &GenericCommunicator::SetLayerOpacity },
 171         { "SetSurfacegroupOpacity",           &GenericCommunicator::SetSurfacegroupOpacity },
 172         { "SetLayergroupOpacity",             &GenericCommunicator::SetLayergroupOpacity },
 173         { "GetSurfaceOpacity",                &GenericCommunicator::GetSurfaceOpacity },
 174         { "GetLayerOpacity",                  &GenericCommunicator::GetLayerOpacity },
 175         { "SetSurfaceOrientation",            &GenericCommunicator::SetSurfaceOrientation },
 176         { "GetSurfaceOrientation",            &GenericCommunicator::GetSurfaceOrientation },
 177         { "SetLayerOrientation",              &GenericCommunicator::SetLayerOrientation },
 178         { "GetLayerOrientation",              &GenericCommunicator::GetLayerOrientation },
 179         { "GetSurfacePixelformat",            &GenericCommunicator::GetSurfacePixelformat },
 180         { "SetSurfaceVisibility",             &GenericCommunicator::SetSurfaceVisibility },
 181         { "SetLayerVisibility",               &GenericCommunicator::SetLayerVisibility },
 182         { "GetSurfaceVisibility",             &GenericCommunicator::GetSurfaceVisibility },
 183         { "GetLayerVisibility",               &GenericCommunicator::GetLayerVisibility },
 184         { "SetSurfacegroupVisibility",        &GenericCommunicator::SetSurfacegroupVisibility },
 185         { "SetLayergroupVisibility",          &GenericCommunicator::SetLayergroupVisibility },
 186         { "SetRenderOrderOfLayers",           &GenericCommunicator::SetRenderOrderOfLayers },
 187         { "SetSurfaceRenderOrderWithinLayer", &GenericCommunicator::SetSurfaceRenderOrderWithinLayer },
 188         { "GetLayerType",                     &GenericCommunicator::GetLayerType },
 189         { "GetLayertypeCapabilities",         &GenericCommunicator::GetLayertypeCapabilities },
 190         { "GetLayerCapabilities",             &GenericCommunicator::GetLayerCapabilities },
 191         { "Exit",                             &GenericCommunicator::Exit },
 192         { "CommitChanges",                    &GenericCommunicator::CommitChanges },
 193         { "CreateShader",                     &GenericCommunicator::CreateShader },
 194         { "DestroyShader",                    &GenericCommunicator::DestroyShader },
 195         { "SetShader",                        &GenericCommunicator::SetShader },
 196         { "SetUniforms",                      &GenericCommunicator::SetUniforms },
 197         { "SetKeyboardFocusOn",               &GenericCommunicator::SetKeyboardFocusOn },
 198         { "GetKeyboardFocusSurfaceId",        &GenericCommunicator::GetKeyboardFocusSurfaceId },
 199         { "UpdateInputEventAcceptanceOn",     &GenericCommunicator::UpdateInputEventAcceptanceOn },
 200         { "SetSurfaceChromaKey",              &GenericCommunicator::SetSurfaceChromaKey },
 201         { "SetLayerChromaKey",                &GenericCommunicator::SetLayerChromaKey },
 202         { "LayerAddNotification",             &GenericCommunicator::LayerAddNotification },
 203         { "SurfaceAddNotification",           &GenericCommunicator::SurfaceAddNotification },
 204         { "LayerRemoveNotification",          &GenericCommunicator::LayerRemoveNotification },
 205         { "SurfaceRemoveNotification",        &GenericCommunicator::SurfaceRemoveNotification },
 206         { "SetOptimizationMode",              &GenericCommunicator::SetOptimizationMode },
 207         { "GetOptimizationMode",              &GenericCommunicator::GetOptimizationMode }
 208     };
 209
 210     int entryCount = sizeof(manager_methods) / sizeof(MethodTable);
 211
 212     for (int index = 0; index < entryCount; ++index)
 213     {
 214         MethodTable* method = &manager_methods[index];
 215         if (method->function)
 216         {
 217             m_callBackTable[method->name] = *method;
 218             LOG_DEBUG("GenericCommunicator", "registered callback for " << method->name);
 219         }
 220     }
 221
 222     memset(&m_ipcModule, 0, sizeof(m_ipcModule));
 223
 224     mThreadId = pthread_self();
 225 }
 226
 227 bool GenericCommunicator::start()
 228 {
 229     LOG_DEBUG("GenericCommunicator", "Starting up IpcModules.");
 230
 231     if (!loadIpcModule(&m_ipcModule))
 232     {
 233         LOG_ERROR("GenericCommunicator", "Loading IpcModule failed.");
 234         return ILM_FALSE;
 235     }
 236     LOG_DEBUG("GenericCommunicator", "Loading IpcModule success.");
 237
 238     if (!m_ipcModule.initServiceMode())
 239     {
 240         LOG_ERROR("GenericCommunicator", "Initializing IpcModule failed.");
 241         return ILM_FALSE;
 242     }
 243     LOG_DEBUG("GenericCommunicator", "Initializing IpcModule success.");
 244
 245     m_running = ILM_TRUE;
 246     pluginSetHealth(HealthRunning);
 247
 248     threadCreate();
 249     threadInit();
 250     threadStart();
 251
 252     return ILM_TRUE;
 253 }
 254
 255 void GenericCommunicator::stop()
 256 {
 257     LOG_INFO("GenericCommunicator","stopping");
 258
 259     threadStop();
 260
 261     if (m_running)
 262     {
 263         m_ipcModule.destroy();
 264     }
 265     pluginSetHealth(HealthStopped);
 266 }
 267
 268 void GenericCommunicator::process(int timeout_ms)
 269 {
 270     t_ilm_message message = m_ipcModule.receive(timeout_ms);
 271     if (!message)
 272     {
 273         return;
 274     }
 275
 276     t_ilm_message_type messageType = m_ipcModule.getMessageType(message);
 277     t_ilm_const_string name = m_ipcModule.getMessageName(message);
 278     t_ilm_client_handle senderHandle = m_ipcModule.getSenderHandle(message);
 279
 280     switch(messageType)
 281     {
 282     case IpcMessageTypeCommand:
 283         if (m_callBackTable.end() != m_callBackTable.find(name))
 284         {
 285             LOG_DEBUG("GenericCommunicator", "received: " << name << " from "
 286                        << m_executor->getSenderName(senderHandle)
 287                        << "(" << m_executor->getSenderPid(senderHandle) << ")");
 288             CallBackMethod method = m_callBackTable[name].function;
 289             (this->*method)(message);
 290         }
 291         else
 292         {
 293             LOG_WARNING("GenericCommunicator", "Received unknown command " << name
 294                   << " from " << m_executor->getSenderName(senderHandle)
 295                   << "(pid " << m_executor->getSenderPid(senderHandle) << ")");
 296         }
 297         processNotificationQueue();
 298         break;
 299
 300     case IpcMessageTypeConnect:
 301         LOG_DEBUG("GenericCommunicator", "client " << m_executor->getSenderName(senderHandle)
 302                   << "(pid " << m_executor->getSenderPid(senderHandle) << ") connected");
 303         break;
 304
 305     case IpcMessageTypeDisconnect:
 306         LOG_DEBUG("GenericCommunicator", "client " << m_executor->getSenderName(senderHandle)
 307                   << "(pid " << m_executor->getSenderPid(senderHandle) << ") disconnected");
 308         {
 309             const LayerMap& layers = m_executor->getScene()->getAllLayers();
 310             LayerMapConstIterator layerIter =  layers.begin();
 311             LayerMapConstIterator layerIterEnd = layers.end();
 312             for (; layerIter != layerIterEnd; ++layerIter)
 313             {
 314                 Layer* layer = layerIter->second;
 315                 layer->removeNotification(senderHandle);
 316             }
 317
 318             const SurfaceMap& surfaces = m_executor->getScene()->getAllSurfaces();
 319             SurfaceMapConstIterator surfaceIter =  surfaces.begin();
 320             SurfaceMapConstIterator surfaceIterEnd = surfaces.end();
 321             for (; surfaceIter != surfaceIterEnd; ++surfaceIter)
 322             {
 323                 Surface* surface = surfaceIter->second;
 324                 surface->removeNotification(senderHandle);
 325             }
 326         }
 327         break;
 328
 329     case IpcMessageTypeError:
 330         LOG_DEBUG("GenericCommunicator", "Received error message " << name << " from "
 331                   << m_executor->getSenderName(senderHandle)
 332                   << "(pid " << m_executor->getSenderPid(senderHandle) << ")");
 333         break;
 334
 335     case IpcMessageTypeShutdown:
 336     case IpcMessageTypeNone:
 337         break;
 338
 339     default:
 340         LOG_DEBUG("GenericCommunicator", "Received unknown data from "
 341                   << m_executor->getSenderName(senderHandle)
 342                   << "(pid " << m_executor->getSenderPid(senderHandle) << "), Message type: " << messageType);
 343         break;
 344     }
 345     m_ipcModule.destroyMessage(message);
 346 }
 347
 348 void GenericCommunicator::setdebug(bool onoff)
 349 {
 350     (void)onoff; // TODO: remove, only prevents warning
 351 }
 352
 353 t_ilm_bool GenericCommunicator::threadMainLoop()
 354 {
 355     process(-1);
 356     return ILM_TRUE;
 357 }
 358
 359 t_ilm_const_string GenericCommunicator::pluginGetName() const
 360 {
 361     return "GenericCommunicator";
 362 }
 363
 364 void GenericCommunicator::ServiceConnect(t_ilm_message message)
 365 {
 366     t_ilm_message response;
 367     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 368
 369     unsigned int processId = 0;
 370     char processName[1024];
 371     m_ipcModule.getUint(message, &processId);
 372     m_ipcModule.getString(message, processName);
 373
 374     m_executor->addApplicationReference(clientHandle, new IApplicationReference(processName, processId));
 375
 376     LOG_DEBUG("GenericCommunicator", "ServiceConnect called from "
 377               << m_executor->getSenderName(clientHandle)
 378               << "(" << m_executor->getSenderPid(clientHandle) << ")");
 379
 380     response = m_ipcModule.createResponse(message);
 381     m_ipcModule.sendToClients(response, &clientHandle, 1);
 382     m_ipcModule.destroyMessage(response);
 383 }
 384
 385 void GenericCommunicator::ServiceDisconnect(t_ilm_message message)
 386 {
 387     t_ilm_message response;
 388     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 389
 390     LOG_DEBUG("GenericCommunicator", "ServiceDisconnect called from "
 391               << m_executor->getSenderName(clientHandle)
 392               << "(" << m_executor->getSenderPid(clientHandle) << ")");
 393
 394     m_executor->removeApplicationReference(clientHandle);
 395
 396     response = m_ipcModule.createResponse(message);
 397     m_ipcModule.sendToClients(response, &clientHandle, 1);
 398     m_ipcModule.destroyMessage(response);
 399 }
 400
 401 void GenericCommunicator::Debug(t_ilm_message message)
 402 {
 403     t_ilm_message response;
 404     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 405     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 406     t_ilm_bool param = ILM_FALSE;
 407     m_ipcModule.getBool(message, &param);
 408
 409     t_ilm_bool status = m_executor->execute(new DebugCommand(clientPid, param));
 410     if (status)
 411     {
 412         response = m_ipcModule.createResponse(message);
 413     }
 414     else
 415     {
 416         response = m_ipcModule.createErrorResponse(message);
 417         m_ipcModule.appendString(response, INVALID_ARGUMENT);
 418     }
 419
 420     m_ipcModule.sendToClients(response, &clientHandle, 1);
 421     m_ipcModule.destroyMessage(response);
 422 }
 423
 424 void GenericCommunicator::GetScreenResolution(t_ilm_message message)
 425 {
 426     t_ilm_message response;
 427     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 428     uint screenid = 0;
 429     m_ipcModule.getUint(message, &screenid);
 430     uint* resolution = m_executor->getScreenResolution(screenid);
 431
 432     response = m_ipcModule.createResponse(message);
 433     m_ipcModule.appendUint(response, resolution[0]);
 434     m_ipcModule.appendUint(response, resolution[1]);
 435     m_ipcModule.sendToClients(response, &clientHandle, 1);
 436     m_ipcModule.destroyMessage(response);
 437 }
 438
 439 void GenericCommunicator::GetNumberOfHardwareLayers(t_ilm_message message)
 440 {
 441     t_ilm_message response;
 442     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 443     uint screenid = 0;
 444     m_ipcModule.getUint(message, &screenid);
 445     uint numberOfHardwareLayers = m_executor->getNumberOfHardwareLayers(screenid);
 446     response = m_ipcModule.createResponse(message);
 447     m_ipcModule.appendUint(response, numberOfHardwareLayers);
 448     m_ipcModule.sendToClients(response, &clientHandle, 1);
 449     m_ipcModule.destroyMessage(response);
 450 }
 451
 452 void GenericCommunicator::GetScreenIDs(t_ilm_message message)
 453 {
 454     t_ilm_message response;
 455     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 456     uint length = 0;
 457     uint* IDs = m_executor->getScreenIDs(&length);
 458     response = m_ipcModule.createResponse(message);
 459     m_ipcModule.appendUintArray(response, IDs, length);
 460     m_ipcModule.sendToClients(response, &clientHandle, 1);
 461     m_ipcModule.destroyMessage(response);
 462 }
 463
 464 void GenericCommunicator::ScreenShot(t_ilm_message message)
 465 {
 466     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 467     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 468     t_ilm_message response;
 469     uint screenid = 0;
 470     char filename[1024];
 471
 472     m_ipcModule.getUint(message, &screenid);
 473     m_ipcModule.getString(message, filename);
 474
 475     t_ilm_bool status = m_executor->execute(new ScreenDumpCommand(clientPid, filename, screenid));
 476     if (status)
 477     {
 478         response = m_ipcModule.createResponse(message);
 479     }
 480     else
 481     {
 482         response = m_ipcModule.createErrorResponse(message);
 483         m_ipcModule.appendString(response, INVALID_ARGUMENT);
 484     }
 485
 486     m_ipcModule.sendToClients(response, &clientHandle, 1);
 487     m_ipcModule.destroyMessage(response);
 488 }
 489
 490 void GenericCommunicator::ScreenShotOfLayer(t_ilm_message message)
 491 {
 492     t_ilm_message response;
 493     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 494     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 495     char filename[1024];
 496     m_ipcModule.getString(message, filename);
 497     uint layerid = 0;
 498     m_ipcModule.getUint(message, &layerid);
 499
 500     t_ilm_bool status = m_executor->execute(new LayerDumpCommand(clientPid, filename, layerid));
 501     if (status)
 502     {
 503         response = m_ipcModule.createResponse(message);
 504     }
 505     else
 506     {
 507         response = m_ipcModule.createErrorResponse(message);
 508         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
 509     }
 510
 511     m_ipcModule.sendToClients(response, &clientHandle, 1);
 512     m_ipcModule.destroyMessage(response);
 513 }
 514
 515 void GenericCommunicator::ScreenShotOfSurface(t_ilm_message message)
 516 {
 517     t_ilm_message response;
 518     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 519     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 520     char filename[1024];
 521     m_ipcModule.getString(message, filename);
 522     uint id = 0;
 523     m_ipcModule.getUint(message, &id);
 524     t_ilm_bool status = m_executor->execute(new SurfaceDumpCommand(clientPid, filename, id));
 525     if (status)
 526     {
 527         response = m_ipcModule.createResponse(message);
 528     }
 529     else
 530     {
 531         response = m_ipcModule.createErrorResponse(message);
 532         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
 533     }
 534
 535     m_ipcModule.sendToClients(response, &clientHandle, 1);
 536     m_ipcModule.destroyMessage(response);
 537 }
 538
 539 void GenericCommunicator::ListAllLayerIDS(t_ilm_message message)
 540 {
 541     t_ilm_message response;
 542     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 543     uint* array = NULL;
 544     uint length = 0;
 545     m_executor->getScene()->lockScene();
 546     m_executor->getScene()->getLayerIDs(&length, &array);
 547     m_executor->getScene()->unlockScene();
 548     response = m_ipcModule.createResponse(message);
 549     m_ipcModule.appendUintArray(response, array, length);
 550     m_ipcModule.sendToClients(response, &clientHandle, 1);
 551     m_ipcModule.destroyMessage(response);
 552 }
 553
 554 void GenericCommunicator::ListAllLayerIDsOnScreen(t_ilm_message message)
 555 {
 556     t_ilm_message response;
 557     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 558     uint screenID = 0;
 559     m_ipcModule.getUint(message, &screenID);
 560
 561     uint* array = NULL;
 562     uint length = 0;
 563     m_executor->getScene()->lockScene();
 564     t_ilm_bool status = m_executor->getScene()->getLayerIDsOfScreen(screenID, &length, &array);
 565     m_executor->getScene()->unlockScene();
 566     if (status)
 567     {
 568         response = m_ipcModule.createResponse(message);
 569         m_ipcModule.appendUintArray(response, array, length);
 570     }
 571     else
 572     {
 573         response = m_ipcModule.createErrorResponse(message);
 574         m_ipcModule.appendString(response, INVALID_ARGUMENT);
 575     }
 576
 577     m_ipcModule.sendToClients(response, &clientHandle, 1);
 578     m_ipcModule.destroyMessage(response);
 579 }
 580
 581 void GenericCommunicator::ListAllSurfaceIDS(t_ilm_message message)
 582 {
 583     t_ilm_message response;
 584     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 585     uint* array = NULL;
 586     uint length = 0;
 587     m_executor->getScene()->lockScene();
 588     m_executor->getScene()->getSurfaceIDs(&length, &array);
 589     m_executor->getScene()->unlockScene();
 590     response = m_ipcModule.createResponse(message);
 591     m_ipcModule.appendUintArray(response, array, length);
 592     m_ipcModule.sendToClients(response, &clientHandle, 1);
 593     m_ipcModule.destroyMessage(response);
 594 }
 595
 596 void GenericCommunicator::ListAllLayerGroupIDS(t_ilm_message message)
 597 {
 598     t_ilm_message response;
 599     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 600     uint* array = NULL;
 601     uint length = 0;
 602     m_executor->getScene()->lockScene();
 603     m_executor->getScene()->getLayerGroupIDs(&length, &array);
 604     m_executor->getScene()->unlockScene();
 605     response = m_ipcModule.createResponse(message);
 606     m_ipcModule.appendUintArray(response, array, length);
 607     m_ipcModule.sendToClients(response, &clientHandle, 1);
 608     m_ipcModule.destroyMessage(response);
 609 }
 610
 611 void GenericCommunicator::ListAllSurfaceGroupIDS(t_ilm_message message)
 612 {
 613     t_ilm_message response;
 614     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 615     uint* array = NULL;
 616     uint length = 0;
 617     m_executor->getScene()->lockScene();
 618     m_executor->getScene()->getSurfaceGroupIDs(&length, &array);
 619     m_executor->getScene()->unlockScene();
 620     response = m_ipcModule.createResponse(message);
 621     m_ipcModule.appendUintArray(response, array, length);
 622     m_ipcModule.sendToClients(response, &clientHandle, 1);
 623     m_ipcModule.destroyMessage(response);
 624 }
 625
 626 void GenericCommunicator::ListSurfacesOfSurfacegroup(t_ilm_message message)
 627 {
 628     t_ilm_message response;
 629     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 630     uint id = 0;
 631     m_ipcModule.getUint(message, &id);
 632     m_executor->getScene()->lockScene();
 633     SurfaceGroup* sg = m_executor->getScene()->getSurfaceGroup(id);
 634     if (NULL != sg)
 635     {
 636         std::list<Surface*> surfaces = sg->getList();
 637         uint length = surfaces.size();
 638         uint* array = new uint[length];
 639         uint arrayPos = 0;
 640
 641         for (std::list<Surface*>::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it)
 642         {
 643             Surface* s = *it;
 644             array[arrayPos] = s->getID();
 645             ++arrayPos;
 646         }
 647         m_executor->getScene()->unlockScene();
 648
 649         response = m_ipcModule.createResponse(message);
 650         m_ipcModule.appendUintArray(response, array, length);
 651     }
 652     else
 653     {
 654         m_executor->getScene()->unlockScene();
 655         response = m_ipcModule.createErrorResponse(message);
 656         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
 657     }
 658
 659     m_ipcModule.sendToClients(response, &clientHandle, 1);
 660     m_ipcModule.destroyMessage(response);
 661 }
 662
 663 void GenericCommunicator::ListLayersOfLayergroup(t_ilm_message message)
 664 {
 665     t_ilm_message response;
 666     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 667     uint id = 0;
 668     m_ipcModule.getUint(message, &id);
 669     m_executor->getScene()->lockScene();
 670     LayerGroup* sg = m_executor->getScene()->getLayerGroup(id);
 671     if (NULL != sg)
 672     {
 673         std::list<Layer*> layers = sg->getList();
 674
 675         uint length = layers.size();
 676         uint* array = new uint[length];
 677         uint arrayPos = 0;
 678
 679         for (std::list<Layer*>::const_iterator it = layers.begin(); it != layers.end(); ++it)
 680         {
 681             Layer* l = *it;
 682             array[arrayPos] = l->getID();
 683             ++arrayPos;
 684         }
 685         m_executor->getScene()->unlockScene();
 686
 687         response = m_ipcModule.createResponse(message);
 688         m_ipcModule.appendUintArray(response, array, length);
 689     }
 690     else
 691     {
 692         m_executor->getScene()->unlockScene();
 693         response = m_ipcModule.createErrorResponse(message);
 694         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
 695     }
 696
 697     m_ipcModule.sendToClients(response, &clientHandle, 1);
 698     m_ipcModule.destroyMessage(response);
 699 }
 700
 701 void GenericCommunicator::ListSurfaceofLayer(t_ilm_message message)
 702 {
 703     t_ilm_message response;
 704     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 705     uint id = 0;
 706     m_ipcModule.getUint(message, &id);
 707     m_executor->getScene()->lockScene();
 708     Layer* layer = m_executor->getScene()->getLayer(id);
 709     if (layer != NULL)
 710     {
 711         std::list<Surface*> surfaces = layer->getAllSurfaces();
 712
 713         uint length = surfaces.size();
 714         uint* array = new uint[length];
 715         uint arrayPos = 0;
 716
 717         for (std::list<Surface*>::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it)
 718         {
 719             Surface* s = *it;
 720             array[arrayPos] = s->getID();
 721             ++arrayPos;
 722         }
 723         m_executor->getScene()->unlockScene();
 724
 725         response = m_ipcModule.createResponse(message);
 726         m_ipcModule.appendUintArray(response, array, length);
 727     }
 728     else
 729     {
 730         m_executor->getScene()->unlockScene();
 731         response = m_ipcModule.createErrorResponse(message);
 732         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
 733     }
 734
 735     m_ipcModule.sendToClients(response, &clientHandle, 1);
 736     m_ipcModule.destroyMessage(response);
 737 }
 738
 739 void GenericCommunicator::GetPropertiesOfSurface(t_ilm_message message)
 740 {
 741     t_ilm_message response;
 742     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 743     uint id = 0;
 744     m_ipcModule.getUint(message, &id);
 745
 746     Surface* surface = m_executor->getScene()->getSurface(id);
 747     if (surface != NULL)
 748     {
 749         Rectangle dest = surface->getDestinationRegion();
 750         Rectangle src = surface->getSourceRegion();
 751         OrientationType orientation = surface->getOrientation();
 752         unsigned char chromaKeyRed = 0;
 753         unsigned char chromaKeyGreen = 0;
 754         unsigned char chromaKeyBlue = 0;
 755         surface->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
 756
 757         response = m_ipcModule.createResponse(message);
 758         m_ipcModule.appendDouble(response, surface->getOpacity());
 759         m_ipcModule.appendUint(response, src.x);
 760         m_ipcModule.appendUint(response, src.y);
 761         m_ipcModule.appendUint(response, src.width);
 762         m_ipcModule.appendUint(response, src.height);
 763         m_ipcModule.appendUint(response, surface->OriginalSourceWidth);
 764         m_ipcModule.appendUint(response, surface->OriginalSourceHeight);
 765         m_ipcModule.appendUint(response, dest.x);
 766         m_ipcModule.appendUint(response, dest.y);
 767         m_ipcModule.appendUint(response, dest.width);
 768         m_ipcModule.appendUint(response, dest.height);
 769         m_ipcModule.appendUint(response, orientation);
 770         m_ipcModule.appendBool(response, surface->getVisibility());
 771         m_ipcModule.appendUint(response, surface->frameCounter);
 772         m_ipcModule.appendUint(response, surface->drawCounter);
 773         m_ipcModule.appendUint(response, surface->updateCounter);
 774         m_ipcModule.appendUint(response, surface->getPixelFormat());
 775         m_ipcModule.appendUint(response, surface->getNativeContent());
 776         m_ipcModule.appendUint(response, surface->getInputEventAcceptanceOnDevices());
 777         m_ipcModule.appendBool(response, surface->getChromaKeyEnabled());
 778         m_ipcModule.appendUint(response, chromaKeyRed);
 779         m_ipcModule.appendUint(response, chromaKeyGreen);
 780         m_ipcModule.appendUint(response, chromaKeyBlue);
 781         m_ipcModule.appendInt(response, surface->getCreatorPid());
 782     }
 783     else
 784     {
 785         response = m_ipcModule.createErrorResponse(message);
 786         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
 787     }
 788
 789     m_ipcModule.sendToClients(response, &clientHandle, 1);
 790     m_ipcModule.destroyMessage(response);
 791 }
 792
 793 void GenericCommunicator::GetPropertiesOfLayer(t_ilm_message message)
 794 {
 795     t_ilm_message response;
 796     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 797     uint id = 0;
 798     m_ipcModule.getUint(message, &id);
 799
 800     Layer* layer = m_executor->getScene()->getLayer(id);
 801     if (layer != NULL)
 802     {
 803         Rectangle dest = layer->getDestinationRegion();
 804         Rectangle src = layer->getSourceRegion();
 805         OrientationType orientation = layer->getOrientation();
 806         unsigned char chromaKeyRed = 0;
 807         unsigned char chromaKeyGreen = 0;
 808         unsigned char chromaKeyBlue = 0;
 809         layer->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
 810
 811         response = m_ipcModule.createResponse(message);
 812         m_ipcModule.appendDouble(response, layer->getOpacity());
 813         m_ipcModule.appendUint(response, src.x);
 814         m_ipcModule.appendUint(response, src.y);
 815         m_ipcModule.appendUint(response, src.width);
 816         m_ipcModule.appendUint(response, src.height);
 817         m_ipcModule.appendUint(response, layer->OriginalSourceWidth);
 818         m_ipcModule.appendUint(response, layer->OriginalSourceHeight);
 819         m_ipcModule.appendUint(response, dest.x);
 820         m_ipcModule.appendUint(response, dest.y);
 821         m_ipcModule.appendUint(response, dest.width);
 822         m_ipcModule.appendUint(response, dest.height);
 823         m_ipcModule.appendUint(response, orientation);
 824         m_ipcModule.appendBool(response, layer->getVisibility());
 825         m_ipcModule.appendUint(response, layer->getLayerType());
 826         m_ipcModule.appendBool(response, layer->getChromaKeyEnabled());
 827         m_ipcModule.appendUint(response, chromaKeyRed);
 828         m_ipcModule.appendUint(response, chromaKeyGreen);
 829         m_ipcModule.appendUint(response, chromaKeyBlue);
 830         m_ipcModule.appendInt(response, layer->getCreatorPid());
 831     }
 832     else
 833     {
 834         response = m_ipcModule.createErrorResponse(message);
 835         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
 836     }
 837
 838     m_ipcModule.sendToClients(response, &clientHandle, 1);
 839     m_ipcModule.destroyMessage(response);
 840 }
 841
 842 void GenericCommunicator::CreateSurface(t_ilm_message message)
 843 {
 844     t_ilm_message response;
 845     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 846     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 847     uint handle = 0;
 848     uint width = 0;
 849     uint height = 0;
 850     uint pixelformat = 0;
 851     PixelFormat pf = PIXELFORMAT_UNKNOWN;
 852     uint id = GraphicalObject::INVALID_ID;
 853
 854     m_ipcModule.getUint(message, &handle);
 855     m_ipcModule.getUint(message, &width);
 856     m_ipcModule.getUint(message, &height);
 857     m_ipcModule.getUint(message, &pixelformat);
 858
 859     pf = (PixelFormat) pixelformat;
 860
 861
 862     // First of all create the surface
 863     t_ilm_bool status = m_executor->execute(new SurfaceCreateCommand(clientPid, &id));
 864
 865     // after that apply the native content
 866     status &= m_executor->execute(new SurfaceSetNativeContentCommand(clientPid, id, handle, pf, width, height));
 867
 868     if (status)
 869     {
 870         response = m_ipcModule.createResponse(message);
 871         m_ipcModule.appendUint(response, id);
 872     }
 873     else
 874     {
 875         response = m_ipcModule.createErrorResponse(message);
 876         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
 877     }
 878
 879     m_ipcModule.sendToClients(response, &clientHandle, 1);
 880     m_ipcModule.destroyMessage(response);
 881 }
 882
 883 void GenericCommunicator::CreateSurfaceFromId(t_ilm_message message)
 884 {
 885     t_ilm_message response;
 886     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 887     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 888     uint handle = 0;
 889     uint width = 0;
 890     uint height = 0;
 891     uint pixelformat = 0;
 892     PixelFormat pf = PIXELFORMAT_UNKNOWN;
 893     uint id = 0;
 894
 895     m_ipcModule.getUint(message, &handle);
 896     m_ipcModule.getUint(message, &width);
 897     m_ipcModule.getUint(message, &height);
 898     m_ipcModule.getUint(message, &pixelformat);
 899     m_ipcModule.getUint(message, &id);
 900
 901     pf = (PixelFormat) pixelformat;
 902
 903     // First of all create the surface
 904     t_ilm_bool status = m_executor->execute(new SurfaceCreateCommand(clientPid, &id));
 905
 906     // after that apply the native content
 907     status &= m_executor->execute(new SurfaceSetNativeContentCommand(clientPid, id, handle, pf, width, height));
 908
 909     if (status)
 910     {
 911         response = m_ipcModule.createResponse(message);
 912         m_ipcModule.appendUint(response, id);
 913     }
 914     else
 915     {
 916         response = m_ipcModule.createErrorResponse(message);
 917         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
 918     }
 919
 920     m_ipcModule.sendToClients(response, &clientHandle, 1);
 921     m_ipcModule.destroyMessage(response);
 922 }
 923
 924 void GenericCommunicator::InitializeSurface(t_ilm_message message)
 925 {
 926     t_ilm_message response;
 927     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 928     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 929     uint id = GraphicalObject::INVALID_ID;
 930
 931     t_ilm_bool status = m_executor->execute(new SurfaceCreateCommand(clientPid, &id));
 932     if (status)
 933     {
 934         response = m_ipcModule.createResponse(message);
 935         m_ipcModule.appendUint(response, id);
 936     }
 937     else
 938     {
 939         response = m_ipcModule.createErrorResponse(message);
 940         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
 941     }
 942
 943     m_ipcModule.sendToClients(response, &clientHandle, 1);
 944     m_ipcModule.destroyMessage(response);
 945 }
 946
 947 void GenericCommunicator::InitializeSurfaceFromId(t_ilm_message message)
 948 {
 949     t_ilm_message response;
 950     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 951     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 952     uint id = 0;
 953     m_ipcModule.getUint(message, &id);
 954     t_ilm_bool status = m_executor->execute(new SurfaceCreateCommand(clientPid, &id));
 955     if (status)
 956     {
 957         response = m_ipcModule.createResponse(message);
 958         m_ipcModule.appendUint(response, id);
 959     }
 960     else
 961     {
 962         response = m_ipcModule.createErrorResponse(message);
 963         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
 964     }
 965
 966     m_ipcModule.sendToClients(response, &clientHandle, 1);
 967     m_ipcModule.destroyMessage(response);
 968 }
 969
 970 void GenericCommunicator::SetSurfaceNativeContent(t_ilm_message message)
 971 {
 972     t_ilm_message response;
 973     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
 974     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
 975     uint id = 0;
 976     uint handle = 0;
 977     uint width = 0;
 978     uint height = 0;
 979     uint pixelformat = 0;
 980     PixelFormat pf = PIXELFORMAT_UNKNOWN;
 981
 982     m_ipcModule.getUint(message, &id);
 983     m_ipcModule.getUint(message, &handle);
 984     m_ipcModule.getUint(message, &width);
 985     m_ipcModule.getUint(message, &height);
 986     m_ipcModule.getUint(message, &pixelformat);
 987
 988     pf = (PixelFormat) pixelformat;
 989
 990     t_ilm_bool status = m_executor->execute(new SurfaceSetNativeContentCommand(clientPid, id, handle, pf, width, height));
 991     if (status)
 992     {
 993         response = m_ipcModule.createResponse(message);
 994     }
 995     else
 996     {
 997         response = m_ipcModule.createErrorResponse(message);
 998         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
 999     }
1000
1001     m_ipcModule.sendToClients(response, &clientHandle, 1);
1002     m_ipcModule.destroyMessage(response);
1003 }
1004
1005 void GenericCommunicator::RemoveSurfaceNativeContent(t_ilm_message message)
1006 {
1007     t_ilm_message response;
1008     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1009     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1010     uint id = 0;
1011     m_ipcModule.getUint(message, &id);
1012
1013     t_ilm_bool status = m_executor->execute(new SurfaceRemoveNativeContentCommand(clientPid, id));
1014     if (status)
1015     {
1016         response = m_ipcModule.createResponse(message);
1017     }
1018     else
1019     {
1020         response = m_ipcModule.createErrorResponse(message);
1021         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1022     }
1023
1024     m_ipcModule.sendToClients(response, &clientHandle, 1);
1025     m_ipcModule.destroyMessage(response);
1026 }
1027
1028 void GenericCommunicator::RemoveSurface(t_ilm_message message)
1029 {
1030     t_ilm_message response;
1031     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1032     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1033     uint param = 0;
1034     m_ipcModule.getUint(message, &param);
1035     t_ilm_bool status = m_executor->execute(new SurfaceRemoveCommand(clientPid, param));
1036     if (status)
1037     {
1038         response = m_ipcModule.createResponse(message);
1039     }
1040     else
1041     {
1042         response = m_ipcModule.createErrorResponse(message);
1043         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1044     }
1045
1046     m_ipcModule.sendToClients(response, &clientHandle, 1);
1047     m_ipcModule.destroyMessage(response);
1048 }
1049
1050 void GenericCommunicator::CreateLayer(t_ilm_message message)
1051 {
1052     t_ilm_message response;
1053     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1054     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1055     uint id = GraphicalObject::INVALID_ID;
1056     // use resolution of default screen as default width and height of layers
1057     uint* resolution = m_executor->getScreenResolution(DEFAULT_SCREEN);
1058     t_ilm_bool status = m_executor->execute(new LayerCreateCommand(clientPid, resolution[0], resolution[1], &id));
1059     if (status)
1060     {
1061         response = m_ipcModule.createResponse(message);
1062         m_ipcModule.appendUint(response, id);
1063     }
1064     else
1065     {
1066         response = m_ipcModule.createErrorResponse(message);
1067         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1068     }
1069
1070     m_ipcModule.sendToClients(response, &clientHandle, 1);
1071     m_ipcModule.destroyMessage(response);
1072 }
1073
1074 void GenericCommunicator::CreateLayerFromId(t_ilm_message message)
1075 {
1076     t_ilm_message response;
1077     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1078     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1079     uint id = GraphicalObject::INVALID_ID;
1080
1081     m_ipcModule.getUint(message, &id);
1082     // use resolution of default screen as default width and height of layers
1083     uint* resolution = m_executor->getScreenResolution(DEFAULT_SCREEN);
1084     t_ilm_bool status = m_executor->execute(new LayerCreateCommand(clientPid, resolution[0], resolution[1], &id));
1085     if (status)
1086     {
1087         response = m_ipcModule.createResponse(message);
1088         m_ipcModule.appendUint(response, id);
1089     }
1090     else
1091     {
1092         response = m_ipcModule.createErrorResponse(message);
1093         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1094     }
1095
1096     m_ipcModule.sendToClients(response, &clientHandle, 1);
1097     m_ipcModule.destroyMessage(response);
1098 }
1099
1100
1101 void GenericCommunicator::CreateLayerWithDimension(t_ilm_message message)
1102 {
1103     t_ilm_message response;
1104     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1105     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1106     uint width = 0;
1107     m_ipcModule.getUint(message, &width);
1108     uint height = 0;
1109     m_ipcModule.getUint(message, &height);
1110
1111     uint id = GraphicalObject::INVALID_ID;
1112     t_ilm_bool status = m_executor->execute(new LayerCreateCommand(clientPid, width, height, &id));
1113     if (status)
1114     {
1115         response = m_ipcModule.createResponse(message);
1116         m_ipcModule.appendUint(response, id);
1117     }
1118     else
1119     {
1120         response = m_ipcModule.createErrorResponse(message);
1121         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1122     }
1123
1124     m_ipcModule.sendToClients(response, &clientHandle, 1);
1125     m_ipcModule.destroyMessage(response);
1126 }
1127
1128 void GenericCommunicator::CreateLayerFromIdWithDimension(t_ilm_message message)
1129 {
1130     t_ilm_message response;
1131     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1132     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1133     uint id = GraphicalObject::INVALID_ID;
1134     uint width = 0;
1135     uint height = 0;
1136     t_ilm_bool status = ILM_FALSE;
1137
1138     m_ipcModule.getUint(message, &id);
1139     m_ipcModule.getUint(message, &width);
1140     m_ipcModule.getUint(message, &height);
1141
1142     status = m_executor->execute(new LayerCreateCommand(clientPid, width, height, &id));
1143     if (status)
1144     {
1145         response = m_ipcModule.createResponse(message);
1146         m_ipcModule.appendUint(response, id);
1147     }
1148     else
1149     {
1150         response = m_ipcModule.createErrorResponse(message);
1151         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1152     }
1153
1154     m_ipcModule.sendToClients(response, &clientHandle, 1);
1155     m_ipcModule.destroyMessage(response);
1156 }
1157
1158 void GenericCommunicator::RemoveLayer(t_ilm_message message)
1159 {
1160     t_ilm_message response;
1161     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1162     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1163     uint param = 0;
1164     m_ipcModule.getUint(message, &param);
1165     t_ilm_bool status = m_executor->execute(new LayerRemoveCommand(clientPid, param));
1166     if (status)
1167     {
1168         response = m_ipcModule.createResponse(message);
1169     }
1170     else
1171     {
1172         response = m_ipcModule.createErrorResponse(message);
1173         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1174     }
1175
1176     m_ipcModule.sendToClients(response, &clientHandle, 1);
1177     m_ipcModule.destroyMessage(response);
1178 }
1179
1180 void GenericCommunicator::AddSurfaceToSurfaceGroup(t_ilm_message message)
1181 {
1182     t_ilm_message response;
1183     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1184     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1185     uint surfaceid = 0;
1186     uint surfacegroupid = 0;
1187
1188     m_ipcModule.getUint(message, &surfaceid);
1189     m_ipcModule.getUint(message, &surfacegroupid);
1190
1191     t_ilm_bool status = m_executor->execute(new SurfacegroupAddSurfaceCommand(clientPid, surfacegroupid, surfaceid));
1192     if (status)
1193     {
1194         response = m_ipcModule.createResponse(message);
1195     }
1196     else
1197     {
1198         response = m_ipcModule.createErrorResponse(message);
1199         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1200     }
1201
1202     m_ipcModule.sendToClients(response, &clientHandle, 1);
1203     m_ipcModule.destroyMessage(response);
1204 }
1205
1206 void GenericCommunicator::RemoveSurfaceFromSurfaceGroup(t_ilm_message message)
1207 {
1208     t_ilm_message response;
1209     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1210     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1211     uint surfaceid = 0;
1212     uint surfacegroupid = 0;
1213
1214     m_ipcModule.getUint(message, &surfaceid);
1215     m_ipcModule.getUint(message, &surfacegroupid);
1216
1217     t_ilm_bool status = m_executor->execute(new SurfacegroupRemoveSurfaceCommand(clientPid, surfacegroupid, surfaceid));
1218     if (status)
1219     {
1220         response = m_ipcModule.createResponse(message);
1221     }
1222     else
1223     {
1224         response = m_ipcModule.createErrorResponse(message);
1225         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1226     }
1227
1228     m_ipcModule.sendToClients(response, &clientHandle, 1);
1229     m_ipcModule.destroyMessage(response);
1230 }
1231
1232 void GenericCommunicator::AddLayerToLayerGroup(t_ilm_message message)
1233 {
1234     t_ilm_message response;
1235     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1236     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1237     uint layerid = 0;
1238     uint layergroupid = 0;
1239
1240     m_ipcModule.getUint(message, &layerid);
1241     m_ipcModule.getUint(message, &layergroupid);
1242
1243     t_ilm_bool status = m_executor->execute(new LayergroupAddLayerCommand(clientPid, layergroupid, layerid));
1244     if (status)
1245     {
1246         response = m_ipcModule.createResponse(message);
1247     }
1248     else
1249     {
1250         response = m_ipcModule.createErrorResponse(message);
1251         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1252     }
1253
1254     m_ipcModule.sendToClients(response, &clientHandle, 1);
1255     m_ipcModule.destroyMessage(response);
1256 }
1257
1258 void GenericCommunicator::RemoveLayerFromLayerGroup(t_ilm_message message)
1259 {
1260     t_ilm_message response;
1261     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1262     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1263     uint layerid = 0;
1264     uint layergroupid = 0;
1265
1266     m_ipcModule.getUint(message, &layerid);
1267     m_ipcModule.getUint(message, &layergroupid);
1268
1269     t_ilm_bool status = m_executor->execute(new LayergroupRemoveLayerCommand(clientPid, layergroupid, layerid));
1270     if (status)
1271     {
1272         response = m_ipcModule.createResponse(message);
1273     }
1274     else
1275     {
1276         response = m_ipcModule.createErrorResponse(message);
1277         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1278     }
1279
1280     m_ipcModule.sendToClients(response, &clientHandle, 1);
1281     m_ipcModule.destroyMessage(response);
1282 }
1283
1284 void GenericCommunicator::AddSurfaceToLayer(t_ilm_message message)
1285 {
1286     t_ilm_message response;
1287     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1288     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1289     uint surfaceid = 0;
1290     uint layer = 0;
1291
1292     m_ipcModule.getUint(message, &surfaceid);
1293     m_ipcModule.getUint(message, &layer);
1294
1295     t_ilm_bool status = m_executor->execute(new LayerAddSurfaceCommand(clientPid, layer, surfaceid));
1296     if (status)
1297     {
1298         response = m_ipcModule.createResponse(message);
1299     }
1300     else
1301     {
1302         response = m_ipcModule.createErrorResponse(message);
1303         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1304     }
1305
1306     m_ipcModule.sendToClients(response, &clientHandle, 1);
1307     m_ipcModule.destroyMessage(response);
1308 }
1309
1310 void GenericCommunicator::RemoveSurfaceFromLayer(t_ilm_message message)
1311 {
1312     t_ilm_message response;
1313     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1314     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1315     uint surfaceid = 0;
1316     uint layerid = 0;
1317     m_ipcModule.getUint(message, &surfaceid);
1318     m_ipcModule.getUint(message, &layerid);
1319
1320     t_ilm_bool status = m_executor->execute(new LayerRemoveSurfaceCommand(clientPid, layerid, surfaceid));
1321     if (status)
1322     {
1323         response = m_ipcModule.createResponse(message);
1324     }
1325     else
1326     {
1327         response = m_ipcModule.createErrorResponse(message);
1328         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1329     }
1330
1331     m_ipcModule.sendToClients(response, &clientHandle, 1);
1332     m_ipcModule.destroyMessage(response);
1333 }
1334
1335 void GenericCommunicator::CreateSurfaceGroup(t_ilm_message message)
1336 {
1337     t_ilm_message response;
1338     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1339     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1340     uint newID = GraphicalObject::INVALID_ID;
1341
1342     t_ilm_bool status = m_executor->execute(new SurfacegroupCreateCommand(clientPid, &newID));
1343     if (status)
1344     {
1345         response = m_ipcModule.createResponse(message);
1346         m_ipcModule.appendUint(response, newID);
1347     }
1348     else
1349     {
1350         response = m_ipcModule.createErrorResponse(message);
1351         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1352     }
1353
1354     m_ipcModule.sendToClients(response, &clientHandle, 1);
1355     m_ipcModule.destroyMessage(response);
1356 }
1357
1358 void GenericCommunicator::CreateSurfaceGroupFromId(t_ilm_message message)
1359 {
1360     t_ilm_message response;
1361     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1362     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1363     uint newID = GraphicalObject::INVALID_ID;
1364
1365     m_ipcModule.getUint(message, &newID);
1366
1367     t_ilm_bool status = m_executor->execute(new SurfacegroupCreateCommand(clientPid, &newID));
1368     if (status)
1369     {
1370         response = m_ipcModule.createResponse(message);
1371         m_ipcModule.appendUint(response, newID);
1372     }
1373     else
1374     {
1375         response = m_ipcModule.createErrorResponse(message);
1376         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1377     }
1378
1379     m_ipcModule.sendToClients(response, &clientHandle, 1);
1380     m_ipcModule.destroyMessage(response);
1381 }
1382
1383 void GenericCommunicator::RemoveSurfaceGroup(t_ilm_message message)
1384 {
1385     t_ilm_message response;
1386     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1387     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1388     uint param = 0;
1389     m_ipcModule.getUint(message, &param);
1390
1391     t_ilm_bool status = m_executor->execute(new SurfacegroupRemoveCommand(clientPid, param));
1392     if (status)
1393     {
1394         response = m_ipcModule.createResponse(message);
1395     }
1396     else
1397     {
1398         response = m_ipcModule.createErrorResponse(message);
1399         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1400     }
1401
1402     m_ipcModule.sendToClients(response, &clientHandle, 1);
1403     m_ipcModule.destroyMessage(response);
1404 }
1405
1406 void GenericCommunicator::CreateLayerGroup(t_ilm_message message)
1407 {
1408     t_ilm_message response;
1409     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1410     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1411     uint newID = GraphicalObject::INVALID_ID;
1412
1413     t_ilm_bool status = m_executor->execute(new LayergroupCreateCommand(clientPid, &newID));
1414     if (status)
1415     {
1416         response = m_ipcModule.createResponse(message);
1417         m_ipcModule.appendUint(response, newID);
1418     }
1419     else
1420     {
1421         response = m_ipcModule.createErrorResponse(message);
1422         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1423     }
1424
1425     m_ipcModule.sendToClients(response, &clientHandle, 1);
1426     m_ipcModule.destroyMessage(response);
1427 }
1428
1429 void GenericCommunicator::CreateLayerGroupFromId(t_ilm_message message)
1430 {
1431     t_ilm_message response;
1432     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1433     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1434     uint newID = GraphicalObject::INVALID_ID;
1435
1436     m_ipcModule.getUint(message, &newID);
1437
1438     t_ilm_bool status = m_executor->execute(new LayergroupCreateCommand(clientPid, &newID));
1439     if (status)
1440     {
1441         response = m_ipcModule.createResponse(message);
1442         m_ipcModule.appendUint(response, newID);
1443     }
1444     else
1445     {
1446         response = m_ipcModule.createErrorResponse(message);
1447         m_ipcModule.appendString(response, RESOURCE_ALREADY_INUSE);
1448     }
1449
1450     m_ipcModule.sendToClients(response, &clientHandle, 1);
1451     m_ipcModule.destroyMessage(response);
1452 }
1453
1454 void GenericCommunicator::RemoveLayerGroup(t_ilm_message message)
1455 {
1456     t_ilm_message response;
1457     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1458     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1459     uint param = 0;
1460     m_ipcModule.getUint(message, &param);
1461
1462     t_ilm_bool status = m_executor->execute(new LayergroupRemoveCommand(clientPid, param));
1463     if (status)
1464     {
1465         response = m_ipcModule.createResponse(message);
1466     }
1467     else
1468     {
1469         response = m_ipcModule.createErrorResponse(message);
1470         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1471     }
1472
1473     m_ipcModule.sendToClients(response, &clientHandle, 1);
1474     m_ipcModule.destroyMessage(response);
1475 }
1476
1477 void GenericCommunicator::SetSurfaceSourceRegion(t_ilm_message message)
1478 {
1479     t_ilm_message response;
1480     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1481     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1482     uint id = 0;
1483     uint x = 0;
1484     uint y = 0;
1485     uint width = 0;
1486     uint height = 0;
1487
1488     m_ipcModule.getUint(message, &id);
1489     m_ipcModule.getUint(message, &x);
1490     m_ipcModule.getUint(message, &y);
1491     m_ipcModule.getUint(message, &width);
1492     m_ipcModule.getUint(message, &height);
1493
1494     t_ilm_bool status = m_executor->execute(new SurfaceSetSourceRectangleCommand(clientPid, id, x, y, width, height));
1495     if (status)
1496     {
1497         response = m_ipcModule.createResponse(message);
1498     }
1499     else
1500     {
1501         response = m_ipcModule.createErrorResponse(message);
1502         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1503     }
1504
1505     m_ipcModule.sendToClients(response, &clientHandle, 1);
1506     m_ipcModule.destroyMessage(response);
1507 }
1508
1509 void GenericCommunicator::SetLayerSourceRegion(t_ilm_message message)
1510 {
1511     t_ilm_message response;
1512     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1513     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1514     uint id = 0;
1515     uint x = 0;
1516     uint y = 0;
1517     uint width = 0;
1518     uint height = 0;
1519
1520     m_ipcModule.getUint(message, &id);
1521     m_ipcModule.getUint(message, &x);
1522     m_ipcModule.getUint(message, &y);
1523     m_ipcModule.getUint(message, &width);
1524     m_ipcModule.getUint(message, &height);
1525
1526     t_ilm_bool status = m_executor->execute(new LayerSetSourceRectangleCommand(clientPid, id, x, y, width, height));
1527     if (status)
1528     {
1529         response = m_ipcModule.createResponse(message);
1530     }
1531     else
1532     {
1533         response = m_ipcModule.createErrorResponse(message);
1534         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1535     }
1536
1537     m_ipcModule.sendToClients(response, &clientHandle, 1);
1538     m_ipcModule.destroyMessage(response);
1539 }
1540
1541 void GenericCommunicator::SetSurfaceDestinationRegion(t_ilm_message message)
1542 {
1543     t_ilm_message response;
1544     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1545     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1546     uint id = 0;
1547     uint x = 0;
1548     uint y = 0;
1549     uint width = 0;
1550     uint height = 0;
1551
1552     m_ipcModule.getUint(message, &id);
1553     m_ipcModule.getUint(message, &x);
1554     m_ipcModule.getUint(message, &y);
1555     m_ipcModule.getUint(message, &width);
1556     m_ipcModule.getUint(message, &height);
1557
1558     t_ilm_bool status = m_executor->execute(new SurfaceSetDestinationRectangleCommand(clientPid, id, x, y, width, height));
1559     if (status)
1560     {
1561         response = m_ipcModule.createResponse(message);
1562     }
1563     else
1564     {
1565         response = m_ipcModule.createErrorResponse(message);
1566         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1567     }
1568
1569     m_ipcModule.sendToClients(response, &clientHandle, 1);
1570     m_ipcModule.destroyMessage(response);
1571 }
1572
1573 void GenericCommunicator::SetSurfacePosition(t_ilm_message message)
1574 {
1575     t_ilm_message response;
1576     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1577     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1578     uint id = 0;
1579     uint x = 0;
1580     uint y = 0;
1581
1582     m_ipcModule.getUint(message, &id);
1583     m_ipcModule.getUint(message, &x);
1584     m_ipcModule.getUint(message, &y);
1585
1586     t_ilm_bool status = m_executor->execute(new SurfaceSetPositionCommand(clientPid, id, x, y));
1587     if (status)
1588     {
1589         response = m_ipcModule.createResponse(message);
1590     }
1591     else
1592     {
1593         response = m_ipcModule.createErrorResponse(message);
1594         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1595     }
1596
1597     m_ipcModule.sendToClients(response, &clientHandle, 1);
1598     m_ipcModule.destroyMessage(response);
1599 }
1600
1601 void GenericCommunicator::GetSurfacePosition(t_ilm_message message)
1602 {
1603     t_ilm_message response;
1604     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1605     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1606     uint id = 0;
1607     uint x = 0;
1608     uint y = 0;
1609
1610     m_ipcModule.getUint(message, &id);
1611
1612     t_ilm_bool status = m_executor->execute(new SurfaceGetPositionCommand(clientPid, id, &x, &y));
1613     if (status)
1614     {
1615         response = m_ipcModule.createResponse(message);
1616         m_ipcModule.appendUint(response, x);
1617         m_ipcModule.appendUint(response, y);
1618     }
1619     else
1620     {
1621         response = m_ipcModule.createErrorResponse(message);
1622         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1623     }
1624
1625     m_ipcModule.sendToClients(response, &clientHandle, 1);
1626     m_ipcModule.destroyMessage(response);
1627 }
1628
1629 void GenericCommunicator::SetSurfaceDimension(t_ilm_message message)
1630 {
1631     t_ilm_message response;
1632     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1633     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1634     uint id = 0;
1635     uint width = 0;
1636     uint height = 0;
1637
1638     m_ipcModule.getUint(message, &id);
1639     m_ipcModule.getUint(message, &width);
1640     m_ipcModule.getUint(message, &height);
1641
1642     t_ilm_bool status = m_executor->execute(new SurfaceSetDimensionCommand(clientPid, id, width, height));
1643     if (status)
1644     {
1645         response = m_ipcModule.createResponse(message);
1646     }
1647     else
1648     {
1649         response = m_ipcModule.createErrorResponse(message);
1650         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1651     }
1652
1653     m_ipcModule.sendToClients(response, &clientHandle, 1);
1654     m_ipcModule.destroyMessage(response);
1655 }
1656
1657 void GenericCommunicator::SetLayerDestinationRegion(t_ilm_message message)
1658 {
1659     t_ilm_message response;
1660     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1661     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1662     uint id = 0;
1663     uint x = 0;
1664     uint y = 0;
1665     uint width = 0;
1666     uint height = 0;
1667
1668     m_ipcModule.getUint(message, &id);
1669     m_ipcModule.getUint(message, &x);
1670     m_ipcModule.getUint(message, &y);
1671     m_ipcModule.getUint(message, &width);
1672     m_ipcModule.getUint(message, &height);
1673
1674     t_ilm_bool status = m_executor->execute(new LayerSetDestinationRectangleCommand(clientPid, id, x, y, width, height));
1675     if (status)
1676     {
1677         response = m_ipcModule.createResponse(message);
1678     }
1679     else
1680     {
1681         response = m_ipcModule.createErrorResponse(message);
1682         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1683     }
1684
1685     m_ipcModule.sendToClients(response, &clientHandle, 1);
1686     m_ipcModule.destroyMessage(response);
1687 }
1688
1689 void GenericCommunicator::SetLayerPosition(t_ilm_message message)
1690 {
1691     t_ilm_message response;
1692     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1693     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1694     uint id = 0;
1695     uint x = 0;
1696     uint y = 0;
1697
1698     m_ipcModule.getUint(message, &id);
1699     m_ipcModule.getUint(message, &x);
1700     m_ipcModule.getUint(message, &y);
1701
1702     t_ilm_bool status = m_executor->execute(new LayerSetPositionCommand(clientPid, id, x, y));
1703     if (status)
1704     {
1705         response = m_ipcModule.createResponse(message);
1706     }
1707     else
1708     {
1709         response = m_ipcModule.createErrorResponse(message);
1710         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1711     }
1712
1713     m_ipcModule.sendToClients(response, &clientHandle, 1);
1714     m_ipcModule.destroyMessage(response);
1715 }
1716
1717 void GenericCommunicator::GetLayerPosition(t_ilm_message message)
1718 {
1719     t_ilm_message response;
1720     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1721     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1722     uint id = 0;
1723     uint x = 0;
1724     uint y = 0;
1725
1726     m_ipcModule.getUint(message, &id);
1727
1728     t_ilm_bool status = m_executor->execute(new LayerGetPositionCommand(clientPid, id, &x, &y));
1729     if (status)
1730     {
1731         response = m_ipcModule.createResponse(message);
1732         m_ipcModule.appendUint(response, x);
1733         m_ipcModule.appendUint(response, y);
1734     }
1735     else
1736     {
1737         response = m_ipcModule.createErrorResponse(message);
1738         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1739     }
1740
1741     m_ipcModule.sendToClients(response, &clientHandle, 1);
1742     m_ipcModule.destroyMessage(response);
1743 }
1744
1745 void GenericCommunicator::SetLayerDimension(t_ilm_message message)
1746 {
1747     t_ilm_message response;
1748     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1749     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1750     uint id = 0;
1751     uint width = 0;
1752     uint height = 0;
1753
1754     m_ipcModule.getUint(message, &id);
1755     m_ipcModule.getUint(message, &width);
1756     m_ipcModule.getUint(message, &height);
1757
1758     t_ilm_bool status = m_executor->execute(new LayerSetDimensionCommand(clientPid, id, width, height));
1759     if (status)
1760     {
1761         response = m_ipcModule.createResponse(message);
1762     }
1763     else
1764     {
1765         response = m_ipcModule.createErrorResponse(message);
1766         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1767     }
1768
1769     m_ipcModule.sendToClients(response, &clientHandle, 1);
1770     m_ipcModule.destroyMessage(response);
1771 }
1772
1773 void GenericCommunicator::GetLayerDimension(t_ilm_message message)
1774 {
1775     t_ilm_message response;
1776     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1777     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1778     uint id = 0;
1779     uint width = 0;
1780     uint height = 0;
1781
1782     m_ipcModule.getUint(message, &id);
1783
1784     t_ilm_bool status = m_executor->execute(new LayerGetDimensionCommand(clientPid, id, &width, &height));
1785     if (status)
1786     {
1787         response = m_ipcModule.createResponse(message);
1788         m_ipcModule.appendUint(response, width);
1789         m_ipcModule.appendUint(response, height);
1790     }
1791     else
1792     {
1793         response = m_ipcModule.createErrorResponse(message);
1794         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1795     }
1796
1797     m_ipcModule.sendToClients(response, &clientHandle, 1);
1798     m_ipcModule.destroyMessage(response);
1799 }
1800
1801 void GenericCommunicator::GetSurfaceDimension(t_ilm_message message)
1802 {
1803     t_ilm_message response;
1804     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1805     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1806     uint id = 0;
1807     uint width = 0;
1808     uint height = 0;
1809
1810     m_ipcModule.getUint(message, &id);
1811
1812     t_ilm_bool status = m_executor->execute(new SurfaceGetDimensionCommand(clientPid, id, &width, &height));
1813     if (status)
1814     {
1815         response = m_ipcModule.createResponse(message);
1816         m_ipcModule.appendUint(response, width);
1817         m_ipcModule.appendUint(response, height);
1818     }
1819     else
1820     {
1821         response = m_ipcModule.createErrorResponse(message);
1822         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1823     }
1824
1825     m_ipcModule.sendToClients(response, &clientHandle, 1);
1826     m_ipcModule.destroyMessage(response);
1827 }
1828
1829 void GenericCommunicator::SetSurfaceOpacity(t_ilm_message message)
1830 {
1831     t_ilm_message response;
1832     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1833     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1834     uint id = 0;
1835     double param = 0.0;
1836
1837     m_ipcModule.getUint(message, &id);
1838     m_ipcModule.getDouble(message, &param);
1839
1840     t_ilm_bool status = m_executor->execute(new SurfaceSetOpacityCommand(clientPid, id, param));
1841     if (status)
1842     {
1843         response = m_ipcModule.createResponse(message);
1844     }
1845     else
1846     {
1847         response = m_ipcModule.createErrorResponse(message);
1848         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1849     }
1850
1851     m_ipcModule.sendToClients(response, &clientHandle, 1);
1852     m_ipcModule.destroyMessage(response);
1853 }
1854
1855 void GenericCommunicator::SetLayerOpacity(t_ilm_message message)
1856 {
1857     t_ilm_message response;
1858     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1859     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1860     uint id = 0;
1861     double param = 0.0;
1862
1863     m_ipcModule.getUint(message, &id);
1864     m_ipcModule.getDouble(message, &param);
1865
1866     t_ilm_bool status = m_executor->execute(new LayerSetOpacityCommand(clientPid, id, param));
1867     if (status)
1868     {
1869         response = m_ipcModule.createResponse(message);
1870     }
1871     else
1872     {
1873         response = m_ipcModule.createErrorResponse(message);
1874         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1875     }
1876
1877     m_ipcModule.sendToClients(response, &clientHandle, 1);
1878     m_ipcModule.destroyMessage(response);
1879 }
1880
1881 void GenericCommunicator::SetSurfacegroupOpacity(t_ilm_message message)
1882 {
1883     t_ilm_message response;
1884     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1885     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1886     uint id = 0;
1887     double param = 0.0;
1888
1889     m_ipcModule.getUint(message, &id);
1890     m_ipcModule.getDouble(message, &param);
1891
1892     t_ilm_bool status = m_executor->execute(new SurfacegroupSetOpacityCommand(clientPid, id, param));
1893     if (status)
1894     {
1895         response = m_ipcModule.createResponse(message);
1896     }
1897     else
1898     {
1899         response = m_ipcModule.createErrorResponse(message);
1900         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1901     }
1902
1903     m_ipcModule.sendToClients(response, &clientHandle, 1);
1904     m_ipcModule.destroyMessage(response);
1905 }
1906
1907 void GenericCommunicator::SetLayergroupOpacity(t_ilm_message message)
1908 {
1909     t_ilm_message response;
1910     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1911     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1912     uint id = 0;
1913     double param = 0.0;
1914
1915     m_ipcModule.getUint(message, &id);
1916     m_ipcModule.getDouble(message, &param);
1917
1918     t_ilm_bool status = m_executor->execute(new LayergroupSetOpacityCommand(clientPid, id, param));
1919     if (status)
1920     {
1921         response = m_ipcModule.createResponse(message);
1922     }
1923     else
1924     {
1925         response = m_ipcModule.createErrorResponse(message);
1926         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1927     }
1928
1929     m_ipcModule.sendToClients(response, &clientHandle, 1);
1930     m_ipcModule.destroyMessage(response);
1931 }
1932
1933 void GenericCommunicator::GetSurfaceOpacity(t_ilm_message message)
1934 {
1935     t_ilm_message response;
1936     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1937     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1938     uint id = 0;
1939     double param = 0.0;
1940
1941     m_ipcModule.getUint(message, &id);
1942
1943     t_ilm_bool status = m_executor->execute(new SurfaceGetOpacityCommand(clientPid, id, &param));
1944     if (status)
1945     {
1946         response = m_ipcModule.createResponse(message);
1947         m_ipcModule.appendDouble(response, param);
1948     }
1949     else
1950     {
1951         response = m_ipcModule.createErrorResponse(message);
1952         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1953     }
1954
1955     m_ipcModule.sendToClients(response, &clientHandle, 1);
1956     m_ipcModule.destroyMessage(response);
1957 }
1958
1959 void GenericCommunicator::GetLayerOpacity(t_ilm_message message)
1960 {
1961     t_ilm_message response;
1962     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1963     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1964     uint id = 0;
1965     double param = 0.0;
1966
1967     m_ipcModule.getUint(message, &id);
1968
1969     t_ilm_bool status = m_executor->execute(new LayerGetOpacityCommand(clientPid, id, &param));
1970     if (status)
1971     {
1972         response = m_ipcModule.createResponse(message);
1973         m_ipcModule.appendDouble(response, param);
1974     }
1975     else
1976     {
1977         response = m_ipcModule.createErrorResponse(message);
1978         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
1979     }
1980
1981     m_ipcModule.sendToClients(response, &clientHandle, 1);
1982     m_ipcModule.destroyMessage(response);
1983 }
1984
1985 void GenericCommunicator::SetSurfaceOrientation(t_ilm_message message)
1986 {
1987     t_ilm_message response;
1988     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
1989     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
1990     uint id = 0;
1991     uint param = 0;
1992     OrientationType o = Zero;
1993
1994     m_ipcModule.getUint(message, &id);
1995     m_ipcModule.getUint(message, &param);
1996
1997     o = (OrientationType) param;
1998
1999     t_ilm_bool status = m_executor->execute(new SurfaceSetOrientationCommand(clientPid, id, o));
2000     if (status)
2001     {
2002         response = m_ipcModule.createResponse(message);
2003     }
2004     else
2005     {
2006         response = m_ipcModule.createErrorResponse(message);
2007         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2008     }
2009
2010     m_ipcModule.sendToClients(response, &clientHandle, 1);
2011     m_ipcModule.destroyMessage(response);
2012 }
2013
2014 void GenericCommunicator::GetSurfaceOrientation(t_ilm_message message)
2015 {
2016     t_ilm_message response;
2017     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2018     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2019     uint id = 0;
2020     OrientationType o;
2021
2022     m_ipcModule.getUint(message, &id);
2023
2024     t_ilm_bool status = m_executor->execute(new SurfaceGetOrientationCommand(clientPid, id, &o));
2025     if (status)
2026     {
2027         response = m_ipcModule.createResponse(message);
2028         m_ipcModule.appendUint(response, o);
2029     }
2030     else
2031     {
2032         response = m_ipcModule.createErrorResponse(message);
2033         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2034     }
2035
2036     m_ipcModule.sendToClients(response, &clientHandle, 1);
2037     m_ipcModule.destroyMessage(response);
2038 }
2039
2040 void GenericCommunicator::SetLayerOrientation(t_ilm_message message)
2041 {
2042     t_ilm_message response;
2043     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2044     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2045     uint id = 0;
2046     uint param = 0;
2047     OrientationType o = Zero;
2048
2049     m_ipcModule.getUint(message, &id);
2050     m_ipcModule.getUint(message, &param);
2051
2052     o = (OrientationType) param;
2053
2054     t_ilm_bool status = m_executor->execute(new LayerSetOrientationCommand(clientPid, id, o));
2055     if (status)
2056     {
2057         response = m_ipcModule.createResponse(message);
2058     }
2059     else
2060     {
2061         response = m_ipcModule.createErrorResponse(message);
2062         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2063     }
2064
2065     m_ipcModule.sendToClients(response, &clientHandle, 1);
2066     m_ipcModule.destroyMessage(response);
2067 }
2068
2069 void GenericCommunicator::GetLayerOrientation(t_ilm_message message)
2070 {
2071     t_ilm_message response;
2072     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2073     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2074     uint id = 0;
2075     OrientationType o;
2076
2077     m_ipcModule.getUint(message, &id);
2078
2079     t_ilm_bool status = m_executor->execute(new LayerGetOrientationCommand(clientPid, id, &o));
2080     if (status)
2081     {
2082         response = m_ipcModule.createResponse(message);
2083         m_ipcModule.appendUint(response, o);
2084     }
2085     else
2086     {
2087         response = m_ipcModule.createErrorResponse(message);
2088         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2089     }
2090
2091     m_ipcModule.sendToClients(response, &clientHandle, 1);
2092     m_ipcModule.destroyMessage(response);
2093 }
2094
2095 void GenericCommunicator::GetSurfacePixelformat(t_ilm_message message)
2096 {
2097     t_ilm_message response;
2098     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2099     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2100     uint id = 0;
2101     PixelFormat pixelFormat;
2102
2103     m_ipcModule.getUint(message, &id);
2104
2105     t_ilm_bool status = m_executor->execute(new SurfaceGetPixelformatCommand(clientPid, id, &pixelFormat));
2106     if (status)
2107     {
2108         response = m_ipcModule.createResponse(message);
2109         m_ipcModule.appendUint(response, pixelFormat);
2110     }
2111     else
2112     {
2113         response = m_ipcModule.createErrorResponse(message);
2114         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2115     }
2116
2117     m_ipcModule.sendToClients(response, &clientHandle, 1);
2118     m_ipcModule.destroyMessage(response);
2119 }
2120
2121 void GenericCommunicator::SetSurfaceVisibility(t_ilm_message message)
2122 {
2123     t_ilm_message response;
2124     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2125     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2126     uint surfaceid = 0;
2127     t_ilm_bool newVis = ILM_FALSE;
2128
2129     m_ipcModule.getUint(message, &surfaceid);
2130     m_ipcModule.getBool(message, &newVis);
2131
2132     t_ilm_bool status = m_executor->execute(new SurfaceSetVisibilityCommand(clientPid, surfaceid, newVis));
2133     if (status)
2134     {
2135         response = m_ipcModule.createResponse(message);
2136     }
2137     else
2138     {
2139         response = m_ipcModule.createErrorResponse(message);
2140         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2141     }
2142
2143     m_ipcModule.sendToClients(response, &clientHandle, 1);
2144     m_ipcModule.destroyMessage(response);
2145 }
2146
2147 void GenericCommunicator::SetLayerVisibility(t_ilm_message message)
2148 {
2149     t_ilm_message response;
2150     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2151     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2152     uint layerid = 0;
2153     t_ilm_bool myparam = ILM_FALSE;
2154
2155     m_ipcModule.getUint(message, &layerid);
2156     m_ipcModule.getBool(message, &myparam);
2157
2158     t_ilm_bool status = m_executor->execute(new LayerSetVisibilityCommand(clientPid, layerid, myparam));
2159     if (status)
2160     {
2161         response = m_ipcModule.createResponse(message);
2162     }
2163     else
2164     {
2165         response = m_ipcModule.createErrorResponse(message);
2166         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2167     }
2168
2169     m_ipcModule.sendToClients(response, &clientHandle, 1);
2170     m_ipcModule.destroyMessage(response);
2171 }
2172
2173 void GenericCommunicator::GetSurfaceVisibility(t_ilm_message message)
2174 {
2175     t_ilm_message response;
2176     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2177     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2178     uint id = 0;
2179     bool visibility;
2180
2181     m_ipcModule.getUint(message, &id);
2182
2183     t_ilm_bool status = m_executor->execute(new SurfaceGetVisibilityCommand(clientPid, id, &visibility));
2184     if (status)
2185     {
2186         response = m_ipcModule.createResponse(message);
2187         m_ipcModule.appendBool(response, visibility);
2188     }
2189     else
2190     {
2191         response = m_ipcModule.createErrorResponse(message);
2192         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2193     }
2194
2195     m_ipcModule.sendToClients(response, &clientHandle, 1);
2196     m_ipcModule.destroyMessage(response);
2197 }
2198
2199 void GenericCommunicator::GetLayerVisibility(t_ilm_message message)
2200 {
2201     t_ilm_message response;
2202     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2203     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2204     uint id = 0;
2205     bool visibility;
2206
2207     m_ipcModule.getUint(message, &id);
2208
2209     t_ilm_bool status = m_executor->execute(new LayerGetVisibilityCommand(clientPid, id, &visibility));
2210     if (status)
2211     {
2212         response = m_ipcModule.createResponse(message);
2213         m_ipcModule.appendBool(response, visibility);
2214     }
2215     else
2216     {
2217         response = m_ipcModule.createErrorResponse(message);
2218         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2219     }
2220
2221     m_ipcModule.sendToClients(response, &clientHandle, 1);
2222     m_ipcModule.destroyMessage(response);
2223 }
2224
2225 void GenericCommunicator::SetSurfacegroupVisibility(t_ilm_message message)
2226 {
2227     t_ilm_message response;
2228     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2229     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2230     uint groupid = 0;
2231     t_ilm_bool myparam = ILM_FALSE;
2232
2233     m_ipcModule.getUint(message, &groupid);
2234     m_ipcModule.getBool(message, &myparam);
2235
2236     t_ilm_bool status = m_executor->execute(new SurfacegroupSetVisibilityCommand(clientPid, groupid, myparam));
2237     if (status)
2238     {
2239         response = m_ipcModule.createResponse(message);
2240     }
2241     else
2242     {
2243         response = m_ipcModule.createErrorResponse(message);
2244         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2245     }
2246
2247     m_ipcModule.sendToClients(response, &clientHandle, 1);
2248     m_ipcModule.destroyMessage(response);
2249 }
2250
2251 void GenericCommunicator::SetLayergroupVisibility(t_ilm_message message)
2252 {
2253     t_ilm_message response;
2254     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2255     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2256     uint groupid = 0;
2257     t_ilm_bool myparam = ILM_FALSE;
2258
2259     m_ipcModule.getUint(message, &groupid);
2260     m_ipcModule.getBool(message, &myparam);
2261
2262     t_ilm_bool status = m_executor->execute(new LayergroupSetVisibilityCommand(clientPid, groupid, myparam));
2263     if (status)
2264     {
2265         response = m_ipcModule.createResponse(message);
2266     }
2267     else
2268     {
2269         response = m_ipcModule.createErrorResponse(message);
2270         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2271     }
2272
2273     m_ipcModule.sendToClients(response, &clientHandle, 1);
2274     m_ipcModule.destroyMessage(response);
2275 }
2276
2277
2278 void GenericCommunicator::SetRenderOrderOfLayers(t_ilm_message message)
2279 {
2280     t_ilm_message response;
2281     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2282     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2283     uint* array = NULL;
2284     int length = 0;
2285     uint screenID = 0;
2286
2287     m_ipcModule.getUintArray(message, &array, &length);
2288     m_ipcModule.getUint(message, &screenID);
2289
2290     t_ilm_bool status = m_executor->execute(new ScreenSetRenderOrderCommand(clientPid, screenID, array, length));
2291     if (status)
2292     {
2293         response = m_ipcModule.createResponse(message);
2294     }
2295     else
2296     {
2297         response = m_ipcModule.createErrorResponse(message);
2298         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2299     }
2300
2301     m_ipcModule.sendToClients(response, &clientHandle, 1);
2302     m_ipcModule.destroyMessage(response);
2303 }
2304
2305 void GenericCommunicator::SetSurfaceRenderOrderWithinLayer(t_ilm_message message)
2306 {
2307     t_ilm_message response;
2308     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2309     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2310     uint* array = NULL;
2311     int length = 0;
2312     uint layerid = 0;
2313
2314     m_ipcModule.getUint(message, &layerid);
2315     m_ipcModule.getUintArray(message, &array, &length);
2316
2317     t_ilm_bool status = m_executor->execute(new LayerSetRenderOrderCommand(clientPid, layerid, array, length));
2318     if (status)
2319     {
2320         response = m_ipcModule.createResponse(message);
2321     }
2322     else
2323     {
2324         response = m_ipcModule.createErrorResponse(message);
2325         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2326     }
2327
2328     m_ipcModule.sendToClients(response, &clientHandle, 1);
2329     m_ipcModule.destroyMessage(response);
2330 }
2331
2332 void GenericCommunicator::GetLayerType(t_ilm_message message)
2333 {
2334     t_ilm_message response;
2335     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2336     uint id = 0;
2337     m_ipcModule.getUint(message, &id);
2338
2339     Layer* layer = m_executor->getScene()->getLayer(id);
2340     if (layer)
2341     {
2342         response = m_ipcModule.createResponse(message);
2343         m_ipcModule.appendUint(response, layer->getLayerType());
2344     }
2345     else
2346     {
2347         response = m_ipcModule.createErrorResponse(message);
2348         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2349     }
2350
2351     m_ipcModule.sendToClients(response, &clientHandle, 1);
2352     m_ipcModule.destroyMessage(response);
2353 }
2354
2355 void GenericCommunicator::GetLayertypeCapabilities(t_ilm_message message)
2356 {
2357     t_ilm_message response;
2358     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2359     uint id = 0;
2360     LayerType type = Unknown;
2361
2362     m_ipcModule.getUint(message, &id);
2363
2364     type = (LayerType) id;
2365
2366     uint capabilities = m_executor->getLayerTypeCapabilities(type);
2367     response = m_ipcModule.createResponse(message);
2368     m_ipcModule.appendUint(response, capabilities);
2369     m_ipcModule.sendToClients(response, &clientHandle, 1);
2370     m_ipcModule.destroyMessage(response);
2371 }
2372
2373 void GenericCommunicator::GetLayerCapabilities(t_ilm_message message)
2374 {
2375     t_ilm_message response;
2376     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2377     uint id = 0;
2378     m_ipcModule.getUint(message, &id);
2379
2380     Layer* layer = m_executor->getScene()->getLayer(id);
2381     if (layer)
2382     {
2383         response = m_ipcModule.createResponse(message);
2384         m_ipcModule.appendUint(response, layer->getCapabilities());
2385     }
2386     else
2387     {
2388         response = m_ipcModule.createErrorResponse(message);
2389         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2390     }
2391
2392     m_ipcModule.sendToClients(response, &clientHandle, 1);
2393     m_ipcModule.destroyMessage(response);
2394 }
2395
2396 void GenericCommunicator::FadeIn(t_ilm_message message)
2397 {
2398     t_ilm_message response;
2399     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2400     response = m_ipcModule.createErrorResponse(message);
2401     m_ipcModule.appendString(response, NOT_IMPLEMENTED);
2402     m_ipcModule.sendToClients(response, &clientHandle, 1);
2403     m_ipcModule.destroyMessage(response);
2404 }
2405
2406 void GenericCommunicator::SynchronizedFade(t_ilm_message message)
2407 {
2408     t_ilm_message response;
2409     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2410     response = m_ipcModule.createErrorResponse(message);
2411     m_ipcModule.appendString(response, NOT_IMPLEMENTED);
2412     m_ipcModule.sendToClients(response, &clientHandle, 1);
2413     m_ipcModule.destroyMessage(response);
2414 }
2415
2416 void GenericCommunicator::FadeOut(t_ilm_message message)
2417 {
2418     t_ilm_message response;
2419     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2420     response = m_ipcModule.createErrorResponse(message);
2421     m_ipcModule.appendString(response, NOT_IMPLEMENTED);
2422     m_ipcModule.sendToClients(response, &clientHandle, 1);
2423     m_ipcModule.destroyMessage(response);
2424 }
2425
2426 void GenericCommunicator::Exit(t_ilm_message message)
2427 {
2428     t_ilm_message response;
2429     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2430     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2431     t_ilm_bool status = m_executor->execute(new ExitCommand(clientPid));
2432     if (status)
2433     {
2434         response = m_ipcModule.createResponse(message);
2435     }
2436     else
2437     {
2438         response = m_ipcModule.createErrorResponse(message);
2439         m_ipcModule.appendString(response, INVALID_ARGUMENT);
2440     }
2441
2442     m_ipcModule.sendToClients(response, &clientHandle, 1);
2443     m_ipcModule.destroyMessage(response);
2444 }
2445
2446 void GenericCommunicator::CommitChanges(t_ilm_message message)
2447 {
2448     t_ilm_message response;
2449     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2450     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2451     t_ilm_bool status = m_executor->execute(new CommitCommand(clientPid));
2452     if (status)
2453     {
2454         response = m_ipcModule.createResponse(message);
2455     }
2456     else
2457     {
2458         response = m_ipcModule.createErrorResponse(message);
2459         m_ipcModule.appendString(response, INVALID_ARGUMENT);
2460     }
2461
2462     m_ipcModule.sendToClients(response, &clientHandle, 1);
2463     m_ipcModule.destroyMessage(response);
2464 }
2465
2466 void GenericCommunicator::CreateShader(t_ilm_message message)
2467 {
2468     t_ilm_message response;
2469     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2470     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2471     char vertname[1024];
2472     char fragname[1024];
2473     uint id = 0;
2474
2475     m_ipcModule.getString(message, vertname);
2476     m_ipcModule.getString(message, fragname);
2477
2478     t_ilm_bool status = m_executor->execute(new ShaderCreateCommand(clientPid, vertname, fragname, &id));
2479     if (status)
2480     {
2481         response = m_ipcModule.createResponse(message);
2482         m_ipcModule.appendUint(response, id);
2483     }
2484     else
2485     {
2486         response = m_ipcModule.createErrorResponse(message);
2487         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2488     }
2489
2490     m_ipcModule.sendToClients(response, &clientHandle, 1);
2491     m_ipcModule.destroyMessage(response);
2492 }
2493
2494 void GenericCommunicator::DestroyShader(t_ilm_message message)
2495 {
2496     t_ilm_message response;
2497     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2498     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2499     uint shaderid = 0;
2500
2501     m_ipcModule.getUint(message, &shaderid);
2502
2503     t_ilm_bool status = m_executor->execute(new ShaderDestroyCommand(clientPid, shaderid));
2504     if (status)
2505     {
2506         response = m_ipcModule.createResponse(message);
2507     }
2508     else
2509     {
2510         response = m_ipcModule.createErrorResponse(message);
2511         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2512     }
2513
2514     m_ipcModule.sendToClients(response, &clientHandle, 1);
2515     m_ipcModule.destroyMessage(response);
2516 }
2517
2518 void GenericCommunicator::SetShader(t_ilm_message message)
2519 {
2520     t_ilm_message response;
2521     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2522     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2523     uint surfaceId = 0;
2524     uint shaderid = 0;
2525
2526     m_ipcModule.getUint(message, &surfaceId);
2527     m_ipcModule.getUint(message, &shaderid);
2528
2529     t_ilm_bool status = m_executor->execute(new SurfaceSetShaderCommand(clientPid, surfaceId, shaderid));
2530     if (status)
2531     {
2532         response = m_ipcModule.createResponse(message);
2533     }
2534     else
2535     {
2536         response = m_ipcModule.createErrorResponse(message);
2537         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2538     }
2539
2540     m_ipcModule.sendToClients(response, &clientHandle, 1);
2541     m_ipcModule.destroyMessage(response);
2542 }
2543
2544 void GenericCommunicator::SetUniforms(t_ilm_message message)
2545 {
2546     t_ilm_message response;
2547     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2548     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2549     uint id = 0;
2550     std::vector<string> uniforms;
2551
2552     m_ipcModule.getUint(message, &id);
2553
2554     // TODO
2555     //m_ipcModule.getStringArray(&uniforms);
2556
2557     t_ilm_bool status = m_executor->execute(new ShaderSetUniformsCommand(clientPid, id, uniforms));
2558     if (status)
2559     {
2560         response = m_ipcModule.createResponse(message);
2561     }
2562     else
2563     {
2564         response = m_ipcModule.createErrorResponse(message);
2565         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2566     }
2567
2568     m_ipcModule.sendToClients(response, &clientHandle, 1);
2569     m_ipcModule.destroyMessage(response);
2570 }
2571
2572 void GenericCommunicator::SetKeyboardFocusOn(t_ilm_message message)
2573 {
2574     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2575     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2576     t_ilm_message response;
2577     uint surfaceId = 0;
2578
2579     m_ipcModule.getUint(message, &surfaceId);
2580
2581     t_ilm_bool status = m_executor->execute(new SurfaceSetKeyboardFocusCommand(clientPid, surfaceId));
2582     if (status)
2583     {
2584         response = m_ipcModule.createResponse(message);
2585     }
2586     else
2587     {
2588         response = m_ipcModule.createErrorResponse(message);
2589         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2590     }
2591
2592     m_ipcModule.sendToClients(response, &clientHandle, 1);
2593     m_ipcModule.destroyMessage(response);
2594 }
2595
2596
2597 void GenericCommunicator::GetKeyboardFocusSurfaceId(t_ilm_message message)
2598 {
2599     t_ilm_message response;
2600     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2601     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2602     uint surfaceId;
2603
2604     t_ilm_bool status = m_executor->execute(new SurfaceGetKeyboardFocusCommand(clientPid, &surfaceId));
2605     if (status)
2606     {
2607         response = m_ipcModule.createResponse(message);
2608         m_ipcModule.appendUint(response, surfaceId);
2609     }
2610     else
2611     {
2612         response = m_ipcModule.createErrorResponse(message);
2613         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2614     }
2615
2616     m_ipcModule.sendToClients(response, &clientHandle, 1);
2617     m_ipcModule.destroyMessage(response);
2618 }
2619
2620
2621 void GenericCommunicator::UpdateInputEventAcceptanceOn(t_ilm_message message)
2622 {
2623     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2624     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2625     t_ilm_message response;
2626     uint surfaceId = 0;
2627     uint udevices = 0;
2628     InputDevice devices;
2629     t_ilm_bool accept;
2630
2631     m_ipcModule.getUint(message, &surfaceId);
2632     m_ipcModule.getUint(message, &udevices);
2633     m_ipcModule.getBool(message, &accept);
2634
2635     devices = (InputDevice) udevices;
2636
2637     t_ilm_bool status = m_executor->execute(new SurfaceUpdateInputEventAcceptance(clientPid, surfaceId, devices, accept));
2638     if (status)
2639     {
2640         response = m_ipcModule.createResponse(message);
2641     }
2642     else
2643     {
2644         response = m_ipcModule.createErrorResponse(message);
2645         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2646     }
2647
2648     m_ipcModule.sendToClients(response, &clientHandle, 1);
2649     m_ipcModule.destroyMessage(response);
2650 }
2651
2652 void GenericCommunicator::SetSurfaceChromaKey(t_ilm_message message)
2653 {
2654     t_ilm_message response;
2655     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2656     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2657     uint* array = NULL;
2658     int length = 0;
2659     uint surfaceid = 0;
2660
2661     m_ipcModule.getUint(message, &surfaceid);
2662     m_ipcModule.getUintArray(message, &array, &length);
2663
2664     t_ilm_bool status = m_executor->execute(new SurfaceSetChromaKeyCommand(clientPid, surfaceid, array, length));
2665     if (status)
2666     {
2667         response = m_ipcModule.createResponse(message);
2668     }
2669     else
2670     {
2671         response = m_ipcModule.createErrorResponse(message);
2672         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2673     }
2674
2675     m_ipcModule.sendToClients(response, &clientHandle, 1);
2676     m_ipcModule.destroyMessage(response);
2677 }
2678
2679 void GenericCommunicator::SetLayerChromaKey(t_ilm_message message)
2680 {
2681     t_ilm_message response;
2682     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2683     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2684     uint* array = NULL;
2685     int length = 0;
2686     uint layerid = 0;
2687
2688     m_ipcModule.getUint(message, &layerid);
2689     m_ipcModule.getUintArray(message, &array, &length);
2690
2691     t_ilm_bool status = m_executor->execute(new LayerSetChromaKeyCommand(clientPid, layerid, array, length));
2692     if (status)
2693     {
2694         response = m_ipcModule.createResponse(message);
2695     }
2696     else
2697     {
2698         response = m_ipcModule.createErrorResponse(message);
2699         m_ipcModule.appendString(response, RESOURCE_NOT_FOUND);
2700     }
2701
2702     m_ipcModule.sendToClients(response, &clientHandle, 1);
2703     m_ipcModule.destroyMessage(response);
2704 }
2705
2706 void GenericCommunicator::LayerAddNotification(t_ilm_message message)
2707 {
2708     t_ilm_message response;
2709     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2710     uint layerid = 0;
2711
2712     m_ipcModule.getUint(message, &layerid);
2713
2714     Layer* layer = m_executor->getScene()->getLayer(layerid);
2715     if (layer)
2716     {
2717         layer->addNotification(clientHandle);
2718         response = m_ipcModule.createResponse(message);
2719     }
2720     else
2721     {
2722         response = m_ipcModule.createErrorResponse(message);
2723         m_ipcModule.appendString(response, INVALID_ARGUMENT);
2724     }
2725
2726     m_ipcModule.sendToClients(response, &clientHandle, 1);
2727     m_ipcModule.destroyMessage(response);
2728 }
2729
2730 void GenericCommunicator::SurfaceAddNotification(t_ilm_message message)
2731 {
2732     t_ilm_message response;
2733     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2734     uint surfaceid = 0;
2735
2736     m_ipcModule.getUint(message, &surfaceid);
2737
2738     Surface* surface = m_executor->getScene()->getSurface(surfaceid);
2739     if (surface)
2740     {
2741         surface->addNotification(clientHandle);
2742         response = m_ipcModule.createResponse(message);
2743     }
2744     else
2745     {
2746         response = m_ipcModule.createErrorResponse(message);
2747         m_ipcModule.appendString(response, INVALID_ARGUMENT);
2748     }
2749
2750     m_ipcModule.sendToClients(response, &clientHandle, 1);
2751     m_ipcModule.destroyMessage(response);
2752 }
2753
2754 void GenericCommunicator::LayerRemoveNotification(t_ilm_message message)
2755 {
2756     t_ilm_message response;
2757     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2758     uint layerid = 0;
2759
2760     m_ipcModule.getUint(message, &layerid);
2761
2762     Layer* layer = m_executor->getScene()->getLayer(layerid);
2763     if (layer)
2764     {
2765         layer->removeNotification(clientHandle);
2766         response = m_ipcModule.createResponse(message);
2767     }
2768     else
2769     {
2770         response = m_ipcModule.createErrorResponse(message);
2771         m_ipcModule.appendString(response, INVALID_ARGUMENT);
2772     }
2773
2774     m_ipcModule.sendToClients(response, &clientHandle, 1);
2775     m_ipcModule.destroyMessage(response);
2776 }
2777
2778 void GenericCommunicator::SurfaceRemoveNotification(t_ilm_message message)
2779 {
2780     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2781     t_ilm_message response;
2782     uint surfaceid = 0;
2783
2784     m_ipcModule.getUint(message, &surfaceid);
2785
2786     Surface* surface = m_executor->getScene()->getSurface(surfaceid);
2787     if (surface)
2788     {
2789         surface->removeNotification(clientHandle);
2790         response = m_ipcModule.createResponse(message);
2791     }
2792     else
2793     {
2794         response = m_ipcModule.createErrorResponse(message);
2795         m_ipcModule.appendString(response, INVALID_ARGUMENT);
2796     }
2797
2798     m_ipcModule.sendToClients(response, &clientHandle, 1);
2799     m_ipcModule.destroyMessage(response);
2800 }
2801
2802 void GenericCommunicator::processNotificationQueue()
2803 {
2804     NotificationQueue& notificationQueue = m_executor->getClientNotificationQueue();
2805     NotificationQueue::iterator iter = notificationQueue.begin();
2806     NotificationQueue::iterator end = notificationQueue.end();
2807
2808     for (; iter != end; ++iter)
2809     {
2810         GraphicalObject* object = iter->first;
2811         t_ilm_notification_mask mask = iter->second;
2812         sendNotification(object, mask);
2813     }
2814     notificationQueue.clear();
2815 }
2816
2817 void GenericCommunicator::sendNotification(GraphicalObject* object, t_ilm_notification_mask mask)
2818 {
2819     switch (object->type)
2820     {
2821     case TypeLayer:
2822     {
2823         Layer* layer = static_cast<Layer*>(object);
2824         if (layer)
2825         {
2826             ApplicationReferenceList& arl = layer->getNotificationClients();
2827
2828             if (arl.size())
2829             {
2830                 t_ilm_message notification;
2831                 Rectangle dest = layer->getDestinationRegion();
2832                 Rectangle src = layer->getSourceRegion();
2833                 OrientationType orientation = layer->getOrientation();
2834
2835                 unsigned char chromaKeyRed = 0;
2836                 unsigned char chromaKeyGreen = 0;
2837                 unsigned char chromaKeyBlue = 0;
2838                 layer->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
2839
2840                 std::stringstream notificationName;
2841                 notificationName << "NotificationForLayer" << layer->getID();
2842
2843                 notification = m_ipcModule.createNotification(notificationName.str().c_str());
2844                 m_ipcModule.appendUint(notification, layer->getID());
2845                 m_ipcModule.appendUint(notification, mask);
2846
2847                 m_ipcModule.appendDouble(notification, layer->getOpacity());
2848                 m_ipcModule.appendUint(notification, src.x);
2849                 m_ipcModule.appendUint(notification, src.y);
2850                 m_ipcModule.appendUint(notification, src.width);
2851                 m_ipcModule.appendUint(notification, src.height);
2852                 m_ipcModule.appendUint(notification, layer->OriginalSourceWidth);
2853                 m_ipcModule.appendUint(notification, layer->OriginalSourceHeight);
2854                 m_ipcModule.appendUint(notification, dest.x);
2855                 m_ipcModule.appendUint(notification, dest.y);
2856                 m_ipcModule.appendUint(notification, dest.width);
2857                 m_ipcModule.appendUint(notification, dest.height);
2858                 m_ipcModule.appendUint(notification, orientation);
2859                 m_ipcModule.appendBool(notification, layer->getVisibility());
2860                 m_ipcModule.appendUint(notification, layer->getLayerType());
2861                 m_ipcModule.appendBool(notification, layer->getChromaKeyEnabled());
2862                 m_ipcModule.appendUint(notification, chromaKeyRed);
2863                 m_ipcModule.appendUint(notification, chromaKeyGreen);
2864                 m_ipcModule.appendUint(notification, chromaKeyBlue);
2865                 m_ipcModule.appendInt(notification, layer->getCreatorPid());
2866
2867                 int clientCount = arl.size();
2868                 t_ilm_client_handle clientArray[256];
2869
2870                 ApplicationReferenceList::iterator iter = arl.begin();
2871                 ApplicationReferenceList::iterator end = arl.end();
2872
2873                 for (int clientNumber = 0;
2874                      iter != end, clientNumber < 256;
2875                      ++iter, ++clientNumber)
2876                 {
2877                     t_ilm_client_handle client = *iter;
2878                     clientArray[clientNumber] = client;
2879                 }
2880
2881                 LOG_DEBUG("GenericCommunicator", "Sending " << clientCount << " notification(s): layer " << layer->getID() << " was updated.");
2882
2883                 if (!m_ipcModule.sendToClients(notification, clientArray, clientCount))
2884                 {
2885                     LOG_ERROR("GenericCommunicator", "Sending notification to clients failed.")
2886                 }
2887
2888                 m_ipcModule.destroyMessage(notification);
2889             }
2890         }
2891     }
2892     break;
2893     case TypeSurface:
2894     {
2895         Surface* surface = static_cast<Surface*>(object);
2896         if (surface)
2897         {
2898             ApplicationReferenceList& arl = surface->getNotificationClients();
2899
2900             if (arl.size())
2901             {
2902                 t_ilm_message notification;
2903                 std::stringstream notificationName;
2904                 notificationName << "NotificationForSurface" << surface->getID();
2905
2906                 unsigned char chromaKeyRed = 0;
2907                 unsigned char chromaKeyGreen = 0;
2908                 unsigned char chromaKeyBlue = 0;
2909                 surface->getChromaKey(chromaKeyRed, chromaKeyGreen, chromaKeyBlue);
2910
2911                 notification = m_ipcModule.createNotification(notificationName.str().c_str());
2912                 m_ipcModule.appendUint(notification, surface->getID());
2913                 m_ipcModule.appendUint(notification, mask);
2914
2915                 m_ipcModule.appendDouble(notification, surface->getOpacity());
2916                 m_ipcModule.appendUint(notification, surface->getSourceRegion().x);
2917                 m_ipcModule.appendUint(notification, surface->getSourceRegion().y);
2918                 m_ipcModule.appendUint(notification, surface->getSourceRegion().width);
2919                 m_ipcModule.appendUint(notification, surface->getSourceRegion().height);
2920                 m_ipcModule.appendUint(notification, surface->OriginalSourceWidth);
2921                 m_ipcModule.appendUint(notification, surface->OriginalSourceHeight);
2922                 m_ipcModule.appendUint(notification, surface->getDestinationRegion().x);
2923                 m_ipcModule.appendUint(notification, surface->getDestinationRegion().y);
2924                 m_ipcModule.appendUint(notification, surface->getDestinationRegion().width);
2925                 m_ipcModule.appendUint(notification, surface->getDestinationRegion().height);
2926                 m_ipcModule.appendUint(notification, surface->getOrientation());
2927                 m_ipcModule.appendBool(notification, surface->getVisibility());
2928                 m_ipcModule.appendUint(notification, surface->frameCounter);
2929                 m_ipcModule.appendUint(notification, surface->drawCounter);
2930                 m_ipcModule.appendUint(notification, surface->updateCounter);
2931                 m_ipcModule.appendUint(notification, surface->getPixelFormat());
2932                 m_ipcModule.appendUint(notification, surface->getNativeContent());
2933                 m_ipcModule.appendUint(notification, surface->getInputEventAcceptanceOnDevices());
2934                 m_ipcModule.appendBool(notification, surface->getChromaKeyEnabled());
2935                 m_ipcModule.appendUint(notification, chromaKeyRed);
2936                 m_ipcModule.appendUint(notification, chromaKeyGreen);
2937                 m_ipcModule.appendUint(notification, chromaKeyBlue);
2938                 m_ipcModule.appendInt(notification, surface->getCreatorPid());
2939
2940                 int clientCount = arl.size();
2941                 t_ilm_client_handle clients[256];
2942
2943                 ApplicationReferenceList::iterator iter = arl.begin();
2944                 ApplicationReferenceList::iterator end = arl.end();
2945
2946                 for (int clientNumber = 0;
2947                      iter != end, clientNumber < 256;
2948                      ++iter, ++clientNumber)
2949                 {
2950                     clients[clientNumber] = *iter;
2951                 }
2952
2953                 LOG_DEBUG("GenericCommunicator", "Sending " << clientCount << " notification(s): surface " << surface->getID() << " was updated.");
2954
2955                 if (!m_ipcModule.sendToClients(notification, clients, clientCount))
2956                 {
2957                     LOG_ERROR("GenericCommunicator", "Sending notification to clients failed.")
2958                 }
2959
2960                 m_ipcModule.destroyMessage(notification);
2961             }
2962         }
2963     }
2964     break;
2965     default:
2966         LOG_INFO("GenericCommunicator", "Unknown notification found in queue.");
2967         break;
2968     }
2969 }
2970
2971 HealthCondition GenericCommunicator::pluginGetHealth()
2972 {
2973     HealthCondition health = PluginBase::pluginGetHealth();
2974     if (0 != pthread_kill(mThreadId, 0))
2975     {
2976         health = HealthDead;
2977     }
2978     return health;
2979 }
2980
2981 void GenericCommunicator::SetOptimizationMode(t_ilm_message message)
2982 {
2983     t_ilm_message response;
2984     OptimizationType optimizationId;
2985     OptimizationModeType optimizationMode;
2986     unsigned int o;
2987     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
2988     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
2989
2990     m_ipcModule.getUint(message,&o);
2991     optimizationId = (OptimizationType) o;
2992     m_ipcModule.getUint(message,&o);
2993     optimizationMode = (OptimizationModeType) o;
2994
2995     t_ilm_bool status = m_executor->execute(new SetOptimizationModeCommand(clientPid, optimizationId, optimizationMode));
2996     if (status)
2997     {
2998         response = m_ipcModule.createResponse(message);
2999     }
3000     else
3001     {
3002         response = m_ipcModule.createErrorResponse(message);
3003         m_ipcModule.appendString(response,RESOURCE_NOT_FOUND);
3004     }
3005     m_ipcModule.sendToClients(response,&clientHandle,1);
3006     m_ipcModule.destroyMessage(response);
3007 }
3008
3009 void GenericCommunicator::GetOptimizationMode(t_ilm_message message)
3010 {
3011     t_ilm_message response;
3012     t_ilm_client_handle clientHandle = m_ipcModule.getSenderHandle(message);
3013     t_ilm_uint clientPid = m_executor->getSenderPid(clientHandle);
3014     OptimizationType optimizationId;
3015     OptimizationModeType optimizationMode;
3016     unsigned int o;
3017
3018     m_ipcModule.getUint(message,&o);
3019     optimizationId = (OptimizationType)o;
3020
3021     t_ilm_bool status = m_executor->execute(new GetOptimizationModeCommand(clientPid, optimizationId, &optimizationMode));
3022     if (status)
3023     {
3024
3025         response = m_ipcModule.createResponse(message);
3026         m_ipcModule.appendUint(response,(unsigned int)optimizationMode);
3027     }
3028     else
3029     {
3030         response = m_ipcModule.createErrorResponse(message);
3031         m_ipcModule.appendString(response,RESOURCE_NOT_FOUND);
3032     }
3033     m_ipcModule.sendToClients(response,&clientHandle,1);
3034     m_ipcModule.destroyMessage(response);
3035
3036 }
3037
3038 DECLARE_LAYERMANAGEMENT_PLUGIN(GenericCommunicator)