header.c

ucgui的3.98版本的源代码

/*
*********************************************************************************************************
*                                             uC/GUI V3.98
*                        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
  #if   WIDGET_USE_SCHEME_SMALL
    #define HEADER_FONT_DEFAULT &GUI_Font13_1
  #elif WIDGET_USE_SCHEME_MEDIUM
    #define HEADER_FONT_DEFAULT &GUI_Font16_1
  #elif WIDGET_USE_SCHEME_LARGE
    #define HEADER_FONT_DEFAULT &GUI_Font24_1
  #endif
#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
*
**********************************************************************
*/
/*********************************************************************
*
*       _DrawTriangle
*/
static void _DrawTriangle(int x, int y, int Size, int Inc) {
  for (; Size >= 0; Size--, y += Inc) {
    GUI_DrawHLine(y, x - Size, x + Size);
  }
}

/*********************************************************************
*
*       _Paint
*/
static void _Paint(HEADER_Obj* pObj) {
  GUI_RECT Rect, RectItem;
  int i, xPos = -pObj->ScrollPos;
  int NumItems = GUI_ARRAY_GetNumItems(&pObj->Columns);
  int EffectSize = pObj->Widget.pEffect->EffectSize;
  int ArrowSize, ArrowPos;
  LCD_SetBkColor(pObj->BkColor);
  GUI_SetFont(pObj->pFont);
  GUI_Clear();
  for (i = 0; i < NumItems; i++) {
    int Subtract = 0;
    HEADER_COLUMN * pColumn = (HEADER_COLUMN*)GUI_ARRAY_GetpItem(&pObj->Columns, i);
    GUI_GetClientRect(&Rect);
    Rect.x0 = xPos;
    Rect.x1 = Rect.x0 + pColumn->Width;
    RectItem = Rect;
    ArrowSize = ((RectItem.y1 - RectItem.y0 - EffectSize * 2) / 3) - 1;
    ArrowPos = RectItem.x1 - 4 - ArrowSize;
    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);
    if ((pObj->DirIndicatorColumn == i) && ((pColumn->Align & GUI_TA_HORIZONTAL) == GUI_TA_RIGHT)) {
      Subtract = (ArrowSize << 1) + 1;
    }
    Rect.x1 -= Subtract;
    GUI_DispStringInRect(pColumn->acText, &Rect, pColumn->Align);
    Rect.x1 += Subtract;
    if (pObj->DirIndicatorColumn == i) {
      LCD_SetColor(GUI_BLACK);
      WM_SetUserClipRect(&RectItem);
      if (pObj->DirIndicatorReverse == 0) {
        _DrawTriangle(ArrowPos, ((Rect.y1 - Rect.y0) >> 1), ArrowSize, 1);
      } else {
        _DrawTriangle(ArrowPos, ((Rect.y1 - Rect.y0) >> 1) + ArrowSize, ArrowSize, -1);
      }
      WM_SetUserClipRect(NULL);
    }
  }
  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();
}

/*********************************************************************
*
*       _GetDividerIndex
*/
#if (HEADER_SUPPORT_DRAG)
static int _GetDividerIndex(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

/*********************************************************************
*
*       _LimitDragWitdh
*
* Purpose:
*   Limits dragging of the captured header item to the right border of the window.
*
* Return value:
*   1 - If function has limitted the clipped header item
*   0 - If function has not limitted the clipped header item
*/
static int _LimitDragWitdh(HEADER_Handle hObj, HEADER_Obj * pObj) {
  if (pObj->DragLimit) {
    int DragLimit, i, SumX;
    GUI_RECT Rect;
    WM_HWIN hVScroll, hParent;
    /* Take the x-size of the widgets client rectangle as limit */
    WM_GetClientRectEx(hObj, &Rect);
    DragLimit = Rect.x1;
    /* If the parent window has a vertical scrollbar, reduce the drag limit by the xsize of the scrollbar */
    hParent = WM_GetParent(hObj);
    if (hParent) {
      hVScroll = WM_GetScrollbarV(WM_GetParent(hObj));
      if (hVScroll) {
        DragLimit -= WM_GetWindowSizeX(hVScroll);
      }
    }
    /* Calculate the sum of the width of all header items */
    for (SumX = i = 0; i <= pObj->CaptureItem; i++) {
      SumX += HEADER_GetItemWidth(hObj, i);
    }
    /* If the sum of the width of all header items exeeds the limit, limit the captured item */
    if (SumX > DragLimit) {
      for (SumX = i = 0; i < pObj->CaptureItem; i++) {
        SumX += HEADER_GetItemWidth(hObj, i);
      }
      HEADER_SetItemWidth(hObj, pObj->CaptureItem, DragLimit - SumX);
      return 1;
    }
  }
  return 0;
}

/*********************************************************************
*
*       _HandlePID
*/
#if (HEADER_SUPPORT_DRAG)
static void _HandlePID(HEADER_Handle hObj, HEADER_Obj * pObj, int x, int y, int Pressed) {
  int Hit = _GetDividerIndex(hObj, pObj, x, y);
  /* set capture position */
  if ((Pressed == 1) && (Hit >= 0) && (pObj->CapturePosX == -1)) {
    pObj->CapturePosX = x;
    pObj->CaptureItem = Hit;
  }
  if (Pressed <= 0) {
    pObj->CapturePosX = -1;
  }
  /* 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);
      if (!_LimitDragWitdh(hObj, pObj)) {
        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

/*********************************************************************
*
*       _GetItemIndex
*/
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);
        if ((x > (xPos + 4)) && (x < (xPos + pColumn->Width - 4))) {
          Item = Index;
          break;
        }
        xPos += pColumn->Width;
      }
    }
  }
  return Item;
}

/*********************************************************************
*
*       _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

/*********************************************************************
*
*       _OnPidStateChange
*/
static void _OnPidStateChange(HEADER_Handle hObj, HEADER_Obj * pObj, WM_MESSAGE * pMsg) {
  const WM_PID_STATE_CHANGED_INFO * pState = (const WM_PID_STATE_CHANGED_INFO *)pMsg->Data.p;
  if ((pState->StatePrev == 1) && (pState->State == 0)) {
    pObj->Sel = _GetItemIndex(hObj, pObj, pState->x + pObj->ScrollPos, pState->y);
  }
}

/*********************************************************************
*
*       Private routines
*
**********************************************************************
*/
/*********************************************************************
*
*       HEADER_h2p
*/
#if GUI_DEBUG_LEVEL >= GUI_DEBUG_LEVEL_CHECK_ALL
HEADER_Obj * HEADER_h2p(HEADER_Handle h) {
  HEADER_Obj * p = (HEADER_Obj *)GUI_ALLOC_h2p(h);
  if (p) {
    if (p->DebugId != HEADER_ID) {
      GUI_DEBUG_ERROROUT("HEADER.c: Wrong handle type or Object not init'ed");
      return 0;
    }
  }
  return p;
}
#endif

/*********************************************************************
*
*       Exported routines:  Callback
*
**********************************************************************
*/
/*********************************************************************
*
*       HEADER_Callback
*/
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;