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