libfreerdp-utils/event.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol client.
   3  * Events
   4  *
   5  * Copyright 2011 Vic Lee
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <freerdp/utils/memory.h>
  24 #include <freerdp/utils/event.h>
  25 #include <freerdp/plugins/cliprdr.h>
  26 #include <freerdp/plugins/tsmf.h>
  27 #include <freerdp/rail.h>
  28
  29 static RDP_EVENT* freerdp_cliprdr_event_new(uint16 event_type)
  30 {
  31         RDP_EVENT* event = NULL;
  32
  33         switch (event_type)
  34         {
  35                 case RDP_EVENT_TYPE_CB_MONITOR_READY:
  36                         event = (RDP_EVENT*) xnew(RDP_CB_MONITOR_READY_EVENT);
  37                         break;
  38                 case RDP_EVENT_TYPE_CB_FORMAT_LIST:
  39                         event = (RDP_EVENT*) xnew(RDP_CB_FORMAT_LIST_EVENT);
  40                         break;
  41                 case RDP_EVENT_TYPE_CB_DATA_REQUEST:
  42                         event = (RDP_EVENT*) xnew(RDP_CB_DATA_REQUEST_EVENT);
  43                         break;
  44                 case RDP_EVENT_TYPE_CB_DATA_RESPONSE:
  45                         event = (RDP_EVENT*) xnew(RDP_CB_DATA_RESPONSE_EVENT);
  46                         break;
  47         }
  48
  49         return event;
  50 }
  51
  52 static RDP_EVENT* freerdp_tsmf_event_new(uint16 event_type)
  53 {
  54         RDP_EVENT* event = NULL;
  55
  56         switch (event_type)
  57         {
  58                 case RDP_EVENT_TYPE_TSMF_VIDEO_FRAME:
  59                         event = (RDP_EVENT*) xnew(RDP_VIDEO_FRAME_EVENT);
  60                         break;
  61                 case RDP_EVENT_TYPE_TSMF_REDRAW:
  62                         event = (RDP_EVENT*) xnew(RDP_REDRAW_EVENT);
  63                         break;
  64         }
  65
  66         return event;
  67 }
  68
  69 static RDP_EVENT* freerdp_rail_event_new(uint16 event_type)
  70 {
  71         RDP_EVENT* event = NULL;
  72         event = xnew(RDP_EVENT);
  73         return event;
  74 }
  75
  76 RDP_EVENT* freerdp_event_new(uint16 event_class, uint16 event_type,
  77         RDP_EVENT_CALLBACK on_event_free_callback, void* user_data)
  78 {
  79         RDP_EVENT* event = NULL;
  80
  81         switch (event_class)
  82         {
  83                 case RDP_EVENT_CLASS_DEBUG:
  84                         event = xnew(RDP_EVENT);
  85                         break;
  86                 case RDP_EVENT_CLASS_CLIPRDR:
  87                         event = freerdp_cliprdr_event_new(event_type);
  88                         break;
  89                 case RDP_EVENT_CLASS_TSMF:
  90                         event = freerdp_tsmf_event_new(event_type);
  91                         break;
  92                 case RDP_EVENT_CLASS_RAIL:
  93                         event = freerdp_rail_event_new(event_type);
  94                         break;
  95         }
  96
  97         if (event != NULL)
  98         {
  99                 event->event_class = event_class;
 100                 event->event_type = event_type;
 101                 event->on_event_free_callback = on_event_free_callback;
 102                 event->user_data = user_data;
 103         }
 104
 105         return event;
 106 }
 107
 108 static void freerdp_cliprdr_event_free(RDP_EVENT* event)
 109 {
 110         switch (event->event_type)
 111         {
 112                 case RDP_EVENT_TYPE_CB_FORMAT_LIST:
 113                         {
 114                                 RDP_CB_FORMAT_LIST_EVENT* cb_event = (RDP_CB_FORMAT_LIST_EVENT*)event;
 115                                 xfree(cb_event->formats);
 116                                 xfree(cb_event->raw_format_data);
 117                         }
 118                         break;
 119                 case RDP_EVENT_TYPE_CB_DATA_RESPONSE:
 120                         {
 121                                 RDP_CB_DATA_RESPONSE_EVENT* cb_event = (RDP_CB_DATA_RESPONSE_EVENT*)event;
 122                                 xfree(cb_event->data);
 123                         }
 124                         break;
 125         }
 126 }
 127
 128 static void freerdp_tsmf_event_free(RDP_EVENT* event)
 129 {
 130         switch (event->event_type)
 131         {
 132                 case RDP_EVENT_TYPE_TSMF_VIDEO_FRAME:
 133                         {
 134                                 RDP_VIDEO_FRAME_EVENT* vevent = (RDP_VIDEO_FRAME_EVENT*)event;
 135                                 xfree(vevent->frame_data);
 136                                 xfree(vevent->visible_rects);
 137                         }
 138                         break;
 139         }
 140 }
 141
 142 static void freerdp_rail_event_free(RDP_EVENT* event)
 143 {
 144 }
 145
 146 void freerdp_event_free(RDP_EVENT* event)
 147 {
 148         if (event != NULL)
 149         {
 150                 if (event->on_event_free_callback != NULL)
 151                         event->on_event_free_callback(event);
 152
 153                 switch (event->event_class)
 154                 {
 155                         case RDP_EVENT_CLASS_CLIPRDR:
 156                                 freerdp_cliprdr_event_free(event);
 157                                 break;
 158                         case RDP_EVENT_CLASS_TSMF:
 159                                 freerdp_tsmf_event_free(event);
 160                                 break;
 161                         case RDP_EVENT_CLASS_RAIL:
 162                                 freerdp_rail_event_free(event);
 163                                 break;
 164                 }
 165                 xfree(event);
 166         }
 167 }