Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

vuSpecPalette.cpp

Go to the documentation of this file.
00001 #include <wx/wx.h>
00002 #include <wx/colordlg.h>
00003 #include <wx/event.h>
00004 #include <wx/statline.h>
00005 #include <wx/dc.h>
00006 
00007 #include "vuSpecPalette.h"
00008 #include <iostream.h>
00009 #include "vuColourRGBa.h"
00010 
00011 //----------------------------------------------------------------------------
00012 //------------------------- The vuSpecPalette event table -----------------
00013 //----------------------------------------------------------------------------
00014 
00015 BEGIN_EVENT_TABLE(vuSpecPalette, wxDialog)
00016     EVT_BUTTON(vuSpecPalette::idCREATESP, vuSpecPalette::OnCreateSpectrum)
00017     EVT_BUTTON(vuSpecPalette::idLOADPAL, vuSpecPalette::OnLoadPal)
00018     EVT_BUTTON(vuSpecPalette::idSAVEPAL, vuSpecPalette::OnSavePal)
00019     EVT_BUTTON(vuSpecPalette::idLOADSP, vuSpecPalette::OnLoadSP)
00020     EVT_BUTTON(vuSpecPalette::idMUL, vuSpecPalette::OnMultiplyScalar)
00021     EVT_BUTTON(vuSpecPalette::idDIV, vuSpecPalette::OnDivideScalar)
00022     EVT_BUTTON(vuSpecPalette::idSAVESP, vuSpecPalette::OnSaveSP)
00023     EVT_BUTTON(vuSpecPalette::idADDREF, vuSpecPalette::OnAddReflectance)
00024     EVT_BUTTON(vuSpecPalette::idADDLIG, vuSpecPalette::OnAddLight)
00025     EVT_BUTTON(wxID_OK, vuSpecPalette::OnOK)
00026     EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
00027     EVT_BUTTON(vuSpecPalette::idSETPLANCK, vuSpecPalette::OnCreatePlanckian)
00028     EVT_SLIDER(vuSpecPalette::idRED_SLIDER, vuSpecPalette::OnCompSlider)
00029     EVT_SLIDER(vuSpecPalette::idGREEN_SLIDER, vuSpecPalette::OnCompSlider)
00030     EVT_SLIDER(vuSpecPalette::idBLUE_SLIDER, vuSpecPalette::OnCompSlider)
00031     EVT_SLIDER(vuSpecPalette::idWEIGHT_SLIDER, vuSpecPalette::OnCompSlider)
00032     EVT_PAINT(vuSpecPalette::OnPaint)
00033     EVT_MOUSE_EVENTS(vuSpecPalette::OnMouseEvent)
00034     //EVT_CLOSE(vuSpecPalette::OnCloseWindow)
00035     EVT_BUTTON(vuSpecPalette::idDCGET, vuSpecPalette::OnGetDCColour)
00036     EVT_BUTTON(vuSpecPalette::idDCGETALL, vuSpecPalette::OnGetAllDCColours)
00037     EVT_CHECKBOX(vuSpecPalette::idDCDES, vuSpecPalette::OnCBDCDesign)
00038     EVT_LISTBOX(vuSpecPalette::idDCFC, vuSpecPalette::OnDCFC) 
00039     EVT_CHECKBOX(vuSpecPalette::idFCUSEB, vuSpecPalette::OnCBFCUseB)
00040     EVT_TEXT_ENTER(vuSpecPalette::idFCUB, vuSpecPalette::OnFCUpperBound)
00041     EVT_TEXT_ENTER(vuSpecPalette::idFCLB, vuSpecPalette::OnFCLowerBound)
00042     EVT_CHECKBOX(vuSpecPalette::idSPDES, vuSpecPalette::OnCBSPDesign)
00043     EVT_CHECKBOX(vuSpecPalette::idSPUSEB, vuSpecPalette::OnCBSPUseB)
00044     EVT_TEXT_ENTER(vuSpecPalette::idSPUB, vuSpecPalette::OnSPUpperBound)
00045     EVT_TEXT_ENTER(vuSpecPalette::idSPLB, vuSpecPalette::OnSPLowerBound)
00046     EVT_TEXT_ENTER(vuSpecPalette::idSPNAME, vuSpecPalette::OnSPName)
00047     EVT_TEXT_ENTER(vuSpecPalette::idWSMOOTH, vuSpecPalette::OnSmoothW)
00048     EVT_TEXT_ENTER(vuSpecPalette::idWERROR, vuSpecPalette::OnErrorW)
00049     EVT_BUTTON(vuSpecPalette::idNORMNORM, vuSpecPalette::OnNormVal)
00050     EVT_BUTTON(vuSpecPalette::idNORMLUM, vuSpecPalette::OnNormVal)
00051     EVT_CHECKBOX(vuSpecPalette::idUSEV7, vuSpecPalette::OnCBUseV7)
00052 END_EVENT_TABLE();
00053 
00054 enum {
00055     SP_RED,
00056     SP_GREEN,
00057     SP_BLUE,
00058     SP_WEIGHT
00059 };
00060 
00061 //----------------------------------------------------------------------------
00062 //------------------------- The constructor ----------------------------------
00063 //----------------------------------------------------------------------------
00064 
00065 vuSpecPalette::vuSpecPalette(wxWindow *parent, SPalette &pal)
00066     : wxDialog(parent, -1, wxString("Spectral palette designer"),
00067                wxPoint(0, 0), wxSize(900, 900),
00068                //wxDefaultPosition,wxDefaultSize,
00069                wxDEFAULT_DIALOG_STYLE), m_Palette(&pal)
00070 {
00071     m_SelDesColourR = 0;
00072     m_SelDesColourL = 0;
00073     m_SelRefl = 0;
00074     m_SelLight = -1;
00075     
00076     CalculateMeasurements();
00077     CreateWidgets();
00078 }
00079 
00080 vuSpecPalette::~vuSpecPalette()
00081 {
00082 }
00083 
00084 //----------------------------------------------------------------------------
00085 //------------------------- private: OnOk() ----------------------------------
00086 //----------------------------------------------------------------------------
00087 
00088 void vuSpecPalette::OnOK(wxCommandEvent &ev)
00089 {
00090     EndModal(wxID_OK);
00091 }
00092 
00093 //----------------------------------------------------------------------------
00094 //------------------------- private: OnLoadPal() ------------------------------
00095 //----------------------------------------------------------------------------
00096 
00097 void vuSpecPalette::OnLoadPal(wxCommandEvent &ev)
00098 {
00099   //open load dialog, ...
00100   wxFileDialog fd(this,"Choose a palette","","","*.pal",wxOPEN);
00101   if(fd.ShowModal() == wxID_OK)
00102   {
00103       cout<<"loading... "<<fd.GetPath()<<endl;
00104       try {
00105           if(m_Palette->load(fd.GetPath()))
00106             {
00107                 cout<<"successful."<<endl;
00108             } else {
00109                 cout<<"failed."<<endl;
00110             }
00111       } catch (char *msg) {
00112           printf("%s\n",msg);
00113       }
00114       if(getNLights()==0) m_Palette->addLight(vuColour31a(1.0f));
00115       if(getNRefls()==0) m_Palette->addReflectance(vuColour31a(1.0f));
00116       m_SelRefl = 0;
00117       m_SelLight = -1;
00118       UpdateWidgets();
00119   }
00120 }
00121 
00122 //----------------------------------------------------------------------------
00123 //------------------------- private: OnSavePal() ------------------------------
00124 //----------------------------------------------------------------------------
00125 
00126 void vuSpecPalette::OnSavePal(wxCommandEvent &ev)
00127 {
00128   //open save dialog, ...
00129   wxFileDialog fd(this,"Save Palette","","","*.pal",wxSAVE|wxOVERWRITE_PROMPT);
00130   if(fd.ShowModal() == wxID_OK)
00131     {
00132       cout<<"saving... "<<fd.GetPath()<<endl;
00133       try {
00134           if(m_Palette->save(fd.GetPath()))
00135               cout<<"successful."<<endl;
00136           else
00137               cout<<"failed."<<endl;
00138       } catch (char *msg) {
00139           printf("%s\n",msg);
00140       }
00141     }
00142 }
00143 
00144 void vuSpecPalette::OnLoadSP(wxCommandEvent &ev)
00145 {
00146   if(!validSpecSelected()) return;
00147     //open load dialog, ...
00148   wxFileDialog fd(this,"load spectrum","","","*.spc",wxOPEN);
00149   if(fd.ShowModal() == wxID_OK)
00150     {
00151       try {
00152           if(!m_Palette->loadSpectrum(m_SelRefl,m_SelLight,fd.GetPath()))
00153           {
00154               cerr<<"failed to load spectrum."<<endl;
00155           }
00156       } catch (char *msg) {
00157           cerr << msg << endl;
00158       }
00159       UpdateWidgets();
00160     }
00161 }
00162 
00163 void vuSpecPalette::OnSaveSP(wxCommandEvent &ev)
00164 {
00165   if(!validSpecSelected()) return;
00166   //open save dialog, ...
00167   wxFileDialog fd(this,"Save spectrum","","","*.spc",
00168                   wxSAVE|wxOVERWRITE_PROMPT);
00169   if(fd.ShowModal() == wxID_OK)
00170     {
00171       cout<<"saving... "<<fd.GetPath()<<endl;
00172       try {
00173           if(m_Palette->saveSpectrum(m_SelRefl,m_SelLight,fd.GetPath()))
00174               cout<<"successful."<<endl;
00175           else
00176               cout<<"failed."<<endl;
00177       } catch (char *msg) {
00178           printf("%s\n",msg);
00179       }
00180     }
00181 }
00182 
00184 void vuSpecPalette::OnMultiplyScalar(wxCommandEvent &ev)
00185 {
00186         if(validSpecSelected()) {
00187             double val;
00188             m_SScale->GetValue().ToDouble(&val);
00189             m_Palette->getSpec(m_SelRefl,m_SelLight) *= val;
00190                 OnColourClick(m_SelRefl,m_SelLight,CC_GET);
00191         }
00192 }
00193 
00195 void vuSpecPalette::OnDivideScalar(wxCommandEvent &ev)
00196 {
00197         if(validSpecSelected()) {
00198             double val;
00199             m_SScale->GetValue().ToDouble(&val);
00200                 if(val!=0.0) {
00201                         m_Palette->getSpec(m_SelRefl,m_SelLight) /= val;
00202                         OnColourClick(m_SelRefl,m_SelLight,CC_GET);
00203                 }
00204         }
00205 }
00206 
00209 void vuSpecPalette::selectSpec(int rid, int lid)
00210 {
00211     if((rid==-1) ^ (lid==-1) &&
00212        (rid<(int)getNRefls()) &&lid<(int)getNLights())
00213     {
00214                 OnColourClick(rid,lid,CC_GET);
00215     }
00216 }
00217 
00218 const SPalette& vuSpecPalette::getSPalette() const
00219 {
00220     return *m_Palette;
00221 }
00222 
00223 //-----------------------------------------------------------------------------
00224 //  stuff copied from wxColourDialog
00225 //-----------------------------------------------------------------------------
00226 
00227 void vuSpecPalette::CalculateMeasurements()
00228 {
00229     m_ColourSize.x = 40; //18;
00230     m_ColourSize.y = 40; //14;
00231     m_GridSpacing = 15;
00232     m_SectionSpacing = 15;
00233     m_Border.x = m_Border.y = 10;
00234         
00235     // make additional row and column for pure light/relf colours
00236     m_PalRect.width = ( ((getNLights()+1)*m_ColourSize.x)
00237                             + ((getNLights())*m_GridSpacing)
00238                             + 2*m_Border.x);
00239     m_PalRect.height = ( ((getNRefls()+1)*m_ColourSize.y)
00240                              + ((getNRefls())*m_GridSpacing) 
00241                              + 2*m_Border.y);
00242     
00243     m_DColRect.width = m_ColourSize.x+ 3*m_Border.x;
00244     m_DColRect.height = m_ColourSize.y*2+m_GridSpacing
00245         + 2*m_Border.y + 100;
00246     
00247 
00248     m_DiagRect.width = 200;
00249     m_DiagRect.height = 100;
00250 }
00251 
00252 void vuSpecPalette::CreateWidgets()
00253 {
00254     wxBeginBusyCursor();
00255 
00256     int sliderX = m_DColRect.width + m_SectionSpacing;
00257 #if defined(__WXMOTIF__)
00258     int sliderSpacing = 65;
00259     int sliderHeight =  130;
00260 #else
00261     int sliderSpacing = 65;
00262     int sliderHeight =  130;
00263 #endif
00264 
00265 // create objects ------------------------------
00266     wxSize size(100,30);
00267     wxSize tbsize(50,30);
00268     m_SmoothW = new wxTextCtrl(this,idWSMOOTH,"0.00", 
00269                                wxDefaultPosition,tbsize,
00270                                wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00271                                wxTextValidator(wxFILTER_NUMERIC));
00272     m_ErrorW = new wxTextCtrl(this,idWERROR,"0.00", 
00273                               wxDefaultPosition,tbsize,
00274                               wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00275                               wxTextValidator(wxFILTER_NUMERIC));
00276     m_SP_name = new wxTextCtrl(this,idSPNAME,"<name>", 
00277                                wxDefaultPosition,size,
00278                                wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00279                                wxTextValidator(wxFILTER_ASCII));
00280     m_SP_upperBound = new wxTextCtrl(this,idSPUB,"10000", 
00281                                      wxDefaultPosition,tbsize,
00282                                      wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00283                                      wxTextValidator(wxFILTER_NUMERIC));
00284     m_SP_lowerBound = new wxTextCtrl(this,idSPLB,"0", 
00285                                      wxDefaultPosition,tbsize,
00286                                      wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00287                                      wxTextValidator(wxFILTER_NUMERIC));
00288     m_FC_upperBound = new wxTextCtrl(this,idFCUB,"1.00", 
00289                                      wxDefaultPosition,tbsize,
00290                                      wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00291                                      wxTextValidator(wxFILTER_NUMERIC));
00292     m_FC_lowerBound = new wxTextCtrl(this,idFCLB,"0.00", 
00293                                      wxDefaultPosition,tbsize,
00294                                      wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00295                                      wxTextValidator(wxFILTER_NUMERIC));
00296     m_SScale = new wxTextCtrl(this,-1,"1.00", 
00297                                wxDefaultPosition,tbsize,
00298                                wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00299                                wxTextValidator(wxFILTER_NUMERIC));
00300     m_SP_Norm = new wxTextCtrl(this, -1,"0.00", 
00301                                wxDefaultPosition,tbsize,
00302                                wxTE_READONLY);
00303                                //wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00304                                //wxTextValidator(wxFILTER_NUMERIC));
00305     m_PlanckT  = new wxTextCtrl(this,-1,"6500", 
00306                                wxDefaultPosition,tbsize,
00307                                wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00308                                wxTextValidator(wxFILTER_NUMERIC));
00309     m_SP_Y   = new wxTextCtrl(this, -1,"0.00", 
00310                               wxDefaultPosition,tbsize,
00311                               wxTE_READONLY);
00312                               //wxTE_PROCESS_ENTER|wxTE_PROCESS_TAB,
00313                               //wxTextValidator(wxFILTER_NUMERIC));
00314     
00315     m_CompSlider[SP_RED] = new wxSlider(this, idRED_SLIDER, 0, 0, 255,
00316                                         wxPoint(sliderX, 10), 
00317                                         wxSize(-1, sliderHeight), 
00318                                         wxVERTICAL|wxSL_LABELS);
00319     m_CompSlider[SP_GREEN] = new wxSlider(this, idGREEN_SLIDER, 0, 0, 255,
00320                                           wxPoint(sliderX+sliderSpacing, 10), 
00321                                           wxSize(-1, sliderHeight), 
00322                                           wxVERTICAL|wxSL_LABELS);
00323     m_CompSlider[SP_BLUE] = new wxSlider(this, idBLUE_SLIDER, 0, 0, 255,
00324                                          wxPoint(sliderX+2*sliderSpacing,10), 
00325                                          wxSize(-1, sliderHeight), 
00326                                          wxVERTICAL|wxSL_LABELS);
00327     m_CompSlider[SP_WEIGHT] = new wxSlider(this, idWEIGHT_SLIDER, 255, 0, 255,
00328                                          wxPoint(sliderX+2*sliderSpacing,10), 
00329                                          wxSize(-1, sliderHeight), 
00330                                          wxVERTICAL|wxSL_LABELS);
00331     m_DC_FreeCol = new wxListBox(this, idDCFC, wxDefaultPosition,
00332                                 wxSize(100,75), 0, NULL, wxLB_SINGLE);
00333     m_DC_FreeCol->Append("<none>");
00334     m_DC_FreeCol->Append("A");
00335     m_DC_FreeCol->Append("B");
00336     
00337     m_DC_design = new wxCheckBox(this,idDCDES,"use colour");
00338     m_DC_design->SetValue(false);
00339     m_SP_design = new wxCheckBox(this,idSPDES,"design spectrum");
00340     m_SP_design->SetValue(false);
00341     m_SP_useBounds = new wxCheckBox(this,idSPUSEB,"use bounds");
00342     m_SP_useBounds->SetValue(true);
00343     m_FC_useBounds = new wxCheckBox(this,idFCUSEB,"use bounds");
00344     m_FC_useBounds->SetValue(true);
00345     m_useV7 = new wxCheckBox(this,idUSEV7,"optimize V7");
00346     m_Palette->useV7(false);
00347     m_useV7->SetValue(false);
00348     //sizers used as place holders
00349     m_DiagSpacer = new wxBoxSizer(wxHORIZONTAL);
00350     m_DiagSpacer->Add(1,1);
00351     //m_DiagSpacer->Add((int)m_DiagRect.width,(int)m_DiagRect.height);
00352     m_DColSpacer = new wxBoxSizer(wxHORIZONTAL);
00353     m_DColSpacer->Add(1,1);
00354     m_PalSpacer = new wxBoxSizer(wxHORIZONTAL);
00355     m_PalSpacer->Add(1,1);
00356     
00357 // create sizers ------------------------------
00358     wxBoxSizer *leftSizer = new wxBoxSizer(wxVERTICAL );
00359     wxBoxSizer *rightSizer = new wxBoxSizer(wxVERTICAL );
00360 
00361 // fill left sizer ------------------------------
00362     wxSizer* palette = new wxFlexGridSizer(2,2,2);
00363     palette->Add(1,1);
00364     palette->Add(new wxStaticText(this,-1,"lights"),
00365                  0,wxALL|wxALIGN_CENTER,1);
00366     palette->Add(new wxStaticText(this,-1,"reflectances"),
00367                  0,wxALL|wxALIGN_CENTER,1);
00368     palette->Add(m_PalSpacer,0,wxALL,3);
00369     
00370     leftSizer->Add(palette,0,wxRIGHT, 20);
00371     wxSizer *spnameSizer = new wxBoxSizer(wxHORIZONTAL);
00372     spnameSizer->Add( m_SP_name, 0, wxALL, 10 );
00373     spnameSizer->Add( m_SP_design, 0, wxALL, 10 );
00374     leftSizer->Add(spnameSizer);
00375 
00376         wxSize buttonSize(wxButton::GetDefaultSize());
00377         buttonSize.SetWidth(120);
00378     wxSizer *lbSizer = new wxBoxSizer(wxHORIZONTAL);
00379     wxSizer *llSizer = new wxBoxSizer(wxVERTICAL);
00380         wxSizer *loadSaveSizer = new wxGridSizer(2, 10, 10);
00381     loadSaveSizer->Add( new wxButton(this, idLOADSP, _("Load Spectrum"), 
00382                                                        wxDefaultPosition, buttonSize ));
00383     loadSaveSizer->Add( new wxButton(this, idSAVESP, _("Save Spectrum"), 
00384                                                            wxDefaultPosition, buttonSize  ));
00385     loadSaveSizer->Add( new wxButton(this, idADDREF, _("Add Reflectance"), wxDefaultPosition, buttonSize  ));
00386     loadSaveSizer->Add( new wxButton(this, idADDLIG, _("Add Light"), wxDefaultPosition, buttonSize  ));
00387         llSizer->Add( loadSaveSizer );
00388 
00389         wxSizer *spInfoSizer = new wxBoxSizer(wxHORIZONTAL);
00390         llSizer->Add(spInfoSizer);
00391     spInfoSizer->Add(m_DiagSpacer, 0, wxBOTTOM|wxTOP,10);       // space for diagram
00392 
00393         wxSizer *spInfo = new wxFlexGridSizer( 3 );
00394         spInfo->Add(new wxStaticText(this, -1, _("Luminance")), 0, 
00395                     wxALIGN_RIGHT|wxLEFT, 5);
00396         spInfo->Add(m_SP_Y, 0, wxALIGN_LEFT, 10);
00397         spInfo->Add( new wxButton( this, idNORMLUM, _("1"), wxDefaultPosition, wxSize(20, buttonSize.GetHeight())), 0, 
00398                      wxLEFT|wxALIGN_LEFT, 5 );
00399 
00400         spInfo->Add(new wxStaticText(this, -1, _("Norm")), 0, wxALIGN_RIGHT|wxLEFT, 5);
00401         spInfo->Add(m_SP_Norm, 0, wxALIGN_LEFT, 10);
00402         spInfo->Add( new wxButton( this, idNORMNORM, _("1"), wxDefaultPosition, wxSize(20, buttonSize.GetHeight())), 0, 
00403                      wxLEFT|wxALIGN_LEFT, 5 );
00404 
00405         spInfo->Add( new wxButton( this, idSETPLANCK, _("Make Planck")), 0, wxLEFT|wxALIGN_CENTRE, 10 );
00406         spInfo->Add(m_PlanckT, 0, wxALIGN_LEFT, 10);
00407         spInfo->Add(new wxStaticText(this, -1, _("K")), 0, wxALIGN_LEFT|wxLEFT, 5);
00408 
00409         spInfoSizer->Add( spInfo, 0, wxLEFT|wxBOTTOM|wxALIGN_BOTTOM, 10  );
00410 
00411         wxSizer *scaleSizer = new wxBoxSizer(wxHORIZONTAL);
00412         scaleSizer->Add( new wxStaticText(this,-1,_("scale by")), 0, wxALIGN_CENTRE, 10 );
00413         scaleSizer->Add( m_SScale, 0, wxLEFT|wxALIGN_CENTRE, 10 );
00414         scaleSizer->Add( new wxButton( this, idMUL, _("MUL")), 0, wxLEFT|wxALIGN_CENTRE, 10 );
00415         scaleSizer->Add( new wxButton( this, idDIV, _("DIV")), 0, wxLEFT|wxALIGN_CENTRE, 10 );
00416         llSizer->Add( scaleSizer, 0, wxTOP, 5 );
00417 
00418         wxSizer *lrSizer = new wxFlexGridSizer( 2 );
00419     lrSizer->Add( 1, 1);
00420     lrSizer->Add( m_SP_useBounds );
00421     lrSizer->Add(new wxStaticText(this,-1,"upper bound"),
00422                  0,wxALIGN_RIGHT|wxTOP,5);
00423     lrSizer->Add( m_SP_upperBound );
00424     lrSizer->Add(new wxStaticText(this,-1,"lower bound"),
00425                  0,wxALIGN_RIGHT|wxTOP,5);
00426     lrSizer->Add( m_SP_lowerBound );
00427     lrSizer->Add(new wxStaticText(this,-1,"smoothness"),
00428                  0,wxALIGN_RIGHT|wxTOP,5);
00429     lrSizer->Add( m_SmoothW );
00430     lrSizer->Add(new wxStaticText(this,-1,"error min."),
00431                  0,wxALIGN_RIGHT|wxTOP,5);
00432     lrSizer->Add( m_ErrorW );
00433     lrSizer->Add(1,1);
00434     lrSizer->Add( m_useV7 );
00435     lbSizer->Add(llSizer, 0, wxALL, 10);
00436     lbSizer->Add(lrSizer, 0, wxALL, 10);
00437     leftSizer->Add(lbSizer);
00438         
00439 // fill right sizer ------------------------------
00440         wxSizer *colGetSizer = new wxGridSizer(2,10,10);
00441     colGetSizer->Add( new wxButton(this, idDCGET, _("Fit Colour"), 
00442                                                            wxDefaultPosition, buttonSize));
00443     colGetSizer->Add( new wxButton(this, idDCGETALL, _("Fit All"), 
00444                                                            wxDefaultPosition, buttonSize));
00445         rightSizer->Add( colGetSizer, 0, wxTOP, 10 );
00446 
00447     wxSizer *colourSizer = new wxBoxSizer(wxHORIZONTAL);
00448     rightSizer->Add(colourSizer);
00449         wxSizer *lcolourSizer = new wxBoxSizer(wxVERTICAL);
00450         colourSizer->Add(lcolourSizer);
00451         lcolourSizer->Add( m_DC_design, 0, wxTOP, 10 );
00452     lcolourSizer->Add(m_DColSpacer);
00453     colourSizer->Add(m_CompSlider[SP_RED],0,wxALL,10);
00454     colourSizer->Add(m_CompSlider[SP_GREEN],0,wxALL,10);
00455     colourSizer->Add(m_CompSlider[SP_BLUE],0,wxALL,10);
00456     colourSizer->Add(m_CompSlider[SP_WEIGHT],0,wxALL,10);
00457     
00458         //lines don't work under windows :-(
00459         //rightSizer->Add( new wxStaticLine(this,-1,wxDefaultPosition,
00460         //                         wxSize(200,20),wxLI_HORIZONTAL),
00461         //            0, wxLEFT|wxRIGHT, 10 );
00462         //rightSizer->Add(200,20);
00463 
00464         wxSizer *fcSizer = new wxFlexGridSizer(2);
00465         wxSizer *lfcSizer = new wxBoxSizer(wxVERTICAL);
00466         fcSizer->Add(lfcSizer);
00467     lfcSizer->Add(new wxStaticText(this,-1,"Free Colour"),
00468                                   0,wxALIGN_LEFT|wxALIGN_TOP);
00469     lfcSizer->Add( m_DC_FreeCol );
00470     wxSizer *rfcSizer = new wxBoxSizer(wxVERTICAL);
00471         fcSizer->Add(rfcSizer);
00472         rfcSizer->Add( m_FC_useBounds, 0, wxTOP|wxBOTTOM, 5 );
00473         rfcSizer->Add( 1, 1 );
00474     rfcSizer->Add(new wxStaticText(this,-1,"Upper bound"),
00475                                   0,wxALL|wxALIGN_RIGHT,1);
00476     rfcSizer->Add( m_FC_upperBound );
00477     rfcSizer->Add(new wxStaticText(this,-1,"Lower bound"),
00478                                   0,wxALL|wxALIGN_RIGHT,1);
00479     rfcSizer->Add( m_FC_lowerBound );
00480         rightSizer->Add( fcSizer );
00481     //rightSizer->Add( new wxStaticLine(this,-1,wxDefaultPosition,
00482         //                            wxSize(200,20),wxLI_HORIZONTAL),
00483         //           0, wxLEFT|wxRIGHT, 10 );
00484         rightSizer->Add(200,20);
00485 
00486     // buttons
00487     wxSizer *buttonSizer = new wxGridSizer( 2 , 10, 10);
00488     buttonSizer->Add( new wxButton(this, idLOADPAL, _("Load Palette"), wxDefaultPosition, buttonSize  ));
00489     buttonSizer->Add( new wxButton(this, idSAVEPAL, _("Save Palette"), wxDefaultPosition, buttonSize  ));
00490     buttonSizer->Add( new wxButton(this, idCREATESP, _("Create Spectra"), wxDefaultPosition, buttonSize ));
00491     buttonSizer->Add( new wxButton(this, wxID_OK, _("Done"), wxDefaultPosition, buttonSize ));
00492     rightSizer->Add(buttonSizer, 0, wxBOTTOM|wxRIGHT, 10);
00493 
00494 // finish ------------------------------
00495     m_TopSizer = new wxBoxSizer( wxHORIZONTAL );
00496     m_TopSizer->Add( leftSizer );
00497     m_TopSizer->Add( rightSizer );
00498     //m_TopSizer->Add( rightSizer, 0, wxCENTRE | wxALL, 10 );
00499 
00500 // calc layout
00501     m_TopSizer->RecalcSizes();
00502     SetAutoLayout( true );
00503     SetSizer( m_TopSizer );
00504     m_TopSizer->SetSizeHints( this );
00505     
00506     Centre( wxBOTH );
00507     
00508     wxEndBusyCursor();
00509 
00510     UpdateWidgets();                    // update the layout
00511 }
00512 
00515 void vuSpecPalette::UpdateWidgets()
00516 {
00517     if(m_SelRefl>=(int)getNRefls() ||
00518        m_SelLight>=(int)getNLights() ||
00519        m_SelDesColourR>=(int)getNRefls() ||
00520        m_SelDesColourL>=(int)getNLights())
00521     {
00522         m_SelRefl = 0;
00523         m_SelLight = -1;
00524         m_SelDesColourR = m_SelDesColourR = 0;
00525     }
00526     
00527 // update values in widgets
00528     OnColourClick(m_SelRefl, m_SelLight, CC_GET);       
00529     OnColourClick(m_SelDesColourR, m_SelDesColourL, CC_GET);
00530 
00531 // recalc layout
00532     CalculateMeasurements();
00533     m_DiagSpacer->Remove(0);
00534     m_DiagSpacer->Add(m_DiagRect.width,m_DiagRect.height);
00535     m_DColSpacer->Remove(0);
00536     m_DColSpacer->Add(m_DColRect.width,m_DColRect.height);
00537     m_PalSpacer->Remove(0);
00538     m_PalSpacer->Add(m_PalRect.width, m_PalRect.height);
00539     
00540     Layout();   // recalc layout for sizers in this window
00541     m_TopSizer->Fit(this);      // tell the window to fit the sizer
00542         Refresh(true);
00543 
00544 // get information about new layout
00545     m_PalRect.x= m_PalSpacer->GetPosition().x + m_Border.x;
00546     m_PalRect.y= m_PalSpacer->GetPosition().y + m_Border.y;
00547     m_DiagRect.x= m_DiagSpacer->GetPosition().x + m_Border.x;
00548     m_DiagRect.y= m_DiagSpacer->GetPosition().y + m_Border.y;
00549     m_DColRect.x= m_DColSpacer->GetPosition().x + m_Border.x;
00550     m_DColRect.y= m_DColSpacer->GetPosition().y + m_Border.y;
00551 }
00552 
00553 // misc event handlers
00554 
00556 #if wxMINOR_VERSION < 5
00557 void vuSpecPalette::OnDCFC(void) {
00558 #else
00559 void vuSpecPalette::OnDCFC(wxCommandEvent&) {
00560 #endif
00561     int fcid = m_DC_FreeCol->GetSelection()-1;
00562     m_Palette->attachFreeColour(m_SelDesColourR,m_SelDesColourL,fcid);
00563         
00564     bool enable = (fcid!=-1);
00565     m_FC_useBounds->Enable(enable);
00566     m_FC_lowerBound->Enable(enable);
00567     m_FC_upperBound->Enable(enable);
00568     if(enable) {
00569         m_FC_useBounds->SetValue(m_Palette->getFreeColBoundState(fcid));
00570         m_FC_upperBound->SetValue(wxString::Format("%.2f", m_Palette->
00571                                                    getFreeColUB(fcid)[0]));
00572     m_FC_lowerBound->SetValue(wxString::Format("%.2f", m_Palette->
00573                                                getFreeColLB(fcid)[0]));
00574     } else {
00575         m_FC_useBounds->SetValue(false);
00576         m_FC_upperBound->SetValue(_(""));
00577         m_FC_lowerBound->SetValue(_(""));
00578     }
00579 }
00580 
00582 #if wxMINOR_VERSION < 5
00583  void vuSpecPalette::OnCBFCUseB(void)
00584 #else
00585  void vuSpecPalette::OnCBFCUseB(wxCommandEvent&)
00586 #endif
00587 {
00588     int fcid = m_Palette->getFreeColourID(m_SelDesColourR,
00589                                           m_SelDesColourL);
00590     if(fcid>=0)
00591         m_Palette->getFreeColBoundState(fcid) = m_FC_useBounds->GetValue();
00592 }
00593 
00595 #if wxMINOR_VERSION < 5
00596 void vuSpecPalette::OnFCLowerBound(void)
00597 #else
00598 void vuSpecPalette::OnFCLowerBound(wxCommandEvent&)
00599 #endif
00600 {
00601     double val;
00602     m_FC_lowerBound->GetValue().ToDouble(&val);
00603     int fcid = m_Palette->getFreeColourID(m_SelDesColourR,
00604                                           m_SelDesColourL);
00605     if(fcid>=0) {
00606         m_Palette->getFreeColLB(fcid) = val;
00607         m_FC_lowerBound->SetValue(wxString::Format("%.2f",val));
00608     }
00609 }
00610 
00611 #if wxMINOR_VERSION < 5
00612 void vuSpecPalette::OnFCUpperBound(void)
00613 #else
00614 void vuSpecPalette::OnFCUpperBound(wxCommandEvent&)
00615 #endif
00616 {
00617     double val;
00618     m_FC_upperBound->GetValue().ToDouble(&val);
00619     int fcid = m_Palette->getFreeColourID(m_SelDesColourR,
00620                                           m_SelDesColourL);
00621     if(fcid>=0) {
00622         m_Palette->getFreeColUB(fcid) = val;
00623         m_FC_upperBound->SetValue(wxString::Format("%.2f",val));
00624     }
00625 };
00626 
00628 #if wxMINOR_VERSION < 5
00629 void vuSpecPalette::OnChangeDCRGBW(void) 
00630 #else
00631 void vuSpecPalette::OnChangeDCRGBW(wxCommandEvent&) 
00632 #endif
00633 {
00634     if(m_SelDesColourR>=0 && m_SelDesColourL>=0) {
00635         vuColourRGBa &rgbw = m_Palette->
00636             getDesignRGBW(m_SelDesColourR,m_SelDesColourL);
00637         rgbw[0] = m_CompSlider[SP_RED]->GetValue()/255.0f;
00638         rgbw[1] = m_CompSlider[SP_GREEN]->GetValue()/255.0f;
00639         rgbw[2] = m_CompSlider[SP_BLUE]->GetValue()/255.0f;
00640         rgbw[3] = m_CompSlider[SP_WEIGHT]->GetValue()/255.0f;
00641     }
00642 }
00643 
00644 #if wxMINOR_VERSION < 5
00645 void vuSpecPalette::OnCompSlider(wxScrollEvent& event)
00646 #else
00647 void vuSpecPalette::OnCompSlider(wxCommandEvent& event)
00648 #endif
00649 {
00650 #if wxMINOR_VERSION < 5
00651     OnChangeDCRGBW();
00652 #else
00653     wxCommandEvent ev;
00654     OnChangeDCRGBW(ev);
00655 #endif
00656     wxClientDC dc(this);
00657     PaintColours(dc);
00658     PaintColour(dc);
00659 }
00660 
00661 void vuSpecPalette::OnCreatePlanckian(wxCommandEvent &ev)
00662 {
00663     if(validSpecSelected()) {
00664         double val;
00665         m_PlanckT->GetValue().ToDouble(&val);
00666         vuColour31a &spec = m_Palette->getSpec(m_SelRefl,m_SelLight);
00667         spec.planckian(val);
00668         float luminance = vuColourXYZa(spec)[1];
00669         if(fabs(luminance) > 0.0000001) spec /= luminance;
00670         OnColourClick(m_SelRefl,m_SelLight,CC_GET);
00671     }
00672 }
00673 
00674 // Internal functions
00675 void vuSpecPalette::OnMouseEvent(wxMouseEvent& event)
00676 {
00677     int x = (int)event.GetX();
00678     int y = (int)event.GetY();
00679     
00680     if ((x >= m_PalRect.x && 
00681                 x <= (m_PalRect.x + m_PalRect.width)) &&
00682         (y >= m_PalRect.y && 
00683                 y <= (m_PalRect.y + m_PalRect.height)))
00684     {
00685                 int indX = (int)(x - m_PalRect.x) / 
00686                   (m_ColourSize.x + m_GridSpacing);
00687                 int indY = (int)(y - m_PalRect.y) /
00688                         (m_ColourSize.y + m_GridSpacing);
00689                 int selRefl = indY-1;
00690                 int selLight = indX-1;
00691                 if(selRefl<(int)getNRefls() && selLight<(int)getNLights())
00692                 {
00693                         if (event.ButtonDown(1) || event.ButtonDown(3))
00694                         {
00695                                 TYPE_COLOUR_CLICK what = event.ButtonDown(1) ? CC_GET : CC_PUT; //LB-get RB-set
00696                                 OnColourClick(selRefl,selLight, what);
00697                         } else if (event.LeftDClick())
00698                         {
00699                                 OnColourClick(selRefl,selLight, CC_TOGGLE_DESIGN);
00700                         }
00701                 }
00702         }
00703 }
00704 
00705 void vuSpecPalette::OnColourClick(int refl, int light, 
00706                                                                   TYPE_COLOUR_CLICK what)
00707 {
00708   wxClientDC dc(this);
00709   if(light==-1 || refl==-1) {
00710       if(light*refl!=1) {
00711                   // a light or a reflectance spectrum has been selected
00712                   m_SelLight = m_SelRefl = -1;
00713                   if(light>=0) m_SelLight = light;
00714                   else m_SelRefl = refl;
00715                   switch(what) {
00716                   case CC_GET:
00717                           {
00718                                   m_SP_name->SetValue(wxString(m_Palette->
00719                                                            getSpecName(m_SelRefl,m_SelLight)));
00720                                   m_SP_design->SetValue(m_Palette->
00721                                                         getSpecDesignState(m_SelRefl,m_SelLight));
00722                                   m_SP_useBounds->SetValue(m_Palette->
00723                                                            useSpecBounds(m_SelRefl,m_SelLight));
00724                                   m_SP_upperBound->
00725                                           SetValue(wxString::
00726                                                    Format("%.2f",m_Palette->getSpecUB(m_SelRefl,
00727                                                                                           m_SelLight)[0]));
00728                                   m_SP_lowerBound->
00729                                           SetValue(wxString::Format
00730                                                    ("%.2f", m_Palette->getSpecLB(m_SelRefl,
00731                                                                                  m_SelLight)[0]));
00732                                   SVector spec(m_Palette->getSpec(m_SelRefl,m_SelLight));
00733                                   vuColourXYZa specXYZ(m_Palette->getSpec(m_SelRefl,m_SelLight));
00734                                   m_SP_Norm->SetValue(wxString::Format("%.2f", spec.norm()));
00735                                   m_SP_Y->SetValue(wxString::Format("%.2f", specXYZ[1]));
00736                           }
00737                           break;
00738                   case CC_PUT: {
00739 #if wxMINOR_VERSION < 5
00740                           OnSPName();
00741                           OnCBSPUseB();
00742                           OnCBSPDesign();
00743                           OnSPLowerBound();
00744                           OnSPUpperBound();
00745 #else
00746                           wxCommandEvent ev;
00747                           OnSPName(ev);
00748                           OnCBSPUseB(ev);
00749                           OnCBSPDesign(ev);
00750                           OnSPLowerBound(ev);
00751                           OnSPUpperBound(ev);
00752 #endif
00753                   }
00754                   break;
00755                   case CC_TOGGLE_DESIGN:
00756                                 if(validSpecSelected()) {
00757                                         bool &des = m_Palette->
00758                                                         getSpecDesignState(m_SelRefl,m_SelLight);
00759                                         des = !des;
00760                                         m_SP_design->SetValue(des);
00761                                 }
00762                           break;
00763                   }
00764       }
00765   } else
00766   {
00767           // a design colour has been selected
00768       m_SelDesColourR = refl;
00769       m_SelDesColourL = light;
00770       switch(what)
00771           {
00772           case CC_GET:
00773                   {
00774                           m_DC_design->SetValue(m_Palette->getDesignState(m_SelDesColourR, 
00775                                                                           m_SelDesColourL));
00776                           vuColourRGBa &rgbw = m_Palette->
00777                                   getDesignRGBW(m_SelDesColourR, m_SelDesColourL);
00778                           m_CompSlider[SP_RED]->SetValue(byte(255.0f*rgbw[0]));
00779                           m_CompSlider[SP_GREEN]->SetValue(byte(255.0f*rgbw[1]));
00780                           m_CompSlider[SP_BLUE]->SetValue(byte(255.0f*rgbw[2]));
00781                           m_CompSlider[SP_WEIGHT]->SetValue(byte(255.0f*rgbw[3]));
00782                           m_DC_FreeCol->
00783                           SetSelection(m_Palette->getFreeColourID(m_SelDesColourR, 
00784                                                                   m_SelDesColourL)+1);
00785 #if wxMINOR_VERSION < 5
00786                           OnDCFC();     // will update all 'free colour' stuff
00787 #else
00788                           wxCommandEvent ev;
00789                           OnDCFC(ev);   // will update all 'free colour' stuff
00790 #endif
00791                   }
00792                   break;
00793           case CC_PUT: {
00794 #if wxMINOR_VERSION < 5
00795                   OnCBDCDesign();
00796                   OnDCFC();
00797                   OnChangeDCRGBW();
00798 #else
00799                   wxCommandEvent ev;
00800                   OnCBDCDesign(ev);
00801                   OnDCFC(ev);
00802                   OnChangeDCRGBW(ev);
00803 #endif
00804           }
00805           break;
00806           case CC_TOGGLE_DESIGN:
00807                         {
00808                                 bool &destate = m_Palette->getDesignState(m_SelDesColourR, m_SelDesColourL);
00809                                 destate = !destate;
00810                                 m_DC_design->SetValue(destate);
00811                         } 
00812                   break;
00813       }
00814   }
00815   
00816   PaintColours(dc);
00817   PaintColour(dc);
00818   PaintSpectrum(dc);
00819 }
00820 
00821 void vuSpecPalette::OnPaint(wxPaintEvent& event)
00822 {
00823 #if !defined(__WXMOTIF__) && !defined(WIN32)
00824   wxDialog::OnPaint(event);
00825 #endif
00826   //Clear();
00827 
00828   wxPaintDC dc(this);
00829 
00830   PaintColours(dc);
00831   PaintColour(dc);
00832   PaintSpectrum(dc);
00833 }
00834 
00835 void vuSpecPalette::ClearAndHighlight(wxDC& dc)
00836 {
00837   dc.BeginDrawing();
00838   //clear background
00839   dc.SetPen(*wxTRANSPARENT_PEN);
00840   //wxBrush lgreyb(wxColour(221,221,221),wxSOLID);
00841   wxBrush lgreyb(dc.GetBackground());
00842   dc.SetBrush(lgreyb);  //*wxLIGHT_GREY_BRUSH);
00843   dc.DrawRectangle(m_PalRect.x-m_GridSpacing,m_PalRect.y-m_GridSpacing,
00844                    m_PalRect.width+m_GridSpacing,m_PalRect.height+m_GridSpacing);
00845   
00846   // Number of pixels bigger than the standard rectangle size
00847   // for drawing a highlight
00848   //int deltaX = 2;
00849   //int deltaY = 2;
00850 
00851   if((m_SelRefl==-1) ^ (m_SelLight==-1))
00852   {
00853       int x = m_SelLight+1;
00854       int y = m_SelRefl+1;
00855 
00856     x = (x*(m_ColourSize.x + m_GridSpacing) 
00857          + m_PalRect.x) - m_GridSpacing/2;
00858     y = (y*(m_ColourSize.y + m_GridSpacing) 
00859          + m_PalRect.y) - m_GridSpacing/2;
00860 
00861     wxColour ibg(200, 200, 250);
00862         //wxColour bg(dc.GetBackground().GetColour());
00863         //wxColour ibg(255-bg.Red(),255-bg.Green(),255-bg.Blue());
00864     wxBrush specbg(ibg,wxSOLID);
00865     dc.SetPen(*wxTRANSPARENT_PEN);
00866     dc.SetBrush(specbg);
00867     if(m_SelRefl==-1)                   //light selected
00868         dc.DrawRectangle( x, y, 
00869                           m_ColourSize.x + (1*m_GridSpacing),
00870                           (getNRefls()+1)*(m_ColourSize.y + m_GridSpacing)
00871                           +(m_GridSpacing/2));
00872     else                                                //reflectance selected
00873         dc.DrawRectangle( x, y, 
00874                           (getNLights()+1)*(m_ColourSize.x + m_GridSpacing) +
00875                           (m_GridSpacing/2), m_ColourSize.y + (1*m_GridSpacing));
00876   }
00877 
00878   if(m_SelDesColourR!=-1 || m_SelDesColourL!=-1)
00879   {
00880       int x = m_SelDesColourL+1;
00881       int y = m_SelDesColourR+1;
00882 
00883     x = (x*(m_ColourSize.x + m_GridSpacing) 
00884             + m_PalRect.x) - m_GridSpacing/4;
00885     y = (y*(m_ColourSize.y + m_GridSpacing) 
00886                 + m_PalRect.y) - m_GridSpacing/4;
00887 
00888     wxBrush selbg(wxColour(100, 255, 0),wxSOLID);
00889     dc.SetPen(*wxTRANSPARENT_PEN);
00890     dc.SetBrush(selbg);
00891     dc.DrawRectangle( x, y, (m_ColourSize.x + m_GridSpacing/2), 
00892                       (m_ColourSize.y + m_GridSpacing/2));
00893   }
00894 
00895   dc.EndDrawing();
00896 }
00897 
00898 void vuSpecPalette::PaintColours(wxDC& dc)
00899 {
00900   dc.BeginDrawing();
00901   ClearAndHighlight(dc);
00902   
00903 //  wxPen despen(wxColour(255,255,255),1,wxSHORT_DASH);
00904   wxPen despen(wxColour(255,0,0),2,wxSOLID);
00905   wxPen nodespen(*wxBLACK_PEN);
00906   for (dword j = 0; j < getNLights(); j++)
00907   {
00908       int x = ((j+1)*(m_ColourSize.x+m_GridSpacing)) + m_PalRect.x;
00909       int y = (0*(m_ColourSize.y+m_GridSpacing)) + m_PalRect.y;
00910       vuColourRGBa col(m_Palette->getSpec(-1,j));
00911       col.clampTo01();
00912       wxColour wxc(byte(255*col[0]),byte(255*col[1]),byte(255*col[2]));
00913       dc.SetPen(m_Palette->getSpecDesignState(-1,j)?despen:nodespen);
00914       wxBrush brush(wxc, wxSOLID);
00915       dc.SetBrush(brush);
00916       dc.DrawRectangle( x, y, 
00917                         m_ColourSize.x, m_ColourSize.y);
00918   }
00919   
00920   for (dword i = 0; i < getNRefls(); i++)
00921   {
00922       int x = (0*(m_ColourSize.x+m_GridSpacing)) + m_PalRect.x;
00923       int y = ((i+1)*(m_ColourSize.y+m_GridSpacing)) + m_PalRect.y;
00924       vuColourRGBa col(m_Palette->getSpec(i,-1));
00925       col.clampTo01();
00926       wxColour wxc(byte(255*col[0]),byte(255*col[1]),byte(255*col[2]));
00927       dc.SetPen(m_Palette->getSpecDesignState(i,-1)?despen:nodespen);
00928       wxBrush brush(wxc, wxSOLID);
00929       dc.SetBrush(brush);
00930       dc.DrawRectangle( x, y, 
00931                         m_ColourSize.x, m_ColourSize.y);
00932   }
00933 
00934   int halfx = 2*m_ColourSize.x/3;       //not really half
00935   int halfy = m_ColourSize.y/2;
00936   for (dword i = 0; i < getNRefls(); i++)
00937   {
00938       for (dword j = 0; j < getNLights(); j++)
00939       {
00940           int x = ((j+1)*(m_ColourSize.x+m_GridSpacing)) 
00941               + m_PalRect.x;
00942           int y = ((i+1)*(m_ColourSize.y+m_GridSpacing)) 
00943               + m_PalRect.y;
00944           
00945           dc.SetPen(*wxTRANSPARENT_PEN);
00946           vuColourRGBa ac31_rgb(m_Palette->getRLColour(i,j,false));
00947           ac31_rgb.clampTo01();
00948           wxColour wxc(byte(255.0f*ac31_rgb[0]),
00949                        byte(255.0f*ac31_rgb[1]),
00950                        byte(255.0f*ac31_rgb[2]));
00951           wxBrush abrush(wxc, wxSOLID);
00952           dc.SetBrush(abrush);
00953           dc.DrawRectangle( x, y, 
00954                             halfx, m_ColourSize.y-halfy+1);
00955           
00956           vuColourRGBa ac7_rgb(m_Palette->getRLColour(i,j,true));
00957           ac7_rgb.clampTo01();
00958           wxColour bwxc(byte(255.0f*ac7_rgb[0]),
00959                        byte(255.0f*ac7_rgb[1]),
00960                        byte(255.0f*ac7_rgb[2]));
00961           wxBrush bbrush(bwxc, wxSOLID);
00962           dc.SetBrush(bbrush);
00963           dc.DrawRectangle( x, y+halfy, 
00964                             halfx, m_ColourSize.y-halfy);
00965 
00966           vuColourRGBa &rgbw = m_Palette->getDesignRGBW(i,j);
00967           rgbw.clampTo01();
00968           wxColour dwxcol(byte(255.0f*rgbw[0]),
00969                           byte(255.0f*rgbw[1]),
00970                           byte(255.0f*rgbw[2]));
00971           wxBrush dbrush(dwxcol, wxSOLID);
00972           dc.SetBrush(dbrush);
00973           
00974           dc.DrawRectangle( x+halfx-1, y, 
00975                             m_ColourSize.x-halfx+1, m_ColourSize.y);
00976           dc.SetBrush(*wxTRANSPARENT_BRUSH);
00977           dc.SetPen(m_Palette->getDesignState(i,j) ? despen : nodespen);
00978           dc.DrawRectangle( x, y, m_ColourSize.x, m_ColourSize.y);
00979       }
00980   }
00981   dc.SetPen(wxNullPen);
00982   dc.SetBrush(wxNullBrush);
00983   dc.EndDrawing();
00984 }
00985 
00986 void vuSpecPalette::PaintColour(wxDC& dc)
00987 {
00988   dc.BeginDrawing();
00989 
00990   dc.SetPen(*wxBLACK_PEN);
00991 
00992   wxColour col(m_CompSlider[SP_RED]->GetValue(),
00993                m_CompSlider[SP_GREEN]->GetValue(),
00994                m_CompSlider[SP_BLUE]->GetValue());
00995 
00996   wxBrush *brush = new wxBrush(col, wxSOLID);
00997   dc.SetBrush(*brush);
00998 
00999   dc.DrawRectangle( m_DColRect.x, m_DColRect.y,
01000                     m_ColourSize.x, m_ColourSize.y);
01001 
01002   dc.SetBrush(wxNullBrush);
01003   delete brush;
01004 
01005   dc.EndDrawing();
01006 }
01007 
01008 void vuSpecPalette::PaintSpectrum(wxDC& dc)
01009 {
01010   dc.BeginDrawing();
01011 
01012   dc.SetPen(*wxBLACK_PEN);
01013 
01014   //wxBrush *brush = new wxBrush(wxColour(200,150,150), wxSOLID);
01015   dc.SetBrush(*wxWHITE_BRUSH);
01016 
01017   dc.DrawRectangle( m_DiagRect.x, m_DiagRect.y,
01018                     m_DiagRect.width, m_DiagRect.height);
01019 
01020   dc.SetBrush(wxNullBrush);
01021   //delete brush;
01022 
01023   if(validSpecSelected()) {
01024       vuColour31a &spec = m_Palette->getSpec(m_SelRefl,m_SelLight);
01025       float max = spec.maxComponent();
01026       float min = spec.minComponent();
01027       if( max == min ) {        // constant spectrum?
01028                   if( max>0 ) {
01029                           max *= 1.1;
01030                   } else if ( max<0 ) {
01031                           min *= 1.1;
01032                   } else {  // spectrum is constant 0
01033                           max=1;
01034                           min=-1;
01035                   } 
01036       }
01037       max = 0>max?0:max;
01038       min = 0<min?0:min;
01039       
01040       float sy = float(m_DiagRect.height)/(max-min);
01041       float sx = float(m_DiagRect.width)/31;
01042       int middle = m_DiagRect.y+int(max*sy);
01043       wxBrush lightredbrush(wxColour(255,230,230),wxSOLID);
01044       dc.SetBrush(lightredbrush);
01045       dc.SetPen(*wxTRANSPARENT_PEN);
01046       dc.DrawRectangle( m_DiagRect.x+1, middle,
01047                         m_DiagRect.width-2, m_DiagRect.height-1
01048                         -int(max*sy));
01049       dc.SetPen(*wxGREY_PEN);
01050       dc.DrawLine(m_DiagRect.x, middle,
01051                   m_DiagRect.x+m_DiagRect.width, middle);
01052 
01053       wxPen greenpen(wxColour(0,100,0),1,wxSOLID);
01054       dc.SetPen(greenpen);
01055       wxPoint points[31];
01056       for(int c=0;c<31;c++)
01057           points[c] = wxPoint(m_DiagRect.x+int(sx*c),middle-int(sy*spec[c]));
01058       dc.DrawSpline(31,(wxPoint*)&points);
01059       
01060       dc.SetPen(wxNullPen);
01061       dc.SetBrush(wxNullBrush);
01062         
01063           //draw scale information
01064           char number[1024];
01065           wxCoord wx, wy;
01066 #if wxMINOR_VERSION < 5
01067           wxFont &oldFont = dc.GetFont();
01068 #else
01069           wxFont oldFont = dc.GetFont();
01070 #endif
01071           wxFont font(6,wxSWISS,wxNORMAL,wxLIGHT);
01072           //dc.SetFont(*wxSMALL_FONT);
01073           dc.SetFont(font);
01074           sprintf(number,"%3.2f",max);
01075           dc.DrawText(wxString(number),m_DiagRect.x,m_DiagRect.y);
01076           sprintf(number,"%3.2f",min);
01077           dc.GetTextExtent(number,&wx,&wy);
01078           dc.DrawText(wxString(number),m_DiagRect.x,m_DiagRect.y+m_DiagRect.height-wy);
01079 
01080           dc.SetFont(oldFont);
01081   }
01082   
01083   dc.EndDrawing();
01084 }
01085 
01086 //----------------------------------------------------------------------------
01087 //----------------------------------------------------------------------------
01088 

Generated on Wed Dec 15 21:20:36 2004 for vuVolume by  doxygen 1.3.9.1