/*
*********************************************************************************************************
*                                                uC/GUI
*                        Universal graphic software for embedded applications
*
*                       (c) Copyright 2002, Micrium Inc., Weston, FL
*                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
*
*              礐/GUI 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 redistributed
*              in any way. We appreciate your understanding and fairness.
*
----------------------------------------------------------------------
File        : HEADER.c
Purpose     : Implementation of header widget
---------------------------END-OF-HEADER------------------------------
*/

#include <stdlib.h>
#include <string.h>

#include "HEADER_Private.h"
#include "SCROLLBAR.h"
#include "GUI.h"

#if GUI_WINSUPPORT

/*********************************************************************
*
*       Private config defaults
*
**********************************************************************
*/

#ifndef HEADER_SUPPORT_DRAG
  #define HEADER_SUPPORT_DRAG 1
#endif

#ifndef HEADER_BORDER_V_DEFAULT
  #define HEADER_BORDER_V_DEFAULT 0
#endif

#ifndef HEADER_BORDER_H_DEFAULT
  #define HEADER_BORDER_H_DEFAULT 2
#endif

/* Define default fonts */
#ifndef HEADER_FONT_DEFAULT
  #define HEADER_FONT_DEFAULT &GUI_Font13_1
#endif

/* Define colors */
#ifndef HEADER_BKCOLOR_DEFAULT
  #define HEADER_BKCOLOR_DEFAULT 0xAAAAAA
#endif

#ifndef HEADER_TEXTCOLOR_DEFAULT
  #define HEADER_TEXTCOLOR_DEFAULT GUI_BLACK
#endif

/* Define cursors */
#ifndef HEADER_CURSOR_DEFAULT
  #define HEADER_CURSOR_DEFAULT &GUI_CursorHeaderM
#endif

/*********************************************************************
*
*       Static data
*
**********************************************************************
*/

/* Remember the old cursor */
static const GUI_CURSOR GUI_UNI_PTR * _pOldCursor;

/* Default values */
static const GUI_CURSOR GUI_UNI_PTR * _pDefaultCursor   = HEADER_CURSOR_DEFAULT;
static GUI_COLOR          _DefaultBkColor   = HEADER_BKCOLOR_DEFAULT;
static GUI_COLOR          _DefaultTextColor = HEADER_TEXTCOLOR_DEFAULT;
static int                _DefaultBorderH   = HEADER_BORDER_H_DEFAULT;
static int                _DefaultBorderV   = HEADER_BORDER_V_DEFAULT;
static const GUI_FONT GUI_UNI_PTR *   _pDefaultFont     = HEADER_FONT_DEFAULT;

/*********************************************************************
*
*       static routines
*
**********************************************************************
*/
/*********************************************************************
*
*       _Paint
*/
static void _Paint(/*HEADER_Handle hObj, */HEADER_Obj* pObj) {
  GUI_RECT Rect;
  int i, xPos = -pObj->ScrollPos;
  int NumItems = GUI_ARRAY_GetNumItems(&pObj->Columns);
  int EffectSize = pObj->Widget.pEffect->EffectSize;
  LCD_SetBkColor(pObj->BkColor);
  GUI_SetFont(pObj->pFont);
  GUI_Clear();
  for (i = 0; i < NumItems; i++) {
    HEADER_COLUMN * pColumn = (HEADER_COLUMN*)GUI_ARRAY_GetpItem(&pObj->Columns, i);
    GUI_GetClientRect(&Rect);
    Rect.x0 = xPos;
    Rect.x1 = Rect.x0 + pColumn->Width;
    if (pColumn->hDrawObj) {
      int xOff = 0, yOff = 0;
      switch (pColumn->Align & GUI_TA_HORIZONTAL) {
        case GUI_TA_RIGHT:
          xOff = (pColumn->Width - GUI_DRAW__GetXSize(pColumn->hDrawObj));
          break;
        case GUI_TA_HCENTER:
          xOff = (pColumn->Width - GUI_DRAW__GetXSize(pColumn->hDrawObj)) / 2;
          break;
      }
      switch (pColumn->Align & GUI_TA_VERTICAL) {
	      case GUI_TA_BOTTOM:
          yOff = ((Rect.y1 - Rect.y0 + 1) - GUI_DRAW__GetYSize(pColumn->hDrawObj));
          break;
	      case GUI_TA_VCENTER:
          yOff = ((Rect.y1 - Rect.y0 + 1) - GUI_DRAW__GetYSize(pColumn->hDrawObj)) / 2;
          break;
      }
      WM_SetUserClipRect(&Rect);
      GUI_DRAW__Draw(pColumn->hDrawObj, xPos + xOff, yOff);
      WM_SetUserClipRect(NULL);
    }
    WIDGET__EFFECT_DrawUpRect(&pObj->Widget, &Rect);
    xPos += Rect.x1 - Rect.x0;
    Rect.x0 += EffectSize + _DefaultBorderH;
    Rect.x1 -= EffectSize + _DefaultBorderH;
    Rect.y0 += EffectSize + _DefaultBorderV;
    Rect.y1 -= EffectSize + _DefaultBorderV;
    LCD_SetColor(pObj->TextColor);
    GUI_DispStringInRect(pColumn->acText, &Rect, pColumn->Align);
  }
  GUI_GetClientRect(&Rect);
  Rect.x0 = xPos;
  Rect.x1 = 0xfff;
  WIDGET__EFFECT_DrawUpRect(&pObj->Widget, &Rect);
}

/*********************************************************************
*
*       _RestoreOldCursor
*/
static void _RestoreOldCursor(void) {
  if (_pOldCursor) {
    #if GUI_SUPPORT_CURSOR
      GUI_CURSOR_Select(_pOldCursor);
    #endif
    _pOldCursor = 0;
  }
}

/*********************************************************************
*
*       _FreeAttached
*
* Delete attached objects (if any)
*/
static void _FreeAttached(HEADER_Obj * pObj) {
  int i, NumItems;
  NumItems = GUI_ARRAY_GetNumItems(&pObj->Columns);
  for (i = 0; i < NumItems; i++) {
    HEADER_COLUMN * pColumn = (HEADER_COLUMN*)GUI_ARRAY_GetpItem(&pObj->Columns, i);
    if (pColumn->hDrawObj) {
      GUI_ALLOC_Free(pColumn->hDrawObj);
    }
  }
  /* Delete attached objects (if any) */
  GUI_ARRAY_Delete(&pObj->Columns);
  _RestoreOldCursor();
}

/*********************************************************************
*
*       _GetItemIndex
*/
#if (HEADER_SUPPORT_DRAG)
static int _GetItemIndex(HEADER_Handle hObj, HEADER_Obj * pObj, int x, int y) {
  int Item = -1;
  if ((y >= 0) && (y < WM_GetWindowSizeY(hObj))) {
    if (hObj) {
      int Index, xPos = 0, NumColumns;
      NumColumns = GUI_ARRAY_GetNumItems(&pObj->Columns);
      for (Index = 0; Index < NumColumns; Index++) {
        HEADER_COLUMN * pColumn;
        pColumn = (HEADER_COLUMN *)GUI_ARRAY_GetpItem(&pObj->Columns, Index);
        xPos += pColumn->Width;
        if ((xPos >= (x - 4)) && (xPos <= (x + 4))) {
          Item = Index;
          if ((Index < (NumColumns - 1)) && (x < xPos)) {
            pColumn = (HEADER_COLUMN *)GUI_ARRAY_GetpItem(&pObj->Columns, Index + 1);
            if (pColumn->Width == 0) {
              break;
            }
          }
        }
      }
    }
  }
  return Item;
}
#endif

/*********************************************************************
*
*       _HandlePID
*/
#if (HEADER_SUPPORT_DRAG)
static void _HandlePID(HEADER_Handle hObj, HEADER_Obj * pObj, int x, int y, int Pressed) {
  int Hit = _GetItemIndex(hObj, pObj, x, y);
  /* set capture position () */
  if ((Pressed == 1) && (Hit >= 0) && (pObj->CapturePosX == -1)) {
    pObj->CapturePosX = x;
    pObj->CaptureItem = Hit;
  }
  /* set mouse cursor and capture () */
  if (Hit >= 0) {
    WM_SetCapture(hObj, 1);
    #if GUI_SUPPORT_CURSOR
      if (!_pOldCursor) {
        _pOldCursor = GUI_CURSOR_Select(_pDefaultCursor);
      }
    #endif
  }
  /* modify header */
  if ((pObj->CapturePosX >= 0) && (x != pObj->CapturePosX) && (Pressed == 1)) {
    int NewSize = HEADER_GetItemWidth(hObj, pObj->CaptureItem) + x - pObj->CapturePosX;
    if (NewSize >= 0) {
      HEADER_SetItemWidth(hObj, pObj->CaptureItem, NewSize);
      pObj->CapturePosX = x;
    }
  }
  /* release capture & restore cursor */
  if (Pressed <= 0) {
    #if (GUI_SUPPORT_MOUSE)
    if (Hit == -1)
    #endif
    {
      _RestoreOldCursor();
      pObj->CapturePosX = -1;
      WM_ReleaseCapture();
    }
  }
}
#endif

/*********************************************************************
*
*       _OnMouseOver
*/
#if (HEADER_SUPPORT_DRAG & GUI_SUPPORT_MOUSE)
static void _OnMouseOver(HEADER_Handle hObj, HEADER_Obj * pObj, WM_MESSAGE * pMsg) {
  const GUI_PID_STATE * pState = (const GUI_PID_STATE *)pMsg->Data.p;
  if (pState) {
    _HandlePID(hObj, pObj, pState->x + pObj->ScrollPos, pState->y, -1);
  }
}
#endif

/*********************************************************************
*
*       _OnTouch
*/
#if (HEADER_SUPPORT_DRAG)
static void _OnTouch(HEADER_Handle hObj, HEADER_Obj * pObj, WM_MESSAGE * pMsg) {
  int Notification;
  const GUI_PID_STATE * pState = (const GUI_PID_STATE *)pMsg->Data.p;
  if (pState) {
    _HandlePID(hObj, pObj, pState->x + pObj->ScrollPos, pState->y, pState->Pressed);
  }
  if (pMsg->Data.p) {  /* Something happened in our area (pressed or released) */
    if (pState->Pressed) {
      Notification = WM_NOTIFICATION_CLICKED;
    } else {
      Notification = WM_NOTIFICATION_RELEASED;
    }
  } else {
    Notification = WM_NOTIFICATION_MOVED_OUT;
  }
  WM_NotifyParent(hObj, Notification);
}
#endif

/*********************************************************************
*
*       _HEADER_Callback
*/
static void _HEADER_Callback (WM_MESSAGE *pMsg) {
  HEADER_Handle hObj;
  HEADER_Obj * pObj;
  hObj = pMsg->hWin;
  /* Let widget handle the standard messages */
  if (WIDGET_HandleActive(hObj, pMsg) == 0) {
    return;
  }
  WM_LOCK();
  pObj = HEADER_H2P(hObj);
  switch (pMsg->MsgId) {
    case WM_PAINT:
      _Paint(/*hObj, */pObj);
      break;
#if (HEADER_SUPPORT_DRAG)
    case WM_TOUCH:
      _OnTouch(hObj, pObj, pMsg);
      break;
#endif
#if (HEADER_SUPPORT_DRAG & GUI_SUPPORT_MOUSE)
    case WM_MOUSEOVER:
      _OnMouseOver(hObj, pObj, pMsg);
      break;
#endif
    case WM_DELETE:
      _FreeAttached(pObj); /* No return here ... WM_DefaultProc needs to be called */
    default:
      WM_DefaultProc(pMsg);
  }
  WM_UNLOCK();
}

/*********************************************************************
*
*       Exported routines:  Create
*
**********************************************************************
*/
/*********************************************************************
*
*       HEADER_Create
*/
HEADER_Handle HEADER_Create(int x0, int y0, int xsize, int ysize, WM_HWIN hParent, int Id, int Flags, int ExFlags) {
  return HEADER_CreateEx(x0, y0, xsize, ysize, hParent, Flags, ExFlags, Id);
}

/*********************************************************************
*
*       HEADER_CreateEx
*/
HEADER_Handle HEADER_CreateEx(int x0, int y0, int xsize, int ysize, WM_HWIN hParent,
                              int WinFlags, int ExFlags, int Id)
{
  HEADER_Handle hObj;
  GUI_USE_PARA(ExFlags);
  /* Create the window */
  WM_LOCK();
  if ((xsize == 0) && (x0 == 0) && (y0 == 0)) {
    GUI_RECT Rect;
    WM_GetInsideRectEx(hParent, &Rect);
    xsize = Rect.x1 - Rect.x0 + 1;
    x0    = Rect.x0;
    y0    = Rect.y0;
  }
  if (ysize == 0) {
    const WIDGET_EFFECT* pEffect = WIDGET_GetDefaultEffect();