/*********************************************************************
*                SEGGER MICROCONTROLLER SYSTEME GmbH                 *
*        Solutions for real time microcontroller applications        *
**********************************************************************
*                                                                    *
*        (c) 1996 - 2004  SEGGER Microcontroller Systeme GmbH        *
*                                                                    *
*        Internet: www.segger.com    Support:  support@segger.com    *
*                                                                    *
**********************************************************************

***** emWin - Graphical user interface for embedded applications *****
emWin is protected by international copyright laws.   Knowledge of the
source code may not be used to write a similar product.  This file may
only be used in accordance with a license and should not be re-
distributed in any way. We appreciate your understanding and fairness.
----------------------------------------------------------------------
File        : GUIDEV_Measure.c
Purpose     : Implementation of measurement devices
              The purpose of a measurement device is to find out the
              area (Rectangle) affected by a sequence of drawing
              operations.
---------------------------END-OF-HEADER------------------------------
*/


#include <string.h>
#include "GUI_Private.h"
#include "GUIDebug.h"
#if GUI_WINSUPPORT
  #include "WM.h"
#endif

/* Memory device capabilities are compiled only if support for them is enabled.*/ 
#if GUI_SUPPORT_MEMDEV

/*********************************************************************
*
*       typedefs
*
**********************************************************************
*/

typedef struct {
  GUI_RECT rUsed;
  tLCDDEV_Color2Index*  pfColor2Index;
  tLCDDEV_Index2Color*  pfIndex2Color;
  tLCDDEV_GetIndexMask* pfGetIndexMask;
} GUI_MEASDEV;

/*********************************************************************
*
*       defines
*
**********************************************************************
*/

#define GUI_MEASDEV_H2P(h) ((GUI_MEASDEV*)GUI_ALLOC_h2p(h))

/*********************************************************************
*
*       static code
*
**********************************************************************
*/
/*********************************************************************
*
*       _MarkPixel
*/
static void _MarkPixel(int x, int y) {
  GUI_MEASDEV* pDev = (GUI_MEASDEV*)(GUI_MEMDEV_H2P(GUI_Context.hDevData));
  if (x < pDev->rUsed.x0)
    pDev->rUsed.x0 = x;
  if (x > pDev->rUsed.x1)
    pDev->rUsed.x1 = x;
  if (y < pDev->rUsed.y0)
    pDev->rUsed.y0 = y;
  if (y > pDev->rUsed.y1)
    pDev->rUsed.y1 = y;
}

/*********************************************************************
*
*       _MarkRect
*/
static void _MarkRect(int x0, int y0, int x1, int y1) {
  GUI_MEASDEV* pDev = (GUI_MEASDEV*)(GUI_MEMDEV_H2P(GUI_Context.hDevData));
  if (x0 < pDev->rUsed.x0)
    pDev->rUsed.x0 = x0;
  if (x1 > pDev->rUsed.x1)
    pDev->rUsed.x1 = x1;
  if (y1 < pDev->rUsed.y0)
    pDev->rUsed.y0 = y0;
  if (y1 > pDev->rUsed.y1)
    pDev->rUsed.y1 = y1;
}

/*********************************************************************
*
*       _DrawBitmap
*/
static void _DrawBitmap(int x0, int y0, int xsize, int ysize,
                       int BitsPerPixel, int BytesPerLine,
                       const U8 GUI_UNI_PTR * pData, int Diff,
                       const LCD_PIXELINDEX* pTrans)
{
  GUI_USE_PARA(BitsPerPixel);
  GUI_USE_PARA(BytesPerLine);
  GUI_USE_PARA(pData);
  GUI_USE_PARA(Diff);
  GUI_USE_PARA(pTrans);
  _MarkRect(x0, y0, x0 + xsize - 1, y0 + ysize - 1);
}

/*********************************************************************
*
*       _DrawHLine
*/
static void _DrawHLine(int x0, int y,  int x1) {
  _MarkRect(x0, y, x1, y);
}

/*********************************************************************
*
*       _DrawVLine
*/
static void _DrawVLine(int x , int y0,  int y1) {
  _MarkRect(x, y0, x, y1);
}

/*********************************************************************
*
*       _SetPixelIndex
*/
static void _SetPixelIndex(int x, int y, int Index) {
  GUI_USE_PARA(Index);
  _MarkPixel(x, y);
}

/*********************************************************************
*
*       _XorPixel
*/
static void _XorPixel(int x, int y) {
  _MarkPixel(x, y);
}

/*********************************************************************
*
*       _GetPixelIndex
*/
static unsigned int _GetPixelIndex(int x, int y) { 
  GUI_USE_PARA(x);
  GUI_USE_PARA(y);
  return 0;
}

/*********************************************************************
*
*       _FillRect
*/
static void _FillRect(int x0, int y0, int x1, int y1) {
  _MarkRect(x0, y0, x1, y1);
}

/*********************************************************************
*
*       _GetRect
*/
static void _GetRect(LCD_RECT* pRect) {
  pRect->x0 = pRect->y0 = -4095;
  pRect->x1 = pRect->y1 =  4095;
}

/*********************************************************************
*
*       _Color2Index
*/
static unsigned int _Color2Index(LCD_COLOR Color) {
  GUI_MEASDEV* pDev = GUI_MEASDEV_H2P(GUI_Context.hDevData);
  return pDev->pfColor2Index(Color);
}

/*********************************************************************
*
*       _Index2Color
*/
static LCD_COLOR _Index2Color(int Index) {
  GUI_MEASDEV* pDev = GUI_MEASDEV_H2P(GUI_Context.hDevData);
  return pDev->pfIndex2Color(Index);
}

/*********************************************************************
*
*       _GetIndexMask
*/
static unsigned int _GetIndexMask(void) {
  GUI_MEASDEV* pDev = GUI_MEASDEV_H2P(GUI_Context.hDevData);
  return pDev->pfGetIndexMask();
}

/*********************************************************************
*
*       _CalcPolyRect
*/
static void _CalcPolyRect(GUI_RECT *pr, const GUI_POINT* paPoint, int NumPoints) {
  int i;
  int xMin, xMax, yMin, yMax;
  xMin = GUI_XMAX;
  yMin = GUI_YMAX;
  xMax = GUI_XMIN;
  yMax = GUI_YMIN;
  for (i = 0; i  <NumPoints; i++) {
    int x = paPoint->x;
    int y = paPoint->y;
    if (xMin > x)
      xMin = x;
    if (xMax < x)
      xMax = x;
    if (yMin > y)
      yMin = y;
    if (yMax < y)
      yMax = y;
    paPoint++;
  }
  pr->x0 = xMin;
  pr->x1 = xMax;
  pr->y0 = yMin;
  pr->y1 = yMax;
}

/*********************************************************************
*
*       _FillPolygon
*/
static void _FillPolygon(const GUI_POINT* paPoint, int NumPoints, int x0, int y0) {
  GUI_RECT r;
  _CalcPolyRect(&r, paPoint, NumPoints);
  GUI_MoveRect(&r, x0, y0);
  _MarkRect(r.x0, r.y0, r.x1, r.y1);
}

/*********************************************************************
*
*       _FillPolygonAA
*/
static void _FillPolygonAA(const GUI_POINT* paPoint, int NumPoints, int x0, int y0) {
  #if GUI_SUPPORT_AA
    GUI_RECT r;
    _CalcPolyRect(&r, paPoint, NumPoints);
    GUI_MoveRect(&r, x0, y0);
    if (GUI_Context.AA_HiResEnable) {
      r.x0 /= GUI_Context.AA_Factor;
      r.y0 /= GUI_Context.AA_Factor;
      r.x1 = (r.x1 + GUI_Context.AA_Factor - 1) / GUI_Context.AA_Factor;
      r.y1 = (r.y1 + GUI_Context.AA_Factor - 1) / GUI_Context.AA_Factor;
    }
    _MarkRect(r.x0, r.y0, r.x1, r.y1);
  #else
    GUI_USE_PARA(paPoint);
    GUI_USE_PARA(NumPoints);
    GUI_USE_PARA(x0);
    GUI_USE_PARA(y0);
  #endif
}

/*********************************************************************
*
*             Device structure
*/
static const tLCDDEV_APIList _APIList = {
  _Color2Index,
  _Index2Color,
  _GetIndexMask,
  (tLCDDEV_DrawBitmap*)_DrawBitmap,
  _DrawHLine,
  _DrawVLine,
  _FillRect,
  _GetPixelIndex,
  _GetRect,
  _SetPixelIndex,
  _XorPixel,
  NULL,
  _FillPolygon,
  _FillPolygonAA
};

/*********************************************************************
*
*       Exported routines
*
**********************************************************************
*/
/*********************************************************************
*
*       GUI_MEASDEV_Delete
*/
void GUI_MEASDEV_Delete(GUI_MEASDEV_Handle hMemDev) {
  /* Make sure memory device is not used */
  if ((GUI_Context.hDevData = hMemDev) != 0) {
	  GUI_SelectLCD();
  }
  GUI_ALLOC_Free(hMemDev);
}

/*********************************************************************
*
*       GUI_MEASDEV_ClearRect
*/
void GUI_MEASDEV_ClearRect(GUI_MEASDEV_Handle hMemDev) {
  if (hMemDev) {
    GUI_MEASDEV* pDevData;
    GUI_LOCK();
    pDevData = (GUI_MEASDEV*)GUI_ALLOC_h2p(hMemDev);
    pDevData->rUsed.x0 = GUI_XMAX;
    pDevData->rUsed.y0 = GUI_YMAX;
    pDevData->rUsed.x1 = GUI_XMIN;
    pDevData->rUsed.y1 = GUI_YMIN;
    GUI_UNLOCK();
  } 
}

/*********************************************************************
*
*       GUI_MEASDEV_Create
*/
GUI_MEASDEV_Handle GUI_MEASDEV_Create(void) {
  int MemSize;
  GUI_MEASDEV_Handle hMemDev;
  MemSize = sizeof(GUI_MEASDEV);
  hMemDev = GUI_ALLOC_AllocZero(MemSize);
  if (hMemDev) {
    GUI_MEASDEV* pDevData;
    GUI_LOCK();
    pDevData = (GUI_MEASDEV*)GUI_ALLOC_h2p(hMemDev);
    pDevData->pfColor2Index = GUI_Context.pDeviceAPI->pfColor2Index;    
    pDevData->pfIndex2Color = GUI_Context.pDeviceAPI->pfIndex2Color;
    GUI_MEASDEV_ClearRect(hMemDev);
    GUI_UNLOCK();
  } else {
    GUI_DEBUG_WARN("GUI_MEASDEV_Create: Alloc failed");
  }
  return hMemDev;
}

/*********************************************************************
*
*       GUI_MEASDEV_Select
*/
void GUI_MEASDEV_Select(GUI_MEASDEV_Handle hMem) {
  if (hMem == 0) {
    GUI_SelectLCD();
  } else {
    #if GUI_WINSUPPORT
      WM_Deactivate();
    #endif
    GUI_Context.hDevData     = hMem;
    GUI_Context.pDeviceAPI   = &_APIList;
    GUI_Context.pClipRect_HL = NULL;
    LCD_SetClipRectMax();
  }
}

/*********************************************************************
*
*       GUI_MEASDEV_GetRect
*/
void GUI_MEASDEV_GetRect(GUI_MEASDEV_Handle hMem, GUI_RECT* pRect) {
  if (hMem) {
    GUI_MEASDEV* pDev;
    GUI_LOCK();
    pDev = (GUI_MEASDEV*)GUI_ALLOC_h2p(hMem);
    if (pRect) {
      pRect->x0 = pDev->rUsed.x0;
      pRect->y0 = pDev->rUsed.y0;
      pRect->x1 = pDev->rUsed.x1;
      pRect->y1 = pDev->rUsed.y1;
    }
    GUI_UNLOCK();
  }
}

#else

void GUIDEV_Measure(void) {} /* avoid empty object files */

#endif /* GUI_MEMDEV_SUPPORT */

/*************************** end of file ****************************/