{-# LANGUAGE ForeignFunctionInterface, TypeFamilies, MultiParamTypeClasses, 
             FlexibleInstances, TypeSynonymInstances, 
             EmptyDataDecls, ExistentialQuantification, ScopedTypeVariables #-}

-- module HROOT.Class.Interface where

module HROOT.Hist.TH1.Interface where


import Data.Word
import Foreign.C
import Foreign.Ptr
import Foreign.ForeignPtr
import FFICXX.Runtime.Cast

import HROOT.Hist.TH1.RawType
import HROOT.Core.TDirectory.RawType
import HROOT.Hist.TF1.RawType
import HROOT.Core.TArrayD.RawType
import HROOT.Core.TObject.Interface
import HROOT.Core.TAttLine.Interface
import HROOT.Core.TAttFill.Interface
import HROOT.Core.TAttMarker.Interface
import HROOT.Core.TDirectory.Interface
---- ============ ----
import {-# SOURCE #-} HROOT.Hist.TF1.Interface
import {-# SOURCE #-} HROOT.Hist.TAxis.Interface

-- |  the TH1 class : the mother class of all histogram classes 
--   
--   > class TH1 : TNamed, TAttLine, TAttFill, TAttMarker
--   

class (ITObject a,ITAttLine a,ITAttFill a,ITAttMarker a) => ITH1 a where
    -- |  
    --   > void TH1::Add( TH1* h1, Double_t c1 ) 
    --   

    add :: (ITH1 c0, FPtr c0) => a -> c0 -> CDouble -> IO () 
    -- | 
    --   > void TH1::AddBinContent( Int_t bin, Double_t w )
    --   

    addBinContent :: a -> CInt -> CDouble -> IO () 
    -- | 
    --   > Double_t TH1::Chi2Test( const TH1* h2, Option_t* option="UU", Double_t* res=0 ) const
    --   

    chi2Test :: (ITH1 c0, FPtr c0) => a -> c0 -> CString -> (Ptr CDouble) -> IO CDouble 
    -- | 
    --   > Double_t TH1::ComputeIntegral ()
    --   

    computeIntegral :: a -> IO CDouble 
    -- | 
    --   > void TH1::DirectoryAutoAdd(TDirectory* )
    --   

    directoryAutoAdd :: (ITDirectory c0, FPtr c0) => a -> c0 -> IO () 
    -- | 
    --   > void TH1::Divide(const TH1* h1, const TH1* h2, Double_t c1=1, Double_t c2=1, Option_t* option="")
    --   

    divide :: (ITH1 c1, FPtr c1, ITH1 c0, FPtr c0) => a -> c0 -> c1 -> CDouble -> CDouble -> CString -> IO () 

    drawCopyTH1 :: a -> CString -> IO a 
    -- | 
    --   > TH1* TH1::DrawNormalized (Option_t* option="", Double_t norm=1) const
    --   

    drawNormalized :: a -> CString -> CDouble -> IO TH1 

    drawPanelTH1 :: a -> IO () 

    bufferEmpty :: a -> CInt -> IO CInt 

    evalF :: (ITF1 c0, FPtr c0) => a -> c0 -> CString -> IO () 

    fFT :: (ITH1 c0, FPtr c0) => a -> c0 -> CString -> IO TH1 

    fill1 :: a -> CDouble -> IO CInt 

    fill1w :: a -> CDouble -> CDouble -> IO CInt 

    fillN1 :: a -> CInt -> (Ptr CDouble) -> (Ptr CDouble) -> CInt -> IO () 

    fillRandom :: (ITH1 c0, FPtr c0) => a -> c0 -> CInt -> IO () 

    findBin :: a -> CDouble -> CDouble -> CDouble -> IO CInt 

    findFixBin :: a -> CDouble -> CDouble -> CDouble -> IO CInt 

    findFirstBinAbove :: a -> CDouble -> CInt -> IO CInt 

    findLastBinAbove :: a -> CDouble -> CInt -> IO CInt 

    fitPanelTH1 :: a -> IO () 

    getNdivisionA :: a -> CString -> IO CInt 

    getAxisColorA :: a -> CString -> IO CInt 

    getLabelColorA :: a -> CString -> IO CInt 

    getLabelFontA :: a -> CString -> IO CInt 

    getLabelOffsetA :: a -> CString -> IO CDouble 

    getLabelSizeA :: a -> CString -> IO CDouble 

    getTitleFontA :: a -> CString -> IO CInt 

    getTitleOffsetA :: a -> CString -> IO CDouble 

    getTitleSizeA :: a -> CString -> IO CDouble 

    getTickLengthA :: a -> CString -> IO CDouble 

    getBarOffset :: a -> IO CDouble 

    getBarWidth :: a -> IO CDouble 

    getContour :: a -> (Ptr CDouble) -> IO CInt 

    getContourLevel :: a -> CInt -> IO CDouble 

    getContourLevelPad :: a -> CInt -> IO CDouble 

    getBin :: a -> CInt -> CInt -> CInt -> IO CInt 

    getBinCenter :: a -> CInt -> IO CDouble 

    getBinContent1 :: a -> CInt -> IO CDouble 

    getBinContent2 :: a -> CInt -> CInt -> IO CDouble 

    getBinContent3 :: a -> CInt -> CInt -> CInt -> IO CDouble 

    getBinError1 :: a -> CInt -> IO CDouble 

    getBinError2 :: a -> CInt -> CInt -> IO CDouble 

    getBinError3 :: a -> CInt -> CInt -> CInt -> IO CDouble 

    getBinLowEdge :: a -> CInt -> IO CDouble 

    getBinWidth :: a -> CInt -> IO CDouble 

    getCellContent :: a -> CInt -> CInt -> IO CDouble 

    getCellError :: a -> CInt -> CInt -> IO CDouble 

    getEntries :: a -> IO CDouble 

    getEffectiveEntries :: a -> IO CDouble 

    getFunction :: a -> CString -> IO TF1 

    getDimension :: a -> IO CInt 

    getKurtosis :: a -> CInt -> IO CDouble 

    getLowEdge :: a -> (Ptr CDouble) -> IO () 

    getMaximumTH1 :: a -> CDouble -> IO CDouble 

    getMaximumBin :: a -> IO CInt 

    getMaximumStored :: a -> IO CDouble 

    getMinimumTH1 :: a -> CDouble -> IO CDouble 

    getMinimumBin :: a -> IO CInt 

    getMinimumStored :: a -> IO CDouble 

    getMean :: a -> CInt -> IO CDouble 

    getMeanError :: a -> CInt -> IO CDouble 

    getNbinsX :: a -> IO CDouble 

    getNbinsY :: a -> IO CDouble 

    getNbinsZ :: a -> IO CDouble 

    getQuantilesTH1 :: a -> CInt -> (Ptr CDouble) -> (Ptr CDouble) -> IO CInt 

    getRandom :: a -> IO CDouble 
    -- | 
    --   > void     GetStats(Double_t *stats) const;
    --   

    getStats :: a -> (Ptr CDouble) -> IO () 

    getSumOfWeights :: a -> IO CDouble 

    getSumw2 :: a -> IO TArrayD 

    getSumw2N :: a -> IO CInt 

    getRMS :: a -> CInt -> IO CDouble 

    getRMSError :: a -> CInt -> IO CDouble 

    getSkewness :: a -> CInt -> IO CDouble 

    integral1 :: a -> CInt -> CInt -> CString -> IO CDouble 
    -- | 
    --   > Double_t Interpolate(Double_t x)
    --   

    interpolate1 :: a -> CDouble -> IO CDouble 
    -- | 
    --   > Double_t Interpolate(Double_t x, Double_t y)
    --   

    interpolate2 :: a -> CDouble -> CDouble -> IO CDouble 
    -- | 
    --   > Double_t Interpolate(Double_t x, Double_t y, Double_t z)
    --   

    interpolate3 :: a -> CDouble -> CDouble -> CDouble -> IO CDouble 
    -- | 
    --   > Double_t KolmogorovTest(const TH1 *h2, Option_t *option="") const
    --   

    kolmogorovTest :: (ITH1 c0, FPtr c0) => a -> c0 -> CString -> IO CDouble 
    -- | 
    --   > void     LabelsDeflate(Option_t *axis="X")
    --   

    labelsDeflate :: a -> CString -> IO () 
    -- | 
    --   > void     LabelsInflate(Option_t *axis="X")
    --   

    labelsInflate :: a -> CString -> IO () 
    -- | 
    --   > void     LabelsOption(Option_t *option="h", Option_t *axis="X")
    --   

    labelsOption :: a -> CString -> CString -> IO () 

    multiflyF :: (ITF1 c0, FPtr c0) => a -> c0 -> CDouble -> IO () 
    -- | 
    --   > void     Multiply(const TH1 *h1, const TH1 *h2, Double_t c1=1, Double_t c2=1, Option_t *option=""); // *MENU*
    --   

    multiply :: (ITH1 c1, FPtr c1, ITH1 c0, FPtr c0) => a -> c0 -> c1 -> CDouble -> CDouble -> CString -> IO () 
    -- | 
    --   > void     PutStats(Double_t *stats)
    --   

    putStats :: a -> (Ptr CDouble) -> IO () 
    -- | 
    --   > TH1     *Rebin(Int_t ngroup=2, const char*newname="", const Double_t *xbins=0);  // *MENU*
    --   

    rebin :: a -> CInt -> CString -> (Ptr CDouble) -> IO TH1 
    -- | 
    --   > void     RebinAxis(Double_t x, TAxis *axis)
    --   

    rebinAxis :: (ITAxis c0, FPtr c0) => a -> CDouble -> c0 -> IO () 
    -- | 
    --   > void     Rebuild(Option_t *option="")
    --   

    rebuild :: a -> CString -> IO () 
    -- | 
    --   > void     RecursiveRemove(TObject *obj)
    --   

    recursiveRemove :: (ITObject c0, FPtr c0) => a -> c0 -> IO () 
    -- | 
    --   > void     Reset(Option_t *option="")
    --   

    reset :: a -> CString -> IO () 
    -- | 
    --   > void     ResetStats()
    --   

    resetStats :: a -> IO () 
    -- | 
    --   > void     Scale(Double_t c1=1, Option_t *option="")
    --   

    scale :: a -> CDouble -> CString -> IO () 
    -- | 
    --   > void     SetAxisColor(Color_t color=1, Option_t *axis="X")
    --   

    setAxisColorA :: a -> CInt -> CString -> IO () 
    -- | 
    --   > void     SetAxisRange(Double_t xmin, Double_t xmax, Option_t *axis="X")
    --   

    setAxisRange :: a -> CDouble -> CDouble -> CString -> IO () 
    -- | 
    --   > void     SetBarOffset(Float_t offset=0.25)
    --   

    setBarOffset :: a -> CDouble -> IO () 
    -- | 
    --   > void     SetBarWidth(Float_t width=0.5) 
    --   

    setBarWidth :: a -> CDouble -> IO () 
    -- | 
    --   > void     SetBinContent(Int_t bin, Double_t content)
    --   

    setBinContent1 :: a -> CInt -> CDouble -> IO () 
    -- | 
    --   > void     SetBinContent(Int_t binx, Int_t biny, Double_t content)
    --   

    setBinContent2 :: a -> CInt -> CInt -> CDouble -> IO () 
    -- | 
    --   > void     SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content)
    --   

    setBinContent3 :: a -> CInt -> CInt -> CInt -> CDouble -> IO () 

    setBinError1 :: a -> CInt -> CDouble -> IO () 

    setBinError2 :: a -> CInt -> CInt -> CDouble -> IO () 

    setBinError3 :: a -> CInt -> CInt -> CInt -> CDouble -> IO () 

    setBins1 :: a -> CInt -> (Ptr CDouble) -> IO () 

    setBins2 :: a -> CInt -> (Ptr CDouble) -> CInt -> (Ptr CDouble) -> IO () 

    setBins3 :: a -> CInt -> (Ptr CDouble) -> CInt -> (Ptr CDouble) -> CInt -> (Ptr CDouble) -> IO () 

    setBinsLength :: a -> CInt -> IO () 

    setBuffer :: a -> CInt -> CString -> IO () 

    setCellContent :: a -> CInt -> CInt -> CDouble -> IO () 

    setContent :: a -> (Ptr CDouble) -> IO () 

    setContour :: a -> CInt -> (Ptr CDouble) -> IO () 

    setContourLevel :: a -> CInt -> CDouble -> IO () 

    setDirectory :: (ITDirectory c0, FPtr c0) => a -> c0 -> IO () 

    setEntries :: a -> CDouble -> IO () 

    setError :: a -> (Ptr CDouble) -> IO () 

    setLabelColorA :: a -> CInt -> CString -> IO () 

    setLabelSizeA :: a -> CDouble -> CString -> IO () 

    setLabelFontA :: a -> CInt -> CString -> IO () 

    setLabelOffsetA :: a -> CDouble -> CString -> IO () 

    setMaximum :: a -> CDouble -> IO () 

    setMinimum :: a -> CDouble -> IO () 

    setNormFactor :: a -> CDouble -> IO () 

    setStats :: a -> CInt -> IO () 

    setOption :: a -> CString -> IO () 

    setXTitle :: a -> CString -> IO () 

    setYTitle :: a -> CString -> IO () 

    setZTitle :: a -> CString -> IO () 
    -- | 
    --   > TH1     *ShowBackground(Int_t niter=20, Option_t *option="same");
    --   

    showBackground :: a -> CInt -> CString -> IO TH1 
    -- | 
    --   > Int_t    ShowPeaks(Double_t sigma=2, Option_t *option="", Double_t threshold=0.05); // *MENU*
    --   

    showPeaks :: a -> CDouble -> CString -> CDouble -> IO CInt 
    -- | 
    --   > void     Smooth(Int_t ntimes=1, Option_t *option=""); // *MENU*
    --   

    smooth :: a -> CInt -> CString -> IO () 

    sumw2 :: a -> IO () 

instance Existable TH1 where
  data Exist TH1 = forall a. (FPtr a, ITH1 a) => ETH1 a

upcastTH1 :: (FPtr a, ITH1 a) => a -> TH1
upcastTH1 h = let fh = get_fptr h
                  fh2 :: ForeignPtr RawTH1 = castForeignPtr fh
              in cast_fptr_to_obj fh2

downcastTH1 :: (FPtr a, ITH1 a) => TH1 -> a 
downcastTH1 h = let fh = get_fptr h
                    fh2 = castForeignPtr fh
                in cast_fptr_to_obj fh2