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     EVT_IDLE(wxNewBitmapButton::OnIdle)
 226
 227 END_EVENT_TABLE()
 228
 229 wxNewBitmapButton::wxNewBitmapButton( const wxBitmap& labelBitmap,
 230                                       const wxString& labelText,
 231                                       int  alignText,
 232                                       bool isFlat,
 233                                       int  firedEventType,
 234                                       int  marginX,
 235                                       int  marginY,
 236                                       int  textToLabelGap,
 237                                       bool isSticky)
 238     :   mTextToLabelGap  ( textToLabelGap ),
 239         mMarginX( marginX ),
 240         mMarginY( marginY ),
 241         mTextAlignment( alignText ),
 242         mIsSticky( isSticky ),
 243         mIsFlat( isFlat ),
 244         mLabelText( labelText ),
 245         mImageFileType( wxBITMAP_TYPE_INVALID ),
 246         mDepressedBmp( labelBitmap ),
 247
 248         mpDepressedImg( NULL ),
 249         mpPressedImg  ( NULL ),
 250         mpDisabledImg ( NULL ),
 251         mpFocusedImg  ( NULL ),
 252
 253
 254         mDragStarted  ( false ),
 255         mIsPressed    ( false ),
 256         mIsInFocus    ( false ),
 257         mIsToggled    ( false ),
 258         mHasFocusedBmp( false ),
 259         mFiredEventType( firedEventType ),
 260
 261         mBlackPen( wxColour(  0,  0,  0), 1, wxSOLID ),
 262         mDarkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID ),
 263         mGrayPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
 264         mLightPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT), 1, wxSOLID ),
 265
 266         mIsCreated( false ),
 267         mSizeIsSet( false )
 268
 269 {
 270 }
 271
 272 wxNewBitmapButton::wxNewBitmapButton( const wxString& bitmapFileName,
 273                                       const wxBitmapType  bitmapFileType,
 274                                       const wxString& labelText,
 275                                       int  alignText,
 276                                       bool isFlat,
 277                                       int  WXUNUSED(firedEventType),
 278                                       int  WXUNUSED(marginX),
 279                                       int  WXUNUSED(marginY),
 280                                       int  WXUNUSED(textToLabelGap),
 281                                       bool WXUNUSED(isSticky))
 282
 283     :   mTextToLabelGap  ( 2 ),
 284         mMarginX( 2 ),
 285         mMarginY( 2 ),
 286         mTextAlignment( alignText ),
 287         mIsSticky( false ),
 288         mIsFlat( isFlat ),
 289         mLabelText( labelText ),
 290         mImageFileName( bitmapFileName ),
 291         mImageFileType( bitmapFileType ),
 292
 293         mpDepressedImg( NULL ),
 294         mpPressedImg  ( NULL ),
 295         mpDisabledImg ( NULL ),
 296         mpFocusedImg  ( NULL ),
 297
 298         mDragStarted  ( false ),
 299         mIsPressed    ( false ),
 300         mIsInFocus    ( false ),
 301         mIsToggled    ( false ),
 302         mHasFocusedBmp( false ),
 303         mFiredEventType( wxEVT_COMMAND_MENU_SELECTED ),
 304
 305         mBlackPen( wxColour(  0,  0,  0), 1, wxSOLID ),
 306         mDarkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID ),
 307         mGrayPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE), 1, wxSOLID ),
 308         mLightPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT), 1, wxSOLID ),
 309
 310         mIsCreated( false ),
 311         mSizeIsSet( false )
 312
 313 {
 314 }
 315
 316 wxNewBitmapButton::~wxNewBitmapButton(void)
 317 {
 318     DestroyLabels();
 319 }
 320
 321 void wxNewBitmapButton::DrawShade( int outerLevel,
 322                                    wxDC&  dc,
 323                                    wxPen& upperLeftSidePen,
 324                                    wxPen& lowerRightSidePen )
 325 {
 326     wxBitmap* pBmp = GetStateLabel();
 327
 328     int x = mMarginX - (outerLevel + 2);
 329     int y = mMarginY - (outerLevel + 2);
 330
 331     int height = pBmp->GetHeight() + (outerLevel + 2)*2 - 1;
 332     int width  = pBmp->GetWidth()  + (outerLevel + 2)*2 - 1;
 333
 334     dc.SetPen( upperLeftSidePen );
 335     dc.DrawLine( x,y, x + width, y  );
 336     dc.DrawLine( x,y, x, y + height );
 337
 338     dc.SetPen( lowerRightSidePen );
 339     dc.DrawLine( x + width, y, x + width, y + height + 1  );
 340     dc.DrawLine( x, y + height, x + width, y + height );
 341 }
 342
 343 void wxNewBitmapButton::DestroyLabels()
 344 {
 345     if ( mpDepressedImg ) delete mpDepressedImg;
 346     if ( mpPressedImg   ) delete mpPressedImg;
 347     if ( mpDisabledImg  ) delete mpDisabledImg;
 348     if ( mpFocusedImg   ) delete mpFocusedImg;
 349
 350     mpDepressedImg = NULL;
 351     mpPressedImg   = NULL;
 352     mpDisabledImg  = NULL;
 353     mpFocusedImg   = NULL;
 354 }
 355
 356 wxBitmap* wxNewBitmapButton::GetStateLabel()
 357 {
 358     if ( IsEnabled() )
 359     {
 360         if ( mIsPressed )
 361         {
 362             return mpPressedImg;
 363         }
 364         else
 365         {
 366             if ( mIsInFocus )
 367             {
 368                 if ( mHasFocusedBmp )
 369
 370                     return mpFocusedImg;
 371                 else
 372                     return mpDepressedImg;
 373             }
 374             else
 375                 return mpDepressedImg;
 376         }
 377     }
 378     else
 379         return mpDisabledImg;
 380 }
 381
 382 #ifndef __WXMSW__
 383
 384 static const unsigned char _gDisableImage[] = { 0x55,0xAA,0x55,0xAA,
 385                                               0x55,0xAA,0x55,0xAA,
 386                                               0x55,0xAA,0x55,0xAA,
 387                                               0x55,0xAA,0x55,0xAA
 388                                             };
 389
 390 #endif
 391
 392 void wxNewBitmapButton::RenderLabelImage( wxBitmap*& destBmp, wxBitmap* srcBmp,
 393                                           bool isEnabled, bool isPressed )
 394 {
 395     if ( destBmp != 0 ) return;
 396
 397     // render labels on-demand
 398
 399     wxMemoryDC srcDc;
 400     srcDc.SelectObject( *srcBmp );
 401
 402     bool hasText = ( mTextAlignment != NB_NO_TEXT ) &&
 403                    ( mLabelText.length() != 0 );
 404
 405     bool hasImage = (mTextAlignment != NB_NO_IMAGE);
 406
 407     wxSize destDim;
 408     wxPoint txtPos;
 409     wxPoint imgPos;
 410
 411     if ( hasText )
 412     {
 413         long txtWidth, txtHeight;
 414
 415         srcDc.SetFont( wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) );
 416         srcDc.GetTextExtent( mLabelText, &txtWidth, &txtHeight );
 417
 418         if ( mTextAlignment == NB_ALIGN_TEXT_RIGHT )
 419         {
 420             destDim.x = srcBmp->GetWidth() + 2*mTextToLabelGap + txtWidth;
 421
 422             destDim.y =
 423                 wxMax( srcBmp->GetHeight(), txtHeight );
 424
 425             txtPos.x = srcBmp->GetWidth() + mTextToLabelGap;
 426             txtPos.y = (destDim.y - txtHeight)/2;
 427             imgPos.x = 0;
 428             imgPos.y = (destDim.y - srcBmp->GetHeight())/2;
 429         }
 430         else
 431         if ( mTextAlignment == NB_ALIGN_TEXT_BOTTOM )
 432         {
 433             destDim.x =
 434                 wxMax( srcBmp->GetWidth(), txtWidth );
 435
 436             destDim.y = srcBmp->GetHeight() + mTextToLabelGap + txtHeight;
 437
 438             txtPos.x = (destDim.x - txtWidth)/2;
 439             txtPos.y = srcBmp->GetHeight() + mTextToLabelGap;
 440             imgPos.x = (destDim.x - srcBmp->GetWidth())/2;
 441             imgPos.y = 0;
 442         }
 443         else
 444         {
 445             wxFAIL_MSG(wxT("Unsupported FL alignment type detected in wxNewBitmapButton::RenderLabelImage()"));
 446         }
 447     }
 448     else
 449     {
 450         imgPos.x = 0;
 451         imgPos.y = 0;
 452         destDim.x = srcBmp->GetWidth();
 453         destDim.y = srcBmp->GetHeight();
 454     }
 455
 456     destBmp = new wxBitmap( int(destDim.x), int(destDim.y) );
 457
 458     wxMemoryDC destDc;
 459     destDc.SelectObject( *destBmp );
 460
 461     wxBrush grayBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE), wxSOLID );
 462
 463     destDc.SetBrush( grayBrush );
 464     destDc.SetPen( *wxTRANSPARENT_PEN );
 465     destDc.DrawRectangle( 0,0, destDim.x+1, destDim.y+1 );
 466
 467     if ( isPressed )
 468     {
 469         ++imgPos.x; ++imgPos.y;
 470         ++txtPos.x; ++txtPos.y;
 471     }
 472
 473     if ( hasImage )
 474     {
 475
 476         destDc.Blit( imgPos.x, imgPos.y,
 477                  srcBmp->GetWidth(),
 478                  srcBmp->GetHeight(),
 479                  &srcDc, 0,0, wxCOPY,true );
 480     }
 481
 482     if ( hasText )
 483     {
 484         wxWindow* pTopWnd = this;
 485
 486         do
 487         {
 488             wxWindow* pParent = pTopWnd->GetParent();
 489
 490             if ( pParent == 0 )
 491                 break;
 492
 493             pTopWnd = pParent;
 494         } while (1);
 495
 496         destDc.SetFont( wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT) );
 497
 498         if ( isEnabled )
 499         {
 500             destDc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT) );
 501         }
 502         else
 503         {
 504             destDc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) );
 505         }
 506         destDc.SetTextBackground( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE) );
 507
 508         destDc.DrawText( mLabelText, txtPos.x, txtPos.y );
 509     }
 510
 511     if ( !isEnabled ){
 512
 513 #ifdef __WXMSW__ // This is currently MSW specific
 514         gray_out_image_on_dc( destDc, destDim.x, destDim.y );
 515 #else
 516         wxBrush checkerBrush( wxBitmap( (const char*)_gDisableImage,8,8) );
 517         checkerBrush.SetColour( wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE ) );
 518         destDc.SetBrush( checkerBrush );
 519         destDc.DrawRectangle( imgPos.x, imgPos.y, srcBmp->GetWidth()+1, srcBmp->GetHeight()+1);
 520 #endif
 521     }
 522     // adjust button size to fit the new dimensions of the label
 523     if ( !mSizeIsSet && 0 )
 524     {
 525         mSizeIsSet = true;
 526         SetSize( wxDefaultCoord, wxDefaultCoord,
 527                  destBmp->GetWidth()  + mMarginX*2,
 528                  destBmp->GetHeight() + mMarginY*2, 0
 529             );
 530     }
 531     destDc.SelectObject( wxNullBitmap );
 532
 533 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 534     // Map to system colours
 535     (void) wxToolBar::MapBitmap(destBmp->GetHBITMAP(), destBmp->GetWidth(), destBmp->GetHeight());
 536 #endif
 537 }
 538
 539 void wxNewBitmapButton::RenderAllLabelImages()
 540 {
 541     if ( !mIsCreated )
 542         return;
 543     RenderLabelImage( mpDisabledImg, &mDepressedBmp, false );
 544     RenderLabelImage( mpPressedImg,   &mDepressedBmp, true, true );
 545     RenderLabelImage( mpDepressedImg, &mDepressedBmp, true, false );
 546     if ( mHasFocusedBmp )
 547     {
 548         RenderLabelImage( mpFocusedImg, &mFocusedBmp, true, false );
 549     }
 550 }
 551
 552
 553 void wxNewBitmapButton::RenderLabelImages()
 554 {
 555     if ( !mIsCreated )
 556         return;
 557
 558     if ( !IsEnabled() )
 559     {
 560         RenderLabelImage( mpDisabledImg, &mDepressedBmp, false );
 561     }
 562     else
 563
 564     if ( mIsPressed )
 565
 566         RenderLabelImage( mpPressedImg,   &mDepressedBmp, true, true );
 567     else
 568     {
 569         if ( mIsInFocus )
 570         {
 571             if ( mHasFocusedBmp )
 572                 RenderLabelImage( mpFocusedImg, &mFocusedBmp, true, false );
 573             else
 574                 RenderLabelImage( mpDepressedImg, &mDepressedBmp, true, false );
 575         }
 576         else
 577             RenderLabelImage( mpDepressedImg, &mDepressedBmp, true, false );
 578     }
 579 }
 580
 581 bool wxNewBitmapButton::Toggle(bool enable)
 582 {
 583     if ( mIsToggled == enable )
 584     {
 585         return false;
 586     }
 587
 588     mIsToggled = enable;
 589     Refresh();
 590
 591     return true;
 592 }
 593
 594 bool wxNewBitmapButton::Enable(bool enable)
 595 {
 596     if ( enable != m_isEnabled )
 597     {
 598         if ( mIsInFocus )
 599         {
 600             mIsInFocus = false;
 601         }
 602
 603         if ( mIsPressed )
 604         {
 605             mIsPressed = false;
 606         }
 607
 608         Refresh();
 609     }
 610
 611     return wxPanel::Enable( enable );
 612 }
 613
 614 void wxNewBitmapButton::DrawDecorations( wxDC& dc )
 615 {
 616     if ( mIsFlat )
 617     {
 618         DrawShade( 1, dc, mGrayPen,  mGrayPen  );
 619         if ( mIsToggled )
 620         {
 621             DrawShade( 0, dc, mDarkPen,  mLightPen  );
 622         }
 623         else if ( mIsInFocus )
 624         {
 625             if ( mIsPressed )
 626                 DrawShade( 0, dc, mDarkPen,  mLightPen  );
 627             else
 628                 DrawShade( 0, dc, mLightPen,  mDarkPen  );
 629         }
 630         else
 631             DrawShade( 0, dc, mGrayPen,  mGrayPen  );
 632     }
 633     else
 634     {
 635         if ( mIsPressed || mIsToggled )
 636         {
 637             DrawShade( 0, dc, mDarkPen,  mGrayPen  );
 638             DrawShade( 1, dc, mBlackPen, mLightPen );
 639         }
 640         else
 641         {
 642             DrawShade( 0, dc, mGrayPen,  mDarkPen  );
 643             DrawShade( 1, dc, mLightPen, mBlackPen );
 644         }
 645     }
 646 }
 647
 648 void wxNewBitmapButton::SetLabel(const wxBitmap& labelBitmap,
 649                                  const wxString& labelText )
 650 {
 651     DestroyLabels();
 652
 653     mLabelText    = labelText;
 654     mDepressedBmp = labelBitmap;
 655
 656     //RenderLabelImages();
 657     RenderAllLabelImages();
 658 }
 659
 660 void wxNewBitmapButton::SetAlignments( int alignText,
 661                                        int marginX,
 662                                        int marginY,
 663                                        int textToLabelGap)
 664 {
 665     DestroyLabels();
 666
 667     mMarginX        = marginX;
 668     mMarginY        = marginY;
 669     mTextAlignment  = alignText;
 670     mTextToLabelGap = textToLabelGap;
 671
 672     //RenderLabelImages();
 673     RenderAllLabelImages();
 674 }
 675
 676 // event handlers
 677
 678 void wxNewBitmapButton::OnLButtonDown( wxMouseEvent& WXUNUSED(event) )
 679 {
 680     mDragStarted      = true;
 681     mIsPressed        = true;
 682     Refresh();
 683 }
 684
 685 void wxNewBitmapButton::OnLButtonUp( wxMouseEvent& event )
 686 {
 687     if ( !mDragStarted )
 688         return;
 689
 690     mDragStarted = false;
 691     mIsPressed   = false;
 692     Refresh();
 693
 694     if ( IsInWindow( event.m_x, event.m_y ) )
 695     {
 696         // fire event, if mouse was released
 697         // within the bounds of button
 698         wxCommandEvent cmd( mFiredEventType, GetId() );
 699         GetParent()->ProcessEvent( cmd );
 700     }
 701 }
 702
 703 bool wxNewBitmapButton::IsInWindow( int x, int y )
 704 {
 705     int width, height;
 706     GetSize( &width, &height );
 707
 708     return ( x >= 0 && y >= 0 &&
 709              x < width &&
 710              y < height );
 711 }
 712
 713 void wxNewBitmapButton::OnMouseEnter( wxMouseEvent& WXUNUSED(event) )
 714 {
 715     bool prevIsInFocus = mIsInFocus;
 716
 717     if ( !mIsInFocus )
 718     {
 719         mIsInFocus = true;
 720     }
 721     if ( prevIsInFocus != mIsInFocus )
 722     {
 723         Refresh();
 724     }
 725 }
 726
 727 void wxNewBitmapButton::OnMouseLeave( wxMouseEvent& WXUNUSED(event) )
 728 {
 729     bool prevIsInFocus = mIsInFocus;
 730     bool prevIsPressed = mIsPressed;
 731     if ( mIsInFocus )
 732     {
 733         mIsInFocus = false;
 734         mIsPressed = false;
 735     }
 736     if ( prevIsInFocus != mIsInFocus || prevIsPressed != mIsPressed )
 737     {
 738         Refresh();
 739     }
 740 }
 741
 742 void wxNewBitmapButton::OnSize( wxSizeEvent& WXUNUSED(event) )
 743 {
 744         //Reshape();
 745 }
 746
 747 void wxNewBitmapButton::Reshape( )
 748 {
 749     bool wasCreated = mIsCreated;
 750     mIsCreated = true;
 751
 752     if ( !wasCreated )
 753     {
 754         // in the case of loading button from stream, check if we
 755         // have non-empty image-file name, load if possible
 756
 757         if (!mImageFileName.empty())
 758         {
 759             mDepressedBmp.LoadFile( mImageFileName, mImageFileType );
 760
 761             //wxMessageBox("Image Loaded!!!");
 762         }
 763
 764         //RenderLabelImages();
 765         RenderAllLabelImages();
 766
 767         wxBitmap* pCurImg = GetStateLabel();
 768
 769         int w = pCurImg->GetWidth(),
 770             h = pCurImg->GetHeight();
 771
 772         SetSize( 0,0, w + mMarginX*2, h + mMarginY*2 , 0 );
 773     }
 774 }
 775
 776 void wxNewBitmapButton::DrawLabel( wxDC& dc )
 777 {
 778     wxBitmap* pCurBmp = GetStateLabel();
 779
 780     if ( pCurBmp == NULL )
 781     {
 782         wxSizeEvent evt;
 783         OnSize( evt ); // fake it up!
 784
 785         //RenderLabelImages();
 786         pCurBmp = GetStateLabel();
 787     }
 788
 789     wxMemoryDC mdc;
 790     mdc.SelectObject( *pCurBmp );
 791
 792     dc.Blit( mMarginX, mMarginY,
 793              pCurBmp->GetWidth(),
 794              pCurBmp->GetHeight(),
 795              &mdc, 0,0, wxCOPY
 796            );
 797
 798     mdc.SelectObject( wxNullBitmap );
 799 }
 800
 801 void wxNewBitmapButton::OnPaint( wxPaintEvent& WXUNUSED(event) )
 802 {
 803     wxPaintDC dc(this);
 804
 805     // first, make sure images for current state are prepared
 806     //RenderLabelImages();
 807
 808     DrawLabel( dc );
 809
 810     DrawDecorations( dc );
 811 }
 812
 813 void wxNewBitmapButton::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
 814 {
 815     // do nothing
 816 }
 817
 818 void wxNewBitmapButton::OnKillFocus( wxFocusEvent& WXUNUSED(event) )
 819 {
 820     // useless
 821
 822     wxMessageBox(wxT("kill-focus for button!"));
 823 }
 824
 825 // ----------------------------------------------------------------------------
 826 // UI updates
 827 // ----------------------------------------------------------------------------
 828
 829 void wxNewBitmapButton::OnIdle(wxIdleEvent& event)
 830 {
 831     DoButtonUpdate();
 832
 833     event.Skip();
 834 }
 835
 836 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
 837 void wxNewBitmapButton::DoButtonUpdate()
 838 {
 839     wxUpdateUIEvent event(GetId());
 840     event.SetEventObject(this);
 841
 842     if ( GetParent()->ProcessEvent(event) )
 843     {
 844         if ( event.GetSetEnabled() )
 845         {
 846             bool enabled = event.GetEnabled();
 847             if ( enabled != IsEnabled() )
 848                 Enable( enabled );
 849         }
 850         if ( event.GetSetChecked() )
 851             Toggle( event.GetChecked() );
 852     }
 853 }