Esempio n. 1
0
static void D4D_PrgrsBarValue2Coor(D4D_OBJECT* pThis)
{
  D4D_PROGRESS_BAR* pPrgrsBar = D4D_GET_PROGRESS_BAR(pThis);
  _calc.position = D4D_GetClientToScreenPoint(pThis, &pThis->position); 
  
  D4D_ComputeGeometry(&_calc.contentGeom, pThis);
  
  _calc.barXY.x = (D4D_COOR)(_calc.contentGeom.pnt.x + D4D_PRGRS_BAR_BAR_OFF);
  _calc.barXY.y = (D4D_COOR)(_calc.contentGeom.pnt.y + D4D_PRGRS_BAR_BAR_OFF);    
  
  _calc.barSize = _calc.contentGeom.sz;
  
  _calc.barSize.cx -= (D4D_COOR)(2 * D4D_PRGRS_BAR_BAR_OFF);
  _calc.barSize.cy -= (D4D_COOR)(2 * D4D_PRGRS_BAR_BAR_OFF);
  
  // value and origin coordinates
  _calc.resultC1 = (D4D_COOR)(_calc.barXY.x + D4D_MulDivUU(pPrgrsBar->pData->value, _calc.barSize.cx, D4D_COLOR_PRGRS_BAR_MAX_VAL));
  
  _calc.resultC2 = _calc.resultC1;
  
#if D4D_ROUND_CORNER_ENABLE == D4D_TRUE  
  
  if(pThis->radius - D4D_PRGRS_BAR_BAR_OFF)
  {
    _calc.inner_radius = (D4D_COOR)(pThis->radius - D4D_PRGRS_BAR_BAR_OFF);
    
    if((_calc.resultC2 - _calc.inner_radius) < _calc.barXY.x)
      _calc.resultC2 = _calc.barXY.x;
    else
      _calc.resultC2 -= _calc.inner_radius;
    
    if((_calc.barXY.x + _calc.barSize.cx - _calc.resultC2) < (2 * _calc.inner_radius))
      _calc.resultC2 = (D4D_COOR)(_calc.barXY.x + _calc.barSize.cx - (2 * _calc.inner_radius));  
    
    if((_calc.resultC1 - _calc.barXY.x) < (2 * _calc.inner_radius))
      _calc.resultC1 = (D4D_COOR)(_calc.barXY.x + (2 * _calc.inner_radius));      
  }
  else
    _calc.inner_radius = 0;
  
#endif  
  
}
Esempio n. 2
0
static void D4D_SldrValue2Coor(D4D_OBJECT* pThis)
{
    D4D_SLIDER* pSldr = D4D_GET_SLIDER(pThis);
    D4D_COOR barMin;
    D4D_COOR barMax;
    D4D_COOR c1, c2;
    D4D_POINT tmpBarOff = pSldr->barOff;
    sWord tmp_scale = (sWord)(pSldr->pData->limits.valueMax - pSldr->pData->limits.valueMin);

    _calc.position = D4D_GetClientToScreenPoint(pThis, &pThis->position);
    D4D_ComputeGeometry(&(_calc.contentGeom), pThis);

    if(tmp_scale < 0)
      tmp_scale *= -1;

    if(pThis->size.cx > pThis->size.cy)
      _calc.isHorizontal = D4D_TRUE;
    else
      _calc.isHorizontal = D4D_FALSE;

    _calc.bar1Geom.sz = pSldr->barSize;

    if(_calc.isHorizontal)
    {
      if(!tmpBarOff.x)
        tmpBarOff.x = D4D_SLDR_BAR_OFF_LENGTH;

      if(!tmpBarOff.y)
        tmpBarOff.y = D4D_SLDR_BAR_OFF_WIDTH;
    }
    else
    {
      if(!tmpBarOff.x)
        tmpBarOff.x = D4D_SLDR_BAR_OFF_WIDTH;

      if(!tmpBarOff.y)
        tmpBarOff.y = D4D_SLDR_BAR_OFF_LENGTH;
    }

    if(!_calc.bar1Geom.sz.cx)
      _calc.bar1Geom.sz.cx = (D4D_COOR)(_calc.contentGeom.sz.cx - (tmpBarOff.x * 2));

    if(!_calc.bar1Geom.sz.cy)
      _calc.bar1Geom.sz.cy = (D4D_COOR)(_calc.contentGeom.sz.cy - (tmpBarOff.y * 2));

    _calc.bar1Geom.pnt = _calc.contentGeom.pnt;
    _calc.bar1Geom.pnt.x += tmpBarOff.x;
    _calc.bar1Geom.pnt.y += tmpBarOff.y;

    // horizontal?
    if(_calc.isHorizontal)
    {
        barMin = (D4D_COOR)(_calc.bar1Geom.pnt.x);
        barMax = (D4D_COOR)(barMin + _calc.bar1Geom.sz.cx - 1);
    }
    // vertical?
    else
    {
        barMin = (D4D_COOR)(_calc.bar1Geom.pnt.y);
        barMax = (D4D_COOR)(barMin + _calc.bar1Geom.sz.cy - 1);
    }


    // value and origin coordinates
    c1 = D4D_MulDivUU((D4D_COOR)(pSldr->pData->limits.valueOrg - pSldr->pData->limits.valueMin), (D4D_COOR)(barMax-barMin),
        (D4D_COOR)tmp_scale);

    c2 = D4D_MulDivUU((D4D_COOR)(pSldr->pData->value - pSldr->pData->limits.valueMin), (D4D_COOR)(barMax-barMin),
        (D4D_COOR)tmp_scale);


    #if D4D_ROUND_CORNER_ENABLE == D4D_TRUE
      if(tmpBarOff.x > tmpBarOff.y)
        tmp_scale = (sWord)(tmpBarOff.x - tmpBarOff.y);
      else
        tmp_scale = (sWord)(tmpBarOff.y - tmpBarOff.x);

      tmp_scale /=2;

      tmp_scale = (sWord)(pThis->radius - tmp_scale);

      if(tmp_scale > 0)
        _calc.inner_radius = (D4D_COOR)tmp_scale;
      else
        _calc.inner_radius = 0;

      _calc.bar_radius = _calc.inner_radius;

    #endif


    // bar rectangle range need to be "sorted"
    if(c1 > c2)
    {
      D4D_COOR tmp_coor;
      tmp_coor = c2;
      c2 = c1;
      c1 = tmp_coor;
    }

    _calc.bar3Geom.sz = _calc.bar2Geom.sz = _calc.bar1Geom.sz;

    // X grows to right, Y grows to top
    if(_calc.isHorizontal)
    {

      if(pSldr->pData->limits.valueOrg > pSldr->pData->value)
        _calc.dir = D4D_DIR_LEFT;
      else
        _calc.dir = D4D_DIR_RIGHT;

      _calc.bar3Geom.sz.cx -= c2;
      _calc.bar1Geom.sz.cx =  c1;
      _calc.bar2Geom.sz.cx =  (D4D_COOR)(c2 - c1 + 1);

      _calc.bar2Geom.pnt.x = (D4D_COOR)(_calc.bar1Geom.pnt.x + c1);
      _calc.bar2Geom.pnt.y = _calc.bar1Geom.pnt.y;

      _calc.bar3Geom.pnt.x = (D4D_COOR)(_calc.bar1Geom.pnt.x + c2);
      _calc.bar3Geom.pnt.y = _calc.bar1Geom.pnt.y;

      #if D4D_ROUND_CORNER_ENABLE == D4D_TRUE

        if(_calc.inner_radius)
        {
          _calc.bar1Geom.sz.cx += _calc.inner_radius * 2;
          _calc.bar3Geom.sz.cx += _calc.inner_radius * 2;

          _calc.bar_radius = D4D_LimitU(_calc.bar_radius, 0, (D4D_COOR)(_calc.bar2Geom.sz.cx / 2));

          if(_calc.inner_radius != _calc.bar_radius)
          {
            D4D_COOR tmp_coor;

            //tmp_coor = D4D_RndCornerGetNonPrintedPxl(_calc.inner_radius, (D4D_COOR)(_calc.pnt2.x + _calc.sz2.cx - (_calc.pnt1.x + _calc.sz1.cx + 0)));
            tmp_coor = (D4D_COOR)(_calc.inner_radius - D4D_RndCornerGetNonPrintedPxl((D4D_COOR)(_calc.inner_radius + 1), (D4D_COOR)(_calc.inner_radius - (_calc.bar2Geom.sz.cx / 2))));

            _calc.bar2Geom.sz.cy -= (D4D_COOR)(tmp_coor*2);
            _calc.bar2Geom.pnt.y += tmp_coor;
          }

          _calc.bar1Geom.sz.cx = D4D_LimitU(_calc.bar1Geom.sz.cx, (D4D_COOR)(_calc.inner_radius * 2), (D4D_COOR)(barMax - barMin + 1));
          _calc.bar3Geom.sz.cx = D4D_LimitU(_calc.bar3Geom.sz.cx, (D4D_COOR)(_calc.inner_radius * 2), (D4D_COOR)(barMax - barMin + 1));

          _calc.bar3Geom.pnt.x -= (D4D_COOR)(2 * _calc.inner_radius);
          _calc.bar3Geom.pnt.x = D4D_LimitU(_calc.bar3Geom.pnt.x, _calc.bar1Geom.pnt.x, (D4D_COOR)(barMax- (_calc.inner_radius * 2)));
        }
      #endif

    }else
    {

      if(pSldr->pData->limits.valueOrg > pSldr->pData->value)
        _calc.dir = D4D_DIR_DOWN;
      else
        _calc.dir = D4D_DIR_UP;

      _calc.bar3Geom.pnt = _calc.bar2Geom.pnt = _calc.bar1Geom.pnt;

      _calc.bar2Geom.pnt.y += (D4D_COOR)(_calc.bar1Geom.sz.cy - (c2 + 1));

      _calc.bar1Geom.pnt.y += (D4D_COOR)(_calc.bar1Geom.sz.cy - (c1 + 1));

      _calc.bar3Geom.sz.cy =  (D4D_COOR)(_calc.bar1Geom.sz.cy - (c2 + 1));
      _calc.bar1Geom.sz.cy =  (D4D_COOR)(c1 + 1);
      _calc.bar2Geom.sz.cy =  (D4D_COOR)(c2 - c1 + 1);

      #if D4D_ROUND_CORNER_ENABLE == D4D_TRUE

        if(_calc.inner_radius)
        {
          _calc.bar1Geom.sz.cy += (D4D_COOR)(_calc.inner_radius * 2);
          _calc.bar3Geom.sz.cy += (D4D_COOR)(_calc.inner_radius * 2);

          _calc.bar_radius = D4D_LimitU(_calc.bar_radius, 0, (D4D_COOR)(_calc.bar2Geom.sz.cy / 2));

          if(_calc.inner_radius != _calc.bar_radius)
          {
            D4D_COOR tmp_coor;

            tmp_coor = (D4D_COOR)(_calc.inner_radius - D4D_RndCornerGetNonPrintedPxl((D4D_COOR)(_calc.inner_radius + 1), (D4D_COOR)(_calc.inner_radius - (_calc.bar2Geom.sz.cy / 2))));

            _calc.bar2Geom.sz.cx -= (D4D_COOR)(tmp_coor * 2);
            _calc.bar2Geom.pnt.x += tmp_coor;
          }

          _calc.bar1Geom.sz.cy = D4D_LimitU(_calc.bar1Geom.sz.cy, (D4D_COOR)(_calc.inner_radius * 2 + 1), (D4D_COOR)(barMax - barMin + 1));
          _calc.bar3Geom.sz.cy = D4D_LimitU(_calc.bar3Geom.sz.cy, (D4D_COOR)(_calc.inner_radius * 2), (D4D_COOR)(barMax - barMin + 1));

          _calc.bar1Geom.pnt.y -= (D4D_COOR)(2 * _calc.inner_radius);
          _calc.bar1Geom.pnt.y = D4D_LimitU(_calc.bar1Geom.pnt.y, _calc.bar3Geom.pnt.y, (D4D_COOR)(barMax - (_calc.inner_radius * 2)));
        }
      #endif
    }


}