Changeset 1902

Show
Ignore:
Timestamp:
Fri Feb 10 20:06:14 2006
Author:
fgerlits
Message:

moved the public constants from WidgetFactory? to a separate class;
this solves some circular reference isssues

Files:

Legend:

Unmodified
Added
Removed
Modified

  • trunk/livesupport/src/products/gLiveSupport/src/NowPlaying.cxx

    r1858 r1902  
    75 75      
    76 76     playButton = Gtk::manage(wf->createButton(  
    77                                       WidgetFactory::masterPlayButton ));  
      77                                     WidgetConstants::masterPlayButton ));  
    77 77     pauseButton = Gtk::manage(wf->createButton(  
    78                                       WidgetFactory::masterPauseButton ));  
      78                                     WidgetConstants::masterPauseButton ));  
    78 78     stopButton = Gtk::manage(wf->createButton(  
    79                                       WidgetFactory::masterStopButton ));  
      79                                     WidgetConstants::masterStopButton ));  
    79 79  
    80 80     playButton->signal_clicked().connect(sigc::mem_fun(*this,  

  • trunk/livesupport/src/products/gLiveSupport/src/SimplePlaylistManagementWindow.cxx

    r1869 r1902  
    71 71                                     Ptr<ResourceBundle>::Ref    bundle)  
    72 72                                                                     throw ()  
    73             : WhiteWindow(WidgetFactory::playlistsWindowTitleImage,  
      73           : WhiteWindow(WidgetConstants::playlistsWindowTitleImage,  
    73 73                         Colors::White,  
    74 74                         WidgetFactory::getInstance()->getWhiteWindowCorners()),  

  • trunk/livesupport/src/products/gLiveSupport/src/SchedulePlaylistWindow.cxx

    r1601 r1902  
    67 67                                     Ptr<Playlist>::Ref          playlist)  
    68 68                                                                     throw ()  
    69             : WhiteWindow(WidgetFactory::schedulerWindowTitleImage,  
      69           : WhiteWindow(WidgetConstants::schedulerWindowTitleImage,  
    69 69                         Colors::White,  
    70 70                         WidgetFactory::getInstance()->getWhiteWindowCorners()),  

  • trunk/livesupport/src/products/gLiveSupport/src/SchedulerWindow.cxx

    r1896 r1902  
    69 69                                     Ptr<ResourceBundle>::Ref    bundle)  
    70 70                                                                     throw ()  
    71             : WhiteWindow(WidgetFactory::schedulerWindowTitleImage,  
      71           : WhiteWindow(WidgetConstants::schedulerWindowTitleImage,  
    71 71                         Colors::White,  
    72 72                         WidgetFactory::getInstance()->getWhiteWindowCorners()),  

  • trunk/livesupport/src/products/gLiveSupport/src/AdvancedSearchItem.cxx

    r1705 r1902  
    90 90      
    91 91     if (isFirst) {  
    92           plusButton = Gtk::manage(wf->createButton(WidgetFactory::plusButton));  
      92         plusButton = Gtk::manage(wf->createButton(WidgetConstants::plusButton));  
    92 92         pack_start(*plusButton, Gtk::PACK_SHRINK, 5);  
    93 93         plusButton->signal_clicked().connect(sigc::mem_fun(*this,  
    94 94                                     &AdvancedSearchItem::onPlusButtonClicked ));  
    95 95     } else {  
    96           closeButton = Gtk::manage(wf->createButton(WidgetFactory::minusButton));  
      96         closeButton = Gtk::manage(wf->createButton(  
      97                                                 WidgetConstants::minusButton));  
    97 98         closeButton->signal_clicked().connect(sigc::mem_fun(*this,  
    98 99                                     &AdvancedSearchItem::destroy_ ));  

  • trunk/livesupport/src/products/gLiveSupport/src/CuePlayer.cxx

    r1601 r1902  
    70 70      
    71 71     playButton = Gtk::manage(wf->createButton(  
    72                                       WidgetFactory::smallPlayButton ));  
      72                                     WidgetConstants::smallPlayButton ));  
    72 72     pauseButton = Gtk::manage(wf->createButton(  
    73                                       WidgetFactory::smallPauseButton ));  
      73                                     WidgetConstants::smallPauseButton ));  
    73 73     stopButton = Gtk::manage(wf->createButton(  
    74                                       WidgetFactory::smallStopButton ));  
      74                                     WidgetConstants::smallStopButton ));  
    74 74  
    75 75     playButton->signal_clicked().connect(sigc::mem_fun(*this,  

  • trunk/livesupport/src/products/gLiveSupport/src/MasterPanelUserInfoWidget.cxx

    r1869 r1902  
    76 76                             &MasterPanelUserInfoWidget::onLoginButtonClicked));  
    77 77  
    78       closeButton = Gtk::manage(wf->createButton(WidgetFactory::deleteButton));  
      78     closeButton = Gtk::manage(wf->createButton(WidgetConstants::deleteButton));  
    78 78     closeButton->signal_clicked().connect(sigc::mem_fun(*this,  
    79 79                             &MasterPanelUserInfoWidget::onCloseButtonClicked));  

  • trunk/livesupport/src/products/gLiveSupport/src/LiveModeWindow.cxx

    r1894 r1902  
    72 72                                   Ptr<ResourceBundle>::Ref    bundle)  
    73 73                                                                     throw ()  
    74             : WhiteWindow(WidgetFactory::liveModeWindowTitleImage,  
      74           : WhiteWindow(WidgetConstants::liveModeWindowTitleImage,  
    74 74                         Colors::White,  
    75 75                         WidgetFactory::getInstance()->getWhiteWindowCorners()),  
    …… 
    99 99     try {  
    100 100         treeView->appendLineNumberColumn("", 2 /* offset */, 50);  
    101   //        treeView->appendColumn("", WidgetFactory::hugePlayButton, 82);  
      101 //        treeView->appendColumn("", WidgetConstants::hugePlayButton, 82);  
    101 101         treeView->appendColumn("", modelColumns.infoColumn, 200);  
    102 102     } catch (std::invalid_argument &e) {  
    125 125     Gtk::HBox *         buttonBox = Gtk::manage(new Gtk::HBox);  
    126 126     ImageButton *       outputPlayButton = Gtk::manage(wf->createButton(  
    127                                           WidgetFactory::hugePlayButton ));  
      127                                         WidgetConstants::hugePlayButton ));  
    127 127     Gtk::VBox *         cueAudioBox = Gtk::manage(new Gtk::VBox);  
    128 128     Gtk::HBox *         cueAudioLabelBox = Gtk::manage(new Gtk::HBox);  

  • trunk/livesupport/src/products/gLiveSupport/src/SearchWindow.cxx

    r1869 r1902  
    70 70                               Ptr<ResourceBundle>::Ref    bundle)  
    71 71                                                                 throw ()  
    72             : WhiteWindow(WidgetFactory::searchWindowTitleImage,  
      72           : WhiteWindow(WidgetConstants::searchWindowTitleImage,  
    72 72                         Colors::White,  
    73 73                         WidgetFactory::getInstance()->getWhiteWindowCorners()),  
    374 374             case Playable::AudioClipType:  
    375 375                 row[modelColumns.typeColumn]  = widgetFactory->getPixbuf(  
    376                                               WidgetFactory::audioClipIconImage);  
      376                                         WidgetConstants::audioClipIconImage);  
    376 376                 break;  
    377 377             case Playable::PlaylistType:  
    378 378                 row[modelColumns.typeColumn]  = widgetFactory->getPixbuf(  
    379                                               WidgetFactory::playlistIconImage);  
      379                                         WidgetConstants::playlistIconImage);  
    379 379                 break;  
    380 380             default:  

  • trunk/livesupport/src/products/gLiveSupport/src/ScratchpadWindow.cxx

    r1898 r1902  
    71 71                                       Ptr<ResourceBundle>::Ref    bundle)  
    72 72                                                                     throw ()  
    73             : WhiteWindow(WidgetFactory::scratchpadWindowTitleImage,  
      73           : WhiteWindow(WidgetConstants::scratchpadWindowTitleImage,  
    73 73                         Colors::White,  
    74 74                         WidgetFactory::getInstance()->getWhiteWindowCorners()),  
    576 576     switch (playable->getType()) {  
    577 577         case Playable::AudioClipType:  
    578               row[modelColumns.typeColumn]    = widgetFactory->getPixbuf(  
    579                                               WidgetFactory::audioClipIconImage);  
      578             row[modelColumns.typeColumn]  = widgetFactory->getPixbuf(  
      579                                           WidgetConstants::audioClipIconImage);  
    580 580             break;  
    581 581  
    582 582         case Playable::PlaylistType:  
    583               row[modelColumns.typeColumn]    = widgetFactory->getPixbuf(  
    584                                               WidgetFactory::playlistIconImage);  
      583             row[modelColumns.typeColumn]  = widgetFactory->getPixbuf(  
      584                                           WidgetConstants::playlistIconImage);  
    585 585             break;  
    586 586     }  
    587 587      
    588       row[modelColumns.titleColumn]           = Glib::Markup::escape_text(  
      588     row[modelColumns.titleColumn]         = Glib::Markup::escape_text(  
    588 588                                                         *playable->getTitle());  
    589 589      

  • trunk/livesupport/src/modules/widgets/include/LiveSupport/Widgets/WhiteWindow.h

    r1869 r1902  
    41 41 #endif  
    42 42  
      43 #include <boost/enable_shared_from_this.hpp>  
    43 44 #include <gtkmm/label.h>  
    44 45 #include <gtkmm/table.h>  
    …… 
    50 51  
    51 52 #include "LiveSupport/Core/Ptr.h"  
      53 #include "LiveSupport/Widgets/WidgetConstants.h"  
    52 54 #include "LiveSupport/Widgets/CornerImages.h"  
    53 55 #include "LiveSupport/Widgets/Colors.h"  
    54 56 #include "LiveSupport/Widgets/ImageButton.h"  
    55 57 #include "LiveSupport/Widgets/BlueBin.h"  
    56   #include "LiveSupport/Widgets/WidgetFactory.h"  
    57 58  
    58 59  
    342 343          *  @param properties   some WindowProperties flags  
    343 344          */  
    344           WhiteWindow(WidgetFactory::ImageType    title,  
      345         WhiteWindow(WidgetConstants::ImageType    title,  
    344 345                     Colors::ColorName           backgroundColor,  
    345 346                     Ptr<CornerImages>::Ref      cornerImages,  

  • trunk/livesupport/src/modules/widgets/include/LiveSupport/Widgets/WidgetFactory.h

    r1601 r1902  
    47 47 #include "LiveSupport/Core/MetadataTypeContainer.h"  
    48 48  
      49 #include "LiveSupport/Widgets/WidgetConstants.h"  
    49 50 #include "LiveSupport/Widgets/CornerImages.h"  
    50 51 #include "LiveSupport/Widgets/ButtonImages.h"  
    …… 
    56 57 #include "LiveSupport/Widgets/BlueBin.h"  
    57 58 #include "LiveSupport/Widgets/EntryBin.h"  
      59 #include "LiveSupport/Widgets/DialogWindow.h"  
      60 #include "LiveSupport/Widgets/ZebraTreeView.h"  
    58 61  
    59 62  
    …… 
    71 74 /* =============================================================== data types */  
    72 75  
    73   class WhiteWindow;  
    74   class ZebraTreeView;  
    75    
    76 76 /**  
    77 77  *  A factory to provide access to LiveSupport Widgets.  
    …… 
    98 98                         virtual public Configurable  
    99 99 {  
    100       public:  
    101           /**  
    102            *  The types of available buttons.  
    103            */  
    104           typedef enum { pushButton, tabButton }      ButtonType;  
    105    
    106           /**  
    107            *  The types of available image buttons.  
    108            */  
    109           typedef enum { deleteButton, plusButton, minusButton,  
    110                          smallPlayButton, smallPauseButton, smallStopButton,  
    111                          hugePlayButton,  
    112                          cuePlayButton, cueStopButton,  
    113                          masterPlayButton, masterPauseButton, masterStopButton,  
    114                          windowMinimizeButton, windowMaximizeButton,  
    115                                                windowCloseButton }  
    116                                                       ImageButtonType;  
    117    
    118           /**  
    119            *  The list of available miscellaneous images.  
    120            */  
    121           typedef enum { resizeImage,  
    122                          scratchpadWindowTitleImage,  
    123                          searchWindowTitleImage,  
    124                          liveModeWindowTitleImage,  
    125                          playlistsWindowTitleImage,  
    126                          schedulerWindowTitleImage,  
    127                          audioClipIconImage,  
    128                          playlistIconImage }  
    129                                                       ImageType;  
    130    
    131    
    132 100     private:  
    133 101         /**  
    …… 
    194 162          *  A container holding the miscallenous image pixbuf references.  
    195 163          */  
    196           std::map<ImageType, Glib::RefPtr<Gdk::Pixbuf> >  
      164         std::map<WidgetConstants::ImageType, Glib::RefPtr<Gdk::Pixbuf> >  
    196 164                                         imageTypePixbufs;  
    197 165  
    …… 
    269 237          */  
    270 238         Button *  
    271           createButton(const Glib::ustring      & label,  
    272                        ButtonType                 type = pushButton)  
      239         createButton(  
      240             const Glib::ustring &           label,  
      241             WidgetConstants::ButtonType     type = WidgetConstants::pushButton)  
    273 242                                                                     throw ();  
    274 243  
    …… 
    282 251          */  
    283 252         ImageButton *  
    284           createButton(ImageButtonType    type)                       throw ();  
      253         createButton(WidgetConstants::ImageButtonType    type)      throw ();  
    284 253  
    285 254         /**  
    …… 
    367 336          */  
    368 337         Glib::RefPtr<Gdk::Pixbuf>  
    369           getPixbuf(ImageType   imageName)                            throw ();  
      338         getPixbuf(WidgetConstants::ImageType   imageName)           throw ();  
    369 338  
    370 339         /**  
    377 346          */  
    378 347         Gtk::Image *  
    379           createImage(ImageType   imageName)                          throw ();  
      348         createImage(WidgetConstants::ImageType   imageName)         throw ();  
    379 348  
    380 349         /**  

  • trunk/livesupport/src/modules/widgets/include/LiveSupport/Widgets/ZebraTreeView.h

    r1895 r1902  
    51 51  
    52 52 #include "LiveSupport/Core/Ptr.h"  
    53   #include "LiveSupport/Widgets/WidgetFactory.h"  
      53 #include "LiveSupport/Widgets/WidgetConstants.h"  
    53 53 #include "LiveSupport/Widgets/CornerImages.h"  
    54 54 #include "LiveSupport/Widgets/ImageButton.h"  
    270 270         int  
    271 271         appendColumn(const Glib::ustring&               title,  
    272                        WidgetFactory::ImageButtonType     buttonType,  
      272                      WidgetConstants::ImageButtonType   buttonType,  
    272 272                      int                                minimumWidth = 0)  
    273 273                                                                 throw ();  

  • trunk/livesupport/src/modules/widgets/include/LiveSupport/Widgets/DialogWindow.h

    r1601 r1902  
    49 49  
    50 50 #include "LiveSupport/Widgets/WhiteWindow.h"  
      51 #include "LiveSupport/Widgets/Button.h"  
    51 52  
    52 53 namespace LiveSupport {  

  • trunk/livesupport/src/modules/widgets/src/ZebraTreeView.cxx

    r1895 r1902  
    37 37 #include <sstream>  
    38 38  
      39 #include "LiveSupport/Widgets/WidgetFactory.h"  
    39 40 #include "LiveSupport/Widgets/ZebraTreeModelColumnRecord.h"  
    40 41  
    156 157 ZebraTreeView :: appendColumn(  
    157 158                     const Glib::ustring &           title,  
    158                       WidgetFactory::ImageButtonType  buttonType,  
      159                     WidgetConstants::ImageButtonType  buttonType,  
    158 159                     int                             minimumWidth)  
    159 160                                                                 throw ()  

  • trunk/livesupport/src/modules/widgets/src/Notebook.cxx

    r1696 r1902  
    59 59 Notebook :: Notebook(void)                                      throw ()  
    60 60 {  
    61       Ptr<WidgetFactory>::Ref   wf = WidgetFactory::getInstance();  
    62    
    63 61     layout     = Gtk::manage(new Gtk::VBox());  
    64 62     tabBox     = Gtk::manage(new Gtk::HBox());  
    217 215     Ptr<WidgetFactory>::Ref     wf     = WidgetFactory::getInstance();  
    218 216     Button                    * button = wf->createButton(label,  
    219                                                       WidgetFactory::tabButton);  
      217                                                     WidgetConstants::tabButton);  
    219 217  
    220 218     Page      * page = new Page(this, pageList.size(), &widget, button);  

  • trunk/livesupport/src/modules/widgets/src/MessageWindow.h

    r1601 r1902  
    46 46 #include "LiveSupport/Core/Ptr.h"  
    47 47  
      48 #include "LiveSupport/Widgets/Button.h"  
    48 49 #include "LiveSupport/Widgets/WhiteWindow.h"  
    49 50  

  • trunk/livesupport/src/modules/widgets/src/TestWindow.cxx

    r1601 r1902  
    73 73     // init the imageButtons  
    74 74     hugeImageButton = Gtk::manage(  
    75                       widgetFactory->createButton(WidgetFactory::hugePlayButton));  
      75                 widgetFactory->createButton(WidgetConstants::hugePlayButton));  
    75 75     cuePlayImageButton = Gtk::manage(  
    76                       widgetFactory->createButton(WidgetFactory::cuePlayButton));  
      76                 widgetFactory->createButton(WidgetConstants::cuePlayButton));  
    76 76     cuePlayImageButton->signal_clicked().connect(sigc::mem_fun(*this,  
    77 77                                             &TestWindow::onPlayButtonClicked));  
    78 78     cueStopImageButton = Gtk::manage(  
    79                       widgetFactory->createButton(WidgetFactory::cueStopButton));  
      79                 widgetFactory->createButton(WidgetConstants::cueStopButton));  
    79 79     cueStopImageButton->signal_clicked().connect(sigc::mem_fun(*this,  
    80 80                                             &TestWindow::onStopButtonClicked));  

  • trunk/livesupport/src/modules/widgets/src/WhiteWindow.cxx

    r1777 r1902  
    36 36 #include <iostream>  
    37 37  
      38 #include "LiveSupport/Widgets/WidgetFactory.h"  
      39  
    38 40 #include "LiveSupport/Widgets/WhiteWindow.h"  
    39 41  
    …… 
    56 58  *  Constructor for windows with image titles.  
    57 59  *----------------------------------------------------------------------------*/  
    58   WhiteWindow :: WhiteWindow(WidgetFactory::ImageType     title,  
      60 WhiteWindow :: WhiteWindow(WidgetConstants::ImageType     title,  
    58 60                            Colors::ColorName            backgroundColor,  
    59 61                            Ptr<CornerImages>::Ref       cornerImages,  
    …… 
    134 136     if (!(properties & isModal)) {  
    135 137         closeButton = Gtk::manage(wf->createButton(  
    136                                           WidgetFactory::windowCloseButton));  
      138                                         WidgetConstants::windowCloseButton));  
    136 138         cornerButtonBox->pack_end(*closeButton, Gtk::PACK_SHRINK, padding);  
    137 139         padding = 0;  
    …… 
    142 144     if (properties & isResizable) {  
    143 145         maximizeButton = Gtk::manage(wf->createButton(  
    144                                           WidgetFactory::windowMaximizeButton));  
      146                                         WidgetConstants::windowMaximizeButton));  
    144 146         cornerButtonBox->pack_end(*maximizeButton, Gtk::PACK_SHRINK, padding);  
    145 147         padding = (padding == 0) ? 5 : 0;  
    …… 
    149 151  
    150 152         minimizeButton = Gtk::manage(wf->createButton(  
    151                                           WidgetFactory::windowMinimizeButton));  
      153                                         WidgetConstants::windowMinimizeButton));  
    151 153         cornerButtonBox->pack_end(*minimizeButton, Gtk::PACK_SHRINK, padding);  
    152 154         minimizeButton->signal_clicked().connect(sigc::mem_fun(*this,  
    168 170     // create the resize image  
    169 171     if (properties & isResizable) {  
    170           resizeImage = Gtk::manage(wf->createImage(WidgetFactory::resizeImage));  
      172         resizeImage = Gtk::manage(wf->createImage(WidgetConstants::resizeImage));  
    170 172         resizeEventBox = Gtk::manage(new Gtk::EventBox());  
    171 173         resizeEventBox->modify_bg(Gtk::STATE_NORMAL, bgColor);  

  • trunk/livesupport/src/modules/widgets/src/WidgetFactory.cxx

    r1870 r1902  
    38 38  
    39 39 #include "LiveSupport/Widgets/Colors.h"  
    40   #include "LiveSupport/Widgets/ZebraTreeView.h"  
    41 40 #include "MessageWindow.h"  
    42 41  
    …… 
    390 389  
    391 390     // load the miscellaneous images  
    392       imageTypePixbufs[resizeImage]   = loadImage(resizeImageName);  
    393       imageTypePixbufs[scratchpadWindowTitleImage]  
      391     imageTypePixbufs[WidgetConstants::resizeImage]  
      392                                     = loadImage(resizeImageName);  
      393     imageTypePixbufs[WidgetConstants::scratchpadWindowTitleImage]  
    394 394                                     = loadImage(scratchpadWindowTitleImageName);  
    395       imageTypePixbufs[searchWindowTitleImage]  
      395     imageTypePixbufs[WidgetConstants::searchWindowTitleImage]  
    395 395                                     = loadImage(searchWindowTitleImageName);  
    396       imageTypePixbufs[liveModeWindowTitleImage]  
      396     imageTypePixbufs[WidgetConstants::liveModeWindowTitleImage]  
    396 396                                     = loadImage(liveModeWindowTitleImageName);  
    397       imageTypePixbufs[playlistsWindowTitleImage]  
      397     imageTypePixbufs[WidgetConstants::playlistsWindowTitleImage]  
    397 397                                     = loadImage(playlistsWindowTitleImageName);  
    398       imageTypePixbufs[schedulerWindowTitleImage]  
      398     imageTypePixbufs[WidgetConstants::schedulerWindowTitleImage]  
    398 398                                     = loadImage(schedulerWindowTitleImageName);  
    399       imageTypePixbufs[audioClipIconImage]  
      399     imageTypePixbufs[WidgetConstants::audioClipIconImage]  
    399 399                                     = loadImage(audioClipIconImageName);  
    400       imageTypePixbufs[playlistIconImage]  
      400     imageTypePixbufs[WidgetConstants::playlistIconImage]  
    400 400                                     = loadImage(playlistIconImageName);  
    401 401 }  
    …… 
    438 438  *----------------------------------------------------------------------------*/  
    439 439 Button *  
    440   WidgetFactory :: createButton(const Glib::ustring & label,  
    441                                 ButtonType            type)           throw ()  
      440 WidgetFactory :: createButton(const Glib::ustring &         label,  
      441                               WidgetConstants::ButtonType   type)   throw ()  
    442 442 {  
    443 443     switch (type) {  
    444           case pushButton:  
      444         case WidgetConstants::pushButton:  
    444 444             return new Button(label, buttonImages);  
    445 445  
    446           case tabButton:  
      446         case WidgetConstants::tabButton:  
    446 446             return new Button(label, tabButtonImages);  
    447 447  
    …… 
    530 530  *----------------------------------------------------------------------------*/  
    531 531 ImageButton *  
    532   WidgetFactory :: createButton(ImageButtonType    type)              throw ()  
      532 WidgetFactory :: createButton(WidgetConstants::ImageButtonType  type)  
      533                                                                     throw ()  
    533 534 {  
    534 535     Glib::RefPtr<Gdk::Pixbuf>   passiveImage;  
    …… 
    536 537  
    537 538     switch (type) {  
    538           case deleteButton:  
      539         case WidgetConstants::deleteButton:  
    538 539             passiveImage = loadImage(deleteButtonPassiveName);  
    539 540             rollImage    = loadImage(deleteButtonRollName);  
    540 541             break;  
    541 542  
    542           case plusButton:  
      543         case WidgetConstants::plusButton:  
    542 543             passiveImage = loadImage(plusButtonPassiveName);  
    543 544             rollImage    = loadImage(plusButtonRollName);  
    544 545             break;  
    545 546  
    546           case minusButton:  
      547         case WidgetConstants::minusButton:  
    546 547             passiveImage = loadImage(minusButtonPassiveName);  
    547 548             rollImage    = loadImage(minusButtonRollName);  
    548 549             break;  
    549 550  
    550           case smallPlayButton:  
      551         case WidgetConstants::smallPlayButton:  
    550 551             passiveImage = loadImage(smallPlayButtonPassiveName);  
    551 552             rollImage    = loadImage(smallPlayButtonRollName);  
    552 553             break;  
    553 554  
    554           case smallPauseButton:  
      555         case WidgetConstants::smallPauseButton:  
    554 555             passiveImage = loadImage(smallPauseButtonPassiveName);  
    555 556             rollImage    = loadImage(smallPauseButtonRollName);  
    556 557             break;  
    557 558  
    558           case smallStopButton:  
      559         case WidgetConstants::smallStopButton:  
    558 559             passiveImage = loadImage(smallStopButtonPassiveName);  
    559 560             rollImage    = loadImage(smallStopButtonRollName);  
    560 561             break;  
    561 562  
    562           case hugePlayButton:  
      563         case WidgetConstants::hugePlayButton:  
    562 563             passiveImage = loadImage(hugePlayButtonPassiveName);  
    563 564             rollImage    = loadImage(hugePlayButtonRollName);  
    564 565             break;  
    565 566  
    566           case cuePlayButton:  
      567         case WidgetConstants::cuePlayButton:  
    566 567             passiveImage = loadImage(cuePlayButtonPassiveName);  
    567 568             rollImage    = loadImage(cuePlayButtonRollName);  
    568 569             break;  
    569 570  
    570           case cueStopButton:  
      571         case WidgetConstants::cueStopButton:  
    570 571             passiveImage = loadImage(cueStopButtonPassiveName);  
    571 572             rollImage    = loadImage(cueStopButtonRollName);  
    572 573             break;  
    573 574  
    574           case masterPlayButton:  
      575         case WidgetConstants::masterPlayButton:  
    574 575             passiveImage = loadImage(masterPlayButtonPassiveName);  
    575 576             rollImage    = loadImage(masterPlayButtonRollName);  
    576 577             break;  
    577 578  
    578           case masterPauseButton:  
      579         case WidgetConstants::masterPauseButton:  
    578 579             passiveImage = loadImage(masterPauseButtonPassiveName);  
    579 580             rollImage    = loadImage(masterPauseButtonRollName);  
    580 581             break;  
    581 582  
    582           case masterStopButton:  
      583         case WidgetConstants::masterStopButton:  
    582 583             passiveImage = loadImage(masterStopButtonPassiveName);  
    583 584             rollImage    = loadImage(masterStopButtonRollName);  
    584 585             break;  
    585 586  
    586           case windowMinimizeButton:  
      587         case WidgetConstants::windowMinimizeButton:  
    586 587             passiveImage = loadImage(windowMinimizeButtonPassiveName);  
    587 588             rollImage    = loadImage(windowMinimizeButtonRollName);  
    588 589             break;  
    589 590  
    590           case windowMaximizeButton:  
      591         case WidgetConstants::windowMaximizeButton:  
    590 591             passiveImage = loadImage(windowMaximizeButtonPassiveName);  
    591 592             rollImage    = loadImage(windowMaximizeButtonRollName);  
    592 593             break;  
    593 594  
    594           case windowCloseButton:  
      595         case WidgetConstants::windowCloseButton:  
    594 595             passiveImage = loadImage(windowCloseButtonPassiveName);  
    595 596             rollImage    = loadImage(windowCloseButtonRollName);  
    …… 
    623 624  *----------------------------------------------------------------------------*/  
    624 625 Glib::RefPtr<Gdk::Pixbuf>  
    625   WidgetFactory :: getPixbuf(ImageType  imageName)                    throw ()  
      626 WidgetFactory :: getPixbuf(WidgetConstants::ImageType  imageName)   throw ()  
    625 626 {  
    626 627     return imageTypePixbufs[imageName];  
    633 634  *----------------------------------------------------------------------------*/  
    634 635 Gtk::Image *  
    635   WidgetFactory :: createImage(ImageType  imageName)                  throw ()  
      636 WidgetFactory :: createImage(WidgetConstants::ImageType  imageName) throw ()  
    635 636 {  
    636 637     return new Gtk::Image(getPixbuf(imageName));