Exemple #1
0
void D4D_PrgrsBarOnMessage(D4D_MESSAGE* pMsg)
{
    D4D_CLR_SCHEME *pScheme_tmp = D4D_ObjectGetScheme(pMsg->pObject);
    
    switch(pMsg->nMsgId)
    {
    case D4D_MSG_DRAW:
        D4D_PrgrsBarOnDraw(pMsg);
        break;       

    
    case D4D_MSG_ONINIT:
        pMsg->pObject->pData->flags &= ~D4D_OBJECT_F_NOTINIT;
    
        if(!(pMsg->pObject->initFlags & (D4D_PRGRS_BAR_F_BAR_AUTOCOLOR | D4D_PRGRS_BAR_F_BAR_SCALECOLOR)))
          D4D_GET_PROGRESS_BAR(pMsg->pObject)->pData->colorBar = pScheme_tmp->objectDepend.progressBar.barFore;                    
        else
          D4D_GET_PROGRESS_BAR(pMsg->pObject)->pData->colorBar = D4D_PrgrsBarComputeColorBar(pMsg->pObject, D4D_GET_PROGRESS_BAR(pMsg->pObject)->pData->value);  
        break;        

    default:
        // call the default behavior of all objects
        D4D_ObjOnMessage(pMsg);
    }
}
Exemple #2
0
static D4D_COLOR D4D_SldrComputeColorBar(D4D_OBJECT* pThis, D4D_SLIDER_VALUE value)
{
  D4D_SLIDER* pSldr = D4D_GET_SLIDER(pThis);
  Byte shade;
  D4D_CLR_SCHEME *pScheme_tmp = D4D_ObjectGetScheme(pThis);

  if(value >= pSldr->pData->limits.valueOrg)
    shade = D4D_MulDivUU8((Byte)(value - pSldr->pData->limits.valueOrg), 255, \
      (Byte)(pSldr->pData->limits.valueMax - pSldr->pData->limits.valueOrg));
  else
    shade = D4D_MulDivUU8((Byte)(pSldr->pData->limits.valueOrg - value), 255, \
      (Byte)(pSldr->pData->limits.valueOrg - pSldr->pData->limits.valueMin));

  return D4D_GetCrossColor(pScheme_tmp->objectDepend.slider.barStart, pScheme_tmp->objectDepend.slider.barEnd, shade);

}
Exemple #3
0
static void D4D_PrgrsBarOnDraw(D4D_MESSAGE* pMsg)
{
    D4D_OBJECT* pThis = pMsg->pObject;    
    D4D_PROGRESS_BAR* pPrgrsBar = D4D_GET_PROGRESS_BAR(pThis);
    D4D_CLR_SCHEME *pScheme_tmp = D4D_ObjectGetScheme(pThis);
    D4D_COLOR clrBar = pPrgrsBar->pData->colorBar;
    D4D_COLOR clrBarBckg = pScheme_tmp->objectDepend.progressBar.barBckg;
    D4D_OBJECT_DRAWFLAGS draw = pMsg->prm.draw;
    D4D_COLOR clrT = D4D_ObjectGetForeColor(pThis, draw);
    D4D_COLOR clrB = D4D_ObjectGetBckgFillColor(pThis);
    
    #ifdef D4D_DEBUG
      // sanity check
      D4D_ASSERT(sizeof(_calc) <= D4D_SCRATCHPAD_SIZE);
    #endif
    
    // bar coordinate calculation
    D4D_PrgrsBarValue2Coor(pThis);

    // when background redraw is needed
    if(draw & D4D_OBJECT_DRAWFLAGS_COMPLETE)
      D4D_RBox(&_calc.position, &pThis->size, D4D_LINE_THIN, clrT, clrB, pThis->radius);
    
    // Draw the frame
    if(draw & (D4D_OBJECT_DRAWFLAGS_COMPLETE | D4D_OBJECT_DRAWFLAGS_STATE))
      D4D_DrawFrame(pThis, clrT, clrB);
    
    // if progress_bar is disabled draw progress_bar in grey scale
    if(!D4D_IsEnabled(pThis))
    {
      clrBar = D4D_GetGreyScale(clrBar);
      clrBarBckg = D4D_GetGreyScale(clrBarBckg);        
    }
        
    if(!pPrgrsBar->pData->drawActiveOnly)
      D4D_FillRRectXY(_calc.resultC2, _calc.barXY.y, (D4D_COOR)(_calc.barXY.x + _calc.barSize.cx - 1), (D4D_COOR)(_calc.barXY.y + _calc.barSize.cy - 1), clrBarBckg, _calc.inner_radius);
    
    // draw active part of the bar
    if(pThis->initFlags & D4D_PRGRS_BAR_F_BAR_SCALECOLOR)
      D4D_FillRRectColorScaleXY(_calc.barXY.x, _calc.barXY.y, _calc.resultC1, (D4D_COOR)(_calc.barXY.y + _calc.barSize.cy - 1), pScheme_tmp->objectDepend.progressBar.barFore, clrBar, D4D_DIR_RIGHT, _calc.inner_radius);                      
    else
      D4D_FillRRectXY(_calc.barXY.x, _calc.barXY.y, _calc.resultC1, (D4D_COOR)(_calc.barXY.y + _calc.barSize.cy - 1), clrBar, _calc.inner_radius);
                
   }
Exemple #4
0
static void D4D_MenuOnDraw(D4D_MESSAGE* pMsg)
{
  D4D_OBJECT* pThis = pMsg->pObject;
  D4D_MENU* pMenu = D4D_GET_MENU(pThis);
  D4D_OBJECT_DRAWFLAGS draw = pMsg->prm.draw;
  D4D_COLOR clrT, clrB;
  D4D_POINT tmp_point;
  D4D_SIZE tmp_size;
  D4D_STRING tmp_txtbuff;
  D4D_STR_PROPERTIES tmp_str_prty;
  Byte tmpB;

  tmp_txtbuff.str_properties = &tmp_str_prty;
  tmp_txtbuff.printOff = 0;
  // Get background simple color
  clrT = D4D_ObjectGetForeFillColor(pThis);
  clrB = D4D_ObjectGetBckgFillColor(pThis);

  #ifdef D4D_DEBUG
    // sanity check
    D4D_ASSERT(sizeof(_calc) <= D4D_SCRATCHPAD_SIZE);
  #endif

  // Compute all tempoarary values
  D4D_MenuValue2Coor(pThis);

  // draw just a color rectangle instead of bitmap
  if(draw & D4D_OBJECT_DRAWFLAGS_COMPLETE)
  {
    D4D_FillRRect(&_calc.position, &pThis->size, clrB, pThis->radius);

    if(pMenu->pIcon != NULL)
    {
      tmp_point.x = (D4D_COOR)(_calc.contentGeom.pnt.x + 2);
      tmp_point.y =  (D4D_COOR)(_calc.contentGeom.pnt.y + ((_calc.titleBar_y - D4D_GetBmpHeight(pMenu->pIcon)) / 2));

      D4D_DrawRBmp(&tmp_point, pMenu->pIcon, (D4D_BOOL)!D4D_IsEnabled(pThis), pThis->radius);
    }

    if(pMenu->title_text.pText)
    {
      tmp_point.x = (D4D_COOR)(_calc.contentGeom.pnt.x + 4);

      #if D4D_ROUND_CORNER_ENABLE != D4D_FALSE
      tmp_point.x += (D4D_COOR)(pThis->radius/2);
      #endif

      if(pMenu->pIcon != NULL)
        tmp_point.x += D4D_GetBmpHeight(pMenu->pIcon);

      tmp_point.y = _calc.contentGeom.pnt.y;

      tmp_size.cx = D4D_GetTextWidth(pMenu->title_text.fontId, pMenu->title_text.pText);
      tmp_size.cy = D4D_GetFontHeight(pMenu->title_text.fontId);

      D4D_DrawTextRect(&tmp_point, &tmp_size, &pMenu->title_text, clrT, clrB);
    }

    if(_calc.titleBar_y)
    {
      D4D_MoveToXY(_calc.contentGeom.pnt.x,\
        (D4D_COOR)(_calc.contentGeom.pnt.y + _calc.titleBar_y));

      D4D_LineToXY((D4D_COOR)(_calc.contentGeom.pnt.x + _calc.contentGeom.sz.cx - 1),\
        (D4D_COOR)(_calc.contentGeom.pnt.y + _calc.titleBar_y), D4D_LINE_THIN, clrT);
    }
  }

  // Draw the frame
  if(draw & (D4D_OBJECT_DRAWFLAGS_COMPLETE | D4D_OBJECT_DRAWFLAGS_STATE))
    D4D_DrawFrame(pThis, clrT, clrB);

  if(pThis->initFlags & D4D_MENU_F_INDEX)
  {
    // Draw index counter
    tmp_txtbuff.printLen = (D4D_INDEX)((_calc.itemsCnt < 10)? 3:5);
    tmp_size.cx = (D4D_COOR)(tmp_txtbuff.printLen * D4D_GetFontWidth(pMenu->indexFontId) + 2);
    tmp_size.cy = (D4D_COOR)(_calc.titleBar_y - 2);
    tmp_point.x = (D4D_COOR)(_calc.contentGeom.pnt.x + _calc.contentGeom.sz.cx - tmp_size.cx - 2);
    tmp_point.y = (D4D_COOR)(_calc.contentGeom.pnt.y);

    #if D4D_ROUND_CORNER_ENABLE != D4D_FALSE
      tmp_size.cy -= (D4D_COOR)(pThis->radius / 2);
      tmp_point.x -= (D4D_COOR)(pThis->radius / 2);
      tmp_point.y += (D4D_COOR)(pThis->radius / 2);
    #endif

    tmp_txtbuff.pText = _calc.index_txt;
    tmp_txtbuff.fontId = pMenu->indexFontId;
    tmp_str_prty.font_properties = D4D_MENU_IX_FNT_PRTY_DEFAULT;
    tmp_str_prty.text_properties = D4D_MENU_IX_TXT_PRTY_DEFAULT;
    D4D_DrawTextRect(&tmp_point, &tmp_size, &tmp_txtbuff, clrT, clrB);
  }

  for(tmpB = 0; (tmpB < _calc.posCnt) && (tmpB + pMenu->pData->page_ix < _calc.itemsCnt); tmpB++)
  {
    if(((pMenu->pData->ix - pMenu->pData->page_ix) != tmpB) || (!D4D_IsEnabled(pThis)))
    {
      clrT = D4D_ObjectGetForeFillColor(pThis);
      clrB = D4D_ObjectGetBckgFillColor(pThis);
    }
    else
    {
      D4D_CLR_SCHEME *pScheme_tmp = D4D_ObjectGetScheme(pThis);
      clrT = pScheme_tmp->foreFocus;
      clrB = pScheme_tmp->bckgFocus;
    }

    // Draw menu item text
    if(pMenu->pItems[tmpB + pMenu->pData->page_ix].text.pText != NULL)
    {
      tmp_point.x = (D4D_COOR)(_calc.contentGeom.pnt.x + _calc.maxIcon.cx + 4);
      tmp_point.y = (D4D_COOR)(_calc.contentGeom.pnt.y + _calc.titleBar_y + 1 + (tmpB * _calc.textOff));

      tmp_size.cx = (D4D_COOR)(_calc.contentGeom.sz.cx - (_calc.maxIcon.cx + 6 + ((D4D_GET_MENU_SCROLL_BAR_HOR(pThis)->pData->flags & D4D_OBJECT_F_VISIBLE)? D4D_MENU_SCRLBR_WIDTH:0)));
      #if D4D_ROUND_CORNER_ENABLE != D4D_FALSE
        tmp_point.x += (D4D_COOR)(pThis->radius / 2);
        tmp_size.cx -= (D4D_COOR)(pThis->radius / 1);
      #endif
      tmp_size.cy = D4D_GetFontHeight(pMenu->itemsFontId); // to invoke autosize capability in axis Y

      tmp_txtbuff.pText = pMenu->pItems[tmpB + pMenu->pData->page_ix].text.pText;
      tmp_txtbuff.fontId = pMenu->itemsFontId;
      tmp_txtbuff.buffSize = 0;
      tmp_txtbuff.printLen = D4D_GetTextLength(tmp_txtbuff.pText);
      tmp_str_prty.font_properties = D4D_MENU_ITEM_FNT_PRTY_DEFAULT;
      tmp_str_prty.text_properties = D4D_MENU_ITEM_TXT_PRTY_DEFAULT;


      D4D_DrawTextRect(&tmp_point, &tmp_size, &tmp_txtbuff, clrT, clrB);
    }

    // Draw menu item icon
    if(_calc.maxIcon.cx)
    {
      tmp_point.x = (D4D_COOR)(_calc.contentGeom.pnt.x + 3);

      if(_calc.maxIcon.cy < _calc.textOff)
        tmp_point.y = (D4D_COOR)(_calc.contentGeom.pnt.y + _calc.titleBar_y + 3 + (tmpB * _calc.textOff) + ((D4D_GetFontHeight(pMenu->itemsFontId) - _calc.maxIcon.cy) / 2));
      else
        tmp_point.y = (D4D_COOR)(_calc.contentGeom.pnt.y + _calc.titleBar_y + 3 + (tmpB * _calc.textOff));

      if(pMenu->pItems[tmpB + pMenu->pData->page_ix].pIcon != NULL)
        D4D_DrawRBmp(&tmp_point, pMenu->pItems[tmpB + pMenu->pData->page_ix].pIcon, (D4D_BOOL)!D4D_IsEnabled(pThis), pThis->radius);
      else
        D4D_FillRRect(&tmp_point, &_calc.maxIcon, D4D_ObjectGetBckgFillColor(pThis), pThis->radius);
    }
  }
}
Exemple #5
0
static void D4D_CheckBoxOnDraw(D4D_MESSAGE* pMsg)
{
    D4D_OBJECT* pThis = pMsg->pObject;
    D4D_CHECKBOX* pCheckB = D4D_GET_CHECKBOX(pThis);
    D4D_CHECKBOX_STATUS* pStatus = D4D_GET_CHECKBOX_STATUS(pThis);    
    D4D_OBJECT_DRAWFLAGS draw = pMsg->prm.draw;    
    D4D_COLOR clrT, clrB;
    D4D_CLR_SCHEME* pScheme = D4D_ObjectGetScheme(pThis);
    D4D_BMP_PROPERTIES bmpProp;
    
    bmpProp = (D4D_ALIGN_V_CENTER_MASK | D4D_ALIGN_H_CENTER_MASK);
    
    D4D_CheckBoxValue2Coor(pThis);
    
    clrT = D4D_ObjectGetForeColor(pThis, draw);
    clrB = D4D_ObjectGetBckgFillColor(pThis);

    if(draw & D4D_OBJECT_DRAWFLAGS_COMPLETE)
      D4D_FillRRect(&_calc.position, &pThis->size, clrB, pThis->radius);  
   
    // Draw the frame
    if(draw & (D4D_OBJECT_DRAWFLAGS_COMPLETE | D4D_OBJECT_DRAWFLAGS_STATE))
      D4D_DrawFrame(pThis, clrT, clrB);    
 
    // normal bitmap (also may be NULL if simple rect button is needed  
    if(*pStatus & D4D_CHECKBOX_STATUS_CHECKED_MASK)
    {
      if(pCheckB->pBmpChecked != NULL)         
        D4D_DrawRBmpRect(&_calc.BmpGeom.pnt, &_calc.BmpGeom.sz, pCheckB->pBmpChecked, bmpProp, pScheme->objectDepend.checkBox.iconBckg, (D4D_BOOL)!D4D_IsEnabled(pThis), _calc.iconRadius);  // draw the bitmap            
      else
      {
        D4D_POINT tmp_point = _calc.BmpGeom.pnt;
        D4D_SIZE tmp_size = _calc.BmpGeom.sz;
        if(tmp_size.cy - 2 > 0)
        {
          tmp_point.x++;
          tmp_point.y++;
          
          tmp_size.cx -= 2;
          tmp_size.cy -= 2;
          
          D4D_RBox(&tmp_point, &tmp_size, D4D_LINE_THICK, clrB, clrT, _calc.iconRadius);
        }
      }
    }    
    // no bitmap
    else
    {     
      if(pCheckB->pBmpUnChecked)
      {
        // draw the bitmap
        D4D_DrawRBmpRect(&_calc.BmpGeom.pnt, &_calc.BmpGeom.sz, pCheckB->pBmpUnChecked, bmpProp, pScheme->objectDepend.checkBox.iconBckg, (D4D_BOOL)!D4D_IsEnabled(pThis), _calc.iconRadius);   
      }else
      {        
        // draw just a color rectangle instead of bitmap
        
        D4D_FillRRect(&_calc.BmpGeom.pnt, &_calc.BmpGeom.sz, pScheme->objectDepend.checkBox.iconBckg, _calc.iconRadius);        
      }
    }
    
    if(pThis->initFlags & D4D_CHECKBOX_F_ICON_RECTANGLE)
      D4D_RRect(&_calc.BmpGeom.pnt, &_calc.BmpGeom.sz, D4D_LINE_THIN, clrT, _calc.iconRadius);        
    
    // draw the text
    if(pCheckB->textBuff.pText)
      D4D_DrawTextRect(&_calc.TxtGeom.pnt, &_calc.TxtGeom.sz, &pCheckB->textBuff, clrT, D4D_ObjectGetBckgColor(pThis, draw));
    
}
Exemple #6
0
static D4D_COLOR D4D_PrgrsBarComputeColorBar(D4D_OBJECT* pThis, D4D_PROGRESS_BAR_VALUE value)
{
  D4D_CLR_SCHEME *pScheme_tmp = D4D_ObjectGetScheme(pThis);
          
  return D4D_GetCrossColor(pScheme_tmp->objectDepend.progressBar.barFore, pScheme_tmp->objectDepend.progressBar.barEnd, D4D_MulDivUU8(value, 255, D4D_COLOR_PRGRS_BAR_MAX_VAL));      
}
Exemple #7
0
void D4D_SldrOnMessage(D4D_MESSAGE* pMsg)
{
    D4D_OBJECT* pThis = pMsg->pObject;
    D4D_CLR_SCHEME *pScheme_tmp = D4D_ObjectGetScheme(pThis);

    #if defined(D4D_LLD_TCH)
    static D4D_INDEX autoTouchTicks;
    #endif

    #if defined(D4D_LLD_MOUSE)
    D4D_SLIDER* pSldr = D4D_GET_SLIDER(pThis);
    #endif

    #if defined(D4D_LLD_TCH) || defined(D4D_LLD_MOUSE)
    D4D_POINT touchClickPoint;
    #endif

    switch(pMsg->nMsgId)
    {
    case D4D_MSG_DRAW:
        D4D_SldrOnDraw(pMsg);
        break;

    case D4D_MSG_KEYUP:
        D4D_SldrOnKeyUp(pMsg);
        break;

    case D4D_MSG_KILLFOCUS:
        D4D_CaptureKeys(NULL);
        break;

    case D4D_MSG_ONINIT:
        pThis->pData->flags &= ~D4D_OBJECT_F_NOTINIT;

        if(!(pThis->initFlags & (D4D_SLDR_F_BAR_AUTOCOLOR | D4D_SLDR_F_BAR_SCALECOLOR)))
          D4D_GET_SLIDER(pThis)->pData->colorBar = pScheme_tmp->objectDepend.slider.barFore;
        else
          D4D_GET_SLIDER(pThis)->pData->colorBar = D4D_SldrComputeColorBar(pThis, D4D_GET_SLIDER(pThis)->pData->value);
        break;

#ifdef D4D_LLD_MOUSE
    case D4D_MSG_MOUSE_BTN_LEFT_UP:
        touchClickPoint = D4D_GetMouseCoordinates(pMsg->pObject);
        D4D_SldrTouched(pMsg, &touchClickPoint);
      break;

    case D4D_MSG_MOUSE_BTN_WHEEL_UP:
      D4D_SldrChangeValue(pThis, pSldr->pData->limits.step);
      break;

    case D4D_MSG_MOUSE_BTN_WHEEL_DOWN:
      D4D_SldrChangeValue(pThis, -pSldr->pData->limits.step);
      break;
#endif



#ifdef D4D_LLD_TCH
    case D4D_MSG_TOUCH_AUTO:
        if(pThis->initFlags & D4D_SLDR_F_AUTOTOUCH_OFF)
          break;

        if(autoTouchTicks--)
          break;

    case D4D_MSG_TOUCHED:
        autoTouchTicks = D4D_SLDR_AUTOTOUCHTICKS;
        touchClickPoint = D4D_GetTouchScreenCoordinates(pMsg->pObject);
        D4D_SldrTouched(pMsg, &touchClickPoint);
        break;
#endif
    default:
        // call the default behavior of all objects
        D4D_ObjOnMessage(pMsg);
    }
}
Exemple #8
0
static void D4D_SldrOnDraw(D4D_MESSAGE* pMsg)
{
    D4D_OBJECT* pThis = pMsg->pObject;
    D4D_SLIDER* pSldr = D4D_GET_SLIDER(pThis);
    D4D_COLOR clrT, clrB;
    D4D_COLOR clrBar = pSldr->pData->colorBar;
    D4D_COLOR clrBarBckg = D4D_ObjectGetScheme(pThis)->objectDepend.slider.barBckg;

    D4D_OBJECT_DRAWFLAGS draw = pMsg->prm.draw;

    #ifdef D4D_DEBUG
      // sanity check
      D4D_ASSERT(sizeof(_calc) <= D4D_SCRATCHPAD_SIZE);
    #endif

    // bar coordinate calculation
    D4D_SldrValue2Coor(pThis);

    clrT = D4D_ObjectGetForeColor(pThis, draw);
    clrB = D4D_ObjectGetBckgColor(pThis, draw);

    // if slider is disabled draw slider in grey scale
    if(!D4D_IsEnabled(pThis))
    {
      clrBar = D4D_GetGreyScale(clrBar);
      clrBarBckg = D4D_GetGreyScale(clrBarBckg);
    }



    // when background redraw is needed
    if(draw & D4D_OBJECT_DRAWFLAGS_COMPLETE)
    {
      // draw the bitmap
      if(pSldr->pBmpBkgd != NULL)
          D4D_DrawRBmp(&_calc.position, pSldr->pBmpBkgd, (D4D_BOOL)!D4D_IsEnabled(pThis), pThis->radius);
      else
          D4D_FillRRect(&_calc.position, &pThis->size, D4D_ObjectGetBckgFillColor(pThis), pThis->radius);
    }

    // draw focus rectangle
    D4D_RRect(&_calc.position, &pThis->size, D4D_LINE_THIN, clrT, pThis->radius);

    // draw first inactive part
    D4D_FillRRect(&_calc.bar1Geom.pnt, &_calc.bar1Geom.sz, clrBarBckg, _calc.inner_radius);

    // draw last inactive part of the bar
    D4D_FillRRect(&_calc.bar3Geom.pnt, &_calc.bar3Geom.sz, clrBarBckg, _calc.inner_radius);

    // draw active part of the bar
    if(pThis->initFlags & D4D_SLDR_F_BAR_SCALECOLOR)
      D4D_FillRRectColorScale(&_calc.bar2Geom.pnt, &_calc.bar2Geom.sz, D4D_COLOR_SLDR_BAR_START, clrBar, _calc.dir, _calc.bar_radius);
    else
      D4D_FillRRect(&_calc.bar2Geom.pnt, &_calc.bar2Geom.sz, clrBar, _calc.inner_radius);

    // Draw the frame
    if(draw & (D4D_OBJECT_DRAWFLAGS_COMPLETE | D4D_OBJECT_DRAWFLAGS_STATE))
      D4D_DrawFrame(pThis, clrT, clrB);


    // draw the text
    if(pSldr->textBuff.pText != NULL)
    {
      D4D_SIZE tmp_size;

      _calc.position.x += pSldr->txtOff.x;
      _calc.position.y += pSldr->txtOff.y;

      if(!pSldr->txtOff.x)
      {
        if(_calc.isHorizontal)
          _calc.position.x += (D4D_COOR) ((_calc.contentGeom.sz.cx - (D4D_COOR)(D4D_GetTextWidth(pSldr->textBuff.fontId, pSldr->textBuff.pText))) / 2);
        else
          _calc.position.x += (D4D_COOR) (_calc.bar1Geom.pnt.x + 1);
      }

      if(!pSldr->txtOff.y)
        _calc.position.y += (D4D_COOR) (((_calc.contentGeom.sz.cy - D4D_GetFontHeight(pSldr->textBuff.fontId)) / 2) + 1);

      if(pThis->initFlags & D4D_SLDR_F_TEXT_AUTOCOLOR)
          clrT = (D4D_COLOR)(~clrBar);

      tmp_size.cx = D4D_GetTextWidth(pSldr->textBuff.fontId, pSldr->textBuff.pText);
      tmp_size.cy = D4D_GetFontHeight(pSldr->textBuff.fontId);


      D4D_DrawTextRect(&_calc.position, &tmp_size, &pSldr->textBuff, clrT, clrB);

    }

}