contrib/src/fl/newbmpbtn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        newbmpbtn.cpp
   3 // Purpose:     wxNewBitmapButton enhanced bitmap button class.
   4 // Author:      Aleksandras Gluchovas
   5 // Modified by:
   6 // Created:     ??/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Aleksandras Gluchovas
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16 #pragma hdrstop
  17 #endif
  18
  19 #ifndef WX_PRECOMP
  20 #include "wx/wx.h"
  21 #endif
  22
  23 #include "wx/fl/newbmpbtn.h"
  24 #include "wx/utils.h"     // import wxMin,wxMax macros
  25
  26 #ifdef __WXMSW__
  27 #include "wx/msw/private.h"
  28 #endif
  29
  30 ///////////// button-label rendering helpers //////////////////
  31
  32 static int* create_array( int width, int height, int fill = 0 )
  33 {
  34     int* array = new int[width*height];
  35
  36     int len = width*height;
  37     int i;
  38     for ( i = 0; i != len; ++i )
  39         array[i] = fill;
  40
  41     return array;
  42 }
  43
  44 #define GET_ELEM(array,x,y) (array[width*(y)+(x)])
  45
  46 #define MIN_COLOR_DIFF 10
  47
  48 #define IS_IN_ARRAY(x,y) ( (x) < width && (y) < height && (x) >= 0 && (y) >= 0 )
  49
  50 #define GET_RED(col)    col        & 0xFF
  51 #define GET_GREEN(col) (col >> 8)  & 0xFF
  52 #define GET_BLUE(col)  (col >> 16) & 0xFF
  53
  54 #define MAKE_INT_COLOR(red,green,blue) (     (red)                      | \
  55                                          ( ( (green) << 8 ) & 0xFF00  ) | \
  56                                          ( ( (blue)  << 16) & 0xFF0000) \
  57                                        )
  58
  59 #define IS_GREATER(col1,col2) ( ( (GET_RED(col1)  ) > (GET_RED(col2)  ) + MIN_COLOR_DIFF ) && \
  60                                 ( (GET_GREEN(col1)) > (GET_GREEN(col2)) + MIN_COLOR_DIFF ) &&  \
  61                                 ( (GET_BLUE(col1) ) > (GET_BLUE(col2) ) + MIN_COLOR_DIFF )     \
  62                               )
  63
  64 #define MASK_BG    0
  65 #define MASK_DARK  1
  66 #define MASK_LIGHT 2
  67
  68 // helper function, used internally
  69
  70 static void gray_out_pixmap( int* src, int* dest, int width, int height )
  71 {
  72     // assuming the pixels along the edges are of the background color
  73
  74     int x = 0;
  75     int y = 1;
  76
  77     do
  78     {
  79         int cur       = GET_ELEM(src,x,y);
  80
  81
  82         if ( IS_IN_ARRAY(x-1,y-1) )
  83         {
  84             int upperElem = GET_ELEM(src,x-1,y-1);
  85
  86             // if the upper element is lighter than current
  87             if ( IS_GREATER(upperElem,cur) )
  88             {
  89                 GET_ELEM(dest,x,y) = MASK_DARK;
  90             }
  91             else
  92             // if the current element is ligher than the upper
  93             if ( IS_GREATER(cur,upperElem) )
  94             {
  95                 GET_ELEM(dest,x,y) = MASK_LIGHT;
  96             }
  97             else
  98             {
  99                 if ( GET_ELEM(dest,x-1,y-1) == MASK_LIGHT )
 100
 101                     GET_ELEM(dest,x,y) = MASK_BG;
 102
 103                 if ( GET_ELEM(dest,x-1,y-1 ) == MASK_DARK )
 104
 105                     GET_ELEM(dest,x,y) = MASK_DARK;
 106                 else
 107                     GET_ELEM(dest,x,y) = MASK_BG;
 108             }
 109         }
 110
 111         // go zig-zag
 112
 113         if ( IS_IN_ARRAY(x+1,y-1) )
 114         {
 115             ++x;
 116             --y;
 117         }
 118         else
 119         {
 120             while ( IS_IN_ARRAY(x-1,y+1) )
 121             {
 122                 --x;
 123                 ++y;
 124             }
 125
 126             if ( IS_IN_ARRAY(x,y+1) )
 127             {
 128                 ++y;
 129                 continue;
 130             }
 131             else
 132             {
 133                 if ( IS_IN_ARRAY(x+1,y) )
 134                 {
 135                     ++x;
 136                     continue;
 137                 }
 138                 else break;
 139             }
 140         }
 141
 142     } while (1);
 143 }
 144
 145 // algorithm for making the image look "grayed" (e.g. disabled button)
 146 // NOTE:: used GetPixel(), which is Windows-Only!
 147
 148 void gray_out_image_on_dc( wxDC& dc, int width, int height )
 149 {
 150     // assuming the pixels along the edges are of the background color
 151     wxColour bgCol;
 152     dc.GetPixel( 0, 0, &bgCol );
 153
 154     wxPen darkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW),1, wxSOLID );
 155     wxPen lightPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT),1, wxSOLID );
 156     wxPen bgPen   ( bgCol,                1, wxSOLID );
 157
 158     int* src  = create_array( width, height, MASK_BG );
 159     int* dest = create_array( width, height, MASK_BG );
 160
 161     int x, y;
 162     for ( y = 0; y != height; ++y )
 163     {
 164         for ( x = 0; x != width; ++x )
 165         {
 166             wxColour col;
 167             dc.GetPixel( x,y, &col );
 168
 169             GET_ELEM(src,x,y) = MAKE_INT_COLOR( col.Red(), col.Green(), col.Blue() );
 170         }
 171     }
 172     gray_out_pixmap( src, dest, width, height );
 173
 174     for ( y = 0; y != height; ++y )
 175     {
 176         for ( x = 0; x != width; ++x )
 177         {
 178             int mask = GET_ELEM(dest,x,y);
 179
 180             switch (mask)
 181             {
 182                 case MASK_BG    : { dc.SetPen( bgPen );
 183                                     dc.DrawPoint( x,y ); break;
 184                                   }
 185                 case MASK_DARK  : { dc.SetPen( darkPen );
 186                                     dc.DrawPoint( x,y ); break;
 187                                   }
 188                 case MASK_LIGHT : { dc.SetPen( lightPen );
 189                                     dc.DrawPoint( x,y ); break;
 190                                   }
 191                 default : break;
 192             }
 193         }
 194     }
 195     delete [] src;
 196     delete [] dest;
 197 }
 198
 199 ///////////////////////////////
 200
 201 /***** Implementation for class wxNewBitmapButton *****/
 202
 203 IMPLEMENT_DYNAMIC_CLASS(wxNewBitmapButton, wxPanel)
 204
 205 BEGIN_EVENT_TABLE( wxNewBitmapButton, wxPanel )
 206
 207     EVT_LEFT_DOWN   ( wxNewBitmapButton::OnLButtonDown   )
 208     EVT_LEFT_UP     ( wxNewBitmapButton::OnLButtonUp     )
 209 //    EVT_LEFT_DCLICK ( wxNewBitmapButton::OnLButtonDClick )
 210     EVT_LEFT_DCLICK ( wxNewBitmapButton::OnLButtonDown )
 211     EVT_ENTER_WINDOW( wxNewBitmapButton::OnMouseEnter    )
 212     EVT_LEAVE_WINDOW( wxNewBitmapButton::OnMouseLeave    )
 213
 214     EVT_SIZE ( wxNewBitmapButton::OnSize  )
 215     EVT_PAINT( wxNewBitmapButton::OnPaint )
 216
 217     //EVT_KILL_FOCUS( wxNewBitmapButton::OnKillFocus )
 218
 219     EVT_ERASE_BACKGROUND( wxNewBitmapButton::OnEraseBackground )
 220
 221     EVT_IDLE(wxNewBitmapButton::OnIdle)
 222
 223 END_EVENT_TABLE()
 224
 225 wxNewBitmapButton::wxNewBitmapButton( const wxBitmap& labelBitmap,
 226                                       const wxString& labelText,
 227                                       int  alignText,
 228                                       bool isFlat,
 229                                       int  firedEventType,
 230                                       int  marginX,
 231                                       int  marginY,
 232                                       int  textToLabelGap,
 233                                       bool isSticky)
 234     :   mTextToLabelGap  ( textToLabelGap ),
 235         mMarginX( marginX ),
 236         mMarginY( marginY ),
 237         mTextAlignment( alignText ),
 238         mIsSticky( isSticky ),
 239         mIsFlat( isFlat ),
 240         mLabelText( labelText ),
 241         mImageFileType( wxBITMAP_TYPE_INVALID ),
 242         mDepressedBmp( labelBitmap ),
 243
 244         mpDepressedImg( NULL ),
 245         mpPressedImg  ( NULL ),
 246         mpDisabledImg ( NULL ),
 247         mpFocusedImg  ( NULL ),
 248
 249
 250         mDragStarted  ( false ),
 251         mIsPressed    ( false ),
 252         mIsInFocus    ( false ),
 253         mIsToggled    ( false ),
 254         mHasFocusedBmp( false ),
 255         mFiredEventType( firedEventType ),
 256
 257         mBlackPen( wxColour(  0,  0,  0), 1, wxSOLID ),
 258         mDarkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID ),
 259         mGrayPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
 260         mLightPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT), 1, wxSOLID ),
 261
 262         mIsCreated( false ),
 263         mSizeIsSet( false )
 264
 265 {
 266 }
 267
 268 wxNewBitmapButton::wxNewBitmapButton( const wxString& bitmapFileName,
 269                                       const wxBitmapType  bitmapFileType,
 270                                       const wxString& labelText,
 271                                       int  alignText,
 272                                       bool isFlat,
 273                                       int  WXUNUSED(firedEventType),
 274                                       int  WXUNUSED(marginX),
 275                                       int  WXUNUSED(marginY),
 276                                       int  WXUNUSED(textToLabelGap),
 277                                       bool WXUNUSED(isSticky))
 278
 279     :   mTextToLabelGap  ( 2 ),
 280         mMarginX( 2 ),
 281         mMarginY( 2 ),
 282         mTextAlignment( alignText ),
 283         mIsSticky( false ),
 284         mIsFlat( isFlat ),
 285         mLabelText( labelText ),
 286         mImageFileName( bitmapFileName ),
 287         mImageFileType( bitmapFileType ),
 288
 289         mpDepressedImg( NULL ),
 290         mpPressedImg  ( NULL ),
 291         mpDisabledImg ( NULL ),
 292         mpFocusedImg  ( NULL ),
 293
 294         mDragStarted  ( false ),
 295         mIsPressed    ( false ),
 296         mIsInFocus    ( false ),
 297         mIsToggled    ( false ),
 298         mHasFocusedBmp( false ),
 299         mFiredEventType( wxEVT_COMMAND_MENU_SELECTED ),
 300
 301         mBlackPen( wxColour(  0,  0,  0), 1, wxSOLID ),
 302         mDarkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID ),
 303         mGrayPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
 304         mLightPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT), 1, wxSOLID ),
 305
 306         mIsCreated( false ),
 307         mSizeIsSet( false )
 308
 309 {
 310 }
 311
 312 wxNewBitmapButton::~wxNewBitmapButton(void)
 313 {
 314     DestroyLabels();
 315 }
 316
 317 void wxNewBitmapButton::DrawShade( int outerLevel,
 318                                    wxDC&  dc,
 319                                    wxPen& upperLeftSidePen,
 320                                    wxPen& lowerRightSidePen )
 321 {
 322     wxBitmap* pBmp = GetStateLabel();
 323
 324     int x = mMarginX - (outerLevel + 2);
 325     int y = mMarginY - (outerLevel + 2);
 326
 327     int height = pBmp->GetHeight() + (outerLevel + 2)*2 - 1;
 328     int width  = pBmp->GetWidth()  + (outerLevel + 2)*2 - 1;
 329
 330     dc.SetPen( upperLeftSidePen );
 331     dc.DrawLine( x,y, x + width, y  );
 332     dc.DrawLine( x,y, x, y + height );
 333
 334     dc.SetPen( lowerRightSidePen );
 335     dc.DrawLine( x + width, y, x + width, y + height + 1  );
 336     dc.DrawLine( x, y + height, x + width, y + height );
 337 }
 338
 339 void wxNewBitmapButton::DestroyLabels()
 340 {
 341     if ( mpDepressedImg ) delete mpDepressedImg;
 342     if ( mpPressedImg   ) delete mpPressedImg;
 343     if ( mpDisabledImg  ) delete mpDisabledImg;
 344     if ( mpFocusedImg   ) delete mpFocusedImg;
 345
 346     mpDepressedImg = NULL;
 347     mpPressedImg   = NULL;
 348     mpDisabledImg  = NULL;
 349     mpFocusedImg   = NULL;
 350 }
 351
 352 wxBitmap* wxNewBitmapButton::GetStateLabel()
 353 {
 354     if ( IsEnabled() )
 355     {
 356         if ( mIsPressed )
 357         {
 358             return mpPressedImg;
 359         }
 360         else
 361         {
 362             if ( mIsInFocus )
 363             {
 364                 if ( mHasFocusedBmp )
 365
 366                     return mpFocusedImg;
 367                 else
 368                     return mpDepressedImg;
 369             }
 370             else
 371                 return mpDepressedImg;
 372         }
 373     }
 374     else
 375         return mpDisabledImg;
 376 }
 377
 378 #ifndef __WXMSW__
 379
 380 static const unsigned char _gDisableImage[] = { 0x55,0xAA,0x55,0xAA,
 381                                               0x55,0xAA,0x55,0xAA,
 382                                               0x55,0xAA,0x55,0xAA,
 383                                               0x55,0xAA,0x55,0xAA
 384                                             };
 385
 386 #endif
 387
 388 void wxNewBitmapButton::RenderLabelImage( wxBitmap*& destBmp, wxBitmap* srcBmp,
 389                                           bool isEnabled, bool isPressed )
 390 {
 391     if ( destBmp != 0 ) return;
 392
 393     // render labels on-demand
 394
 395     wxMemoryDC srcDc;
 396     srcDc.SelectObject( *srcBmp );
 397
 398     bool hasText = ( mTextAlignment != NB_NO_TEXT ) &&
 399                    ( mLabelText.length() != 0 );
 400
 401     bool hasImage = (mTextAlignment != NB_NO_IMAGE);
 402
 403     wxSize destDim;
 404     wxPoint txtPos;
 405     wxPoint imgPos;
 406
 407     if ( hasText )
 408     {
 409         long txtWidth, txtHeight;
 410
 411         srcDc.SetFont( wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) );
 412         srcDc.GetTextExtent( mLabelText, &txtWidth, &txtHeight );
 413
 414         if ( mTextAlignment == NB_ALIGN_TEXT_RIGHT )
 415         {
 416             destDim.x = srcBmp->GetWidth() + 2*mTextToLabelGap + txtWidth;
 417
 418             destDim.y =
 419                 wxMax( srcBmp->GetHeight(), txtHeight );
 420
 421             txtPos.x = srcBmp->GetWidth() + mTextToLabelGap;
 422             txtPos.y = (destDim.y - txtHeight)/2;
 423             imgPos.x = 0;
 424             imgPos.y = (destDim.y - srcBmp->GetHeight())/2;
 425         }
 426         else
 427         if ( mTextAlignment == NB_ALIGN_TEXT_BOTTOM )
 428         {
 429             destDim.x =
 430                 wxMax( srcBmp->GetWidth(), txtWidth );
 431
 432             destDim.y = srcBmp->GetHeight() + mTextToLabelGap + txtHeight;
 433
 434             txtPos.x = (destDim.x - txtWidth)/2;
 435             txtPos.y = srcBmp->GetHeight() + mTextToLabelGap;
 436             imgPos.x = (destDim.x - srcBmp->GetWidth())/2;
 437             imgPos.y = 0;
 438         }
 439         else
 440         {
 441             wxFAIL_MSG(wxT("Unsupported FL alignment type detected in wxNewBitmapButton::RenderLabelImage()"));
 442         }
 443     }
 444     else
 445     {
 446         imgPos.x = 0;
 447         imgPos.y = 0;
 448         destDim.x = srcBmp->GetWidth();
 449         destDim.y = srcBmp->GetHeight();
 450     }
 451
 452     destBmp = new wxBitmap( int(destDim.x), int(destDim.y) );
 453
 454     wxMemoryDC destDc;
 455     destDc.SelectObject( *destBmp );
 456
 457     wxBrush grayBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE), wxSOLID );
 458
 459     destDc.SetBrush( grayBrush );
 460     destDc.SetPen( *wxTRANSPARENT_PEN );
 461     destDc.DrawRectangle( 0,0, destDim.x+1, destDim.y+1 );
 462
 463     if ( isPressed )
 464     {
 465         ++imgPos.x; ++imgPos.y;
 466         ++txtPos.x; ++txtPos.y;
 467     }
 468
 469     if ( hasImage )
 470     {
 471
 472         destDc.Blit( imgPos.x, imgPos.y,
 473                  srcBmp->GetWidth(),
 474                  srcBmp->GetHeight(),
 475                  &srcDc, 0,0, wxCOPY,true );
 476     }
 477
 478     if ( hasText )
 479     {
 480         wxWindow* pTopWnd = this;
 481
 482         do
 483         {
 484             wxWindow* pParent = pTopWnd->GetParent();
 485
 486             if ( pParent == 0 )
 487                 break;
 488
 489             pTopWnd = pParent;
 490         } while (1);
 491
 492         destDc.SetFont( wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT) );
 493
 494         if ( isEnabled )
 495         {
 496             destDc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT) );
 497         }
 498         else
 499         {
 500             destDc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) );
 501         }
 502         destDc.SetTextBackground( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE) );
 503
 504         destDc.DrawText( mLabelText, txtPos.x, txtPos.y );
 505     }
 506
 507     if ( !isEnabled ){
 508
 509 #ifdef __WXMSW__ // This is currently MSW specific
 510         gray_out_image_on_dc( destDc, destDim.x, destDim.y );
 511 #else
 512         wxBitmap bmp( (const char*)_gDisableImage,8,8);
 513         wxBrush checkerBrush(bmp);
 514         checkerBrush.SetColour( wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE ) );
 515         destDc.SetBrush( checkerBrush );
 516         destDc.DrawRectangle( imgPos.x, imgPos.y, srcBmp->GetWidth()+1, srcBmp->GetHeight()+1);
 517 #endif
 518     }
 519     // adjust button size to fit the new dimensions of the label
 520     if ( !mSizeIsSet && 0 )
 521     {
 522         mSizeIsSet = true;
 523         SetSize( wxDefaultCoord, wxDefaultCoord,
 524                  destBmp->GetWidth()  + mMarginX*2,
 525                  destBmp->GetHeight() + mMarginY*2, 0
 526             );
 527     }
 528     destDc.SelectObject( wxNullBitmap );
 529
 530 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 531     // Map to system colours
 532     (void) wxToolBar::MapBitmap(destBmp->GetHBITMAP(), destBmp->GetWidth(), destBmp->GetHeight());
 533 #endif
 534 }
 535
 536 void wxNewBitmapButton::RenderAllLabelImages()
 537 {
 538     if ( !mIsCreated )
 539         return;
 540     RenderLabelImage( mpDisabledImg, &mDepressedBmp, false );
 541     RenderLabelImage( mpPressedImg,   &mDepressedBmp, true, true );
 542     RenderLabelImage( mpDepressedImg, &mDepressedBmp, true, false );
 543     if ( mHasFocusedBmp )
 544     {
 545         RenderLabelImage( mpFocusedImg, &mFocusedBmp, true, false );
 546     }
 547 }
 548
 549
 550 void wxNewBitmapButton::RenderLabelImages()
 551 {
 552     if ( !mIsCreated )
 553         return;
 554
 555     if ( !IsEnabled() )
 556     {
 557         RenderLabelImage( mpDisabledImg, &mDepressedBmp, false );
 558     }
 559     else
 560
 561     if ( mIsPressed )
 562
 563         RenderLabelImage( mpPressedImg,   &mDepressedBmp, true, true );
 564     else
 565     {
 566         if ( mIsInFocus )
 567         {
 568             if ( mHasFocusedBmp )
 569                 RenderLabelImage( mpFocusedImg, &mFocusedBmp, true, false );
 570             else
 571                 RenderLabelImage( mpDepressedImg, &mDepressedBmp, true, false );
 572         }
 573         else
 574             RenderLabelImage( mpDepressedImg, &mDepressedBmp, true, false );
 575     }
 576 }
 577
 578 bool wxNewBitmapButton::Toggle(bool enable)
 579 {
 580     if ( mIsToggled == enable )
 581     {
 582         return false;
 583     }
 584
 585     mIsToggled = enable;
 586     Refresh();
 587
 588     return true;
 589 }
 590
 591 bool wxNewBitmapButton::Enable(bool enable)
 592 {
 593     if ( enable != m_isEnabled )
 594     {
 595         if ( mIsInFocus )
 596         {
 597             mIsInFocus = false;
 598         }
 599
 600         if ( mIsPressed )
 601         {
 602             mIsPressed = false;
 603         }
 604
 605         Refresh();
 606     }
 607
 608     return wxPanel::Enable( enable );
 609 }
 610
 611 void wxNewBitmapButton::DrawDecorations( wxDC& dc )
 612 {
 613     if ( mIsFlat )
 614     {
 615         DrawShade( 1, dc, mGrayPen,  mGrayPen  );
 616         if ( mIsToggled )
 617         {
 618             DrawShade( 0, dc, mDarkPen,  mLightPen  );
 619         }
 620         else if ( mIsInFocus )
 621         {
 622             if ( mIsPressed )
 623                 DrawShade( 0, dc, mDarkPen,  mLightPen  );
 624             else
 625                 DrawShade( 0, dc, mLightPen,  mDarkPen  );
 626         }
 627         else
 628             DrawShade( 0, dc, mGrayPen,  mGrayPen  );
 629     }
 630     else
 631     {
 632         if ( mIsPressed || mIsToggled )
 633         {
 634             DrawShade( 0, dc, mDarkPen,  mGrayPen  );
 635             DrawShade( 1, dc, mBlackPen, mLightPen );
 636         }
 637         else
 638         {
 639             DrawShade( 0, dc, mGrayPen,  mDarkPen  );
 640             DrawShade( 1, dc, mLightPen, mBlackPen );
 641         }
 642     }
 643 }
 644
 645 void wxNewBitmapButton::SetLabel(const wxBitmap& labelBitmap,
 646                                  const wxString& labelText )
 647 {
 648     DestroyLabels();
 649
 650     mLabelText    = labelText;
 651     mDepressedBmp = labelBitmap;
 652
 653     //RenderLabelImages();
 654     RenderAllLabelImages();
 655 }
 656
 657 void wxNewBitmapButton::SetAlignments( int alignText,
 658                                        int marginX,
 659                                        int marginY,
 660                                        int textToLabelGap)
 661 {
 662     DestroyLabels();
 663
 664     mMarginX        = marginX;
 665     mMarginY        = marginY;
 666     mTextAlignment  = alignText;
 667     mTextToLabelGap = textToLabelGap;
 668
 669     //RenderLabelImages();
 670     RenderAllLabelImages();
 671 }
 672
 673 // event handlers
 674
 675 void wxNewBitmapButton::OnLButtonDown( wxMouseEvent& WXUNUSED(event) )
 676 {
 677     mDragStarted      = true;
 678     mIsPressed        = true;
 679     Refresh();
 680 }
 681
 682 void wxNewBitmapButton::OnLButtonUp( wxMouseEvent& event )
 683 {
 684     if ( !mDragStarted )
 685         return;
 686
 687     mDragStarted = false;
 688     mIsPressed   = false;
 689     Refresh();
 690
 691     if ( IsInWindow( event.m_x, event.m_y ) )
 692     {
 693         // fire event, if mouse was released
 694         // within the bounds of button
 695         wxCommandEvent cmd( mFiredEventType, GetId() );
 696         GetParent()->ProcessEvent( cmd );
 697     }
 698 }
 699
 700 bool wxNewBitmapButton::IsInWindow( int x, int y )
 701 {
 702     int width, height;
 703     GetSize( &width, &height );
 704
 705     return ( x >= 0 && y >= 0 &&
 706              x < width &&
 707              y < height );
 708 }
 709
 710 void wxNewBitmapButton::OnMouseEnter( wxMouseEvent& WXUNUSED(event) )
 711 {
 712     bool prevIsInFocus = mIsInFocus;
 713
 714     if ( !mIsInFocus )
 715     {
 716         mIsInFocus = true;
 717     }
 718     if ( prevIsInFocus != mIsInFocus )
 719     {
 720         Refresh();
 721     }
 722 }
 723
 724 void wxNewBitmapButton::OnMouseLeave( wxMouseEvent& WXUNUSED(event) )
 725 {
 726     bool prevIsInFocus = mIsInFocus;
 727     bool prevIsPressed = mIsPressed;
 728     if ( mIsInFocus )
 729     {
 730         mIsInFocus = false;
 731         mIsPressed = false;
 732     }
 733     if ( prevIsInFocus != mIsInFocus || prevIsPressed != mIsPressed )
 734     {
 735         Refresh();
 736     }
 737 }
 738
 739 void wxNewBitmapButton::OnSize( wxSizeEvent& WXUNUSED(event) )
 740 {
 741         //Reshape();
 742 }
 743
 744 void wxNewBitmapButton::Reshape( )
 745 {
 746     bool wasCreated = mIsCreated;
 747     mIsCreated = true;
 748
 749     if ( !wasCreated )
 750     {
 751         // in the case of loading button from stream, check if we
 752         // have non-empty image-file name, load if possible
 753
 754         if (!mImageFileName.empty())
 755         {
 756             mDepressedBmp.LoadFile( mImageFileName, mImageFileType );
 757
 758             //wxMessageBox("Image Loaded!!!");
 759         }
 760
 761         //RenderLabelImages();
 762         RenderAllLabelImages();
 763
 764         wxBitmap* pCurImg = GetStateLabel();
 765
 766         int w = pCurImg->GetWidth(),
 767             h = pCurImg->GetHeight();
 768
 769         SetSize( 0,0, w + mMarginX*2, h + mMarginY*2 , 0 );
 770     }
 771 }
 772
 773 void wxNewBitmapButton::DrawLabel( wxDC& dc )
 774 {
 775     wxBitmap* pCurBmp = GetStateLabel();
 776
 777     if ( pCurBmp == NULL )
 778     {
 779         wxSizeEvent evt;
 780         OnSize( evt ); // fake it up!
 781
 782         //RenderLabelImages();
 783         pCurBmp = GetStateLabel();
 784     }
 785
 786     wxMemoryDC mdc;
 787     mdc.SelectObject( *pCurBmp );
 788
 789     dc.Blit( mMarginX, mMarginY,
 790              pCurBmp->GetWidth(),
 791              pCurBmp->GetHeight(),
 792              &mdc, 0,0, wxCOPY
 793            );
 794
 795     mdc.SelectObject( wxNullBitmap );
 796 }
 797
 798 void wxNewBitmapButton::OnPaint( wxPaintEvent& WXUNUSED(event) )
 799 {
 800     wxPaintDC dc(this);
 801
 802     // first, make sure images for current state are prepared
 803     //RenderLabelImages();
 804
 805     DrawLabel( dc );
 806
 807     DrawDecorations( dc );
 808 }
 809
 810 void wxNewBitmapButton::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
 811 {
 812     // do nothing
 813 }
 814
 815 void wxNewBitmapButton::OnKillFocus( wxFocusEvent& WXUNUSED(event) )
 816 {
 817     // useless
 818
 819     wxMessageBox(wxT("kill-focus for button!"));
 820 }
 821
 822 // ----------------------------------------------------------------------------
 823 // UI updates
 824 // ----------------------------------------------------------------------------
 825
 826 void wxNewBitmapButton::OnIdle(wxIdleEvent& event)
 827 {
 828     DoButtonUpdate();
 829
 830     event.Skip();
 831 }
 832
 833 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
 834 void wxNewBitmapButton::DoButtonUpdate()
 835 {
 836     wxUpdateUIEvent event(GetId());
 837     event.SetEventObject(this);
 838
 839     if ( GetParent()->ProcessEvent(event) )
 840     {
 841         if ( event.GetSetEnabled() )
 842         {
 843             bool enabled = event.GetEnabled();
 844             if ( enabled != IsEnabled() )
 845                 Enable( enabled );
 846         }
 847         if ( event.GetSetChecked() )
 848             Toggle( event.GetChecked() );
 849     }
 850 }