// @(#)root/asimage:$Id$
// Author: Reiner Rohlfs   24/03/2002

/*************************************************************************
 * Copyright (C) 1995-2002, Rene Brun, Fons Rademakers and Reiner Rohlfs *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TASPaletteEditor                                                    //
//                                                                      //
//  This is a GUI window to edit a color palette.                       //
//  It is called by a pull down menu item of TASImage.                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TASImage.h"
#include "TRootEmbeddedCanvas.h"
#include "TCanvas.h"
#include "TH1.h"
#include "TFile.h"
#include "TASPaletteEditor.h"
#include "TGXYLayout.h"
#include "TGButton.h"
#include "TGComboBox.h"
#include "TGFileDialog.h"
#include "TLine.h"
#include "TROOT.h"
#include "TClass.h"
#include "TMath.h"
#include "RConfigure.h"

#ifdef R__HAS_COCOA
#   define X_DISPLAY_MISSING 1
#endif

#ifdef WIN32
#include "Windows4root.h"
#endif

extern "C" {
#ifndef WIN32
#   include <afterbase.h>
#else
#   include <win32/config.h>
#   include <win32/afterbase.h>
#endif
#   include <afterimage.h>
#   include <bmp.h>

}


static const char *gFileTypes[] = {
   "ROOT palette file",  "*.pal.root",
   "ASCII palette file", "*.pal.txt",
   0,                    0
};

static UShort_t gRedRainbow[12] = {
   0x0000, 0x7000, 0x0000, 0x0000, 0x0000,
   0xffff, 0xffff, 0x7000, 0x8000, 0xffff
};
static UShort_t gGreenRainbow[12] = {
   0x0000, 0x0000, 0x0000, 0xffff, 0xffff,
   0xffff, 0x0000, 0x0000, 0x8000, 0xffff
};
static UShort_t gBlueRainbow[12] = {
   0x0000, 0x7000, 0xffff, 0xffff, 0x0000,
   0x0000, 0x0000, 0x0000, 0xa000, 0xffff
};


ClassImp(TASPaletteEditor)

//______________________________________________________________________________
TASPaletteEditor::TASPaletteEditor(TAttImage *attImage, UInt_t w, UInt_t h)
   : TPaletteEditor(attImage, w, h), TGMainFrame(0, w, h)
{
   // Palette editor constructor.
   // The palette editor aloows the editing of the color palette of the image.

   SetLayoutManager(new TGXYLayout(this));
   fHisto        = 0;
   fLimitLine[0] = 0;
   fLimitLine[1] = 0;
   fRampFactor   = 0;
   fImagePad     = gPad;

   fPaletteList = new TList;
   fPaletteList->SetOwner();

   fPalette = new TImagePalette(attImage->GetPalette());
   fPaletteList->Add(fPalette);

   // buttons
   TGTextButton *button;

   button = new TGTextButton(this, "&Apply", 1);
   button->SetToolTipText("Apply the palette to the image");
   AddFrame(button, new TGXYLayoutHints(70, 1, 8, 1.8));

   button = new TGTextButton(this, "&Ok", 2);
   button->SetToolTipText("Same as Apply and Cancel button");
   AddFrame(button, new TGXYLayoutHints(70, 3, 8, 1.8));

   button = new TGTextButton(this, "&Cancel", 3);
   button->SetToolTipText("Close this window");
   AddFrame(button, new TGXYLayoutHints(70, 5, 8, 1.8));

   button = new TGTextButton(this, "&Save", 4);
   button->SetToolTipText("Save the palette in a ROOT or an ASCII file");
   AddFrame(button, new TGXYLayoutHints(70, 7.5, 8, 1.8));

   button = new TGTextButton(this, "O&pen", 5);
   button->SetToolTipText("Read a palette from a ROOT or an ASCII file");
   AddFrame(button, new TGXYLayoutHints(70, 9.5, 8, 1.8));

   button = new TGTextButton(this, "&New", 6);
   button->SetToolTipText("Create a new palette (not yet implemented)");
   button->SetState(kButtonDisabled);
   AddFrame(button, new TGXYLayoutHints(70, 12, 8, 1.8));

   button = new TGTextButton(this, "&Edit", 7);
   button->SetToolTipText("Edit a palette (not yet implemented)");
   button->SetState(kButtonDisabled);
   AddFrame(button, new TGXYLayoutHints(70, 14, 8, 1.8));

   fAutoUpdate = new TGCheckButton(this, "Auto Update", 13);
   fAutoUpdate->SetToolTipText("Automatic update of the image (without Apply button)");
   AddFrame(fAutoUpdate, new TGXYLayoutHints(50, 1, 20, 1.8));

   fUnDoButton = new TGTextButton(this, "&Undo", 20);
   fUnDoButton->SetToolTipText("Undo the last modification (repeatable)");
   AddFrame(fUnDoButton, new TGXYLayoutHints(50, 3, 8, 1.8));

   fReDoButton = new TGTextButton(this, "&Redo", 21);
   fReDoButton->SetToolTipText("Undo the last undo operation (repeatable)");
   AddFrame(fReDoButton, new TGXYLayoutHints(60, 3, 8, 1.8));

   button = new TGTextButton(this, "&Log", 8);
   button->SetToolTipText("Apply a log operation to the anchor points of the palette");
   AddFrame(button, new TGXYLayoutHints(50, 15, 8, 1.8));

   button = new TGTextButton(this, "E&xp", 9);
   button->SetToolTipText("Apply a exp operation to the anchor points of the palette");
   AddFrame(button, new TGXYLayoutHints(50, 17, 8, 1.8));

   button = new TGTextButton(this, "L&in", 10);
   button->SetToolTipText("Make the distance of all anchor points constant");
   AddFrame(button, new TGXYLayoutHints(50, 19, 8, 1.8));

   button = new TGTextButton(this, "In&vert", 11);
   button->SetToolTipText("Invert the order of the colors");
   AddFrame(button, new TGXYLayoutHints(60, 17, 8, 1.8));

   fStepButton = new TGCheckButton(this, "Step", 12);
   fStepButton->SetToolTipText("Apply a step function to the palette");
   AddFrame(fStepButton, new TGXYLayoutHints(60, 19, 8, 1.8));

   // ramp: 1, 2 or 4
   TGGroupFrame *rampFrame = new TGGroupFrame(this, "Ramps");
   rampFrame->SetLayoutManager(new TGXYLayout(rampFrame));
   AddFrame(rampFrame, new TGXYLayoutHints(50, 8.5, 14, 6,
            TGXYLayoutHints::kLRubberX | TGXYLayoutHints::kLRubberY |
            TGXYLayoutHints::kLRubberH | TGXYLayoutHints::kLRubberW));

   fRamps[0] = new TGRadioButton(rampFrame, "1", 1);
   fRamps[0]->SetToolTipText("Repeat the palette once");
   rampFrame->AddFrame(fRamps[0], new TGXYLayoutHints(2, 1.4, 5, 1.8));

   fRamps[1] = new TGRadioButton(rampFrame, "2", 2);
   fRamps[1]->SetToolTipText("Repeat the palette twice");
   rampFrame->AddFrame(fRamps[1], new TGXYLayoutHints(2, 3.3, 5, 1.8));

   fRamps[2] = new TGRadioButton(rampFrame, "4", 4);
   fRamps[2]->SetToolTipText("Repeat the palette four times");
   rampFrame->AddFrame(fRamps[2], new TGXYLayoutHints(8, 3.3, 5, 1.8));

   fRamps[0]->Associate(this);
   fRamps[1]->Associate(this);
   fRamps[2]->Associate(this);

   // the histogram of the data
   fHistCanvas = new TRootEmbeddedCanvas("data hist", this, 300, 50);
   AddFrame(fHistCanvas, new TGXYLayoutHints(1, 1, 48, 20,
            TGXYLayoutHints::kLRubberW | TGXYLayoutHints::kLRubberH));

   const ASImage *image = ((TASImage*)attImage)->GetImage();
   if (image && image->alt.vector) {
      Int_t pixel;
      Double_t *data = image->alt.vector;
      Int_t numPixel = image->width * image->height;
      Int_t numBins = numPixel / 20;
      numBins = (numBins < 10) ? 10 : (numBins > 200) ? 200 : numBins;

      // get min and max value of image
      fMinValue = fMaxValue = *image->alt.vector;
      for (pixel = 1; pixel < numPixel; pixel++) {
         if (fMinValue > *(data + pixel)) fMinValue = *(data + pixel);
         if (fMaxValue < *(data + pixel)) fMaxValue = *(data + pixel);
      }

      fHisto = new TH1D("Statistics", "Pixel histogram of unzoomed image    ",
                        numBins, fMinValue, fMaxValue);
      for (pixel = 0; pixel < numPixel; pixel++)
         fHisto->Fill(*(data + pixel));

      fHisto->Draw("HIST");
      fHisto->GetXaxis()->SetLabelFont(63);
      fHisto->GetXaxis()->SetLabelSize(10);
      fHisto->GetYaxis()->SetLabelFont(63);
      fHisto->GetYaxis()->SetLabelSize(10);

      fLimitLine[0] = new LimitLine(fMinValue + fPalette->fPoints[1] * (fMaxValue - fMinValue),
                                    0, fHisto->GetMaximum(), this);
      fLimitLine[0]->Draw();
      fLimitLine[1] = new LimitLine(fMinValue + fPalette->fPoints[fPalette->fNumPoints - 2] *
                                    (fMaxValue - fMinValue), 0, fHisto->GetMaximum(), this);
      fLimitLine[1]->Draw();
   }

   // the combobox of different palettes
   fComboBox = new TGComboBox(this, 100);
   AddFrame(fComboBox, new TGXYLayoutHints(50, 6, 14, 2));

   fComboBox->AddEntry("Rainbow", 0);
   fComboBox->AddEntry("Grey", 1);
   fComboBox->AddEntry("Hot",  2);
   fComboBox->AddEntry("Cold", 3);
   fComboBox->AddEntry("Bowlerhat", 4);
   fComboBox->AddEntry("", 5);


   // the palette
   fPaletteCanvas = new TRootEmbeddedCanvas("palette", this, 300, 50);
   AddFrame(fPaletteCanvas, new TGXYLayoutHints(1, 22, 78, 2.5,
            TGXYLayoutHints::kLRubberW | TGXYLayoutHints::kLRubberY));

   fPaintPalette = new PaintPalette(&fPalette, attImage);
   fPaintPalette->Draw();

   MapSubwindows();
   Layout();

   SetWindowName("Palette Editor");
   SetIconName("Palette Editor");

   MapWindow();

   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
TASPaletteEditor::~TASPaletteEditor()
{
   // Palette editor destructor. Deletes all frames and their layout hints.

   TGFrameElement *ptr;

   // delete all frames and layout hints
   if (fList) {
      TIter next(fList);
      while ((ptr = (TGFrameElement *) next())) {
         if (ptr->fLayout)
            delete ptr->fLayout;
         if (ptr->fFrame)
            delete ptr->fFrame;
      }
   }

   delete fHisto;
   delete fPaintPalette;
   delete fLimitLine[0];
   delete fLimitLine[1];
   delete fPaletteList;
}

//______________________________________________________________________________
void TASPaletteEditor::CloseWindow()
{
   // Close editor.

   TPaletteEditor::CloseWindow();
   delete this;
}

//______________________________________________________________________________
Bool_t TASPaletteEditor::ProcessMessage(Long_t msg, Long_t param1, Long_t param2)
{
   // Process all editor mouse events

   switch (GET_MSG(msg)) {

      case kC_COMMAND:
         switch (GET_SUBMSG(msg)) {

            case kCM_COMBOBOX:
               NewPalette(param2);
               break;

            case kCM_RADIOBUTTON:
               SetRamp(param1);
               break;

            case kCM_CHECKBUTTON:
               if (param1 == 12)
                  SetStep();
               break;

            case kCM_BUTTON:
               switch (param1) {

                  case 1 :  // Apply
                     fAttImage->SetPalette(fPalette);
                     fImagePad->Modified();
                     fImagePad->Update();
                     break;

                  case 2 :  // OK
                     fAttImage->SetPalette(fPalette);
                     fImagePad->Modified();
                     fImagePad->Update();
                     CloseWindow();
                     break;

                  case 3 : // Cancel
                     CloseWindow();
                     break;

                  case 4 : // Save
                     Save();
                     break;

                  case 5 : // Open
                     Open();
                     break;

                  case 8: // log
                     LogPalette();
                     break;

                  case 9: // exp
                     ExpPalette();
                     break;

                  case 10: // lin
                     LinPalette();
                     break;

                  case 11: // invert
                     InvertPalette();
                     break;


                  case 20: // undo
                     fPalette = (TImagePalette*)(fPaletteList->Before(fPalette));
                     if (fAutoUpdate->GetState() == kButtonDown) {
                        fAttImage->SetPalette(fPalette);
                        fImagePad->Modified();
                        fImagePad->Update();
                     }
                     if (fPalette) UpdateScreen(kTRUE);
                     break;

                  case 21: // redo
                     fPalette = (TImagePalette*)(fPaletteList->After(fPalette));
                     if (fAutoUpdate->GetState() == kButtonDown) {
                        fAttImage->SetPalette(fPalette);
                        fImagePad->Modified();
                        fImagePad->Update();
                     }
                     if (fPalette) UpdateScreen(kTRUE);
                     break;

                  default: ;
               }
               break;

            default: ;
         }
         break;

      default: ;
   }

   return kTRUE;
}

//______________________________________________________________________________
void TASPaletteEditor::InsertNewPalette(TImagePalette *newPalette)
{
   // The newPalette is inserted in the list of palettes (fPaletteList) and
   // fPalette is set to the newPalette. Protected method,

   // first remove all palettes in the list which are behind the
   // current palette
   TObject *obj;
   while ((obj = fPaletteList->After(fPalette)) != 0)
      delete fPaletteList->Remove(obj);

   // add new palette and make it to the current palette
   fPaletteList->Add(newPalette);
   fPalette = newPalette;

   // update the image
   if (fAutoUpdate->GetState() == kButtonDown) {
      fAttImage->SetPalette(fPalette);
      fImagePad->Modified();
      fImagePad->Update();
   }
}

//______________________________________________________________________________
void TASPaletteEditor::Save()
{
   // Saves the current palette either into a ROOT file or in an ASCII file.
   // It is called by the Save - button. Protected method.

   TGFileInfo fi;
   fi.fFileTypes = gFileTypes;
   static Bool_t overwr = kFALSE;
   fi.fOverwrite = overwr;

   new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi);
   overwr = fi.fOverwrite;
   if (fi.fFilename == 0)
      return;

   if (strcmp(".pal.txt", fi.fFilename + strlen(fi.fFilename) - 8) == 0) {
      // write into an ASCII file
      FILE *fl = fopen(fi.fFilename, "w");
      if (!fl) return;
      fprintf(fl, "%u\n", fPalette->fNumPoints);
      for (Int_t pt = 0; pt < Int_t(fPalette->fNumPoints); pt++)
         fprintf(fl, "%10.9f %04hx %04hx %04hx %04hx\n",
                 fPalette->fPoints[pt],
                 fPalette->fColorRed[pt],
                 fPalette->fColorGreen[pt],
                 fPalette->fColorBlue[pt],
                 fPalette->fColorAlpha[pt] );
      fclose(fl);
   } else {
      // write into a ROOT file
      char fn[512];
      if (strcmp(".pal.root", fi.fFilename + strlen(fi.fFilename) - 9) != 0)
         snprintf(fn,512, "%s%s", fi.fFilename, ".pal.root");
      else
         strlcpy(fn, fi.fFilename,512);

      gROOT->ProcessLine(Form("gROOT->SaveObjectAs((TASPaletteEditor*)0x%lx,\"%s\",\"%s\");",(ULong_t)this,fn,"q"));
   }
}

//______________________________________________________________________________
void TASPaletteEditor::Open()
{
   // Opens either a ROOT file or an ASCII file and reads a palette.
   // It is called by the Open - button. Protected method.

   TGFileInfo fi;
   fi.fFileTypes = gFileTypes;

   new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
   if (fi.fFilename == 0)
      return;

   TImagePalette *newPalette;

   if (strcmp(".pal.txt", fi.fFilename + strlen(fi.fFilename) - 8) == 0) {
      FILE *fl = fopen(fi.fFilename, "r");
      if (!fl) return;
      UInt_t numPoints;
      // coverity [Calling risky function : FALSE]
      if (fscanf(fl, "%u\n", &numPoints)) {;}
      newPalette = new TImagePalette(numPoints);
      for (Int_t pt = 0; pt < Int_t(numPoints); pt++)
         // coverity [Calling risky function : FALSE]
         if (fscanf(fl, "%lf %hx %hx %hx %hx\n",
                newPalette->fPoints + pt,
                newPalette->fColorRed + pt,
                newPalette->fColorGreen + pt,
                newPalette->fColorBlue + pt,
                    newPalette->fColorAlpha + pt )) {;}
             fclose(fl);
   } else {
      // read from a ROOT file
      char fn[512];
      if (strcmp(".pal.root", fi.fFilename + strlen(fi.fFilename) - 9) != 0)
         snprintf(fn,512, "%s%s", fi.fFilename, ".pal.root");
      else
         strlcpy(fn, fi.fFilename,512);
      TDirectory *dirsav = gDirectory;

      TFile *fsave = new TFile(fn, "READ");
      if (!fsave->IsOpen()) {
         delete fsave;
         return;
      }

      newPalette = (TImagePalette*)fsave->Get("TImagePalette");
      delete fsave;
      if (dirsav) dirsav->cd();
      if (!newPalette)
         return;
   }

   InsertNewPalette(newPalette);
   UpdateScreen(kTRUE);

   fComboBox->Select(5);  // empty entry
}

//______________________________________________________________________________
void TASPaletteEditor::UpdateScreen(Bool_t histoUpdate)
{
   // All widgeds of the screen are updated with the current palette.
   // Protected method.

   // update the color palette
   fPaletteCanvas->GetCanvas()->Modified();
   fPaletteCanvas->GetCanvas()->Update();

   if (histoUpdate) {
      // update the limit lines
      Double_t xPos = fMinValue + fPalette->fPoints[1] * (fMaxValue - fMinValue);
      fLimitLine[0]->SetX1(xPos);
      fLimitLine[0]->SetX2(xPos);

      xPos = fMinValue + fPalette->fPoints[fPalette->fNumPoints - 2] * (fMaxValue - fMinValue);
      fLimitLine[1]->SetX1(xPos);
      fLimitLine[1]->SetX2(xPos);

      fHistCanvas->GetCanvas()->Modified();
      fHistCanvas->GetCanvas()->Update();
   }

   // update undo / redo button
   fUnDoButton->SetState(fPalette == fPaletteList->First() ? kButtonDisabled : kButtonUp);
   fReDoButton->SetState(fPalette == fPaletteList->Last()  ? kButtonDisabled : kButtonUp);

   // test if it is a step palette
   EButtonState step = kButtonDown;

   Int_t pt;
   for (pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt += 2)
      if (TMath::Abs(fPalette->fPoints[pt] - fPalette->fPoints[pt + 1])  > 0.0001 ||
          fPalette->fColorRed[pt]   != fPalette->fColorRed[pt-1]   ||
          fPalette->fColorGreen[pt] != fPalette->fColorGreen[pt-1] ||
          fPalette->fColorBlue[pt]  != fPalette->fColorBlue[pt-1])
         step = kButtonUp;
   fStepButton->SetState(step);

   // find the ramp factor
   fRampFactor = 4;
   Int_t off = (fPalette->fNumPoints - 2) / 4;
   for (pt = 0; pt < Int_t(fPalette->fNumPoints - 2) / 4 * 3; pt++)
      if (fPalette->fColorRed[pt + 1]   != fPalette->fColorRed[pt + 1 + off]   ||
          fPalette->fColorGreen[pt + 1] != fPalette->fColorGreen[pt + 1 + off] ||
          fPalette->fColorBlue[pt + 1]  != fPalette->fColorBlue[pt + 1 + off]  ||
          fPalette->fColorAlpha[pt + 1] != fPalette->fColorAlpha[pt + 1 + off]) {
         fRampFactor = 2;
         break;
      }

   off = (fPalette->fNumPoints - 2) / 2;
   for (pt = 0; pt < Int_t(fPalette->fNumPoints - 2) / 2; pt++)
      if (fPalette->fColorRed[pt + 1]   != fPalette->fColorRed[pt + 1 + off]   ||
          fPalette->fColorGreen[pt + 1] != fPalette->fColorGreen[pt + 1 + off] ||
          fPalette->fColorBlue[pt + 1]  != fPalette->fColorBlue[pt + 1 + off]  ||
          fPalette->fColorAlpha[pt + 1] != fPalette->fColorAlpha[pt + 1 + off]) {
         fRampFactor = 1;
         break;
      }

   fRamps[0]->SetState(fRampFactor == 1 ? kButtonDown : kButtonUp);
   fRamps[1]->SetState(fRampFactor == 2 ? kButtonDown : kButtonUp);
   fRamps[2]->SetState(fRampFactor == 4 ? kButtonDown : kButtonUp);
}

//______________________________________________________________________________
void TASPaletteEditor::LogPalette()
{
   // The anchor points are rescaled by a log operation.
   // It is called by the log - button. Protected method.

   TImagePalette *newPalette = new TImagePalette(*fPalette);

   Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];

   for (Int_t pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
      newPalette->fPoints[pt] = fPalette->fPoints[1] +
         TMath::Log(fPalette->fPoints[pt] - fPalette->fPoints[1] + 1) /
         TMath::Log(delta + 1) * delta;

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::ExpPalette()
{
   // The anchor points are rescaled by a exp operation.
   // It is called by the exp - button. Protected method.

   TImagePalette *newPalette = new TImagePalette(*fPalette);

   Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];

   for (Int_t pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
      newPalette->fPoints[pt] = fPalette->fPoints[1] +
         TMath::Exp((fPalette->fPoints[pt] - fPalette->fPoints[1]) *
         TMath::Log(delta + 1) / delta) - 1;

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::LinPalette()
{
   // The anchor points are rescaled to be linar.
   // It is called by the lin - button. Protected method.

   TImagePalette *newPalette = new TImagePalette(*fPalette);

   Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
   if (fStepButton->GetState() == kButtonUp) {
      for (Int_t pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
         newPalette->fPoints[pt] = fPalette->fPoints[1] +
            delta * (pt - 1) / (fPalette->fNumPoints - 3);
   } else {
      for (Int_t pt = 0; pt < Int_t(fPalette->fNumPoints - 4); pt += 2) {
         newPalette->fPoints[pt + 3] = fPalette->fPoints[1] + delta * (pt + 2) /
                                       (fPalette->fNumPoints - 2) ;
         newPalette->fPoints[pt + 2] = newPalette->fPoints[pt + 3];
      }
   }

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::InvertPalette()
{
   // The palette is inverted.
   // It is called by the invert - button. Protected method.

   TImagePalette *newPalette = new TImagePalette(*fPalette);

   Int_t pt;
   for (pt = 0; pt < Int_t(fPalette->fNumPoints); pt++)  {
      newPalette->fColorRed[pt]   = fPalette->fColorRed[fPalette->fNumPoints - 1 - pt];
      newPalette->fColorGreen[pt] = fPalette->fColorGreen[fPalette->fNumPoints - 1 - pt];
      newPalette->fColorBlue[pt]  = fPalette->fColorBlue[fPalette->fNumPoints - 1 - pt];
      newPalette->fColorAlpha[pt] = fPalette->fColorAlpha[fPalette->fNumPoints - 1 - pt];
   }

   for (pt = 2; pt < Int_t(fPalette->fNumPoints - 2); pt++)
      newPalette->fPoints[pt] = fPalette->fPoints[1] +
         fPalette->fPoints[fPalette->fNumPoints - 2] -
         fPalette->fPoints[fPalette->fNumPoints - 1 - pt];

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::NewPalette(Long_t id)
{
   // A new palette is created, depending on the id.
   // It is called by the combo box. Protected method.

   if (id == 5) // empty entry
      return;

   TImagePalette *newPalette;

   Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
   UInt_t   numPt;

   numPt = id == 0 ? 12 : 13;
   newPalette = new TImagePalette(numPt);
   Int_t pt;
   for (pt = 1; pt < Int_t(numPt - 1); pt++) {
      newPalette->fPoints[pt] = fPalette->fPoints[1] + (pt - 1) * delta / (numPt - 3);
      newPalette->fColorAlpha[pt] = 0xffff;
   }

   switch (id) {
      case 0:  // rainbow
         memcpy(newPalette->fColorRed + 1,   gRedRainbow,   12 * sizeof(UShort_t));
         memcpy(newPalette->fColorGreen + 1, gGreenRainbow, 12 * sizeof(UShort_t));
         memcpy(newPalette->fColorBlue + 1,  gBlueRainbow,  12 * sizeof(UShort_t));
         break;

      case 1:  // gray
         for (pt = 1; pt < Int_t(numPt - 1); pt++) {
            newPalette->fColorRed[pt]   = 0xffff * (pt - 1) / (numPt - 3);
            newPalette->fColorGreen[pt] = 0xffff * (pt - 1) / (numPt - 3);
            newPalette->fColorBlue[pt]  = 0xffff * (pt - 1) / (numPt - 3);
         }
         break;

      case 2:  // hot (red)
         for (pt = 1; pt < Int_t(numPt - 1) / 2; pt++) {
            newPalette->fColorRed[pt]   = 0xffff * (pt - 1) / ((numPt - 3) / 2);
            newPalette->fColorGreen[pt] = 0;
            newPalette->fColorBlue[pt]  = 0;
         }

         for (; pt < Int_t(numPt - 1); pt++) {
            newPalette->fColorRed[pt]   = 0xffff;
            newPalette->fColorGreen[pt] = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
            newPalette->fColorBlue[pt]  = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
         }
         break;

      case 3:  // cold (blue)
         for (pt = 1; pt < Int_t(numPt - 1) / 2; pt++) {
            newPalette->fColorRed[pt]   = 0;
            newPalette->fColorGreen[pt] = 0;
            newPalette->fColorBlue[pt]  = 0xffff * (pt - 1) / ((numPt - 3) / 2);
         }

         for (; pt < Int_t(numPt - 1); pt++) {
            newPalette->fColorRed[pt]   = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
            newPalette->fColorGreen[pt] = 0xffff * (pt - (numPt - 1) / 2) / ((numPt - 3) / 2);
            newPalette->fColorBlue[pt]  = 0xffff;
         }
         break;

      case 4:  // bolwerhat
         for (pt = 1; pt < Int_t(numPt + 1) / 2; pt++) {
            newPalette->fColorRed[pt]   = newPalette->fColorRed[numPt - pt - 1]
                                        = 0xffff * (pt - 1) / ((numPt - 3) / 2);
            newPalette->fColorGreen[pt] = newPalette->fColorGreen[numPt - pt - 1]
                                        = 0xffff * (pt - 1) / ((numPt - 3) / 2);
            newPalette->fColorBlue[pt]  = newPalette->fColorBlue[numPt - pt - 1]
                                        = 0xffff * (pt - 1) / ((numPt - 3) / 2);
         }
         break;
   }

   newPalette->fPoints[0]     = 0;
   newPalette->fColorRed[0]   = newPalette->fColorRed[1];
   newPalette->fColorGreen[0] = newPalette->fColorGreen[1];
   newPalette->fColorBlue[0]  = newPalette->fColorBlue[1];
   newPalette->fColorAlpha[0] = newPalette->fColorAlpha[1];

   newPalette->fPoints[newPalette->fNumPoints-1]     = 1.0;
   newPalette->fColorRed[newPalette->fNumPoints-1]   = newPalette->fColorRed[newPalette->fNumPoints-2];
   newPalette->fColorGreen[newPalette->fNumPoints-1] = newPalette->fColorGreen[newPalette->fNumPoints-2];
   newPalette->fColorBlue[newPalette->fNumPoints-1]  = newPalette->fColorBlue[newPalette->fNumPoints-2];
   newPalette->fColorAlpha[newPalette->fNumPoints-1] = newPalette->fColorAlpha[newPalette->fNumPoints-2];

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::SetStep()
{
   // Create a step palette. This is called by the step - check button.
   // Protected method.

   TImagePalette *newPalette;

   if (fStepButton->GetState() == kButtonDown) {
      // change colors in steps
      newPalette = new TImagePalette(fPalette->fNumPoints * 2 - 2);
      Double_t fkt = (Double_t)(fPalette->fNumPoints - 3) / (fPalette->fNumPoints - 2);
      for (Int_t pt = 1; pt < Int_t(fPalette->fNumPoints - 1); pt++) {
         newPalette->fPoints[pt * 2 - 1] = fPalette->fPoints[1] + (fPalette->fPoints[pt] - fPalette->fPoints[1]) * fkt;
         newPalette->fPoints[pt * 2] = fPalette->fPoints[1] + (fPalette->fPoints[pt + 1] - fPalette->fPoints[1]) * fkt;
         newPalette->fColorRed[pt * 2 - 1]   = newPalette->fColorRed[pt * 2]   = fPalette->fColorRed[pt];
         newPalette->fColorGreen[pt * 2 - 1] = newPalette->fColorGreen[pt * 2] = fPalette->fColorGreen[pt];
         newPalette->fColorBlue[pt * 2 - 1]  = newPalette->fColorBlue[pt * 2]  = fPalette->fColorBlue[pt];
         newPalette->fColorAlpha[pt * 2 - 1] = newPalette->fColorAlpha[pt * 2] = fPalette->fColorAlpha[pt];
      }
   } else {
      // continuous change of colors
      newPalette = new TImagePalette(fPalette->fNumPoints / 2 + 1);
      Double_t fkt = (Double_t) (fPalette->fPoints[fPalette->fNumPoints - 2] - fPalette->fPoints[1]) /
                                (fPalette->fPoints[fPalette->fNumPoints - 3] - fPalette->fPoints[1]);
      for (Int_t pt = 1; pt < Int_t(newPalette->fNumPoints - 1); pt++) {
         newPalette->fPoints[pt] = fPalette->fPoints[pt * 2 -1] * fkt;
         newPalette->fColorRed[pt]   = fPalette->fColorRed[pt * 2 - 1];
         newPalette->fColorGreen[pt] = fPalette->fColorGreen[pt * 2 - 1];
         newPalette->fColorBlue[pt]  = fPalette->fColorBlue[pt * 2 - 1];
         newPalette->fColorAlpha[pt] = fPalette->fColorAlpha[pt * 2 - 1];
      }
   }

   newPalette->fPoints[0]     = fPalette->fPoints[0];
   newPalette->fColorRed[0]   = fPalette->fColorRed[0];
   newPalette->fColorGreen[0] = fPalette->fColorGreen[0];
   newPalette->fColorBlue[0]  = fPalette->fColorBlue[0];
   newPalette->fColorAlpha[0] = fPalette->fColorAlpha[0];

   newPalette->fPoints[newPalette->fNumPoints-2]     = fPalette->fPoints[fPalette->fNumPoints-2];
   newPalette->fPoints[newPalette->fNumPoints-1]     = fPalette->fPoints[fPalette->fNumPoints-1];
   newPalette->fColorRed[newPalette->fNumPoints-1]   = fPalette->fColorRed[fPalette->fNumPoints-1];
   newPalette->fColorGreen[newPalette->fNumPoints-1] = fPalette->fColorGreen[fPalette->fNumPoints-1];
   newPalette->fColorBlue[newPalette->fNumPoints-1]  = fPalette->fColorBlue[fPalette->fNumPoints-1];
   newPalette->fColorAlpha[newPalette->fNumPoints-1] = fPalette->fColorAlpha[fPalette->fNumPoints-1];

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::SetRamp(Long_t ramp)
{
   // The palette is repeated up to 4 times.
   // This is called by one of the ramp radio buttons. Protected method.

   if (ramp == fRampFactor)
      return;

   Int_t ptPerRamp = (fPalette->fNumPoints - 2) / fRampFactor;
   TImagePalette *newPalette = new TImagePalette(ptPerRamp * ramp + 2);

   Double_t delta = fPalette->fPoints[fPalette->fNumPoints-2] - fPalette->fPoints[1];
   for (Int_t rp = 0; rp < ramp; rp++) {
      for (Int_t pt = 0; pt < ptPerRamp; pt++) {
         newPalette->fPoints[1 + pt + rp * ptPerRamp] = fPalette->fPoints[1] +
              delta / ramp * rp +
              (fPalette->fPoints[1+pt] - fPalette->fPoints[1]) * fRampFactor / ramp;
         newPalette->fColorRed  [1 + pt + rp * ptPerRamp] = fPalette->fColorRed  [1 + pt];
         newPalette->fColorGreen[1 + pt + rp * ptPerRamp] = fPalette->fColorGreen[1 + pt];
         newPalette->fColorBlue [1 + pt + rp * ptPerRamp] = fPalette->fColorBlue [1 + pt];
         newPalette->fColorAlpha[1 + pt + rp * ptPerRamp] = fPalette->fColorAlpha[1 + pt];
      }
   }

   newPalette->fPoints[0]     = fPalette->fPoints[0];
   newPalette->fColorRed[0]   = fPalette->fColorRed[0];
   newPalette->fColorGreen[0] = fPalette->fColorGreen[0];
   newPalette->fColorBlue[0]  = fPalette->fColorBlue[0];
   newPalette->fColorAlpha[0] = fPalette->fColorAlpha[0];

   newPalette->fPoints[newPalette->fNumPoints-2]     = fPalette->fPoints[fPalette->fNumPoints-2];
   newPalette->fPoints[newPalette->fNumPoints-1]     = fPalette->fPoints[fPalette->fNumPoints-1];
   newPalette->fColorRed[newPalette->fNumPoints-1]   = fPalette->fColorRed[fPalette->fNumPoints-1];
   newPalette->fColorGreen[newPalette->fNumPoints-1] = fPalette->fColorGreen[fPalette->fNumPoints-1];
   newPalette->fColorBlue[newPalette->fNumPoints-1]  = fPalette->fColorBlue[fPalette->fNumPoints-1];
   newPalette->fColorAlpha[newPalette->fNumPoints-1] = fPalette->fColorAlpha[fPalette->fNumPoints-1];

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::UpdateRange()
{
   // Updates the range of the palette.
   // This is called after the blue limit lines were moved to define
   // a new range.

   if (fMaxValue == fMinValue)
      return;

   TImagePalette *newPalette = new TImagePalette(*fPalette);

   Double_t l0 = fLimitLine[0]->GetX1();
   Double_t l1 = fLimitLine[1]->GetX1();
   l0 = (l0 < fMinValue) ? fMinValue : ((l0 > fMaxValue) ?  fMaxValue : l0);
   l1 = (l1 < fMinValue) ? fMinValue : ((l1 > fMaxValue) ?  fMaxValue : l1);
   if (l0 > l1) {
      Double_t tmp = l0;
      l0 = l1;
      l1 = tmp;
   }

   Double_t oldDelta = fPalette->fPoints[fPalette->fNumPoints - 2] - fPalette->fPoints[1];
   Double_t newDelta = (l1 - l0) / (fMaxValue - fMinValue);
   Double_t newOff = (l0 - fMinValue) / (fMaxValue - fMinValue);

   if (newDelta < 0.001 || oldDelta < 0.001)
      return;

   for (Int_t pt = 1; pt < Int_t(fPalette->fNumPoints - 1); pt++)
      newPalette->fPoints[pt] = newOff +
            (fPalette->fPoints[pt] - fPalette->fPoints[1]) * newDelta / oldDelta;

   InsertNewPalette(newPalette);
   UpdateScreen(kFALSE);
}

//______________________________________________________________________________
void TASPaletteEditor::PaintPalette::Paint(Option_t *)
{
   // Actually paint the paletter.

   // get geometry of pad
   Int_t to_w = TMath::Abs(gPad->XtoPixel(gPad->GetX2()) -
                           gPad->XtoPixel(gPad->GetX1()));
   Int_t to_h = TMath::Abs(gPad->YtoPixel(gPad->GetY2()) -
                           gPad->YtoPixel(gPad->GetY1()));

   ASGradient grad;

   grad.npoints = (*fPalette)->fNumPoints - 2;
   grad.type = GRADIENT_Left2Right;
   grad.color = new ARGB32[grad.npoints];
   grad.offset = new double[grad.npoints];
   for (Int_t pt = 0; pt < grad.npoints; pt++) {
      grad.offset[pt] = ((*fPalette)->fPoints[pt + 1] - (*fPalette)->fPoints[1]) /
                        ((*fPalette)->fPoints[(*fPalette)->fNumPoints - 2] - (*fPalette)->fPoints[1]);
      grad.color[pt] = (((ARGB32)((*fPalette)->fColorBlue[pt + 1]   & 0xff00)) >>  8) |
                        (((ARGB32)((*fPalette)->fColorGreen[pt + 1] & 0xff00))      ) |
                        (((ARGB32)((*fPalette)->fColorRed[pt + 1]   & 0xff00)) <<  8) |
                        (((ARGB32)((*fPalette)->fColorAlpha[pt + 1] & 0xff00)) << 16);
   }

   ASImage * grad_im = make_gradient((ASVisual*)TASImage::GetVisual(), &grad , to_w, to_h,
                                     SCL_DO_COLOR, ASA_ARGB32, 0,
                                     fAttImage->GetImageQuality());
   delete [] grad.color;
   delete [] grad.offset;

   Window_t wid = (Window_t)gVirtualX->GetWindowID(gPad->GetPixmapID());
   TASImage::Image2Drawable(grad_im, wid, 0, 0);
   destroy_asimage(&grad_im);
}

//______________________________________________________________________________
TASPaletteEditor::LimitLine::LimitLine(Coord_t x, Coord_t y1, Coord_t y2,
                                       TASPaletteEditor *gui)
   : TLine(x, y1, x, y2)
{
   // The blue limit line in the pixel value histogram.

   fGui = gui;
   SetLineColor(4);
   SetLineWidth(2);
}

//______________________________________________________________________________
void TASPaletteEditor::LimitLine::Paint(Option_t *option)
{
   // Paint the limit lines.

   fY1 = gPad->GetUymin();
   fY2 = gPad->GetUymax();

   TLine::Paint(option);
}

//______________________________________________________________________________
void TASPaletteEditor::LimitLine::ExecuteEvent(Int_t event,
                                               Int_t px, Int_t /*py*/)
{
   static Int_t oldX;

   if (!gPad) return;

   switch(event) {
      case kMouseMotion:
         gPad->SetCursor(kMove);
         break;

      case kButton1Down:
         gVirtualX->SetLineColor(-1);
         TAttLine::Modify();  //Change line attributes only if necessary
         oldX = gPad->XtoAbsPixel(fX1);
         break;

      case kButton1Motion:
         gVirtualX->DrawLine(oldX, gPad->YtoPixel(fY1), oldX, gPad->YtoPixel(fY2));
         oldX = px;
         gVirtualX->DrawLine(oldX, gPad->YtoPixel(fY1), oldX, gPad->YtoPixel(fY2));
         gVirtualX->Update();
         break;

      case kButton1Up:
         gVirtualX->SetLineColor(-1);
         TAttLine::Modify();  //Change line attributes only if necessary
         fX1 = fX2 = gPad->AbsPixeltoX(oldX);
         fGui->UpdateRange();
         gPad->Modified(kTRUE);
         gPad->Update();
         break;

      default:
         break;
   }
}
 TASPaletteEditor.cxx:1
 TASPaletteEditor.cxx:2
 TASPaletteEditor.cxx:3
 TASPaletteEditor.cxx:4
 TASPaletteEditor.cxx:5
 TASPaletteEditor.cxx:6
 TASPaletteEditor.cxx:7
 TASPaletteEditor.cxx:8
 TASPaletteEditor.cxx:9
 TASPaletteEditor.cxx:10
 TASPaletteEditor.cxx:11
 TASPaletteEditor.cxx:12
 TASPaletteEditor.cxx:13
 TASPaletteEditor.cxx:14
 TASPaletteEditor.cxx:15
 TASPaletteEditor.cxx:16
 TASPaletteEditor.cxx:17
 TASPaletteEditor.cxx:18
 TASPaletteEditor.cxx:19
 TASPaletteEditor.cxx:20
 TASPaletteEditor.cxx:21
 TASPaletteEditor.cxx:22
 TASPaletteEditor.cxx:23
 TASPaletteEditor.cxx:24
 TASPaletteEditor.cxx:25
 TASPaletteEditor.cxx:26
 TASPaletteEditor.cxx:27
 TASPaletteEditor.cxx:28
 TASPaletteEditor.cxx:29
 TASPaletteEditor.cxx:30
 TASPaletteEditor.cxx:31
 TASPaletteEditor.cxx:32
 TASPaletteEditor.cxx:33
 TASPaletteEditor.cxx:34
 TASPaletteEditor.cxx:35
 TASPaletteEditor.cxx:36
 TASPaletteEditor.cxx:37
 TASPaletteEditor.cxx:38
 TASPaletteEditor.cxx:39
 TASPaletteEditor.cxx:40
 TASPaletteEditor.cxx:41
 TASPaletteEditor.cxx:42
 TASPaletteEditor.cxx:43
 TASPaletteEditor.cxx:44
 TASPaletteEditor.cxx:45
 TASPaletteEditor.cxx:46
 TASPaletteEditor.cxx:47
 TASPaletteEditor.cxx:48
 TASPaletteEditor.cxx:49
 TASPaletteEditor.cxx:50
 TASPaletteEditor.cxx:51
 TASPaletteEditor.cxx:52
 TASPaletteEditor.cxx:53
 TASPaletteEditor.cxx:54
 TASPaletteEditor.cxx:55
 TASPaletteEditor.cxx:56
 TASPaletteEditor.cxx:57
 TASPaletteEditor.cxx:58
 TASPaletteEditor.cxx:59
 TASPaletteEditor.cxx:60
 TASPaletteEditor.cxx:61
 TASPaletteEditor.cxx:62
 TASPaletteEditor.cxx:63
 TASPaletteEditor.cxx:64
 TASPaletteEditor.cxx:65
 TASPaletteEditor.cxx:66
 TASPaletteEditor.cxx:67
 TASPaletteEditor.cxx:68
 TASPaletteEditor.cxx:69
 TASPaletteEditor.cxx:70
 TASPaletteEditor.cxx:71
 TASPaletteEditor.cxx:72
 TASPaletteEditor.cxx:73
 TASPaletteEditor.cxx:74
 TASPaletteEditor.cxx:75
 TASPaletteEditor.cxx:76
 TASPaletteEditor.cxx:77
 TASPaletteEditor.cxx:78
 TASPaletteEditor.cxx:79
 TASPaletteEditor.cxx:80
 TASPaletteEditor.cxx:81
 TASPaletteEditor.cxx:82
 TASPaletteEditor.cxx:83
 TASPaletteEditor.cxx:84
 TASPaletteEditor.cxx:85
 TASPaletteEditor.cxx:86
 TASPaletteEditor.cxx:87
 TASPaletteEditor.cxx:88
 TASPaletteEditor.cxx:89
 TASPaletteEditor.cxx:90
 TASPaletteEditor.cxx:91
 TASPaletteEditor.cxx:92
 TASPaletteEditor.cxx:93
 TASPaletteEditor.cxx:94
 TASPaletteEditor.cxx:95
 TASPaletteEditor.cxx:96
 TASPaletteEditor.cxx:97
 TASPaletteEditor.cxx:98
 TASPaletteEditor.cxx:99
 TASPaletteEditor.cxx:100
 TASPaletteEditor.cxx:101
 TASPaletteEditor.cxx:102
 TASPaletteEditor.cxx:103
 TASPaletteEditor.cxx:104
 TASPaletteEditor.cxx:105
 TASPaletteEditor.cxx:106
 TASPaletteEditor.cxx:107
 TASPaletteEditor.cxx:108
 TASPaletteEditor.cxx:109
 TASPaletteEditor.cxx:110
 TASPaletteEditor.cxx:111
 TASPaletteEditor.cxx:112
 TASPaletteEditor.cxx:113
 TASPaletteEditor.cxx:114
 TASPaletteEditor.cxx:115
 TASPaletteEditor.cxx:116
 TASPaletteEditor.cxx:117
 TASPaletteEditor.cxx:118
 TASPaletteEditor.cxx:119
 TASPaletteEditor.cxx:120
 TASPaletteEditor.cxx:121
 TASPaletteEditor.cxx:122
 TASPaletteEditor.cxx:123
 TASPaletteEditor.cxx:124
 TASPaletteEditor.cxx:125
 TASPaletteEditor.cxx:126
 TASPaletteEditor.cxx:127
 TASPaletteEditor.cxx:128
 TASPaletteEditor.cxx:129
 TASPaletteEditor.cxx:130
 TASPaletteEditor.cxx:131
 TASPaletteEditor.cxx:132
 TASPaletteEditor.cxx:133
 TASPaletteEditor.cxx:134
 TASPaletteEditor.cxx:135
 TASPaletteEditor.cxx:136
 TASPaletteEditor.cxx:137
 TASPaletteEditor.cxx:138
 TASPaletteEditor.cxx:139
 TASPaletteEditor.cxx:140
 TASPaletteEditor.cxx:141
 TASPaletteEditor.cxx:142
 TASPaletteEditor.cxx:143
 TASPaletteEditor.cxx:144
 TASPaletteEditor.cxx:145
 TASPaletteEditor.cxx:146
 TASPaletteEditor.cxx:147
 TASPaletteEditor.cxx:148
 TASPaletteEditor.cxx:149
 TASPaletteEditor.cxx:150
 TASPaletteEditor.cxx:151
 TASPaletteEditor.cxx:152
 TASPaletteEditor.cxx:153
 TASPaletteEditor.cxx:154
 TASPaletteEditor.cxx:155
 TASPaletteEditor.cxx:156
 TASPaletteEditor.cxx:157
 TASPaletteEditor.cxx:158
 TASPaletteEditor.cxx:159
 TASPaletteEditor.cxx:160
 TASPaletteEditor.cxx:161
 TASPaletteEditor.cxx:162
 TASPaletteEditor.cxx:163
 TASPaletteEditor.cxx:164
 TASPaletteEditor.cxx:165
 TASPaletteEditor.cxx:166
 TASPaletteEditor.cxx:167
 TASPaletteEditor.cxx:168
 TASPaletteEditor.cxx:169
 TASPaletteEditor.cxx:170
 TASPaletteEditor.cxx:171
 TASPaletteEditor.cxx:172
 TASPaletteEditor.cxx:173
 TASPaletteEditor.cxx:174
 TASPaletteEditor.cxx:175
 TASPaletteEditor.cxx:176
 TASPaletteEditor.cxx:177
 TASPaletteEditor.cxx:178
 TASPaletteEditor.cxx:179
 TASPaletteEditor.cxx:180
 TASPaletteEditor.cxx:181
 TASPaletteEditor.cxx:182
 TASPaletteEditor.cxx:183
 TASPaletteEditor.cxx:184
 TASPaletteEditor.cxx:185
 TASPaletteEditor.cxx:186
 TASPaletteEditor.cxx:187
 TASPaletteEditor.cxx:188
 TASPaletteEditor.cxx:189
 TASPaletteEditor.cxx:190
 TASPaletteEditor.cxx:191
 TASPaletteEditor.cxx:192
 TASPaletteEditor.cxx:193
 TASPaletteEditor.cxx:194
 TASPaletteEditor.cxx:195
 TASPaletteEditor.cxx:196
 TASPaletteEditor.cxx:197
 TASPaletteEditor.cxx:198
 TASPaletteEditor.cxx:199
 TASPaletteEditor.cxx:200
 TASPaletteEditor.cxx:201
 TASPaletteEditor.cxx:202
 TASPaletteEditor.cxx:203
 TASPaletteEditor.cxx:204
 TASPaletteEditor.cxx:205
 TASPaletteEditor.cxx:206
 TASPaletteEditor.cxx:207
 TASPaletteEditor.cxx:208
 TASPaletteEditor.cxx:209
 TASPaletteEditor.cxx:210
 TASPaletteEditor.cxx:211
 TASPaletteEditor.cxx:212
 TASPaletteEditor.cxx:213
 TASPaletteEditor.cxx:214
 TASPaletteEditor.cxx:215
 TASPaletteEditor.cxx:216
 TASPaletteEditor.cxx:217
 TASPaletteEditor.cxx:218
 TASPaletteEditor.cxx:219
 TASPaletteEditor.cxx:220
 TASPaletteEditor.cxx:221
 TASPaletteEditor.cxx:222
 TASPaletteEditor.cxx:223
 TASPaletteEditor.cxx:224
 TASPaletteEditor.cxx:225
 TASPaletteEditor.cxx:226
 TASPaletteEditor.cxx:227
 TASPaletteEditor.cxx:228
 TASPaletteEditor.cxx:229
 TASPaletteEditor.cxx:230
 TASPaletteEditor.cxx:231
 TASPaletteEditor.cxx:232
 TASPaletteEditor.cxx:233
 TASPaletteEditor.cxx:234
 TASPaletteEditor.cxx:235
 TASPaletteEditor.cxx:236
 TASPaletteEditor.cxx:237
 TASPaletteEditor.cxx:238
 TASPaletteEditor.cxx:239
 TASPaletteEditor.cxx:240
 TASPaletteEditor.cxx:241
 TASPaletteEditor.cxx:242
 TASPaletteEditor.cxx:243
 TASPaletteEditor.cxx:244
 TASPaletteEditor.cxx:245
 TASPaletteEditor.cxx:246
 TASPaletteEditor.cxx:247
 TASPaletteEditor.cxx:248
 TASPaletteEditor.cxx:249
 TASPaletteEditor.cxx:250
 TASPaletteEditor.cxx:251
 TASPaletteEditor.cxx:252
 TASPaletteEditor.cxx:253
 TASPaletteEditor.cxx:254
 TASPaletteEditor.cxx:255
 TASPaletteEditor.cxx:256
 TASPaletteEditor.cxx:257
 TASPaletteEditor.cxx:258
 TASPaletteEditor.cxx:259
 TASPaletteEditor.cxx:260
 TASPaletteEditor.cxx:261
 TASPaletteEditor.cxx:262
 TASPaletteEditor.cxx:263
 TASPaletteEditor.cxx:264
 TASPaletteEditor.cxx:265
 TASPaletteEditor.cxx:266
 TASPaletteEditor.cxx:267
 TASPaletteEditor.cxx:268
 TASPaletteEditor.cxx:269
 TASPaletteEditor.cxx:270
 TASPaletteEditor.cxx:271
 TASPaletteEditor.cxx:272
 TASPaletteEditor.cxx:273
 TASPaletteEditor.cxx:274
 TASPaletteEditor.cxx:275
 TASPaletteEditor.cxx:276
 TASPaletteEditor.cxx:277
 TASPaletteEditor.cxx:278
 TASPaletteEditor.cxx:279
 TASPaletteEditor.cxx:280
 TASPaletteEditor.cxx:281
 TASPaletteEditor.cxx:282
 TASPaletteEditor.cxx:283
 TASPaletteEditor.cxx:284
 TASPaletteEditor.cxx:285
 TASPaletteEditor.cxx:286
 TASPaletteEditor.cxx:287
 TASPaletteEditor.cxx:288
 TASPaletteEditor.cxx:289
 TASPaletteEditor.cxx:290
 TASPaletteEditor.cxx:291
 TASPaletteEditor.cxx:292
 TASPaletteEditor.cxx:293
 TASPaletteEditor.cxx:294
 TASPaletteEditor.cxx:295
 TASPaletteEditor.cxx:296
 TASPaletteEditor.cxx:297
 TASPaletteEditor.cxx:298
 TASPaletteEditor.cxx:299
 TASPaletteEditor.cxx:300
 TASPaletteEditor.cxx:301
 TASPaletteEditor.cxx:302
 TASPaletteEditor.cxx:303
 TASPaletteEditor.cxx:304
 TASPaletteEditor.cxx:305
 TASPaletteEditor.cxx:306
 TASPaletteEditor.cxx:307
 TASPaletteEditor.cxx:308
 TASPaletteEditor.cxx:309
 TASPaletteEditor.cxx:310
 TASPaletteEditor.cxx:311
 TASPaletteEditor.cxx:312
 TASPaletteEditor.cxx:313
 TASPaletteEditor.cxx:314
 TASPaletteEditor.cxx:315
 TASPaletteEditor.cxx:316
 TASPaletteEditor.cxx:317
 TASPaletteEditor.cxx:318
 TASPaletteEditor.cxx:319
 TASPaletteEditor.cxx:320
 TASPaletteEditor.cxx:321
 TASPaletteEditor.cxx:322
 TASPaletteEditor.cxx:323
 TASPaletteEditor.cxx:324
 TASPaletteEditor.cxx:325
 TASPaletteEditor.cxx:326
 TASPaletteEditor.cxx:327
 TASPaletteEditor.cxx:328
 TASPaletteEditor.cxx:329
 TASPaletteEditor.cxx:330
 TASPaletteEditor.cxx:331
 TASPaletteEditor.cxx:332
 TASPaletteEditor.cxx:333
 TASPaletteEditor.cxx:334
 TASPaletteEditor.cxx:335
 TASPaletteEditor.cxx:336
 TASPaletteEditor.cxx:337
 TASPaletteEditor.cxx:338
 TASPaletteEditor.cxx:339
 TASPaletteEditor.cxx:340
 TASPaletteEditor.cxx:341
 TASPaletteEditor.cxx:342
 TASPaletteEditor.cxx:343
 TASPaletteEditor.cxx:344
 TASPaletteEditor.cxx:345
 TASPaletteEditor.cxx:346
 TASPaletteEditor.cxx:347
 TASPaletteEditor.cxx:348
 TASPaletteEditor.cxx:349
 TASPaletteEditor.cxx:350
 TASPaletteEditor.cxx:351
 TASPaletteEditor.cxx:352
 TASPaletteEditor.cxx:353
 TASPaletteEditor.cxx:354
 TASPaletteEditor.cxx:355
 TASPaletteEditor.cxx:356
 TASPaletteEditor.cxx:357
 TASPaletteEditor.cxx:358
 TASPaletteEditor.cxx:359
 TASPaletteEditor.cxx:360
 TASPaletteEditor.cxx:361
 TASPaletteEditor.cxx:362
 TASPaletteEditor.cxx:363
 TASPaletteEditor.cxx:364
 TASPaletteEditor.cxx:365
 TASPaletteEditor.cxx:366
 TASPaletteEditor.cxx:367
 TASPaletteEditor.cxx:368
 TASPaletteEditor.cxx:369
 TASPaletteEditor.cxx:370
 TASPaletteEditor.cxx:371
 TASPaletteEditor.cxx:372
 TASPaletteEditor.cxx:373
 TASPaletteEditor.cxx:374
 TASPaletteEditor.cxx:375
 TASPaletteEditor.cxx:376
 TASPaletteEditor.cxx:377
 TASPaletteEditor.cxx:378
 TASPaletteEditor.cxx:379
 TASPaletteEditor.cxx:380
 TASPaletteEditor.cxx:381
 TASPaletteEditor.cxx:382
 TASPaletteEditor.cxx:383
 TASPaletteEditor.cxx:384
 TASPaletteEditor.cxx:385
 TASPaletteEditor.cxx:386
 TASPaletteEditor.cxx:387
 TASPaletteEditor.cxx:388
 TASPaletteEditor.cxx:389
 TASPaletteEditor.cxx:390
 TASPaletteEditor.cxx:391
 TASPaletteEditor.cxx:392
 TASPaletteEditor.cxx:393
 TASPaletteEditor.cxx:394
 TASPaletteEditor.cxx:395
 TASPaletteEditor.cxx:396
 TASPaletteEditor.cxx:397
 TASPaletteEditor.cxx:398
 TASPaletteEditor.cxx:399
 TASPaletteEditor.cxx:400
 TASPaletteEditor.cxx:401
 TASPaletteEditor.cxx:402
 TASPaletteEditor.cxx:403
 TASPaletteEditor.cxx:404
 TASPaletteEditor.cxx:405
 TASPaletteEditor.cxx:406
 TASPaletteEditor.cxx:407
 TASPaletteEditor.cxx:408
 TASPaletteEditor.cxx:409
 TASPaletteEditor.cxx:410
 TASPaletteEditor.cxx:411
 TASPaletteEditor.cxx:412
 TASPaletteEditor.cxx:413
 TASPaletteEditor.cxx:414
 TASPaletteEditor.cxx:415
 TASPaletteEditor.cxx:416
 TASPaletteEditor.cxx:417
 TASPaletteEditor.cxx:418
 TASPaletteEditor.cxx:419
 TASPaletteEditor.cxx:420
 TASPaletteEditor.cxx:421
 TASPaletteEditor.cxx:422
 TASPaletteEditor.cxx:423
 TASPaletteEditor.cxx:424
 TASPaletteEditor.cxx:425
 TASPaletteEditor.cxx:426
 TASPaletteEditor.cxx:427
 TASPaletteEditor.cxx:428
 TASPaletteEditor.cxx:429
 TASPaletteEditor.cxx:430
 TASPaletteEditor.cxx:431
 TASPaletteEditor.cxx:432
 TASPaletteEditor.cxx:433
 TASPaletteEditor.cxx:434
 TASPaletteEditor.cxx:435
 TASPaletteEditor.cxx:436
 TASPaletteEditor.cxx:437
 TASPaletteEditor.cxx:438
 TASPaletteEditor.cxx:439
 TASPaletteEditor.cxx:440
 TASPaletteEditor.cxx:441
 TASPaletteEditor.cxx:442
 TASPaletteEditor.cxx:443
 TASPaletteEditor.cxx:444
 TASPaletteEditor.cxx:445
 TASPaletteEditor.cxx:446
 TASPaletteEditor.cxx:447
 TASPaletteEditor.cxx:448
 TASPaletteEditor.cxx:449
 TASPaletteEditor.cxx:450
 TASPaletteEditor.cxx:451
 TASPaletteEditor.cxx:452
 TASPaletteEditor.cxx:453
 TASPaletteEditor.cxx:454
 TASPaletteEditor.cxx:455
 TASPaletteEditor.cxx:456
 TASPaletteEditor.cxx:457
 TASPaletteEditor.cxx:458
 TASPaletteEditor.cxx:459
 TASPaletteEditor.cxx:460
 TASPaletteEditor.cxx:461
 TASPaletteEditor.cxx:462
 TASPaletteEditor.cxx:463
 TASPaletteEditor.cxx:464
 TASPaletteEditor.cxx:465
 TASPaletteEditor.cxx:466
 TASPaletteEditor.cxx:467
 TASPaletteEditor.cxx:468
 TASPaletteEditor.cxx:469
 TASPaletteEditor.cxx:470
 TASPaletteEditor.cxx:471
 TASPaletteEditor.cxx:472
 TASPaletteEditor.cxx:473
 TASPaletteEditor.cxx:474
 TASPaletteEditor.cxx:475
 TASPaletteEditor.cxx:476
 TASPaletteEditor.cxx:477
 TASPaletteEditor.cxx:478
 TASPaletteEditor.cxx:479
 TASPaletteEditor.cxx:480
 TASPaletteEditor.cxx:481
 TASPaletteEditor.cxx:482
 TASPaletteEditor.cxx:483
 TASPaletteEditor.cxx:484
 TASPaletteEditor.cxx:485
 TASPaletteEditor.cxx:486
 TASPaletteEditor.cxx:487
 TASPaletteEditor.cxx:488
 TASPaletteEditor.cxx:489
 TASPaletteEditor.cxx:490
 TASPaletteEditor.cxx:491
 TASPaletteEditor.cxx:492
 TASPaletteEditor.cxx:493
 TASPaletteEditor.cxx:494
 TASPaletteEditor.cxx:495
 TASPaletteEditor.cxx:496
 TASPaletteEditor.cxx:497
 TASPaletteEditor.cxx:498
 TASPaletteEditor.cxx:499
 TASPaletteEditor.cxx:500
 TASPaletteEditor.cxx:501
 TASPaletteEditor.cxx:502
 TASPaletteEditor.cxx:503
 TASPaletteEditor.cxx:504
 TASPaletteEditor.cxx:505
 TASPaletteEditor.cxx:506
 TASPaletteEditor.cxx:507
 TASPaletteEditor.cxx:508
 TASPaletteEditor.cxx:509
 TASPaletteEditor.cxx:510
 TASPaletteEditor.cxx:511
 TASPaletteEditor.cxx:512
 TASPaletteEditor.cxx:513
 TASPaletteEditor.cxx:514
 TASPaletteEditor.cxx:515
 TASPaletteEditor.cxx:516
 TASPaletteEditor.cxx:517
 TASPaletteEditor.cxx:518
 TASPaletteEditor.cxx:519
 TASPaletteEditor.cxx:520
 TASPaletteEditor.cxx:521
 TASPaletteEditor.cxx:522
 TASPaletteEditor.cxx:523
 TASPaletteEditor.cxx:524
 TASPaletteEditor.cxx:525
 TASPaletteEditor.cxx:526
 TASPaletteEditor.cxx:527
 TASPaletteEditor.cxx:528
 TASPaletteEditor.cxx:529
 TASPaletteEditor.cxx:530
 TASPaletteEditor.cxx:531
 TASPaletteEditor.cxx:532
 TASPaletteEditor.cxx:533
 TASPaletteEditor.cxx:534
 TASPaletteEditor.cxx:535
 TASPaletteEditor.cxx:536
 TASPaletteEditor.cxx:537
 TASPaletteEditor.cxx:538
 TASPaletteEditor.cxx:539
 TASPaletteEditor.cxx:540
 TASPaletteEditor.cxx:541
 TASPaletteEditor.cxx:542
 TASPaletteEditor.cxx:543
 TASPaletteEditor.cxx:544
 TASPaletteEditor.cxx:545
 TASPaletteEditor.cxx:546
 TASPaletteEditor.cxx:547
 TASPaletteEditor.cxx:548
 TASPaletteEditor.cxx:549
 TASPaletteEditor.cxx:550
 TASPaletteEditor.cxx:551
 TASPaletteEditor.cxx:552
 TASPaletteEditor.cxx:553
 TASPaletteEditor.cxx:554
 TASPaletteEditor.cxx:555
 TASPaletteEditor.cxx:556
 TASPaletteEditor.cxx:557
 TASPaletteEditor.cxx:558
 TASPaletteEditor.cxx:559
 TASPaletteEditor.cxx:560
 TASPaletteEditor.cxx:561
 TASPaletteEditor.cxx:562
 TASPaletteEditor.cxx:563
 TASPaletteEditor.cxx:564
 TASPaletteEditor.cxx:565
 TASPaletteEditor.cxx:566
 TASPaletteEditor.cxx:567
 TASPaletteEditor.cxx:568
 TASPaletteEditor.cxx:569
 TASPaletteEditor.cxx:570
 TASPaletteEditor.cxx:571
 TASPaletteEditor.cxx:572
 TASPaletteEditor.cxx:573
 TASPaletteEditor.cxx:574
 TASPaletteEditor.cxx:575
 TASPaletteEditor.cxx:576
 TASPaletteEditor.cxx:577
 TASPaletteEditor.cxx:578
 TASPaletteEditor.cxx:579
 TASPaletteEditor.cxx:580
 TASPaletteEditor.cxx:581
 TASPaletteEditor.cxx:582
 TASPaletteEditor.cxx:583
 TASPaletteEditor.cxx:584
 TASPaletteEditor.cxx:585
 TASPaletteEditor.cxx:586
 TASPaletteEditor.cxx:587
 TASPaletteEditor.cxx:588
 TASPaletteEditor.cxx:589
 TASPaletteEditor.cxx:590
 TASPaletteEditor.cxx:591
 TASPaletteEditor.cxx:592
 TASPaletteEditor.cxx:593
 TASPaletteEditor.cxx:594
 TASPaletteEditor.cxx:595
 TASPaletteEditor.cxx:596
 TASPaletteEditor.cxx:597
 TASPaletteEditor.cxx:598
 TASPaletteEditor.cxx:599
 TASPaletteEditor.cxx:600
 TASPaletteEditor.cxx:601
 TASPaletteEditor.cxx:602
 TASPaletteEditor.cxx:603
 TASPaletteEditor.cxx:604
 TASPaletteEditor.cxx:605
 TASPaletteEditor.cxx:606
 TASPaletteEditor.cxx:607
 TASPaletteEditor.cxx:608
 TASPaletteEditor.cxx:609
 TASPaletteEditor.cxx:610
 TASPaletteEditor.cxx:611
 TASPaletteEditor.cxx:612
 TASPaletteEditor.cxx:613
 TASPaletteEditor.cxx:614
 TASPaletteEditor.cxx:615
 TASPaletteEditor.cxx:616
 TASPaletteEditor.cxx:617
 TASPaletteEditor.cxx:618
 TASPaletteEditor.cxx:619
 TASPaletteEditor.cxx:620
 TASPaletteEditor.cxx:621
 TASPaletteEditor.cxx:622
 TASPaletteEditor.cxx:623
 TASPaletteEditor.cxx:624
 TASPaletteEditor.cxx:625
 TASPaletteEditor.cxx:626
 TASPaletteEditor.cxx:627
 TASPaletteEditor.cxx:628
 TASPaletteEditor.cxx:629
 TASPaletteEditor.cxx:630
 TASPaletteEditor.cxx:631
 TASPaletteEditor.cxx:632
 TASPaletteEditor.cxx:633
 TASPaletteEditor.cxx:634
 TASPaletteEditor.cxx:635
 TASPaletteEditor.cxx:636
 TASPaletteEditor.cxx:637
 TASPaletteEditor.cxx:638
 TASPaletteEditor.cxx:639
 TASPaletteEditor.cxx:640
 TASPaletteEditor.cxx:641
 TASPaletteEditor.cxx:642
 TASPaletteEditor.cxx:643
 TASPaletteEditor.cxx:644
 TASPaletteEditor.cxx:645
 TASPaletteEditor.cxx:646
 TASPaletteEditor.cxx:647
 TASPaletteEditor.cxx:648
 TASPaletteEditor.cxx:649
 TASPaletteEditor.cxx:650
 TASPaletteEditor.cxx:651
 TASPaletteEditor.cxx:652
 TASPaletteEditor.cxx:653
 TASPaletteEditor.cxx:654
 TASPaletteEditor.cxx:655
 TASPaletteEditor.cxx:656
 TASPaletteEditor.cxx:657
 TASPaletteEditor.cxx:658
 TASPaletteEditor.cxx:659
 TASPaletteEditor.cxx:660
 TASPaletteEditor.cxx:661
 TASPaletteEditor.cxx:662
 TASPaletteEditor.cxx:663
 TASPaletteEditor.cxx:664
 TASPaletteEditor.cxx:665
 TASPaletteEditor.cxx:666
 TASPaletteEditor.cxx:667
 TASPaletteEditor.cxx:668
 TASPaletteEditor.cxx:669
 TASPaletteEditor.cxx:670
 TASPaletteEditor.cxx:671
 TASPaletteEditor.cxx:672
 TASPaletteEditor.cxx:673
 TASPaletteEditor.cxx:674
 TASPaletteEditor.cxx:675
 TASPaletteEditor.cxx:676
 TASPaletteEditor.cxx:677
 TASPaletteEditor.cxx:678
 TASPaletteEditor.cxx:679
 TASPaletteEditor.cxx:680
 TASPaletteEditor.cxx:681
 TASPaletteEditor.cxx:682
 TASPaletteEditor.cxx:683
 TASPaletteEditor.cxx:684
 TASPaletteEditor.cxx:685
 TASPaletteEditor.cxx:686
 TASPaletteEditor.cxx:687
 TASPaletteEditor.cxx:688
 TASPaletteEditor.cxx:689
 TASPaletteEditor.cxx:690
 TASPaletteEditor.cxx:691
 TASPaletteEditor.cxx:692
 TASPaletteEditor.cxx:693
 TASPaletteEditor.cxx:694
 TASPaletteEditor.cxx:695
 TASPaletteEditor.cxx:696
 TASPaletteEditor.cxx:697
 TASPaletteEditor.cxx:698
 TASPaletteEditor.cxx:699
 TASPaletteEditor.cxx:700
 TASPaletteEditor.cxx:701
 TASPaletteEditor.cxx:702
 TASPaletteEditor.cxx:703
 TASPaletteEditor.cxx:704
 TASPaletteEditor.cxx:705
 TASPaletteEditor.cxx:706
 TASPaletteEditor.cxx:707
 TASPaletteEditor.cxx:708
 TASPaletteEditor.cxx:709
 TASPaletteEditor.cxx:710
 TASPaletteEditor.cxx:711
 TASPaletteEditor.cxx:712
 TASPaletteEditor.cxx:713
 TASPaletteEditor.cxx:714
 TASPaletteEditor.cxx:715
 TASPaletteEditor.cxx:716
 TASPaletteEditor.cxx:717
 TASPaletteEditor.cxx:718
 TASPaletteEditor.cxx:719
 TASPaletteEditor.cxx:720
 TASPaletteEditor.cxx:721
 TASPaletteEditor.cxx:722
 TASPaletteEditor.cxx:723
 TASPaletteEditor.cxx:724
 TASPaletteEditor.cxx:725
 TASPaletteEditor.cxx:726
 TASPaletteEditor.cxx:727
 TASPaletteEditor.cxx:728
 TASPaletteEditor.cxx:729
 TASPaletteEditor.cxx:730
 TASPaletteEditor.cxx:731
 TASPaletteEditor.cxx:732
 TASPaletteEditor.cxx:733
 TASPaletteEditor.cxx:734
 TASPaletteEditor.cxx:735
 TASPaletteEditor.cxx:736
 TASPaletteEditor.cxx:737
 TASPaletteEditor.cxx:738
 TASPaletteEditor.cxx:739
 TASPaletteEditor.cxx:740
 TASPaletteEditor.cxx:741
 TASPaletteEditor.cxx:742
 TASPaletteEditor.cxx:743
 TASPaletteEditor.cxx:744
 TASPaletteEditor.cxx:745
 TASPaletteEditor.cxx:746
 TASPaletteEditor.cxx:747
 TASPaletteEditor.cxx:748
 TASPaletteEditor.cxx:749
 TASPaletteEditor.cxx:750
 TASPaletteEditor.cxx:751
 TASPaletteEditor.cxx:752
 TASPaletteEditor.cxx:753
 TASPaletteEditor.cxx:754
 TASPaletteEditor.cxx:755
 TASPaletteEditor.cxx:756
 TASPaletteEditor.cxx:757
 TASPaletteEditor.cxx:758
 TASPaletteEditor.cxx:759
 TASPaletteEditor.cxx:760
 TASPaletteEditor.cxx:761
 TASPaletteEditor.cxx:762
 TASPaletteEditor.cxx:763
 TASPaletteEditor.cxx:764
 TASPaletteEditor.cxx:765
 TASPaletteEditor.cxx:766
 TASPaletteEditor.cxx:767
 TASPaletteEditor.cxx:768
 TASPaletteEditor.cxx:769
 TASPaletteEditor.cxx:770
 TASPaletteEditor.cxx:771
 TASPaletteEditor.cxx:772
 TASPaletteEditor.cxx:773
 TASPaletteEditor.cxx:774
 TASPaletteEditor.cxx:775
 TASPaletteEditor.cxx:776
 TASPaletteEditor.cxx:777
 TASPaletteEditor.cxx:778
 TASPaletteEditor.cxx:779
 TASPaletteEditor.cxx:780
 TASPaletteEditor.cxx:781
 TASPaletteEditor.cxx:782
 TASPaletteEditor.cxx:783
 TASPaletteEditor.cxx:784
 TASPaletteEditor.cxx:785
 TASPaletteEditor.cxx:786
 TASPaletteEditor.cxx:787
 TASPaletteEditor.cxx:788
 TASPaletteEditor.cxx:789
 TASPaletteEditor.cxx:790
 TASPaletteEditor.cxx:791
 TASPaletteEditor.cxx:792
 TASPaletteEditor.cxx:793
 TASPaletteEditor.cxx:794
 TASPaletteEditor.cxx:795
 TASPaletteEditor.cxx:796
 TASPaletteEditor.cxx:797
 TASPaletteEditor.cxx:798
 TASPaletteEditor.cxx:799
 TASPaletteEditor.cxx:800
 TASPaletteEditor.cxx:801
 TASPaletteEditor.cxx:802
 TASPaletteEditor.cxx:803
 TASPaletteEditor.cxx:804
 TASPaletteEditor.cxx:805
 TASPaletteEditor.cxx:806
 TASPaletteEditor.cxx:807
 TASPaletteEditor.cxx:808
 TASPaletteEditor.cxx:809
 TASPaletteEditor.cxx:810
 TASPaletteEditor.cxx:811
 TASPaletteEditor.cxx:812
 TASPaletteEditor.cxx:813
 TASPaletteEditor.cxx:814
 TASPaletteEditor.cxx:815
 TASPaletteEditor.cxx:816
 TASPaletteEditor.cxx:817
 TASPaletteEditor.cxx:818
 TASPaletteEditor.cxx:819
 TASPaletteEditor.cxx:820
 TASPaletteEditor.cxx:821
 TASPaletteEditor.cxx:822
 TASPaletteEditor.cxx:823
 TASPaletteEditor.cxx:824
 TASPaletteEditor.cxx:825
 TASPaletteEditor.cxx:826
 TASPaletteEditor.cxx:827
 TASPaletteEditor.cxx:828
 TASPaletteEditor.cxx:829
 TASPaletteEditor.cxx:830
 TASPaletteEditor.cxx:831
 TASPaletteEditor.cxx:832
 TASPaletteEditor.cxx:833
 TASPaletteEditor.cxx:834
 TASPaletteEditor.cxx:835
 TASPaletteEditor.cxx:836
 TASPaletteEditor.cxx:837
 TASPaletteEditor.cxx:838
 TASPaletteEditor.cxx:839
 TASPaletteEditor.cxx:840
 TASPaletteEditor.cxx:841
 TASPaletteEditor.cxx:842
 TASPaletteEditor.cxx:843
 TASPaletteEditor.cxx:844
 TASPaletteEditor.cxx:845
 TASPaletteEditor.cxx:846
 TASPaletteEditor.cxx:847
 TASPaletteEditor.cxx:848
 TASPaletteEditor.cxx:849
 TASPaletteEditor.cxx:850
 TASPaletteEditor.cxx:851
 TASPaletteEditor.cxx:852
 TASPaletteEditor.cxx:853
 TASPaletteEditor.cxx:854
 TASPaletteEditor.cxx:855
 TASPaletteEditor.cxx:856
 TASPaletteEditor.cxx:857
 TASPaletteEditor.cxx:858
 TASPaletteEditor.cxx:859
 TASPaletteEditor.cxx:860
 TASPaletteEditor.cxx:861
 TASPaletteEditor.cxx:862
 TASPaletteEditor.cxx:863
 TASPaletteEditor.cxx:864
 TASPaletteEditor.cxx:865
 TASPaletteEditor.cxx:866
 TASPaletteEditor.cxx:867
 TASPaletteEditor.cxx:868
 TASPaletteEditor.cxx:869
 TASPaletteEditor.cxx:870
 TASPaletteEditor.cxx:871
 TASPaletteEditor.cxx:872
 TASPaletteEditor.cxx:873
 TASPaletteEditor.cxx:874
 TASPaletteEditor.cxx:875
 TASPaletteEditor.cxx:876
 TASPaletteEditor.cxx:877
 TASPaletteEditor.cxx:878
 TASPaletteEditor.cxx:879
 TASPaletteEditor.cxx:880
 TASPaletteEditor.cxx:881
 TASPaletteEditor.cxx:882
 TASPaletteEditor.cxx:883
 TASPaletteEditor.cxx:884
 TASPaletteEditor.cxx:885
 TASPaletteEditor.cxx:886
 TASPaletteEditor.cxx:887
 TASPaletteEditor.cxx:888
 TASPaletteEditor.cxx:889
 TASPaletteEditor.cxx:890
 TASPaletteEditor.cxx:891
 TASPaletteEditor.cxx:892
 TASPaletteEditor.cxx:893
 TASPaletteEditor.cxx:894
 TASPaletteEditor.cxx:895
 TASPaletteEditor.cxx:896
 TASPaletteEditor.cxx:897
 TASPaletteEditor.cxx:898
 TASPaletteEditor.cxx:899
 TASPaletteEditor.cxx:900
 TASPaletteEditor.cxx:901
 TASPaletteEditor.cxx:902
 TASPaletteEditor.cxx:903
 TASPaletteEditor.cxx:904
 TASPaletteEditor.cxx:905
 TASPaletteEditor.cxx:906
 TASPaletteEditor.cxx:907
 TASPaletteEditor.cxx:908
 TASPaletteEditor.cxx:909
 TASPaletteEditor.cxx:910
 TASPaletteEditor.cxx:911
 TASPaletteEditor.cxx:912
 TASPaletteEditor.cxx:913
 TASPaletteEditor.cxx:914
 TASPaletteEditor.cxx:915
 TASPaletteEditor.cxx:916
 TASPaletteEditor.cxx:917
 TASPaletteEditor.cxx:918
 TASPaletteEditor.cxx:919
 TASPaletteEditor.cxx:920
 TASPaletteEditor.cxx:921
 TASPaletteEditor.cxx:922
 TASPaletteEditor.cxx:923
 TASPaletteEditor.cxx:924
 TASPaletteEditor.cxx:925
 TASPaletteEditor.cxx:926
 TASPaletteEditor.cxx:927
 TASPaletteEditor.cxx:928
 TASPaletteEditor.cxx:929
 TASPaletteEditor.cxx:930
 TASPaletteEditor.cxx:931
 TASPaletteEditor.cxx:932
 TASPaletteEditor.cxx:933
 TASPaletteEditor.cxx:934
 TASPaletteEditor.cxx:935
 TASPaletteEditor.cxx:936
 TASPaletteEditor.cxx:937
 TASPaletteEditor.cxx:938
 TASPaletteEditor.cxx:939
 TASPaletteEditor.cxx:940
 TASPaletteEditor.cxx:941
 TASPaletteEditor.cxx:942
 TASPaletteEditor.cxx:943
 TASPaletteEditor.cxx:944
 TASPaletteEditor.cxx:945
 TASPaletteEditor.cxx:946
 TASPaletteEditor.cxx:947
 TASPaletteEditor.cxx:948
 TASPaletteEditor.cxx:949
 TASPaletteEditor.cxx:950
 TASPaletteEditor.cxx:951
 TASPaletteEditor.cxx:952
 TASPaletteEditor.cxx:953
 TASPaletteEditor.cxx:954
 TASPaletteEditor.cxx:955
 TASPaletteEditor.cxx:956
 TASPaletteEditor.cxx:957
 TASPaletteEditor.cxx:958
 TASPaletteEditor.cxx:959
 TASPaletteEditor.cxx:960
 TASPaletteEditor.cxx:961
 TASPaletteEditor.cxx:962
 TASPaletteEditor.cxx:963
 TASPaletteEditor.cxx:964
 TASPaletteEditor.cxx:965
 TASPaletteEditor.cxx:966
 TASPaletteEditor.cxx:967
 TASPaletteEditor.cxx:968
 TASPaletteEditor.cxx:969
 TASPaletteEditor.cxx:970
 TASPaletteEditor.cxx:971
 TASPaletteEditor.cxx:972
 TASPaletteEditor.cxx:973
 TASPaletteEditor.cxx:974
 TASPaletteEditor.cxx:975
 TASPaletteEditor.cxx:976
 TASPaletteEditor.cxx:977
 TASPaletteEditor.cxx:978
 TASPaletteEditor.cxx:979
 TASPaletteEditor.cxx:980
 TASPaletteEditor.cxx:981
 TASPaletteEditor.cxx:982
 TASPaletteEditor.cxx:983
 TASPaletteEditor.cxx:984
 TASPaletteEditor.cxx:985
 TASPaletteEditor.cxx:986
 TASPaletteEditor.cxx:987
 TASPaletteEditor.cxx:988
 TASPaletteEditor.cxx:989
 TASPaletteEditor.cxx:990
 TASPaletteEditor.cxx:991
 TASPaletteEditor.cxx:992
 TASPaletteEditor.cxx:993
 TASPaletteEditor.cxx:994