layout.h

Aller à la documentation de ce fichier.

/* ***********************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        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.
        http://www.gnu.org/copyleft/gpl.html
*********************************************************************************** */

#ifndef INCLUDE_LAYOUT_H
#define INCLUDE_LAYOUT_H

template <class T> class LayoutVar // T peut etre de preferance float ou double
{
public:
        T constValue;
        double percentValue;

public:
        LayoutVar()
        {
                Zero();
        }

        void Zero()
        {
                constValue=0;
                percentValue=0;
        }

        void operator=(LayoutVar &source)
        {
                constValue = source.constValue;
                percentValue = source.percentValue;
        }

        void Set(T _percentValue,T _constValue) 
        {
                constValue = _constValue;
                percentValue = _percentValue;
        }

        void Move(T delta)
        {
                constValue+=delta;
        }

        void MoveTo(T value)
        {
                constValue=value;
        }

        void Scale(T delta)
        {
                percentValue*=(double)delta;
        }

        T Get(T base=0)
        {
                return (double)base*percentValue+constValue;
        }
};

template <class T> class Layout // T peut etre de preferance float ou double
{
public:
        LayoutVar<T> xDeb,yDeb,xFin,yFin;

public:
        Layout()
        {
        }

        void Zero()
        {
                xDeb.Zero();
                yDeb.Zero();
                xFin.Zero();
                yFin.Zero();
        }

        void operator=(Layout &src)
        {
                xDeb = src.xDeb;
                yDeb = src.yDeb;
                xFin = src.xFin;
                yFin = src.yFin;
        }

        void Set(double xDebPercent,T xDebConst,double yDebPercent,T yDebConst,GLdouble xFinPercent,T xFinConst,double yFinPercent,T yFinConst)
        {   
                xDeb.Set(xDebPercent,xDebConst);
                xFin.Set(xFinPercent,xFinConst);
                yDeb.Set(yDebPercent,yDebConst);
                yFin.Set(yFinPercent,yFinConst);
        }

        void SetFull()
        {
                xDeb.Zero();
                yDeb.Zero();
                xFin.Set(1,0);
                yFin.Set(1,0);
        }

        void Move(double deltaX,double deltaY)
        {
                xDeb.Move(deltaX);
                yDeb.Move(deltaY);
                xFin.Move(deltaX);
                yFin.Move(deltaY);
        }

        void MoveTo(double x,double y)
        {
                T deltaX,deltaY;
                deltaX=xFin.constValue-xDeb.constValue;
                deltaY=yFin.constValue-yDeb.constValue;
                xDeb.MoveTo(x);
                yDeb.MoveTo(y);
                xFin.MoveTo(x+deltaX);
                yFin.MoveTo(y+deltaY);
        }

        void Scale(double deltaX,double deltaY)
        {
                xDeb.Scale(deltaX);
                yDeb.Scale(deltaY);
                xFin.Scale(deltaX);
                yFin.Scale(deltaY);
        }
};

#endif

---