cmdsources.h

/*

  This file is a part of GRALESHELL, a program to facilitate the simulation
  and inversion of gravitational lenses, based on the GRALE library.

  Copyright (C) 2008-2012 Jori Liesenborgs

  Contact: jori.liesenborgs@gmail.com
  
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  
*/

#ifndef CMDSOURCES_H

#define CMDSOURCES_H

#include <shellp/shellcommand.h>
#include <shellp/shellcmdrealarg.h>
#include <shellp/shellcmdboolarg.h>
#include <shellp/shellcmdintarg.h>
#include <shellp/shellcmdstringarg.h>

class CmdSourcePlane : public shellp::ShellCommand
{
public:
        CmdSourcePlane(const std::string &cmdname);
        ~CmdSourcePlane();
        bool execute();
private:
        shellp::ShellCmdRealArg *Dsarg,*Ddsarg;
        shellp::ShellCmdBoolArg *delsrcarg;
};

class CmdSourcePlaneLoadSave : public shellp::ShellCommand
{
public:
        CmdSourcePlaneLoadSave(const std::string &cmdname);
        ~CmdSourcePlaneLoadSave();
protected:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdBoolArg *processsourcesarg;
};

class CmdSourcePlaneLoad : public CmdSourcePlaneLoadSave
{
public:
        CmdSourcePlaneLoad(const std::string &cmdname);
        ~CmdSourcePlaneLoad();
        bool execute();
};

class CmdSourcePlaneSave : public CmdSourcePlaneLoadSave
{
public:
        CmdSourcePlaneSave(const std::string &cmdname);
        ~CmdSourcePlaneSave();
        bool execute();
};

class CmdSourcesAddBase : public shellp::ShellCommand
{
protected:
        CmdSourcesAddBase(const std::string &cmdName);
public:
        ~CmdSourcesAddBase();
protected:
        int getSourceNumber() const                                             { return m_pSrcNumArg->getValue(); }
        double getX() const                                                     { return m_pXPosArg->getValue(); }
        double getY() const                                                     { return m_pYPosArg->getValue(); }
        double getBrightnessScale() const                                       { return m_pBrightnessScale->getValue(); }
private:
        shellp::ShellCmdIntArg *m_pSrcNumArg;
        shellp::ShellCmdRealArg *m_pXPosArg, *m_pYPosArg;
        shellp::ShellCmdRealArg *m_pBrightnessScale;
};

class CmdSourcesAddCircular : public CmdSourcesAddBase
{
public:
        CmdSourcesAddCircular(const std::string &cmdName);
        ~CmdSourcesAddCircular();
        bool execute();
private:
        shellp::ShellCmdRealArg *m_pRadiusArg;
        shellp::ShellCmdBoolArg *m_pFadeArg;
};

class CmdSourcesAddPoint : public CmdSourcesAddBase
{
public:
        CmdSourcesAddPoint(const std::string &cmdName);
        ~CmdSourcesAddPoint();
        bool execute();
};

class CmdSourcesAddRotatedBase : public CmdSourcesAddBase
{
protected:
        CmdSourcesAddRotatedBase(const std::string &cmdName);
public:
        ~CmdSourcesAddRotatedBase();
protected:
        double getAngle() const                                                 { return m_pAngleArg->getValue(); }
private:
        shellp::ShellCmdRealArg *m_pAngleArg;
};

class CmdSourcesAddElliptical : public CmdSourcesAddRotatedBase
{
public:
        CmdSourcesAddElliptical(const std::string &cmdname);
        ~CmdSourcesAddElliptical();
        bool execute();
private:
        shellp::ShellCmdRealArg *axisarg;
        shellp::ShellCmdRealArg *excentrarg;
        shellp::ShellCmdBoolArg *fadearg;
};

class CmdSourcesAddFITS : public CmdSourcesAddRotatedBase
{
public:
        CmdSourcesAddFITS(const std::string &cmdname);
        ~CmdSourcesAddFITS();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        shellp::ShellCmdRealArg *widtharg;
        shellp::ShellCmdRealArg *heightarg;
};

class CmdSourcesAddPolygon : public CmdSourcesAddRotatedBase
{
public:
        CmdSourcesAddPolygon(const std::string &cmdname);
        ~CmdSourcesAddPolygon();
        bool execute();
private:
        shellp::ShellCmdStringArg *fnamearg;
        std::vector<shellp::ShellCmdArg *> pointargs;
        shellp::ShellCmdRealArg *xposarg,*yposarg;
};

class CmdSourcesDelete : public shellp::ShellCommand
{
public:
        CmdSourcesDelete(const std::string &cmdname);
        ~CmdSourcesDelete();
        bool execute();
private:
        shellp::ShellCmdIntArg *srcnumarg;
};

class CmdSourcesClear : public shellp::ShellCommand
{
public:
        CmdSourcesClear(const std::string &cmdname);
        ~CmdSourcesClear();
        bool execute();
};

class CmdSourcesMove : public shellp::ShellCommand
{
public:
        CmdSourcesMove(const std::string &cmdname);
        ~CmdSourcesMove();
        bool execute();
private:
        shellp::ShellCmdIntArg *srcnumarg;
        shellp::ShellCmdRealArg *xarg,*yarg;
        shellp::ShellCmdBoolArg *relarg;
};

class CmdSourcesRotate : public shellp::ShellCommand
{
public:
        CmdSourcesRotate(const std::string &cmdname);
        ~CmdSourcesRotate();
        bool execute();
private:
        shellp::ShellCmdIntArg *srcnumarg;
        shellp::ShellCmdRealArg *anglearg;
        shellp::ShellCmdBoolArg *relarg;
};

class CmdSourcePlaneImagesData : public shellp::ShellCommand
{
public:
        CmdSourcePlaneImagesData(const std::string &cmdname);
        ~CmdSourcePlaneImagesData();
        bool execute();
private:
        shellp::ShellCmdIntArg *numarg;
        shellp::ShellCmdIntArg *m_pImageNumberArg;
        shellp::ShellCmdBoolArg *m_pUseMagnifications;
};

class CmdSourcePlaneImagesDataPointSource : public shellp::ShellCommand
{
public:
        CmdSourcePlaneImagesDataPointSource(const std::string &cmdname);
        ~CmdSourcePlaneImagesDataPointSource();
        bool execute();
private:
        shellp::ShellCmdIntArg *numarg;
        shellp::ShellCmdIntArg *m_pImageNumberArg;
        shellp::ShellCmdRealArg *m_pRadiusArg;
};

#endif // CMDSOURCES_H