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