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