#ifndef _MUSIC_IONIANSCALE_HPP_
#define _MUSIC_IONIANSCALE_HPP_
#ifndef _MUSIC_SCALE_HPP_
#include <music/scale.hpp>
#endif
#ifndef _MUSIC_SCALES_HPP_
#include <music/scales.hpp>
#endif
#ifndef _MUSIC_DORIANSCALE_HPP_
#include <music/DorianScale.hpp>
#endif
#ifndef _MUSIC_DORIANIISCALE_HPP_
#include <music/DorianIIScale.hpp>
#endif
#ifndef _MUSIC_PHRYGIANSCALE_HPP_
#include <music/PhrygianScale.hpp>
#endif
#ifndef _MUSIC_MIXOLYDIANSCALE_HPP_
#include <music/MixolydianScale.hpp>
#endif
#ifndef _MUSIC_LYDIANSCALE_HPP_
#include <music/LydianScale.hpp>
#endif
#ifndef _MUSIC_AEOLIANSCALE_HPP_
#include <music/AeolianScale.hpp>
#endif
#ifndef _MUSIC_LOCRIANSCALE_HPP_
#include <music/LocrianScale.hpp>
#endif
#ifndef _MUSIC_MINORPENTATONICSCALE_HPP_
#include <music/PentatonicMinorScale.hpp>
#endif
#ifndef _MUSIC_PENTATONICMINORBLUESSCALE_HPP_
#include <music/PentatonicMinorBluesScale.hpp>
#endif
#ifndef _MUSIC_HARMONICMINORSCALE_HPP_
#include <music/HarmonicMinorScale.hpp>
#endif
#ifndef _MUSIC_MELODICMINORSCALE_HPP_
#include <music/MelodicMinorScale.hpp>
#endif
#ifndef _MUSIC_LYDIANAUGMENTEDSCALE_HPP_
#include <music/LydianAugmentedScale.hpp>
#endif
#ifndef _MUSIC_LYDIANDOMINANTSCALE_HPP_
#include <music/LydianDominantScale.hpp>
#endif
#ifndef _MUSIC_LOCRIAN2SCALE_HPP_
#include <music/Locrian2Scale.hpp>
#endif
#ifndef _MUSIC_ALTEREDSCALE_HPP_
#include <music/AlteredScale.hpp>
#endif
#ifndef _MUSIC_DIMINISHEDWHOLESCALE_HPP_
#include <music/DiminishedWholeScale.hpp>
#endif
#ifndef _MUSIC_DIMINISHEDHALFSCALE_HPP_
#include <music/DiminishedHalfScale.hpp>
#endif
#ifndef _MUSIC_WHOLETONESCALE_HPP_
#include <music/WholeToneScale.hpp>
#endif
#ifndef _MUSIC_BEBOPDOMINANTSCALE_HPP_
#include <music/BeBopDominantScale.hpp>
#endif
#ifndef _MUSIC_BEBOPMAJORSCALE_HPP_
#include <music/BeBopMajorScale.hpp>
#endif
#ifndef _MUSIC_BEBOPTONICMINORSCALE_HPP_
#include <music/BeBopTonicMinorScale.hpp>
#endif
#ifndef _MUSIC_BEBOPMINORSCALE_HPP_
#include <music/BeBopMinorScale.hpp>
#endif
#ifndef _MUSIC_EIGHTTONESPANISHSCALE_HPP_
#include <music/EightToneSpanishScale.hpp>
#endif
#ifndef _MUSIC_ENIGMATICSCALE_HPP_
#include <music/EnigmaticScale.hpp>
#endif
#ifndef _MUSIC_GYPSYSCALE_HPP_
#include <music/GypsyScale.hpp>
#endif
#ifndef _MUSIC_HUNGARIANSCALE_HPP_
#include <music/HungarianScale.hpp>
#endif
#ifndef _MUSIC_HUNGARIANMINORSCALE_HPP_
#include <music/HungarianMinorScale.hpp>
#endif
#ifndef _MUSIC_LEADINGWHOLETONESCALE_HPP_
#include <music/LeadingWholeToneScale.hpp>
#endif
#ifndef _MUSIC_LYDIANMINORSCALE_HPP_
#include <music/LydianMinorScale.hpp>
#endif
#ifndef _MUSIC_MAJORLOCRIANSCALE_HPP_
#include <music/MajorLocrianScale.hpp>
#endif
#ifndef _MUSIC_NEAPOLITANMAJORSCALE_HPP_
#include <music/NeapolitanMajorScale.hpp>
#endif
#ifndef _MUSIC_NEAPOLITANMINORSCALE_HPP_
#include <music/NeapolitanMinorScale.hpp>
#endif
#ifndef _MUSIC_ORIENTALSCALE_HPP_
#include <music/OrientalScale.hpp>
#endif
#ifndef _MUSIC_TODISCALE_HPP_
#include <music/ToDiScale.hpp>
#endif
#ifndef _MUSIC_SUPERLCORIANSCALE_HPP_
#include <music/SuperLocrianScale.hpp>
#endif
#ifndef _MUSIC_BAROQUESCALE_HPP_
#include <music/BaroqueScale.hpp>
#endif


class IonianScale;
typedef IonianScale MajorScale;

class IonianScale : public Scale
{
public:
  IonianScale(Note root=Note::G,const String &description="IonianScale");
	virtual ~IonianScale();
	DorianScale getDorianScale(void)const;                             // get Dorian mode
	PhrygianScale getPhrygianScale(void)const;                         // get Phrygian mode
	LydianScale getLydianScale(void)const;                             // get Lydian mode
	MixolydianScale getMixolydianScale(void)const;                     // get Mixolydian mode
	AeolianScale getAeolianScale(void)const;                           // get Aeolian mode
	LocrianScale getLocrianScale(void)const;                           // get Locrian mode
	PentatonicMinorScale getPentatonicMinorScale(void)const;           // get Pentatonic Minor mode
	PentatonicMinorBluesScale getPentatonicMinorBluesScale(void)const; // get Pentatonic Minor Blues
	HarmonicMinorScale getHarmonicMinorScale(void)const;               // get Harmonic Minor mode
	MelodicMinorScale getMelodicMinorScale(void)const;                 // get Melodic Minor mode
	DorianIIScale getDorianIIScale(void)const;                         // get DorianII Mode
	LydianAugmentedScale getLydianAugmentedScale(void)const;           // get Lydian Augmented
	LydianDominantScale getLydianDominantScale(void)const;             // get Lydian Dominant
	Locrian2Scale getLocrian2Scale(void)const;                         // get Locrian2
	AlteredScale getAlteredScale(void)const;                           // get AlteredScale
	DiminishedWholeScale getDiminishedWholeScale(void)const;           // get Diminished Whole
	DiminishedHalfScale getDiminishedHalfScale(void)const;             // get Diminished Half
	WholeToneScale getWholeToneScale(void)const;                       // get WholeTone
	BeBopDominantScale getBeBopDominantScale(void)const;               // get BeBop Dominant 
  BeBopMajorScale getBeBopMajorScale(void)const;
  BeBopTonicMinorScale getBeBopTonicMinorScale(void)const;
  BeBopMinorScale getBeBopMinorScale(void)const;
  EightToneSpanishScale getEightToneSpanishScale(void)const;
  EnigmaticScale getEnigmaticScale(void)const;
  GypsyScale getGypsyScale(void)const;
  HungarianScale getHungarianScale(void)const;
  HungarianMinorScale getHungarianMinorScale(void)const;
  LeadingWholeToneScale getLeadingWholeToneScale(void)const;
  LydianMinorScale getLydianMinorScale(void)const;
  MajorLocrianScale getMajorLocrianScale(void)const;
  NeapolitanMajorScale getNeapolitanMajorScale(void)const;
  NeapolitanMinorScale getNeapolitanMinorScale(void)const;
  OrientalScale getOrientalScale(void)const;
  TodiScale getTodiScale(void)const;
  SuperLocrianScale getSuperLocrianScale(void)const;
	BaroqueScale getBaroqueScale(void)const;
protected:
  virtual void createScale(void);
private:
};

inline
IonianScale::IonianScale(Note root,const String &description)
: Scale(root,description)
{
  createScale();
}

inline
IonianScale::~IonianScale()
{
}

inline
DorianScale IonianScale::getDorianScale(void)const
{
  return DorianScale(getDegree(Degree::II));
}

inline
PhrygianScale IonianScale::getPhrygianScale(void)const
{
  return PhrygianScale(getDegree(Degree::III));
}

inline
LydianScale IonianScale::getLydianScale(void)const
{
  return LydianScale(getDegree(Degree::IV));  
}

inline
MixolydianScale IonianScale::getMixolydianScale(void)const
{
  return MixolydianScale(getDegree(Degree::V));
}

inline
AeolianScale IonianScale::getAeolianScale(void)const
{
  return AeolianScale(getDegree(Degree::VI));
}

inline
HarmonicMinorScale IonianScale::getHarmonicMinorScale(void)const
{
  return HarmonicMinorScale(getDegree(Degree::VI));
}

inline
MelodicMinorScale IonianScale::getMelodicMinorScale(void)const
{
  return MelodicMinorScale(getDegree(Degree::VI));
}

inline
LocrianScale IonianScale::getLocrianScale(void)const
{
  return LocrianScale(getDegree(Degree::VII));
}

inline
PentatonicMinorScale IonianScale::getPentatonicMinorScale(void)const
{
  return PentatonicMinorScale(getDegree(Degree::I));
}

inline
PentatonicMinorBluesScale IonianScale::getPentatonicMinorBluesScale(void)const
{
  return PentatonicMinorBluesScale(getDegree(Degree::I));
}

inline
DorianIIScale IonianScale::getDorianIIScale(void)const
{
  return DorianIIScale(getDegree(Degree::I));
}

inline
LydianAugmentedScale IonianScale::getLydianAugmentedScale(void)const
{
  return LydianAugmentedScale(getDegree(Degree::I));
}

inline
LydianDominantScale IonianScale::getLydianDominantScale(void)const
{
  return LydianDominantScale(getDegree(Degree::I));
}

inline
Locrian2Scale IonianScale::getLocrian2Scale(void)const
{
  return Locrian2Scale(getDegree(Degree::I));
}

inline
AlteredScale IonianScale::getAlteredScale(void)const
{
  return AlteredScale(getDegree(Degree::I));
}

inline
DiminishedWholeScale IonianScale::getDiminishedWholeScale(void)const
{
  return DiminishedWholeScale(getDegree(Degree::I));
}

inline
DiminishedHalfScale IonianScale::getDiminishedHalfScale(void)const
{
  return DiminishedHalfScale(getDegree(Degree::I));
}

inline
WholeToneScale IonianScale::getWholeToneScale(void)const
{
  return WholeToneScale(getDegree(Degree::I));
}

inline
BeBopDominantScale IonianScale::getBeBopDominantScale(void)const
{
  return BeBopDominantScale(getDegree(Degree::I));
}

inline
BeBopMajorScale IonianScale::getBeBopMajorScale(void)const
{
  return BeBopMajorScale(getDegree(Degree::I));
}

inline
BeBopTonicMinorScale IonianScale::getBeBopTonicMinorScale(void)const
{
  return BeBopTonicMinorScale(getDegree(Degree::I));
}

inline
BeBopMinorScale IonianScale::getBeBopMinorScale(void)const
{
  return BeBopMinorScale(getDegree(Degree::I));
}

inline
EightToneSpanishScale IonianScale::getEightToneSpanishScale(void)const
{
  return EightToneSpanishScale(getDegree(Degree::I));
}

inline
EnigmaticScale IonianScale::getEnigmaticScale(void)const
{
  return EnigmaticScale(getDegree(Degree::I));
}

inline
GypsyScale IonianScale::getGypsyScale(void)const
{
  return GypsyScale(getDegree(Degree::I));
}

inline
HungarianScale IonianScale::getHungarianScale(void)const
{
  return HungarianScale(getDegree(Degree::I));
}

inline
HungarianMinorScale IonianScale::getHungarianMinorScale(void)const
{
  return HungarianMinorScale(getDegree(Degree::I));
}

inline
LeadingWholeToneScale IonianScale::getLeadingWholeToneScale(void)const
{
  return LeadingWholeToneScale(getDegree(Degree::I));
}

inline
LydianMinorScale IonianScale::getLydianMinorScale(void)const
{
  return LydianMinorScale(getDegree(Degree::I));
}

inline
MajorLocrianScale IonianScale::getMajorLocrianScale(void)const
{
  return MajorLocrianScale(getDegree(Degree::I));
}

inline
NeapolitanMajorScale IonianScale::getNeapolitanMajorScale(void)const
{
  return NeapolitanMajorScale(getDegree(Degree::I));
}

inline
NeapolitanMinorScale IonianScale::getNeapolitanMinorScale(void)const
{
  return NeapolitanMinorScale(getDegree(Degree::I));
}

inline
OrientalScale IonianScale::getOrientalScale(void)const
{
  return OrientalScale(getDegree(Degree::I));
}

inline
TodiScale IonianScale::getTodiScale(void)const
{
  return TodiScale(getDegree(Degree::I));
}

inline
SuperLocrianScale IonianScale::getSuperLocrianScale(void)const
{
  return SuperLocrianScale(getDegree(Degree::I));
}

inline
BaroqueScale IonianScale::getBaroqueScale(void)const
{
  return BaroqueScale(getDegree(Degree::I));
}

inline
void IonianScale::createScale()
{
  Note root(getRoot());
  Notes::operator[](0)=root;
	root+=Note::WholeStep;
	Notes::operator[](1)=root;
	root+=Note::WholeStep;
	Notes::operator[](2)=root;
	root+=Note::HalfStep;
  Notes::operator[](3)=root;
	root+=Note::WholeStep;
  Notes::operator[](4)=root;
	root+=Note::WholeStep;
  Notes::operator[](5)=root;
	root+=Note::WholeStep;
  Notes::operator[](6)=root;
	root+=Note::HalfStep;
  Notes::operator[](7)=root;
}
#endif