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