TAttFill.cxx

Go to the documentation of this file.

// @(#)root/base:$Id$
// Author: Rene Brun   12/12/94
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include <iostream>
#include "TAttFill.h"
#include "TVirtualPad.h"
#include "TStyle.h"
#include "TVirtualX.h"
#include "TVirtualPadEditor.h"
#include "TColor.h"
 
ClassImp(TAttFill);
 
/** \class TAttFill
\ingroup Base
\ingroup GraphicsAtt
 
Fill Area Attributes class.
 
This class is used (in general by secondary inheritance)
by many other classes (graphics, histograms). It holds all the fill area
attributes.
 
## Fill Area attributes
Fill Area attributes are:
 
  - [Fill Area color](\ref ATTFILL1)
  - [Fill Area style](\ref ATTFILL2)
 
\anchor ATTFILL1
## Fill Area color
The fill area color is a color index (integer) pointing in the ROOT
color table.
The fill area color of any class inheriting from `TAttFill` can
be changed using the method `SetFillColor` and retrieved using the
method `GetFillColor`.
The following table shows the first 50 default colors.
 
Begin_Macro
{
   TCanvas *c = new TCanvas("c","Fill Area colors",0,0,500,200);
   c->DrawColorTable();
   return c;
}
End_Macro
 
### Color transparency
`SetFillColorAlpha()`, allows to set a transparent color.
In the following example the fill color of the histogram `histo`
is set to blue with an opacity of 35% (i.e. a transparency of 65%).
(The color `kBlue` itself is internally stored as fully opaque.)
 
~~~ {.cpp}
histo->SetFillColorAlpha(kBlue, 0.35);
~~~
 
The transparency is available on all platforms when the flag
`OpenGL.CanvasPreferGL` is set to `1` in `$ROOTSYS/etc/system.rootrc`, or on Mac
with the Cocoa backend.
On the file output it is visible with PDF, PNG, Gif, JPEG, SVG, TeX... but not PostScript.
 
Alternatively, you can call at the top of your script `gSytle->SetCanvasPreferGL();`.
Or if you prefer to activate GL for a single canvas `c`, then use `c->SetSupportGL(true);`.
 
### The ROOT Color Wheel.
The wheel contains the recommended 216 colors to be used in web applications.
The colors in the Color Wheel are created by TColor::CreateColorWheel.
 
Using this color set for your text, background or graphics will give your
application a consistent appearance across different platforms and browsers.
 
Colors are grouped by hue, the aspect most important in human perception
Touching color chips have the same hue, but with different brightness and vividness.
 
Colors of slightly different hues _clash_. If you intend to display
colors of the same hue together, you should pick them from the same group.
 
Each color chip is identified by a mnemonic (eg kYellow) and a number.
The keywords, kRed, kBlue, kYellow, kPink, etc are defined in the header file __Rtypes.h__
that is included in all ROOT other header files. We strongly recommend to use these keywords
in your code instead of hardcoded color numbers, eg:
~~~ {.cpp}
   myObject.SetFillColor(kRed);
   myObject.SetFillColor(kYellow-10);
   myLine.SetLineColor(kMagenta+2);
~~~
 
Begin_Macro
{
   TColorWheel *w = new TColorWheel();
   auto cw = new TCanvas("cw","cw",0,0,400,400);
   w->SetCanvas(cw);
   w->Draw();
}
End_Macro
 
### Special case forcing black&white output.
If the current style fill area color is set to 0, then ROOT will force
a black&white output for all objects with a fill area defined and independently
of the object fill style.
 
\anchor ATTFILL2
## Fill Area style
The fill area style defines the pattern used to fill a polygon.
The fill area style of any class inheriting from `TAttFill` can
be changed using the method `SetFillStyle` and retrieved using the
method `GetFillStyle`.
### Conventions for fill styles:
 
  -   0    : hollow
  -   1001 : Solid
  -   3000+pattern_number (see below)
  -   For TPad only:
 
     -   4000 :the window is transparent.
     -   4000 to 4100 the window is 100% transparent to 100% opaque.
 
      The pad transparency is visible in binary outputs files like gif, jpg, png etc ..
      but not in vector graphics output files like PS, PDF and SVG. This convention
      (fill style > 4000) is kept for backward compatibility. It is better to use
      the color transparency instead.
 
pattern_number can have any value from 1 to 25 (see table), or any
value from 100 to 999. For the latest the numbering convention is the following:
~~~ {.cpp}
      pattern_number = ijk      (FillStyle = 3ijk)
 
      i (1-9) : specify the space between each hatch
                1 = 1/2mm  9 = 6mm
 
      j (0-9) : specify angle between 0 and 90 degrees
                0 = 0
                1 = 10
                2 = 20
                3 = 30
                4 = 45
                5 = Not drawn
                6 = 60
                7 = 70
                8 = 80
                9 = 90
 
      k (0-9) : specify angle between 90 and 180 degrees
                0 = 180
                1 = 170
                2 = 160
                3 = 150
                4 = 135
                5 = Not drawn
                6 = 120
                7 = 110
                8 = 100
                9 = 90
~~~
The following table shows the list of pattern styles.
The first table displays the 25 fixed patterns. They cannot be
customized unlike the hatches displayed in the second table which be
customized using:
 
  -  `gStyle->SetHatchesSpacing()` to define the spacing between hatches.
  -  `gStyle->SetHatchesLineWidth()` to define the hatches line width.
 
Begin_Macro
fillpatterns.C(500,700)
End_Macro
*/
 
////////////////////////////////////////////////////////////////////////////////
/// AttFill default constructor.
/// Default fill attributes are taking from the current style
 
TAttFill::TAttFill()
{
   if (!gStyle) {fFillColor=1; fFillStyle=0; return;}
   fFillColor = gStyle->GetFillColor();
   fFillStyle = gStyle->GetFillStyle();
}
 
////////////////////////////////////////////////////////////////////////////////
/// AttFill normal constructor.
///   - color Fill Color
///   - style Fill Style
 
TAttFill::TAttFill(Color_t color, Style_t style)
{
   fFillColor = color;
   fFillStyle = style;
}
 
////////////////////////////////////////////////////////////////////////////////
/// AttFill destructor.
 
TAttFill::~TAttFill()
{
}
 
////////////////////////////////////////////////////////////////////////////////
/// Copy this fill attributes to a new TAttFill.
 
void TAttFill::Copy(TAttFill &attfill) const
{
   attfill.fFillColor  = fFillColor;
   attfill.fFillStyle  = fFillStyle;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Change current fill area attributes if necessary.
 
void TAttFill::Modify()
{
   if (!gPad) return;
   if (!gPad->IsBatch()) {
      gVirtualX->SetFillColor(fFillColor);
      gVirtualX->SetFillStyle(fFillStyle);
   }
 
   gPad->SetAttFillPS(fFillColor,fFillStyle);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Reset this fill attributes to default values.
 
void TAttFill::ResetAttFill(Option_t *)
{
   fFillColor = 1;
   fFillStyle = 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Save fill attributes as C++ statement(s) on output stream out
 
void TAttFill::SaveFillAttributes(std::ostream &out, const char *name, Int_t coldef, Int_t stydef)
{
   if (fFillColor != coldef) {
      if (TColor::SaveColor(out, fFillColor))
         out<<"   "<<name<<"->SetFillColor(ci);" << std::endl;
      else
         out<<"   "<<name<<"->SetFillColor("<<fFillColor<<");"<<std::endl;
   }
   if (fFillStyle != stydef)
      out<<"   "<<name<<"->SetFillStyle("<<fFillStyle<<");"<<std::endl;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Invoke the DialogCanvas Fill attributes.
 
void TAttFill::SetFillAttributes()
{
   TVirtualPadEditor::UpdateFillAttributes(fFillColor,fFillStyle);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set a transparent fill color. 
/// \param fcolor defines the fill color
/// \param falpha defines the percentage of opacity from 0. (fully transparent) to 1. (fully opaque).
/// \note falpha is ignored (treated as 1) if the TCanvas has no GL support activated.
 
void TAttFill::SetFillColorAlpha(Color_t fcolor, Float_t falpha)
{
   fFillColor = TColor::GetColorTransparent(fcolor, falpha);
}