core/graphics.c

 
#include <freerdp/config.h>
 
#include <winpr/crt.h>
 
#include <freerdp/graphics.h>
 
#include "graphics.h"
 
/* Bitmap Class */
 
rdpBitmap* Bitmap_Alloc(rdpContext* context)
{
  rdpBitmap* bitmap = NULL;
  rdpGraphics* graphics = NULL;
  graphics = context->graphics;
  bitmap = (rdpBitmap*)calloc(1, graphics->Bitmap_Prototype->size);
 
  if (bitmap)
  {
    *bitmap = *graphics->Bitmap_Prototype;
    bitmap->data = NULL;
  }
 
  return bitmap;
}
 
void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
{
  if (bitmap)
    bitmap->Free(context, bitmap);
}
 
BOOL Bitmap_SetRectangle(rdpBitmap* bitmap, UINT16 left, UINT16 top, UINT16 right, UINT16 bottom)
{
  if (!bitmap)
    return FALSE;
 
  bitmap->left = left;
  bitmap->top = top;
  bitmap->right = right;
  bitmap->bottom = bottom;
  return TRUE;
}
 
BOOL Bitmap_SetDimensions(rdpBitmap* bitmap, UINT16 width, UINT16 height)
{
  if (!bitmap)
    return FALSE;
 
  bitmap->right = bitmap->left + width - 1;
  bitmap->bottom = bitmap->top + height - 1;
  bitmap->width = width;
  bitmap->height = height;
  return TRUE;
}
 
void graphics_register_bitmap(rdpGraphics* graphics, const rdpBitmap* bitmap)
{
  WINPR_ASSERT(graphics);
  WINPR_ASSERT(graphics->Bitmap_Prototype);
  WINPR_ASSERT(bitmap);
 
  *graphics->Bitmap_Prototype = *bitmap;
}
 
/* Pointer Class */
rdpPointer* Pointer_Alloc(rdpContext* context)
{
  rdpPointer* pointer = NULL;
  rdpGraphics* graphics = NULL;
  graphics = context->graphics;
  pointer = (rdpPointer*)calloc(1, graphics->Pointer_Prototype->size);
 
  if (pointer)
  {
    *pointer = *graphics->Pointer_Prototype;
  }
 
  return pointer;
}
 
/* static method */
void graphics_register_pointer(rdpGraphics* graphics, const rdpPointer* pointer)
{
  WINPR_ASSERT(graphics);
  WINPR_ASSERT(graphics->Pointer_Prototype);
  WINPR_ASSERT(pointer);
 
  *graphics->Pointer_Prototype = *pointer;
}
 
/* Glyph Class */
 
rdpGlyph* Glyph_Alloc(rdpContext* context, INT32 x, INT32 y, UINT32 cx, UINT32 cy, UINT32 cb,
                      const BYTE* aj)
{
  rdpGlyph* glyph = NULL;
  rdpGraphics* graphics = NULL;
 
  if (!context || !context->graphics)
    return NULL;
 
  graphics = context->graphics;
 
  if (!graphics->Glyph_Prototype)
    return NULL;
 
  glyph = (rdpGlyph*)calloc(1, graphics->Glyph_Prototype->size);
 
  if (!glyph)
    return NULL;
 
  *glyph = *graphics->Glyph_Prototype;
  glyph->cb = cb;
  glyph->cx = cx;
  glyph->cy = cy;
  glyph->x = x;
  glyph->y = y;
  glyph->aj = malloc(glyph->cb);
 
  if (!glyph->aj)
  {
    free(glyph);
    return NULL;
  }
 
  CopyMemory(glyph->aj, aj, cb);
 
  if (!glyph->New(context, glyph))
  {
    free(glyph->aj);
    free(glyph);
    return NULL;
  }
 
  return glyph;
}
 
void graphics_register_glyph(rdpGraphics* graphics, const rdpGlyph* glyph)
{
  WINPR_ASSERT(graphics);
  WINPR_ASSERT(graphics->Glyph_Prototype);
  WINPR_ASSERT(glyph);
 
  *graphics->Glyph_Prototype = *glyph;
}
 
/* Graphics Module */
 
rdpGraphics* graphics_new(rdpContext* context)
{
  rdpGraphics* graphics = NULL;
  graphics = (rdpGraphics*)calloc(1, sizeof(rdpGraphics));
 
  if (graphics)
  {
    graphics->context = context;
    graphics->Bitmap_Prototype = (rdpBitmap*)calloc(1, sizeof(rdpBitmap));
 
    if (!graphics->Bitmap_Prototype)
    {
      free(graphics);
      return NULL;
    }
 
    graphics->Bitmap_Prototype->size = sizeof(rdpBitmap);
    graphics->Pointer_Prototype = (rdpPointer*)calloc(1, sizeof(rdpPointer));
 
    if (!graphics->Pointer_Prototype)
    {
      free(graphics->Bitmap_Prototype);
      free(graphics);
      return NULL;
    }
 
    graphics->Pointer_Prototype->size = sizeof(rdpPointer);
    graphics->Glyph_Prototype = (rdpGlyph*)calloc(1, sizeof(rdpGlyph));
 
    if (!graphics->Glyph_Prototype)
    {
      free(graphics->Pointer_Prototype);
      free(graphics->Bitmap_Prototype);
      free(graphics);
      return NULL;
    }
 
    graphics->Glyph_Prototype->size = sizeof(rdpGlyph);
  }
 
  return graphics;
}
 
void graphics_free(rdpGraphics* graphics)
{
  if (graphics)
  {
    free(graphics->Bitmap_Prototype);
    free(graphics->Pointer_Prototype);
    free(graphics->Glyph_Prototype);
    free(graphics);
  }
}