control.h

Go to the documentation of this file.

/* ***********************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-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_CONTROL_H
#define INCLUDE_CONTROL_H

#include "MyList.h"
#include "MyString.h"
#include "MyDebug.h"
#include "input.h"
#include "inertia.h"
#include "face.h"
#include "sigslot.h"

// parametre des dimentions des controls
#define DEFAULT_DEPTH_TEXTBOX            4
#define DEFAULT_DEPTH_MAX_BUTTON         5
#define DEFAULT_DEPTH_MIN_BUTTON         1 // ne peut etre =0 sinon erreur de picking
#define DEFAULT_DEPTH_CONTAINER          3
#define DEFAULT_DEPTH_TITLE                      2
#define DEFAULT_DEPTH_WINDOW             10 
#define DEFAULT_SIZE_TRACK_BUTTON        16

#define TIME_OUT_PUSH_DOWN_BUTTON    0.3

/*
 *      Gestion des debugs
 */

// Info de debug

#define Debug0Param(text) MyDebug::SendEvent(name,text);
#define Debug1Param(text,p1) MyDebug::SendEvent(name,text,p1);
#define Debug2Param(text,p1,p2) MyDebug::SendEvent(name,text,p1,p2);
#define Debug3Param(text,p1,p2,p3) MyDebug::SendEvent(name,text,p1,p2,p3);

// Pas d'info de debug
/*
#define Debug0Param(text)
#define Debug1Param(text,p1)
#define Debug2Param(text,p1,p2)
#define Debug3Param(text,p1,p2,p3)
*/
typedef Point2D<int> Point2D_int;
typedef Point2D<double> Point2D_double;

using namespace sigslot;  // pour signal (evit l'ecriture sigslot::signal?<...>)

class EventMouseButton
{ 
public:
        signal2<StateMouse *,int > up;                  //Call: int OnUp(StateMouse *mouse,int face);
        signal2<StateMouse *,int > down;                //Call: int OnDown(StateMouse *mouse,int face);
        signal2<StateMouse *,int > doubleClick; //Call: int OnDoubleClick(StateMouse *mouse,int face);
        signal2<StateMouse *,int > click;               //Call: int OnClick(StateMouse *mouse,int face);

        Timer timerClick;
        int GetNbLinks()
        {
                return up.size()+down.size()+doubleClick.size()+click.size();
        }
};

class EventKey
{ 
/*
private:
        static StateKey oldKey;
        static int oldFace;
        static Timer *timerDoubleClick;

        void TimeOutDoubleClick()
        {
                timer->StopAndUnBind();
                click(&oldKey,oldFace);
        }
*/
public:
        signal2<StateKey *,int> up;                             //Call: int OnUp(StateKey *key,int face);
        signal2<StateKey *,int> down;                   //Call: int OnDown(StateKey *key,int face);
        signal2<StateKey *,int> doubleClick;    //Call: int OnDoubleClick(StateKey *key,int face);
        signal2<StateKey *,int> click;                  //Call: int OnClick(StateKey *key,int face);

        int GetNbLinks()
        {
                return up.size()+down.size()+doubleClick.size()+click.size();
        }
/*
        int Up(StateKey *key,int face)
        {
                if (doubleClick.size())
                {
                        oldKey=*key;
                        oldFace=face;
                        BindTimer(timerDoubleClick,TimeOutDoubleClick,10);
                }
        }

        int Down()
        {
                if (doubleClick.size())
                {
                        timerDoubleClick->StopAndUnBind();
                }
        }
*/
};

typedef enum
{
        buttonLeft = 0,
        buttonMid = 1,
        buttonRight = 2
} TypeButton;

class EventMouse
{
public:
        EventMouseButton left,right,mid;

        signal4<StateMouse *,int,int,int> move; //Call: int OnMove(StateMouse *mouse,int deltaX,int deltaY,int face);
        signal2<StateMouse *,int> wheel;//Call: int OnWheel(StateMouse *mouse,int face);

        int GetNbLinks()
        {
                return move.size()+wheel.size()+left.GetNbLinks()+right.GetNbLinks()+mid.GetNbLinks();
        }
} ;

class EventOver
{
public:
        signal2<Control *,int> in; //Call: int OnIn(Control *oldControl,int face);
        signal2<Control *,int> out;//Call: int OnOut(Control *newControl,int face);

        int GetNbLinks()
        {
                return in.size()+out.size();
        }
} ;

class EventFaceOver
{
public:
        signal1<int> in; //Call: int OnIn(int face);
        signal1<int> out;//Call: int OnOut(int face);

        int GetNbLinks()
        {
                return in.size()+out.size();
        }
} ;

class EventControl
{
public:
        EventMouse mouse;
        EventKey key;
        EventOver over;
        EventFaceOver faceOver;
        signal0<> sleeped;      //Call: int OnSleeped();

        int GetNbLinks()
        {
                return mouse.GetNbLinks()+key.GetNbLinks()+over.GetNbLinks()+faceOver.GetNbLinks()+sleeped.size();
        }
};

class Control : public has_slots<>
{
public:
        // list des instansition de control
        static MyList<Control *> controls;      
        static int nextId;
        static Inertia inertia;
        static Timer timerAutoWheel;    
        static Timer timerSleeped;              
        static BOOL leftDown;                   
        static BOOL midDown;                    
        static BOOL rightDown;                  

public:
        // variable membre
        int id;
        FaceNode *faceNode;                     
        MyString name;
        BOOL isEnable;
        BOOL isView;
        int sleepedDelay;                       
        Control *parent;                        
        int parentFace;                         

        // evenement disponible
        EventControl onControl;

        // methodes
private:
        BOOL UseInertia(int numButton,StateMouse *mouse,int face);//utilise une inertie sur bouton souris up uniquement
        int  OnAutoMouseWheel(Timer *timer);
        int  OnSleeped(Timer *timer);
        void DeleteSub(FaceNode *curFaceNode);
        void DeleteFaces(FaceNode *curFaceNode);

public:
        Control();
        ~Control();
        void SetParent();                                                               // config le parent
        BOOL Delete();                                                                  // supression de l'element dans la liste static
        void DeleteFaces();                                                             // supression des face du control
        void DeleteSub();                                                               // supression des controls contenue
        static Control * Find(int _idControl);                  // recherche un control par son idControl dans la list des instances
        void operator= (Control &src);                                  // operateur de copie   
        virtual void Create() {};                                               // pour le prototipage des conteneurs
        void ToString(MyString &str);                                   // pour le debugage
        void SetBlending(BOOL enable);                                  // active/desactive le blending sur toute les faces
        void SetAlphaBlending(float alpha);                             // positionne l'alpha de toute le faces
        void SetLines(Color color,float size);                  // positionne les ligne de toute le faces

        void OverIn(Control *oldControl,int face);              // on rentre sur le control
        void OverOut(Control *newControl,int face);             // on part du control
        void FaceOverIn (int oldFace);                                  // on entre sur un nouvelle face du control
        void FaceOverOut (int newFace);                                 // on sort d'un face

        BOOL ScreenMove(double x,double y,double z);    // deplace en position ecran
        BOOL ScreenMoveTo(double x,double y,double z);  // place en position ecran
        BOOL Move(double x,double y,double z);                  // deplace le control
        BOOL MoveTo(double x,double y,double z);                // positione le control
        BOOL Size(double x,double y);                                   // assigne une taille du control
        BOOL ReSize(double dx,double dy);                               // redimetionne un control
        BOOL Rotate(double x,double y,double z);                // delta-rotation du control
        BOOL RotateQuaternion(double x,double y,double z);// delta-rotation du control par rapport a l'unives
        BOOL RotateTo(double x,double y,double z);              // assigne une rotation du control

        // placement par rapport au pere
        BOOL XDockLeft(double margeX,double sizeX,BOOL isCenter=FALSE);
        BOOL XDockRight(double margeX,double sizeX,BOOL isCenter=FALSE);
        BOOL XDockCenter(double sizeX);
        BOOL XDockCenter(double margeLeft,double margeRight);
        BOOL YDockTop(double margeY,double sizeY,BOOL isCenter=FALSE);
        BOOL YDockBottom(double margeY,double sizeY,BOOL isCenter=FALSE);
        BOOL YDockCenter(double sizeY);
        BOOL YDockCenter(double margeTop,double margeBottom);

        BOOL ChangeDirection();

        int OnMouseWheel(StateMouse *mouse,int face);   // rotation de wheel de la souris
        int OnMouseMove(StateMouse *mouse,int face);    // la souris bouge      
        int OnLButtonDown(StateMouse *mouse,int face);  // appuis
        int OnMButtonDown(StateMouse *mouse,int face);  // appuis
        int OnRButtonDown(StateMouse *mouse,int face);  // appuis
        int OnLButtonUp(StateMouse *mouse,int face);    // relachement
        int OnMButtonUp(StateMouse *mouse,int face);    // relachement
        int OnRButtonUp(StateMouse *mouse,int face);    // relachement 
        int OnLButtonDouble(StateMouse *mouse,int face);// double click
        int OnMButtonDouble(StateMouse *mouse,int face);// double click
        int OnRButtonDouble(StateMouse *mouse,int face);// double click
        int OnKeyUp(StateKey *key,int face);                    // appuis 
        int OnKeyDown(StateKey *key,int face);                  // relachement
        int OnKeyDouble(StateKey *key,int face);                // double click 
        int OnClick(StateMouse *mouse,int face);                // click sans chagement de control depuis l'appuis

        void GetCorners(int face,Point3D<double> *points);
        Point2D<double> GetLocalPos(int face,Point2D<double> absolutePos);
};

#endif

---