d4/d47/drawitem_8cpp_source.html

//----------------------------------------------------------------------------

// ObjectWindows

// Copyright (c) 1998, by Yura Bidus, All Rights Reserved

//

/// \file

/// Implementation of class TDrawItemProxy, TDrawItem,TButtonTextDrawItem,

/// TDrawMenuItem, TDrawMenuItemProxy. Owner draw family.

//

// Note this classes stil under development!!!!!!!!!!!!!!!

//

//----------------------------------------------------------------------------

#include <owl/pch.h>

#include <owl/uimetric.h>

#include <owl/template.h>

#include <owl/gadgetwi.h>

#include <owl/celarray.h>

#include <owl/uihelper.h>

#include <owl/glyphbtn.h>


#include <owl/drawitem.h>

#include <owl/resource.h>


#include <algorithm>


using namespace std;


namespace owl {


//

// class TDrawItemProxy

// ~~~~~ ~~~~~~~~~~~~~~

/// Constructs a TDrawItemProxy object using the specified font. Ownership of the

/// font transfers to the new object.

//


TDrawItemProxy::TDrawItemProxy(TFont* font)

:

  Font(font ? font : new TGadgetWindowFont()), CelArray(0), DeleteCel(false)

{

  ItemArray = new TDrawItemArray;

}

TDrawItemProxy::TDrawItemProxy(TFont* font) {…}

//

/// Deletes Font. If DeleteCel is true, delets CelArray.

//


TDrawItemProxy::~TDrawItemProxy()

{

  delete Font;

  if(DeleteCel)

    delete CelArray;

  delete ItemArray;

}

TDrawItemProxy::~TDrawItemProxy() {…}

//

/// Deletes Font and sets it to font. Ownership of font transfers to the

/// TDrawItemProxy.

//


void TDrawItemProxy::SetFont(TFont* font)

{

  delete Font;

  Font = font;

}

void TDrawItemProxy::SetFont(TFont* font) {…}

//

/// If DeleteCel is true, deletes CelArray. CelArray is then set to celarray and

/// DeleteCel is set to del.

//


void TDrawItemProxy::SetCelArray(TCelArray* celarray, TAutoDelete del)

{

  if(DeleteCel)

    delete CelArray;

  CelArray = celarray;

  DeleteCel = del == AutoDelete;

}

void TDrawItemProxy::SetCelArray(TCelArray* celarray, TAutoDelete del) {…}

//

/// Loads a TDib with resource id resId from module. It then uses this TDib and

/// count to create a new TCelArray. SetCelArray is then called with this TCelArray

/// and AutoDelete.

//


void TDrawItemProxy::SetCelArray(TResId resId, uint count, TModule* module)

{

  TBtnBitmap* bitmap = new TBtnBitmap(*module, resId, TColor::LtGray);

  SetCelArray(new TCelArray(bitmap,count),AutoDelete);

}

void TDrawItemProxy::SetCelArray(TResId resId, uint count, TModule* module) {…}

//

/// Adds item to ItemArray.

//


void TDrawItemProxy::RegisterItem(TDrawItem* item)

{

  ItemArray->Add(item);

}

void TDrawItemProxy::RegisterItem(TDrawItem* item) {…}

//

//---------------------------------------------------------------------------

//

// class TButtonTextDrawItem

// ~~~~~ ~~~~~~~~~~~~~~~~~~~

//

const int TextSpaceH = 2;

const int TextSpaceV = 2;

const int TextSpaceE = 15;

const int ButtonSpaceH = 0;

const int ButtonSpaceV = 0;

//---------------------------------------------------------------------------------------

//

/// Constructs a TButtonTextDrawItem with proxy as it's parent.

//


TButtonTextDrawItem::TButtonTextDrawItem(TDrawItemProxy* proxy)

:

  Text(0),

  Index(-1),

  Align(aLeft),

  Style(sNone),

  LayoutStyle(lTextRight),

  Flags(0),

  Font(0),

  CelArray(0),

  DeleteCel(false),

  Proxy(proxy)

{

}

TButtonTextDrawItem::TButtonTextDrawItem(TDrawItemProxy* proxy) {…}

//

/// Destroys a TButtonTextDrawItem object. If DeleteCel is true, deletes CelArray.

//


TButtonTextDrawItem::~TButtonTextDrawItem()

{

  if(DeleteCel)

    delete   CelArray;

  delete[] Text;

  delete   Font;

}

TButtonTextDrawItem::~TButtonTextDrawItem() {…}

//

/// Deletes Text and clears the text style. If text is not NULL, a copy is assigned

/// to Text and the sText style is added to Style.

//

void


TButtonTextDrawItem::SetText(LPCTSTR text)

{

  delete[] Text;

  Text = 0;

  uint style = (uint)Style;

  style &= ~sText;

  if(text){

    Text    = strnewdup(text);

    // replace all '\a' to '\t'

    // '\a' in *.rc becomes '\b' in *.res

    tchar c = _T('\b');

    tchar* p = _tcschr(Text,c);

    while(p){

      *p = _T('\t');

      p = _tcschr(Text,_T('\b'));

    }

    style |= sText;

  }

  Style = (TStyle)style;

}

TButtonTextDrawItem::SetText(LPCTSTR text) {…}

//

/// Index is set to index and the sBitmap style is cleared from Style. If index >=

/// 0, the sBitmap style is added to Style.

//

void


TButtonTextDrawItem::SetIndex(int index)

{

  Index = index;

  uint style = (uint)Style;

  style &= ~sBitmap;

  if(Index >=0)

    style |= sBitmap;

  Style = (TStyle)style;

}

TButtonTextDrawItem::SetIndex(int index) {…}

//

/// Deletes Font and then assigns font to Font. Ownership of font is transferred to

/// this instance.

//

void


TButtonTextDrawItem::SetFont(TFont* font)

{

  delete Font;

  Font = font;

}

TButtonTextDrawItem::SetFont(TFont* font) {…}

//

/// If DeleteCel is true, CelArray is deleted. celarray is assigned to CelArray and

/// del is assigned to DeleteCel.

//

void


TButtonTextDrawItem::SetCelArray(TCelArray* celarray, TAutoDelete del)

{

  if(DeleteCel)

    delete CelArray;

  CelArray = celarray;

  DeleteCel = del == AutoDelete;

}

TButtonTextDrawItem::SetCelArray(TCelArray* celarray, TAutoDelete del) {…}

//

/// A bitmap with resource id resId is loaded from module and used to create a

/// TCelArray with count cells. SetCelArray is then called with this TCelArray.

//

void


TButtonTextDrawItem::SetCelArray(TResId resId, uint count, TModule* module)

{

  TBtnBitmap* bitmap = new TBtnBitmap(*module, resId, TColor::LtGray);

  SetCelArray(new TCelArray(bitmap,count));

}

TButtonTextDrawItem::SetCelArray(TResId resId, uint count, TModule* module) {…}

//

/// Extracts information from drawItem and calls Paint.

//

void


TButtonTextDrawItem::Draw(DRAWITEMSTRUCT & drawItem)

{

  Flags = drawItem.itemState;


  TDC dc(drawItem.hDC);

  TRect rect(drawItem.rcItem);

  Paint(dc, rect);

}

TButtonTextDrawItem::Draw(DRAWITEMSTRUCT & drawItem) {…}

//

/// Calculates the area required to display the button and text.

//

void


TButtonTextDrawItem::Measure(MEASUREITEMSTRUCT & measureItem)

{

  TSize textSize;

  GetTextSize(textSize);


  TSize btnSize(0,0);

  if(GetStyle() & TButtonTextDrawItem::sBitmap)

    GetButtonSize(btnSize);


  measureItem.itemWidth    = textSize.cx + btnSize.cx;

  measureItem.itemHeight  = std::max(textSize.cy,btnSize.cy);

}

TButtonTextDrawItem::Measure(MEASUREITEMSTRUCT & measureItem) {…}

//

/// Does an lstrcmp on Text from the instances contained in drawItem.

//

int


TButtonTextDrawItem::Compare(COMPAREITEMSTRUCT & compareItem)

{

  TButtonTextDrawItem* item1 = (TButtonTextDrawItem*)compareItem.itemData1;

  TButtonTextDrawItem* item2 = (TButtonTextDrawItem*)compareItem.itemData2;

  return lstrcmp(item1->GetText(), item2->GetText());

}

TButtonTextDrawItem::Compare(COMPAREITEMSTRUCT & compareItem) {…}

//

/// If selected returns TColor::SysActiveCaption; otherwise returns

/// TColor::SysWindow.

//

TColor


TButtonTextDrawItem::GetBkColor()

{

  return IsSelected() ? TColor::SysActiveCaption : TColor::SysWindow;

}

TButtonTextDrawItem::GetBkColor() {…}

//

/// If selected, returns TColor::Sys3dHilight if a 3d User interface is in use or

/// TColor::SysGrayText otherwise.

//

TColor


TButtonTextDrawItem::GetTextColor()

{

  if (IsSelected() || !IsEnabled())

    return TColor::Sys3dHilight;

  else

    return TColor::SysWindowText;

}

TButtonTextDrawItem::GetTextColor() {…}

//

/// Calculates the size of the rectangle need to paint the text.

//

void


TButtonTextDrawItem::GetTextSize(TSize& size)

{

  TFont* font = Font;

  if(!font)

    font = Proxy->GetFont();


  TScreenDC dc;


  if(font)

   dc.SelectObject(*font);


  dc.GetTextExtent(GetText(), static_cast<int>(::_tcslen(GetText())), size);


  if(font)

    dc.RestoreFont();

}

TButtonTextDrawItem::GetTextSize(TSize& size) {…}

//

/// Paint function.

//

void


TButtonTextDrawItem::Paint(TDC& dc, TRect& rect)

{

  TRect textRect, btnRect;


  Layout(rect, textRect, btnRect);


  // 1. Erase all

  TColor oldBkColor = dc.SetBkColor(GetBkColor());


  dc.TextRect(rect);


   PaintText(dc, textRect);


  PaintBitmap(dc, btnRect);


  dc.SetBkColor(oldBkColor);


  PaintBorder(dc, rect);

}

TButtonTextDrawItem::Paint(TDC& dc, TRect& rect) {…}

//

/// Layout Text and Bitmap

///

/// Determines the bounding rectangles for the current style.

//

void


TButtonTextDrawItem::Layout(const TRect& faceRect, TRect& textRect, TRect& btnRect)

{

  TSize textSize;

  GetTextSize(textSize);


  TSize btnSize;

  GetButtonSize(btnSize);


  switch(LayoutStyle){


    case lTextLeft:

      textRect = TRect(faceRect.TopLeft(), TSize(textSize.cx,faceRect.Height()));

      btnRect  = TRect(faceRect.left+textSize.cx+ButtonSpaceH,faceRect.top+ButtonSpaceV,

                       faceRect.right-ButtonSpaceH,faceRect.bottom-ButtonSpaceV);

       break;


    case lTextRight:

      btnRect = TRect(faceRect.left+ButtonSpaceH, faceRect.top+ButtonSpaceV,

                      faceRect.left+btnSize.cx-ButtonSpaceH, faceRect.bottom-ButtonSpaceV);

      textRect = TRect(btnRect.right+TextSpaceH+ButtonSpaceH,faceRect.top,

                       faceRect.right-TextSpaceH, faceRect.bottom);


      break;


    case lTextTop:

       textRect = TRect(faceRect.TopLeft(), TSize(faceRect.Width()-TextSpaceH,textSize.cy));

      btnRect  = TRect(faceRect.left+ButtonSpaceH,faceRect.top+textSize.cy+TextSpaceV,

                       faceRect.right-ButtonSpaceH, faceRect.bottom-ButtonSpaceV);

       break;


    case lTextBottom:

       textRect = TRect(faceRect.left,faceRect.bottom-textSize.cy,

                      faceRect.right,faceRect.bottom);

       btnRect  = TRect(faceRect.left+ButtonSpaceH,faceRect.top+ButtonSpaceV,

                      faceRect.right-ButtonSpaceH, faceRect.bottom-textSize.cy-ButtonSpaceV);

      break;

  }

}

TButtonTextDrawItem::Layout(const TRect& faceRect, TRect& textRect, TRect& btnRect) {…}

//

/// Paint the text.

//

void


TButtonTextDrawItem::PaintText(TDC& dc, TRect& rect)

{

  if((Style&sText)==0)

    return;


  TFont* font = Font;

  if (!font)

    font = Proxy->GetFont();

  if(font)

   dc.SelectObject(*font);


   TColor oldTxColor  = dc.SetTextColor(GetTextColor());


  uint format =  DT_SINGLELINE|DT_EXPANDTABS;

  switch(Align){

    case aLeft:

      format |= DT_LEFT;

      break;

    case aRight:

      format |= DT_RIGHT;

      break;

    case aCenter:

      format |= DT_CENTER;

      break;

  }

  switch(LayoutStyle){

    case lTextLeft:

    case lTextRight:

      format |= DT_VCENTER;

      break;

    case lTextTop:

      format |= DT_VCENTER;//DT_BOTTOM;

      break;

    case lTextBottom:

      format |= DT_VCENTER;//DT_TOP;

      break;

  }


  // Create a UI Face object for this button & let it paint the button face

  //

  TRect  tRect(rect);

  TPoint dstPt(tRect.TopLeft());


  TUIFace face(tRect, Text, GetBkColor(), format);

  if ((!IsEnabled()||IsGrayed()) && !IsSelected())

    face.Paint(dc, dstPt, TUIFace::Disabled, false, false);

  else

    face.Paint(dc, dstPt, TUIFace::Normal, false, false);


  dc.SetTextColor(oldTxColor);


  if(font)

    dc.RestoreFont();

}

TButtonTextDrawItem::PaintText(TDC& dc, TRect& rect) {…}

//

/// Calculates the size of button.

//

void


TButtonTextDrawItem::GetButtonSize(TSize& btnSize)

{

  btnSize = TSize(0,0);

  if(Index == sepNoBitmap) // == -2

    return;

  TCelArray* celArray = CelArray ? CelArray : Proxy->GetCelArray();

  if(celArray)

    btnSize = celArray->CelSize();

}

TButtonTextDrawItem::GetButtonSize(TSize& btnSize) {…}

//

/// Paint the border of the gadget based on the BorderStyle member

//

void


TButtonTextDrawItem::PaintBorder(TDC& dc, TRect& boundsRect)

{

  if(IsFocused())

    dc.DrawFocusRect(boundsRect);

}

TButtonTextDrawItem::PaintBorder(TDC& dc, TRect& boundsRect) {…}

//

/// Paint the bitmap.

//

void


TButtonTextDrawItem::PaintBitmap(TDC& dc, TRect& rect)

{

  if((Style&sBitmap)==0 || Index < 0)

    return;


  // Determine which CelArray to paint from: ours or our Window's

  //

  TCelArray& celArray = CelArray ? *CelArray : *Proxy->GetCelArray();

  // Create a UI Face object for this button & let it paint the button face

  celArray.BitBlt(Index, dc, rect.left, rect.top);

}

TButtonTextDrawItem::PaintBitmap(TDC& dc, TRect& rect) {…}

//////////////////////////////////////////////////////////////////////////////////////

//

//


//

/// Called with the proxy parent, the command it, the index in the menu and the text

/// to display.

//


TDrawMenuItem::TDrawMenuItem(TDrawItemProxy* proxy, int cmdId, int index, LPCTSTR title)

:

  TButtonTextDrawItem(proxy),CmdId(cmdId),CheckPainter(0)

{

  SetText(title);

  SetIndex(index);

}

TDrawMenuItem::TDrawMenuItem(TDrawItemProxy* proxy, int cmdId, int index, LPCTSTR title) {…}


//

/// String-aware overload

//


TDrawMenuItem::TDrawMenuItem(TDrawItemProxy* proxy, int cmdId, int index, const tstring& title)

  : TButtonTextDrawItem(proxy), CmdId(cmdId), CheckPainter(0)

{

  SetText(title.c_str());

  SetIndex(index);

}

TDrawMenuItem::TDrawMenuItem(TDrawItemProxy* proxy, int cmdId, int index, const tstring& title) {…}


//

//

//

void


TDrawMenuItem::GetTextSize(TSize& size)

{

  TButtonTextDrawItem::GetTextSize(size);

  size.cx += TextSpaceE;

  if((GetStyle() & TButtonTextDrawItem::sBitmap)==0)

    size.cx += TextSpaceE;

  size.cy = std::max((int)size.cy, 16);

}

TDrawMenuItem::GetTextSize(TSize& size) {…}

//

/// Get the size of the bitmap button.

//

void


TDrawMenuItem::GetButtonSize(TSize& btnSize)

{

  btnSize = TSize(0,0);

  if(Index == sepNoBitmap) // == -2

    return;

  TCelArray* celArray = CelArray ? CelArray : Proxy->GetCelArray();

  if(celArray){

    btnSize = celArray->CelSize();

    btnSize.cx  += 3;

    btnSize.cy  += 3;

  }

}

TDrawMenuItem::GetButtonSize(TSize& btnSize) {…}

//

/// If the menu item is selected returns TColor::SysActiveCaption; otherwise returns

/// TColor::SysMenu.

//

TColor


TDrawMenuItem::GetBkColor()

{

  return IsSelected() ? TColor::SysActiveCaption : TColor::SysMenu;

}

TDrawMenuItem::GetBkColor() {…}

//

/// Returns the text color.

//

TColor


TDrawMenuItem::GetTextColor()

{

  if (IsSelected() || !IsEnabled())

    return TColor::Sys3dHilight;

  else

    return TColor::SysMenuText;

}

TDrawMenuItem::GetTextColor() {…}

//

/// Paint the bitmap on the menu entry.

//

void


TDrawMenuItem::PaintBitmap(TDC& dc, TRect& rect)

{

  if(((Style&sBitmap)==0 || Index < 0) && CheckPainter==0)

    return;


  TColor oldBkColor = dc.SetBkColor(TColor::SysMenu);

  dc.TextRect(rect);


  if(CheckPainter){


    if(IsChecked())

      (this->*CheckPainter)(dc, rect);

    else

      PaintCheck_None(dc,rect);


    dc.SetBkColor(oldBkColor);

    return;

  }


  // Determine which CelArray to paint from: ours or our Window's

  //

  TCelArray& celArray = CelArray ? *CelArray : *Proxy->GetCelArray();


  // Calc the source rect from the celarray. The dest point of the glyph is

  // relative to the face rect.

  //

  TRect  srcRect(celArray.CelRect(Index));


  // Paint border

  //

  TUIBorder::TEdge edge = TUIBorder::TEdge(0);

  if(IsChecked())

    edge = TUIBorder::SunkenInner;

  else if(IsSelected()&&IsEnabled())

    edge = TUIBorder::RaisedInner;

  if(edge)

    TUIBorder(rect, edge).Paint(dc);


  rect.Inflate(-1,-1);


  // Create a UI Face object for this button & let it paint the button face

  //

  TUIFace face(rect, celArray.operator TBitmap&());

  TPoint dstPt(1,1);


  if (!IsEnabled())

    face.Paint(dc, srcRect, dstPt, TUIFace::Disabled, IsChecked());

  else if(IsGrayed())

    face.Paint(dc, srcRect, dstPt, TUIFace::Indeterm, IsChecked());

  else

#if 0

    face.Paint(dc, srcRect, (IsSelected() && !IsChecked()) ?

               dstPt.Offset(-1,-1) : dstPt, TUIFace::Normal, IsChecked());

#else

    face.Paint(dc, srcRect, dstPt, TUIFace::Normal, IsChecked());

#endif

  dc.SetBkColor(oldBkColor);

}

TDrawMenuItem::PaintBitmap(TDC& dc, TRect& rect) {…}

//

// Paint Text

//

void


TDrawMenuItem::PaintText(TDC& dc, TRect& rect)

{

  if((Style&sText)==0)

    return;


  TFont* font = Font;

  if (!font)

    font = Proxy->GetFont();

  if(font)

   dc.SelectObject(*font);


   TColor oldTxColor  = dc.SetTextColor(GetTextColor());


  uint format =  DT_SINGLELINE|DT_EXPANDTABS;

  switch(Align){

    case aLeft:

      format |= DT_LEFT;

      break;

    case aRight:

      format |= DT_RIGHT;

      break;

    case aCenter:

      format |= DT_CENTER;

      break;

  }

  switch(LayoutStyle){

    case lTextLeft:

    case lTextRight:

      format |= DT_VCENTER;

      break;

    case lTextTop:

      format |= DT_VCENTER;//DT_BOTTOM;

      break;

    case lTextBottom:

      format |= DT_VCENTER;//DT_TOP;

      break;

  }


  // DT_RIGHT for \t

  tstring cs1;

  tstring cs(Text);

  size_t t_pos = cs.find(_T("\t")); //JJH changed int -> size_t


  TRect   tRect(rect);

  tRect.right -= TextSpaceE;


  // Accelerator can be \b instead of \t (NOTE: \a in .rc make a \b in res)

  //

  if (t_pos == cs.npos)

    t_pos = cs.find(_T("\b"));


  if (t_pos != cs.npos)

  {

    cs1 = cs.substr(t_pos+1);

    cs  = cs.substr(0, t_pos);

    // Create a UI Face object for this button & let it paint the button face

    //

    TPoint  dstPt(tRect.TopLeft());


    TUIFace face1(tRect, cs.c_str(), GetBkColor(), format);

    format &= ~DT_LEFT;

    format |= DT_RIGHT;

    TUIFace face2(tRect, cs1.c_str(), GetBkColor(), format);


    if ((!IsEnabled()||IsGrayed()) && !IsSelected()){

      face1.Paint(dc, dstPt, TUIFace::Disabled, false, false);

      face2.Paint(dc, dstPt, TUIFace::Disabled, false, false);

    }

    else{

      face1.Paint(dc, dstPt, TUIFace::Normal, false, false);

      face2.Paint(dc, dstPt, TUIFace::Normal, false, false);

    }

  }

  else{

    // Create a UI Face object for this button & let it paint the button face

    //

    TPoint  dstPt(tRect.TopLeft());


    TUIFace face(tRect, Text, GetBkColor(), format);

    if ((!IsEnabled()||IsGrayed()) && !IsSelected())

      face.Paint(dc, dstPt, TUIFace::Disabled, false, false);

    else

      face.Paint(dc, dstPt, TUIFace::Normal, false, false);

  }


  dc.SetTextColor(oldTxColor);


  if(font)

    dc.RestoreFont();

}

TDrawMenuItem::PaintText(TDC& dc, TRect& rect) {…}

//

/// If checked, clears the area in preparation for painting the check mark.

//

void


TDrawMenuItem::PaintCheckFace(TDC& dc, TRect& rect)

{

  if(IsChecked()){

    TColor oldBkColor = dc.SetBkColor(TColor::SysMenu);

    if(!IsSelected() || !IsEnabled())

      dc.FillRect(rect, TUIFace::GetDitherBrush());

    else

      dc.TextRect(rect);

    TUIBorder(rect, TUIBorder::Recessed).Paint(dc);

    dc.SetBkColor(oldBkColor);

  }

}

TDrawMenuItem::PaintCheckFace(TDC& dc, TRect& rect) {…}

///////////////////////////////////////////////////////////////////////////////////////////

//

// Check Draw functions

//

static TColor SelectColor(bool enabled)

{

  return enabled ? TColor::SysMenuText : TColor::Sys3dHilight;

}

//

///   Draw this:

/// \code

///   01234567

/// 0 ---x----

/// 1 ---xx---

/// 2 ---xxx--

/// 3 ---xxxx-

/// 4 ---xxx--

/// 5 ---xx---

/// 6 ---x----

/// 7 --------

/// \endcode

//

void


TDrawMenuItem::PaintCheck_3Angle(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  //TPoint point(rect.left+3,rect.top+3);

  rect.Inflate(-2,-2);

  TPoint point(rect.left+3,rect.top+2);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 ---x----

  // 1 ---xx---

  // 2 ---xxx--

  // 3 ---xxxx-

  // 4 ---xxx--

  // 5 ---xx---

  // 6 ---x----

  // 7 --------

  //

  dc.SetPixel(point.x + 3, point.y + 0, color);

  dc.SetPixel(point.x + 3, point.y + 1, color);

  dc.SetPixel(point.x + 3, point.y + 2, color);

  dc.SetPixel(point.x + 3, point.y + 3, color);

  dc.SetPixel(point.x + 3, point.y + 4, color);

  dc.SetPixel(point.x + 3, point.y + 5, color);

  dc.SetPixel(point.x + 3, point.y + 6, color);

  dc.SetPixel(point.x + 4, point.y + 1, color);

  dc.SetPixel(point.x + 4, point.y + 2, color);

  dc.SetPixel(point.x + 4, point.y + 3, color);

  dc.SetPixel(point.x + 4, point.y + 4, color);

  dc.SetPixel(point.x + 4, point.y + 5, color);

  dc.SetPixel(point.x + 5, point.y + 2, color);

  dc.SetPixel(point.x + 5, point.y + 3, color);

  dc.SetPixel(point.x + 5, point.y + 4, color);

  dc.SetPixel(point.x + 6, point.y + 3, color);

  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 --------

    // 3 --------

    // 4 ------x-

    // 5 -----x--

    // 6 ----x---

    // 7 ---x----

    //

    TColor clr = TColor::Sys3dHilight;

    dc.SetPixel(point.x + 3, point.y + 7, clr);

    dc.SetPixel(point.x + 4, point.y + 6, clr);

    dc.SetPixel(point.x + 5, point.y + 5, clr);

    dc.SetPixel(point.x + 6, point.y + 4, clr);

  }

}

TDrawMenuItem::PaintCheck_3Angle(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  0 ---x----

///  1 ---xx---

///  2 ---xxx--

///  3 xxxxxxx-

///  4 ---xxx--

///  5 ---xx---

///  6 ---x----

///  7 --------

/// \endcode

void


TDrawMenuItem::PaintCheck_Arrow(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  //TPoint point(rect.left+4,rect.top+3);

  rect.Inflate(-2,-2);

  TPoint point(rect.left+4,rect.top+2);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 ---x----

  // 1 ---xx---

  // 2 ---xxx--

  // 3 xxxxxxx-

  // 4 ---xxx--

  // 5 ---xx---

  // 6 ---x----

  // 7 --------

  //


  dc.SetPixel(point.x + 0, point.y + 3, color);

  dc.SetPixel(point.x + 1, point.y + 3, color);

  dc.SetPixel(point.x + 2, point.y + 3, color);

  dc.SetPixel(point.x + 3, point.y + 0, color);

  dc.SetPixel(point.x + 3, point.y + 1, color);

  dc.SetPixel(point.x + 3, point.y + 2, color);

  dc.SetPixel(point.x + 3, point.y + 3, color);

  dc.SetPixel(point.x + 3, point.y + 4, color);

  dc.SetPixel(point.x + 3, point.y + 5, color);

  dc.SetPixel(point.x + 3, point.y + 6, color);

  dc.SetPixel(point.x + 4, point.y + 1, color);

  dc.SetPixel(point.x + 4, point.y + 2, color);

  dc.SetPixel(point.x + 4, point.y + 3, color);

  dc.SetPixel(point.x + 4, point.y + 4, color);

  dc.SetPixel(point.x + 4, point.y + 5, color);

  dc.SetPixel(point.x + 5, point.y + 2, color);

  dc.SetPixel(point.x + 5, point.y + 3, color);

  dc.SetPixel(point.x + 5, point.y + 4, color);

  dc.SetPixel(point.x + 6, point.y + 3, color);

  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 --------

    // 3 --------

    // 4 ------x-

    // 5 -----x--

    // 6 ----x---

    // 7 ---x----

    //

    TColor clr = TColor::Sys3dHilight;

    dc.SetPixel(point.x + 3, point.y + 7, clr);

    dc.SetPixel(point.x + 4, point.y + 6, clr);

    dc.SetPixel(point.x + 5, point.y + 5, clr);

    dc.SetPixel(point.x + 6, point.y + 4, clr);

  }

}

TDrawMenuItem::PaintCheck_Arrow(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  1 -xxxxxxx

///  2 -xxxxxxx

///  3 -xxxxxxx

///  4 -xxxxxxx

///  5 -xxxxxxx

///  6 -xxxxxxx

///  7 -xxxxxxx

/// \endcode

//

void


TDrawMenuItem::PaintCheck_Box(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  //TPoint point(rect.left+4,rect.top+3);

  rect.Inflate(-2,-2);

  TPoint point(rect.left+4,rect.top+2);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 --------

  // 1 -xxxxxxx

  // 2 -xxxxxxx

  // 3 -xxxxxxx

  // 4 -xxxxxxx

  // 5 -xxxxxxx

  // 6 -xxxxxxx

  // 7 -xxxxxxx

  //


  dc.TextRect(point.x + 1, point.y + 1, point.x + 7, point.y + 7, color);


  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 --------x

    // 3 --------x

    // 4 --------x

    // 5 --------x

    // 6 --------x

    // 7 --------x

    //     xxxxxxx

    //

    TPen pen(TColor::Sys3dHilight, 0, PS_SOLID);

    dc.SelectObject(pen);

    dc.MoveTo(point.x + 2, point.y + 8);

    dc.LineTo(point.x + 8, point.y + 8);

    dc.MoveTo(point.x + 8, point.y + 2);

    dc.LineTo(point.x + 8, point.y + 9);

    dc.RestorePen();

  }

}

TDrawMenuItem::PaintCheck_Box(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  0 --------

///  1 ----x---

///  2 ---xxx--

///  3 --xxxxx-

///  4 -xxxxxxx

///  5 --xxxxx-

///  6 ---xxx--

///  7 ----x---

/// \endcode

void


TDrawMenuItem::PaintCheck_Diamond(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  //TPoint point(rect.left+3,rect.top+2);

  rect.Inflate(-2,-2);

  TPoint point(rect.left+3,rect.top+1);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 --------

  // 1 ----x---

  // 2 ---xxx--

  // 3 --xxxxx-

  // 4 -xxxxxxx

  // 5 --xxxxx-

  // 6 ---xxx--

  // 7 ----x---

  //


  dc.SetPixel(point.x + 1, point.y + 4, color);

  dc.SetPixel(point.x + 2, point.y + 3, color);

  dc.SetPixel(point.x + 2, point.y + 4, color);

  dc.SetPixel(point.x + 2, point.y + 5, color);

  dc.SetPixel(point.x + 3, point.y + 2, color);

  dc.SetPixel(point.x + 3, point.y + 3, color);

  dc.SetPixel(point.x + 3, point.y + 4, color);

  dc.SetPixel(point.x + 3, point.y + 5, color);

  dc.SetPixel(point.x + 3, point.y + 6, color);

  dc.SetPixel(point.x + 4, point.y + 1, color);

  dc.SetPixel(point.x + 4, point.y + 2, color);

  dc.SetPixel(point.x + 4, point.y + 3, color);

  dc.SetPixel(point.x + 4, point.y + 4, color);

  dc.SetPixel(point.x + 4, point.y + 5, color);

  dc.SetPixel(point.x + 4, point.y + 6, color);

  dc.SetPixel(point.x + 4, point.y + 7, color);

  dc.SetPixel(point.x + 5, point.y + 2, color);

  dc.SetPixel(point.x + 5, point.y + 3, color);

  dc.SetPixel(point.x + 5, point.y + 4, color);

  dc.SetPixel(point.x + 5, point.y + 5, color);

  dc.SetPixel(point.x + 5, point.y + 6, color);

  dc.SetPixel(point.x + 6, point.y + 3, color);

  dc.SetPixel(point.x + 6, point.y + 4, color);

  dc.SetPixel(point.x + 6, point.y + 5, color);

  dc.SetPixel(point.x + 7, point.y + 4, color);

  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 --------

    // 3 --------

    // 4 --------

    // 5 -------x

    // 6 ------x-

    // 7 -----x--

    //       x

    //

    TColor clr = TColor::Sys3dHilight;

    dc.SetPixel(point.x + 4, point.y + 8, clr);

    dc.SetPixel(point.x + 5, point.y + 7, clr);

    dc.SetPixel(point.x + 6, point.y + 6, clr);

    dc.SetPixel(point.x + 7, point.y + 5, clr);

  }

}

TDrawMenuItem::PaintCheck_Diamond(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  0 ---xx---

///  1 --xxxx--

///  2 -xxxxxx-

///  3 -xxxxxx-

///  4 -xxxxxx-

///  5 --xxxx--

///  6 ---xx---

///  7 --------

/// \endcode

//

void


TDrawMenuItem::PaintCheck_Dot(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  //TPoint point(rect.left+4,rect.top+3);

  rect.Inflate(-2,-2);

  TPoint point(rect.left+4,rect.top+2);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 ---xx---

  // 1 --xxxx--

  // 2 -xxxxxx-

  // 3 -xxxxxx-

  // 4 -xxxxxx-

  // 5 --xxxx--

  // 6 ---xx---

  // 7 --------

  //


  TPen pen(color, 0, PS_SOLID);

  dc.SelectObject(pen);


  dc.MoveTo(point.x + 1, point.y + 2);

  dc.LineTo(point.x + 1, point.y + 5);

  dc.MoveTo(point.x + 2, point.y + 1);

  dc.LineTo(point.x + 2, point.y + 6);

  dc.MoveTo(point.x + 3, point.y + 0);

  dc.LineTo(point.x + 3, point.y + 7);

  dc.MoveTo(point.x + 4, point.y + 0);

  dc.LineTo(point.x + 4, point.y + 7);

  dc.MoveTo(point.x + 5, point.y + 1);

  dc.LineTo(point.x + 5, point.y + 6);

  dc.MoveTo(point.x + 6, point.y + 2);

  dc.LineTo(point.x + 6, point.y + 5);

  dc.RestorePen();

  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 --------

    // 3 --------

    // 4 --------

    // 5 ------x-

    // 6 -----x--

    // 7 ---xx---

    //

    TColor clr = TColor::Sys3dHilight;

    dc.SetPixel(point.x + 3, point.y + 7, clr);

    dc.SetPixel(point.x + 4, point.y + 7, clr);

    dc.SetPixel(point.x + 5, point.y + 6, clr);

    dc.SetPixel(point.x + 6, point.y + 5, clr);

  }

}

TDrawMenuItem::PaintCheck_Dot(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  0 --------

///  1 --------

///  2 --------

///  3 --------

///  4 --------

///  5 --------

///  6 --------

///  7 --------

/// \endcode

//

void


TDrawMenuItem::PaintCheck_None(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  rect.Inflate(-2,-2);


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 --------

  // 1 --------

  // 2 --------

  // 3 --------

  // 4 --------

  // 5 --------

  // 6 --------

  // 7 --------

  //

}

TDrawMenuItem::PaintCheck_None(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  0 --------

///  1 ---xx---

///  2 ---xx---

///  3 -xxxxxx-

///  4 -xxxxxx-

///  5 ---xx---

///  6 ---xx---

///  7 --------

/// \endcode

//

void


TDrawMenuItem::PaintCheck_Plus(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  //TPoint point(rect.left+4,rect.top+3);

  rect.Inflate(-2,-2);

  TPoint point(rect.left+4,rect.top+2);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 --------

  // 1 ---xx---

  // 2 ---xx---

  // 3 -xxxxxx-

  // 4 -xxxxxx-

  // 5 ---xx---

  // 6 ---xx---

  // 7 --------

  //


  TPen Pen(color, 0, PS_SOLID);

  dc.SelectObject(Pen);


  dc.MoveTo(point.x + 3, point.y + 1);

  dc.LineTo(point.x + 3, point.y + 7);

  dc.MoveTo(point.x + 4, point.y + 1);

  dc.LineTo(point.x + 4, point.y + 7);

  dc.MoveTo(point.x + 1, point.y + 3);

  dc.LineTo(point.x + 7, point.y + 3);

  dc.MoveTo(point.x + 1, point.y + 4);

  dc.LineTo(point.x + 7, point.y + 4);

  dc.RestorePen();

  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 --------

    // 3 --------

    // 4 --------

    // 5 -----xx-

    // 6 -----x--

    // 7 ---xxx--

    //

    TColor clr = TColor::Sys3dHilight;

    dc.SetPixel(point.x + 3, point.y + 7, clr);

    dc.SetPixel(point.x + 4, point.y + 7, clr);

    dc.SetPixel(point.x + 5, point.y + 7, clr);

    dc.SetPixel(point.x + 5, point.y + 6, clr);

    dc.SetPixel(point.x + 5, point.y + 5, clr);

    dc.SetPixel(point.x + 6, point.y + 5, clr);

  }

}

TDrawMenuItem::PaintCheck_Plus(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  0 ------x-

///  1 -----xx-

///  2 x---xxx-

///  3 xx-xxx--

///  4 xxxxx---

///  5 -xxx----

///  6 --x-----

///  7 --------

/// \endcode

//

void


TDrawMenuItem::PaintCheck_V(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  //TPoint point(rect.left+4,rect.top+3);

  rect.Inflate(-2,-2);

  TPoint point(rect.left+4,rect.top+2);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 ------x-

  // 1 -----xx-

  // 2 x---xxx-

  // 3 xx-xxx--

  // 4 xxxxx---

  // 5 -xxx----

  // 6 --x-----

  // 7 --------

  //


  dc.SetPixel(point.x + 0, point.y + 2, color);

  dc.SetPixel(point.x + 0, point.y + 3, color);

  dc.SetPixel(point.x + 0, point.y + 4, color);

  dc.SetPixel(point.x + 1, point.y + 3, color);

  dc.SetPixel(point.x + 1, point.y + 4, color);

  dc.SetPixel(point.x + 1, point.y + 5, color);

  dc.SetPixel(point.x + 2, point.y + 4, color);

  dc.SetPixel(point.x + 2, point.y + 5, color);

  dc.SetPixel(point.x + 2, point.y + 6, color);

  dc.SetPixel(point.x + 3, point.y + 3, color);

  dc.SetPixel(point.x + 3, point.y + 4, color);

  dc.SetPixel(point.x + 3, point.y + 5, color);

  dc.SetPixel(point.x + 4, point.y + 2, color);

  dc.SetPixel(point.x + 4, point.y + 3, color);

  dc.SetPixel(point.x + 4, point.y + 4, color);

  dc.SetPixel(point.x + 5, point.y + 1, color);

  dc.SetPixel(point.x + 5, point.y + 2, color);

  dc.SetPixel(point.x + 5, point.y + 3, color);

  dc.SetPixel(point.x + 6, point.y + 0, color);

  dc.SetPixel(point.x + 6, point.y + 1, color);

  dc.SetPixel(point.x + 6, point.y + 2, color);

  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 --------

    // 3 ------x-

    // 4 -----x--

    // 5 ----x---

    // 6 ---x----

    // 7 --x-----

    //

    TColor clr = TColor::Sys3dHilight;

    dc.SetPixel(point.x + 2, point.y + 7, clr);

    dc.SetPixel(point.x + 3, point.y + 6, clr);

    dc.SetPixel(point.x + 4, point.y + 5, clr);

    dc.SetPixel(point.x + 5, point.y + 4, clr);

    dc.SetPixel(point.x + 6, point.y + 3, clr);

  }

}

TDrawMenuItem::PaintCheck_V(TDC& dc, TRect& rect) {…}

//

///   Draw this:

/// \code

///    01234567

///  0 --------

///  1 xx---xx-

///  2 -xx-xx--

///  3 --xx----

///  4 ---xx---

///  5 -xx-xx--

///  6 xx---xx-

///  7 --------

/// \endcode

//

void


TDrawMenuItem::PaintCheck_X(TDC& dc, TRect& rect)

{

  //rect.Inflate(-3,-3);

  rect.Inflate(-2,-2);

  TColor color = SelectColor(IsEnabled());


  PaintCheckFace(dc,rect);


  //  Draw this:

  //

  //   01234567

  // 0 --------

  // 1 xx---xx-

  // 2 -xx-xx--

  // 3 --xx----

  // 4 ---xx---

  // 5 -xx-xx--

  // 6 xx---xx-

  // 7 --------

  //

  //TPoint point(rect.left+4,rect.top+3);

  TPoint point(rect.left+4,rect.top+2);

  dc.SetPixel(point.x + 0, point.y + 1, color);

  dc.SetPixel(point.x + 1, point.y + 1, color);

  dc.SetPixel(point.x + 1, point.y + 2, color);

  dc.SetPixel(point.x + 2, point.y + 2, color);

  dc.SetPixel(point.x + 2, point.y + 3, color);

  dc.SetPixel(point.x + 3, point.y + 3, color);

  dc.SetPixel(point.x + 3, point.y + 4, color);

  dc.SetPixel(point.x + 4, point.y + 4, color);

  dc.SetPixel(point.x + 4, point.y + 5, color);

  dc.SetPixel(point.x + 5, point.y + 5, color);

  dc.SetPixel(point.x + 5, point.y + 6, color);

  dc.SetPixel(point.x + 6, point.y + 6, color);

  dc.SetPixel(point.x + 5, point.y + 1, color);

  dc.SetPixel(point.x + 6, point.y + 1, color);

  dc.SetPixel(point.x + 4, point.y + 2, color);

  dc.SetPixel(point.x + 5, point.y + 2, color);

  dc.SetPixel(point.x + 1, point.y + 5, color);

  dc.SetPixel(point.x + 2, point.y + 5, color);

  dc.SetPixel(point.x + 0, point.y + 6, color);

  dc.SetPixel(point.x + 1, point.y + 6, color);

  if(!IsEnabled()){

    //  Add this:

    //

    //   01234567

    // 0 --------

    // 1 --------

    // 2 ------x-

    // 3 ----x---

    // 4 --------

    // 5 ---x----

    // 6 --x-----

    // 7 -x------

    //

    TColor clr = TColor::Sys3dHilight;

    dc.SetPixel(point.x + 6, point.y + 2, clr);

    dc.SetPixel(point.x + 4, point.y + 3, clr);

    dc.SetPixel(point.x + 3, point.y + 5, clr);

    dc.SetPixel(point.x + 2, point.y + 6, clr);

    dc.SetPixel(point.x + 1, point.y + 7, clr);

  }

}

TDrawMenuItem::PaintCheck_X(TDC& dc, TRect& rect) {…}


//-------------------------------------------------------------------------

//

// class TDrawMenuItemProxy

// ~~~~~ ~~~~~~~~~~~~~~~~~~

//

/// Creates a font for use in menu bars.

//

TFont*


TDrawMenuItemProxy::CreateProxyMenuFont()

{

  NONCLIENTMETRICS ncm;

  ncm.cbSize = sizeof(NONCLIENTMETRICS);

  SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0);

  return new TFont(ncm.lfMenuFont);

}

TDrawMenuItemProxy::CreateProxyMenuFont() {…}

//

/// Constructs a TDrawMenuItemProxy object using the specified resource.

//


TDrawMenuItemProxy::TDrawMenuItemProxy(TResId resId, TModule* module)

:

 TDrawItemProxy(CreateProxyMenuFont())

{

  Array = new TUIntAray;

  TToolbarRes barRes(*module, resId, NoAutoDelete);

  int numRows = barRes.GetBitmap().Height()/barRes.GetHeight();

  { // map colors

    TBtnBitmap bitmap(barRes.GetBitmap(), TColor::LtGray, NoAutoDelete);

  }


  TCelArray* celAray = new TCelArray(

    &barRes.GetBitmap(),

    barRes.GetCount(),

    TSize(barRes.GetWidth(), barRes.GetHeight()),

    TPoint(0, 0), // offset

    numRows);

  SetCelArray(celAray);


  for(int i = 0; i < (int)barRes.GetCount(); i++){

    if(barRes.GetIds()[i] >0)

      Array->Add((uint)barRes.GetIds()[i]);

  }

}

TDrawMenuItemProxy::TDrawMenuItemProxy(TResId resId, TModule* module) {…}

//

/// Destroys the instance.

//


TDrawMenuItemProxy::~TDrawMenuItemProxy()

{

  delete Array;

}

TDrawMenuItemProxy::~TDrawMenuItemProxy() {…}

//

/// Returns the item with id cmdId if it exists; otherwise creates a new item and

/// returns it.

//

TDrawItem*


TDrawMenuItemProxy::CreateItem(uint cmdId, const tstring& text)

{

  TDrawItemArray& items = GetItems();

  int index = GetIndex((int)cmdId);


  // if item already exist -> return existing one

  for(int i = 0; i < (int)items.Size(); i++){

    TButtonTextDrawItem* item = TYPESAFE_DOWNCAST(items[i], TButtonTextDrawItem);

    if(item->GetIndex() == index && item->GetText() == text)

      return items[i];

  }

  if(cmdId == static_cast<uint>(TButtonTextDrawItem::sepNoBitmap)) //JJH added static_cast

    index = TButtonTextDrawItem::sepNoBitmap;


  // if none found -> add new one

  TDrawMenuItem* item = new TDrawMenuItem(this, cmdId, index, text);

  RegisterItem(item);


  return item;

}

TDrawMenuItemProxy::CreateItem(uint cmdId, const tstring& text) {…}

//

/// Walks through the menu tree hMenu adding seperators.

//

void


TDrawMenuItemProxy::RemapMenu(HMENU hMenu)

{

  iRecurse = 0; // this->iRecurse = 0;


  iRecurse++;

  int nItem = ::GetMenuItemCount(hMenu);

  while ((--nItem)>=0) {

    uint itemId = ::GetMenuItemID(hMenu, nItem);

    if (itemId == (uint) -1){

      HMENU pops = ::GetSubMenu(hMenu, nItem);

      if (pops)

        RemapMenu(pops);

      if (iRecurse>0){

        tchar buffer[MAX_PATH];

        if (::GetMenuString(hMenu, nItem, buffer, MAX_PATH, MF_BYPOSITION) > 0){

          TDrawItem* item = CreateItem((uint)TButtonTextDrawItem::sepNoBitmap, buffer); // itemId = -1

          ::ModifyMenu(hMenu, nItem, MF_BYPOSITION|MF_OWNERDRAW, (uint)-1, (LPCTSTR)item);

        }

      }

    }

    else {

      uint oldState = ::GetMenuState(hMenu, nItem, MF_BYPOSITION);

      if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))  {

        if ((oldState&MF_SEPARATOR) || itemId == 0){

          // Insert separator items only if a background bitmap is drawn

          //

        }

        else{

          tchar buffer[MAX_PATH];

          if (::GetMenuString(hMenu, nItem, buffer, MAX_PATH, MF_BYPOSITION) > 0){

            TDrawItem* item = CreateItem(itemId, buffer);

            ::ModifyMenu(hMenu, nItem, MF_BYPOSITION|MF_OWNERDRAW|oldState,

               (LPARAM)itemId, (LPCTSTR)item);

          }

        }

      }

    }

  }

  iRecurse--;

}

TDrawMenuItemProxy::RemapMenu(HMENU hMenu) {…}

//

/// Returns true if a shortcut was pressed that fits into the menu and false if not.

//

bool


TDrawMenuItemProxy::EvMenuChar(uint uChar, uint, HMENU hMenu, TParam2& param)

{

  PRECONDITION(hMenu);

  tchar keyPressed = (tchar)_totupper(uChar);

  int count = ::GetMenuItemCount(hMenu);

  while(count >= 0){

    uint itemId = ::GetMenuItemID(hMenu, count);

    if(itemId){

      TMenuItemInfo itemInfo(MIIM_DATA | MIIM_TYPE);

      if(::GetMenuItemInfo(hMenu, count, true, &itemInfo)){

        if(itemInfo.fType & MFT_OWNERDRAW){

          TDrawMenuItem* item = 0;

          try{

            item = TYPESAFE_DOWNCAST((TDrawMenuItem*)itemInfo.dwItemData,TDrawMenuItem);

          }

          catch(...){

            //.........

          }

          if(item){

            const tchar* p = _tcschr(item->GetText(),_T('&'));

            if(p){

              p++;

              if(_totupper(*p) == keyPressed){

                // Shortcut found.

                param = MkUint32((uint16)count, 2);

                return true;

              }

            }

          }

        }

      }

    }

    count--;

  }

  // Shortcut not found.

  return false;

}

TDrawMenuItemProxy::EvMenuChar(uint uChar, uint, HMENU hMenu, TParam2& param) {…}

//

/// Returns the TDrawItem with id cmdId, or 0 if it doesn't exist.

//


TDrawItem* TDrawMenuItemProxy::FindItem(uint cmdId)

{

  TDrawItemArray& items = GetItems();

  auto index = GetIndex(cmdId);

  if (index != items.NPOS)

    return items[index];


  const auto n = static_cast<int>(items.Size());

  for (index = 0; index != n; ++index)

  {

    const auto m = dynamic_cast<TDrawMenuItem*>(items[index]);

    if (m && m->GetCmdId() == static_cast<int>(cmdId))

      break;

  }

  return index < n ? items[index] : nullptr;

}

TDrawItem* TDrawMenuItemProxy::FindItem(uint cmdId) {…}

//

/// Returns the array index of the item with id cmdId.

//


int TDrawMenuItemProxy::GetIndex(int cmdId)

{

  return Array->Find(cmdId);

}

int TDrawMenuItemProxy::GetIndex(int cmdId) {…}

//

} // OWL namespace


////////////////////////////////////////////////////////////////////////////////


celarray.h
Definition of a bitmap Cel array class.

PRECONDITION
#define PRECONDITION(condition)
Definition checks.h:227

VarType
Definition safearray.h:14

owl::TBitmap
TBitmap is the GDI bitmap class derived from TGdiObject.
Definition gdiobjec.h:510

owl::TBtnBitmap
TBtnBitmap is an enhanced version of TBitmap with the ability to update the face color of a bitmap to...
Definition glyphbtn.h:49

owl::TButtonTextDrawItem
Definition drawitem.h:70

owl::TButtonTextDrawItem::Measure
virtual void Measure(MEASUREITEMSTRUCT &drawItem)
Calculates the area required to display the button and text.
Definition drawitem.cpp:214

owl::TButtonTextDrawItem::Compare
virtual int Compare(COMPAREITEMSTRUCT &drawItem)
Does an lstrcmp on Text from the instances contained in drawItem.
Definition drawitem.cpp:230

owl::TButtonTextDrawItem::IsSelected
bool IsSelected()
Returns true if (Flags & ODS_SELECTED)==0; false otherwise.
Definition drawitem.h:142

owl::TButtonTextDrawItem::lTextTop
@ lTextTop
Text top, bitmap bottom.
Definition drawitem.h:93

owl::TButtonTextDrawItem::lTextRight
@ lTextRight
Text right, bitmap left.
Definition drawitem.h:94

owl::TButtonTextDrawItem::lTextBottom
@ lTextBottom
Text bottom, bitmap top.
Definition drawitem.h:95

owl::TButtonTextDrawItem::lTextLeft
@ lTextLeft
Text left, bitmap right.
Definition drawitem.h:92

owl::TButtonTextDrawItem::PaintBitmap
virtual void PaintBitmap(TDC &rc, TRect &rect)
Paint the bitmap.
Definition drawitem.cpp:428

owl::TButtonTextDrawItem::GetStyle
TStyle GetStyle() const
Returns Style: Bitmap only, Text only, or Bitmap and Text.
Definition drawitem.h:290

owl::TButtonTextDrawItem::PaintText
virtual void PaintText(TDC &rc, TRect &rect)
Paint the text.
Definition drawitem.cpp:348

owl::TButtonTextDrawItem::IsChecked
bool IsChecked()
Returns true if (Flags & ODS_CHECKED)==0; false otherwise.
Definition drawitem.h:151

owl::TButtonTextDrawItem::SetFont
void SetFont(TFont *font)
Deletes Font and then assigns font to Font.
Definition drawitem.cpp:171

owl::TButtonTextDrawItem::IsGrayed
bool IsGrayed()
Returns true if (Flags & ODS_GRAYED)==0; false otherwise.
Definition drawitem.h:148

owl::TButtonTextDrawItem::PaintBorder
virtual void PaintBorder(TDC &rc, TRect &rect)
Paint the border of the gadget based on the BorderStyle member.
Definition drawitem.cpp:419

owl::TButtonTextDrawItem::GetBkColor
virtual TColor GetBkColor()
If selected returns TColor::SysActiveCaption; otherwise returns TColor::SysWindow.
Definition drawitem.cpp:241

owl::TButtonTextDrawItem::Layout
virtual void Layout(const TRect &src, TRect &textRect, TRect &bmpRect)
Layout Text and Bitmap.
Definition drawitem.cpp:306

owl::TButtonTextDrawItem::IsFocused
bool IsFocused()
Returns true if (Flags & ODS_FOCUS)==0; false otherwise.
Definition drawitem.h:145

owl::TButtonTextDrawItem::~TButtonTextDrawItem
~TButtonTextDrawItem()
Destroys a TButtonTextDrawItem object. If DeleteCel is true, deletes CelArray.
Definition drawitem.cpp:120

owl::TButtonTextDrawItem::TButtonTextDrawItem
TButtonTextDrawItem(TDrawItemProxy *proxy=0)
Constructs a TButtonTextDrawItem with proxy as it's parent.
Definition drawitem.cpp:103

owl::TButtonTextDrawItem::Draw
virtual void Draw(DRAWITEMSTRUCT &drawItem)
Extracts information from drawItem and calls Paint.
Definition drawitem.cpp:202

owl::TButtonTextDrawItem::SetText
void SetText(LPCTSTR text)
Deletes Text and clears the text style.
Definition drawitem.cpp:132

owl::TButtonTextDrawItem::GetTextColor
virtual TColor GetTextColor()
If selected, returns TColor::Sys3dHilight if a 3d User interface is in use or TColor::SysGrayText oth...
Definition drawitem.cpp:250

owl::TButtonTextDrawItem::SetCelArray
void SetCelArray(TCelArray *celarray, TAutoDelete del=AutoDelete)
If DeleteCel is true, CelArray is deleted.
Definition drawitem.cpp:181

owl::TButtonTextDrawItem::aRight
@ aRight
Aligns the text at the right edge of the bounding rectangle.
Definition drawitem.h:77

owl::TButtonTextDrawItem::aLeft
@ aLeft
Aligns the text at the left edge of the bounding rectangle.
Definition drawitem.h:75

owl::TButtonTextDrawItem::aCenter
@ aCenter
Aligns the text horizontally at the center of the bounding rectangle.
Definition drawitem.h:76

owl::TButtonTextDrawItem::sepNoBitmap
@ sepNoBitmap
Definition drawitem.h:98

owl::TButtonTextDrawItem::TStyle
TStyle
TStyle contains values that defines how the button will be displayed.
Definition drawitem.h:82

owl::TButtonTextDrawItem::sText
@ sText
Only text is displayed.
Definition drawitem.h:85

owl::TButtonTextDrawItem::sBitmap
@ sBitmap
Only the bitmap is displayed.
Definition drawitem.h:84

owl::TButtonTextDrawItem::GetIndex
int GetIndex() const
Returns Index, the index of Bitmap in the Proxy CellArray or -1.
Definition drawitem.h:283

owl::TButtonTextDrawItem::Paint
virtual void Paint(TDC &rc, TRect &rect)
Paint function.
Definition drawitem.cpp:281

owl::TButtonTextDrawItem::IsEnabled
bool IsEnabled()
Returns true if (Flags & ODS_DISABLED)==0; false otherwise.
Definition drawitem.h:139

owl::TButtonTextDrawItem::GetText
LPCTSTR GetText() const
Returns Text, the text do display on the button.
Definition drawitem.h:276

owl::TButtonTextDrawItem::GetTextSize
virtual void GetTextSize(TSize &size)
Calculates the size of the rectangle need to paint the text.
Definition drawitem.cpp:261

owl::TButtonTextDrawItem::GetButtonSize
virtual void GetButtonSize(TSize &btnSize)
Calculates the size of button.
Definition drawitem.cpp:406

owl::TButtonTextDrawItem::SetIndex
void SetIndex(int index)
Index is set to index and the sBitmap style is cleared from Style.
Definition drawitem.cpp:157

owl::TCelArray
TCelArray is a horizontal array of cels (a unit of animation) created by slicing a portion of or an e...
Definition celarray.h:35

owl::TColor
Class wrapper for management of color values.
Definition color.h:245

owl::TColor::SysMenuText
static const TColor SysMenuText
The symbolic system color value for the text shown on menus.
Definition color.h:331

owl::TColor::SysActiveCaption
static const TColor SysActiveCaption
The symbolic system color value for the caption of the active window.
Definition color.h:326

owl::TColor::Sys3dHilight
static const TColor Sys3dHilight
The symbolic system color value for highlighted 3-dimensional display elements (for edges facing the ...
Definition color.h:344

owl::TColor::LtGray
static const TColor LtGray
Static TColor object with fixed Value set by RGB(192, 192, 192).
Definition color.h:306

owl::TColor::SysWindowText
static const TColor SysWindowText
The symbolic system color value for text in every window.
Definition color.h:332

owl::TColor::SysMenu
static const TColor SysMenu
The symbolic system color value for the background of menus.
Definition color.h:328

owl::TColor::SysWindow
static const TColor SysWindow
The symbolic system color value for the background of each window.
Definition color.h:329

owl::TDC
TDC is the root class for GDI DC wrappers.
Definition dc.h:64

owl::TDC::MoveTo
bool MoveTo(int x, int y)
Moves the current position of this DC to the given x- and y-coordinates or to the given point.
Definition dc.h:1690

owl::TDC::SetPixel
TColor SetPixel(int x, int y, const TColor &color)
Sets the color of the pixel at the given location to the given color and returns the pixel's previous...
Definition dc.h:2394

owl::TDC::SelectObject
void SelectObject(const TBrush &brush)
Selects the given GDI brush object into this DC.
Definition dc.cpp:113

owl::TDC::GetTextExtent
bool GetTextExtent(const tstring &str, int stringLen, TSize &size) const
Computes the extent (width and height) in logical units of the text line consisting of stringLen char...
Definition dc.h:2968

owl::TDC::FillRect
bool FillRect(int x1, int y1, int x2, int y2, const TBrush &brush)
Fills the given rectangle on this DC using the specified brush.
Definition dc.h:1802

owl::TDC::RestorePen
void RestorePen()
Restores the original GDI pen object to this DC.
Definition dc.cpp:220

owl::TDC::TextRect
bool TextRect(int x1, int y1, int x2, int y2)
Fills the given rectangle, clipping any text to the rectangle.
Definition dc.h:1878

owl::TDC::DrawFocusRect
bool DrawFocusRect(int x1, int y1, int x2, int y2)
Draws the given rectangle on this DC in the style used to indicate focus.
Definition dc.h:1854

owl::TDC::SetBkColor
virtual TColor SetBkColor(const TColor &color)
Sets the current background color of this DC to the given color value or the nearest available.
Definition dc.cpp:405

owl::TDC::RestoreFont
virtual void RestoreFont()
Restores the original GDI font object to this DC.
Definition dc.cpp:246

owl::TDC::LineTo
bool LineTo(int x, int y)
Draws a line on this DC using the current pen object.
Definition dc.h:2148

owl::TDC::SetTextColor
virtual TColor SetTextColor(const TColor &color)
Sets the current text color of this DC to the given color value.
Definition dc.cpp:417

owl::TDrawItem
Definition window.h:188

owl::TDrawItemProxy
Proxy parent for TDrawItem.
Definition drawitem.h:40

owl::TDrawItemProxy::SetCelArray
void SetCelArray(TCelArray *celarray, TAutoDelete del=AutoDelete)
If DeleteCel is true, deletes CelArray.
Definition drawitem.cpp:64

owl::TDrawItemProxy::SetFont
void SetFont(TFont *font)
Deletes Font and sets it to font.
Definition drawitem.cpp:55

owl::TDrawItemProxy::RegisterItem
void RegisterItem(TDrawItem *item)
For automatic deletion of items.
Definition drawitem.cpp:84

owl::TDrawItemProxy::~TDrawItemProxy
virtual ~TDrawItemProxy()
Deletes Font. If DeleteCel is true, delets CelArray.
Definition drawitem.cpp:44

owl::TDrawItemProxy::GetCelArray
virtual TCelArray * GetCelArray()
Definition drawitem.h:51

owl::TDrawItemProxy::GetFont
virtual TFont * GetFont()
Definition drawitem.h:48

owl::TDrawItemProxy::TDrawItemArray
TIPtrArray< TDrawItem * > TDrawItemArray
Definition drawitem.h:42

owl::TDrawItemProxy::GetItems
TDrawItemArray & GetItems()
Returns ItemArray.
Definition drawitem.h:269

owl::TDrawItemProxy::TDrawItemProxy
TDrawItemProxy(TFont *font=0)
Constructs a TDrawItemProxy object using the specified font.
Definition drawitem.cpp:35

owl::TDrawMenuItem
Derived from TButtonTextDrawItem, the TDrawMenuItem class is used for owner drawn menus.
Definition drawitem.h:184

owl::TDrawMenuItem::PaintCheck_3Angle
void PaintCheck_3Angle(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:708

owl::TDrawMenuItem::TDrawMenuItem
TDrawMenuItem(TDrawItemProxy *proxy, int cmdId, int index, LPCTSTR title=0)
Called with the proxy parent, the command it, the index in the menu and the text to display.
Definition drawitem.cpp:447

owl::TDrawMenuItem::PaintText
virtual void PaintText(TDC &rc, TRect &rect)
Definition drawitem.cpp:579

owl::TDrawMenuItem::PaintBitmap
virtual void PaintBitmap(TDC &dc, TRect &rect)
Paint the bitmap on the menu entry.
Definition drawitem.cpp:517

owl::TDrawMenuItem::PaintCheck_Box
void PaintCheck_Box(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:856

owl::TDrawMenuItem::PaintCheck_Plus
void PaintCheck_Plus(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:1111

owl::TDrawMenuItem::PaintCheck_X
void PaintCheck_X(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:1263

owl::TDrawMenuItem::PaintCheck_Arrow
void PaintCheck_Arrow(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:780

owl::TDrawMenuItem::PaintCheck_V
void PaintCheck_V(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:1183

owl::TDrawMenuItem::GetButtonSize
virtual void GetButtonSize(TSize &btnSize)
Get the size of the bitmap button.
Definition drawitem.cpp:481

owl::TDrawMenuItem::PaintCheck_Dot
void PaintCheck_Dot(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:1002

owl::TDrawMenuItem::PaintCheckFace
virtual void PaintCheckFace(TDC &dc, TRect &rect)
If checked, clears the area in preparation for painting the check mark.
Definition drawitem.cpp:673

owl::TDrawMenuItem::GetTextColor
virtual TColor GetTextColor()
Returns the text color.
Definition drawitem.cpp:506

owl::TDrawMenuItem::PaintCheck_None
void PaintCheck_None(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:1076

owl::TDrawMenuItem::PaintCheck_Diamond
void PaintCheck_Diamond(TDC &dc, TRect &rect)
Draw this:
Definition drawitem.cpp:918

owl::TDrawMenuItem::GetBkColor
virtual TColor GetBkColor()
If the menu item is selected returns TColor::SysActiveCaption; otherwise returns TColor::SysMenu.
Definition drawitem.cpp:498

owl::TDrawMenuItem::GetTextSize
virtual void GetTextSize(TSize &size)
Definition drawitem.cpp:469

owl::TDrawMenuItemProxy::TDrawMenuItemProxy
TDrawMenuItemProxy(TResId resId, TModule *module=&GetGlobalModule())
Constructs a TDrawMenuItemProxy object using the specified resource.
Definition drawitem.cpp:1345

owl::TDrawMenuItemProxy::CreateItem
virtual TDrawItem * CreateItem(uint itemId, const tstring &text)
Returns the item with id cmdId if it exists; otherwise creates a new item and returns it.
Definition drawitem.cpp:1381

owl::TDrawMenuItemProxy::~TDrawMenuItemProxy
virtual ~TDrawMenuItemProxy()
Destroys the instance.
Definition drawitem.cpp:1372

owl::TDrawMenuItemProxy::RemapMenu
void RemapMenu(HMENU hMenu)
Walks through the menu tree hMenu adding seperators.
Definition drawitem.cpp:1405

owl::TDrawMenuItemProxy::CreateProxyMenuFont
static TFont * CreateProxyMenuFont()
Creates a font for use in menu bars.
Definition drawitem.cpp:1335

owl::TDrawMenuItemProxy::Array
TUIntAray * Array
Array of id's.
Definition drawitem.h:249

owl::TDrawMenuItemProxy::GetIndex
int GetIndex(int cmdId)
Returns the array index of the item with id cmdId.
Definition drawitem.cpp:1508

owl::TDrawMenuItemProxy::FindItem
TDrawItem * FindItem(uint cmdId)
Returns the TDrawItem with id cmdId, or 0 if it doesn't exist.
Definition drawitem.cpp:1489

owl::TDrawMenuItemProxy::EvMenuChar
bool EvMenuChar(uint uChar, uint, HMENU hMenu, TParam2 &param)
Returns true if a shortcut was pressed that fits into the menu and false if not.
Definition drawitem.cpp:1449

owl::TDrawMenuItemProxy::TUIntAray
TTypedArray< uint, uint, TStandardAllocator > TUIntAray
Container of TDrawItem's.
Definition drawitem.h:232

owl::TFont
TFont derived from TGdiObject provides constructors for creating font objects from explicit informati...
Definition gdiobjec.h:296

owl::TGadgetWindowFont
Derived from TFont, TGadgetWindowFont is the default font used by TGadgetWindow.
Definition gadgetwi.h:92

owl::TMenuItemInfo
Definition menu.h:46

owl::TModule
ObjectWindows dynamic-link libraries (DLLs) construct an instance of TModule, which acts as an object...
Definition module.h:75

owl::TPen
TPen is derived from TGdiObject.
Definition gdiobjec.h:138

owl::TPoint
TPoint is a support class, derived from tagPOINT.
Definition geometry.h:87

owl::TRect
TRect is a mathematical class derived from tagRect.
Definition geometry.h:308

owl::TResId
Definition wsyscls.h:206

owl::TScreenDC
Derived from TWindowDC, TScreenDC is a DC class that provides direct access to the screen bitmap.
Definition dc.h:610

owl::TSize
The tagSIZE struct is defined as.
Definition geometry.h:234

owl::TToolbarRes
Definition resource.h:85

owl::TUIBorder
Assists in drawing borders of many styles.
Definition uihelper.h:270

owl::TUIBorder::TEdge
TEdge
Enumeration describing the type of edge to be drawn.
Definition uihelper.h:315

owl::TUIBorder::RaisedInner
@ RaisedInner
Raised inner edge only.
Definition uihelper.h:318

owl::TUIBorder::SunkenInner
@ SunkenInner
Sunken inner edge only.
Definition uihelper.h:319

owl::TUIBorder::Paint
void Paint(TDC &dc) const
Paints this UIBorder object onto a given device context.
Definition uiborder.cpp:112

owl::TUIBorder::Recessed
@ Recessed
Status field style recessed.
Definition uihelper.h:300

owl::TUIFace
TUIFace assists in painting UI elements in various states.
Definition uihelper.h:367

owl::TUIFace::GetDitherBrush
static THatch8x8Brush & GetDitherBrush()
Internal static helper function that can be used alone.
Definition uiface.cpp:124

owl::TUIFace::Disabled
@ Disabled
Disabled or Unavailable state (embossed 3d no color)
Definition uihelper.h:376

owl::TUIFace::Indeterm
@ Indeterm
Indeterminant, or mixed-value state.
Definition uihelper.h:375

owl::TUIFace::Normal
@ Normal
Normal state.
Definition uihelper.h:373

MAX_PATH
#define MAX_PATH
Definition cygwin.h:98

_totupper
#define _totupper
Definition cygwin.h:73

_tcslen
#define _tcslen
Definition cygwin.h:74

_T
#define _T(x)
Definition cygwin.h:51

_tcschr
#define _tcschr
Definition cygwin.h:85

drawitem.h
Definitions of classes TDrawItemProxy, TDrawItem,TButtonTextDrawItem, TDrawMenuItem,...

gadgetwi.h
Definition of TGadgetList, TGadgetWindow & TGadgetWindowFont A list holding gadgets,...

glyphbtn.h
Definition of class TGlyphButton.

owl::TAutoDelete
TAutoDelete
Flag for Handle ctors to control Handle deletion in dtor.
Definition gdibase.h:70

owl::AutoDelete
@ AutoDelete
Definition gdibase.h:70

owl::NoAutoDelete
@ NoAutoDelete
Definition gdibase.h:70

pch.h

strnewdup
char * strnewdup(const char *s, size_t minAllocSize=0)
Definition memory.cpp:25

owl
Object Windows Library (OWLNext Core)
Definition animctrl.h:22

owl::MkUint32
uint32 MkUint32(uint16 lo, uint16 hi)
Definition defs.h:261

owl::TextSpaceV
const int TextSpaceV
Definition btntextg.cpp:94

owl::tchar
char tchar
Definition defs.h:77

owl::TParam2
LPARAM TParam2
Second parameter type.
Definition dispatch.h:55

owl::ButtonSpaceH
const int ButtonSpaceH
Definition drawitem.cpp:97

owl::ButtonSpaceV
const int ButtonSpaceV
Definition drawitem.cpp:98

owl::TextSpaceE
const int TextSpaceE
Definition drawitem.cpp:96

owl::tstring
std::string tstring
Definition defs.h:79

owl::uint
unsigned int uint
Definition number.h:25

owl::TextSpaceH
const int TextSpaceH
Definition btntextg.cpp:95

TYPESAFE_DOWNCAST
#define TYPESAFE_DOWNCAST(object, toClass)
Definition defs.h:269

resource.h
Defines classes handling Windows resources.

template.h
Definition of container classes used and made available by OWL.

uihelper.h
Definition of the UI Helper Classes: TUIHandle, TUIBorder, TUIFace, TUIPart.

uimetric.h
Definition of TUIMetric, a UI metrics provider class.