control.cpp

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
************************************************************************************* */

#include "3d.h"
#include "input.h"
#include "controlEngine.h"
#include "container.h"
#include "mylist.h"
#include "control.h"

extern ControlEngine ce;

Control::Control()
{
        parent=NULL;
        parentFace=-1;
        faceNode=NULL;
        sleepedDelay=-1;
        id=nextId++;
        name="Control";
        isEnable=TRUE;
        isView=TRUE;
        leftDown = FALSE;
        midDown = FALSE;
        rightDown = FALSE;
        controls.i+=this; // placement dans les instansiations de control
}

Control::~Control()
{
        Delete();
}

void Control::SetParent()
{
        parent = ce.Peek();
        FaceNode *faceNode = ce.primitive.tree.GetCurrent();// ce.primitive.Peek();
        if (faceNode) parentFace = faceNode->elem->idFace;
        else parentFace = -1;
}

// ********************************************************************************

void Control::operator= (Control &src)
{
        parent = src.parent;
        parentFace = src.parentFace;
        faceNode = src.faceNode;
        name = src.name;
        isEnable=src.isEnable;
        isView=src.isView;
        onControl = src.onControl;
        sleepedDelay = src.sleepedDelay;
}

// ********************************************************************************

BOOL Control::Delete()
{
        DeleteFaces();

        // supression de l'element dans la liste static
        if (controls.i.GoTo((Control *)this)) 
        {
                controls.i.Supr();
                return TRUE;
        }
        return FALSE;
}

void Control::DeleteFaces()
{
        DeleteFaces(faceNode);
        faceNode=NULL;
}

void Control::DeleteFaces(FaceNode *curFaceNode)
{
        if (!curFaceNode || curFaceNode->elem->idControl!=id) return;
        
        FaceNode *curChild;
        MyListItem<FaceNode *> *item;
        item = curFaceNode->childs.first;
        while (item)
        {
                curChild = *item->elem;
                item = item->after;
                DeleteFaces(curChild);
        }
        ce.primitive.tree.SuprNode(curFaceNode,FALSE);
}

void Control::DeleteSub()
{
        DeleteSub(faceNode);
}


void Control::DeleteSub(FaceNode *curFaceNode)
{
        if (!curFaceNode) return ;
        if (curFaceNode->elem->idControl!=id) 
        {
                // retrouve le control lié a une face particuliere
                Control *control = Control::Find(curFaceNode->elem->idControl);
                if (control) 
                {
                        control->DeleteSub();
                        delete control;
                        return;
                }
        }

        FaceNode *curChild;
        MyListItem<FaceNode *> *item;
        item = curFaceNode->childs.first;
        while (item)
        {
                curChild = *item->elem;
                item = item->after;
                DeleteSub(curChild);
        }
}

void Control::SetBlending(BOOL enable) 
{
        if (!faceNode) return;
        faceNode->elem->blending=enable;
        for (faceNode->childs.i=0;faceNode->childs.i.More();faceNode->childs.i++)
        {
                faceNode->childs.i.GetElem()->elem->blending=enable;
        }
}

void Control::SetAlphaBlending(float alpha) 
{
        if (!faceNode) return;
        Face * face = faceNode->elem;
        face->material.SetAlpha(alpha);
        face->blending=TRUE;
        for (faceNode->childs.i=0;faceNode->childs.i.More();faceNode->childs.i++)
        {
                face = faceNode->childs.i.GetElem()->elem;
                face->material.SetAlpha(alpha);
                face->blending=TRUE;
        }
}

void Control::SetLines(Color color,float size)                                          
{
        if (!faceNode) return;
        Face * face = faceNode->elem;
        face->lineMaterial.SetDS(color);
        face->line=size;
        for (faceNode->childs.i=0;faceNode->childs.i.More();faceNode->childs.i++)
        {
                face = faceNode->childs.i.GetElem()->elem;
                face->lineMaterial.SetDS(color);
                face->line=size;
        }
}

BOOL Control::ScreenMove(double x,double y,double z)
{
        double zDistOfSelected;
        if (ce.usingInertia) zDistOfSelected = ce.pickingInertia.zDist;
        else zDistOfSelected = ce.pickingCursor.zDist;
        double realZ =ce.ComputeRealZ(zDistOfSelected);
        return Move(x*realZ,y*realZ,z);

}

BOOL Control::ScreenMoveTo(double x,double y,double z)
{
        double realZ =ce.ComputeRealZ(ce.pickingCursor.zDist);
        return MoveTo(x*realZ,y*realZ,z);
}

BOOL Control::MoveTo(double x,double y,double z)
{
        if (!faceNode) return FALSE;
        faceNode->elem->MoveTo(x,y,z);
        return TRUE;
}

BOOL Control::Move(double x,double y,double z)
{
        if (!faceNode) return FALSE;
        faceNode->elem->Move(x,y,z);
        return TRUE;
}

BOOL Control::ReSize(double dx,double dy)
{
        if (!faceNode) return FALSE;
        faceNode->elem->size.x.constValue+=dx;
        faceNode->elem->size.y.constValue+=dy;
        return TRUE;
}

BOOL Control::Size(double x,double y)
{
        if (!faceNode) return FALSE;
        faceNode->elem->size.x=x;
        faceNode->elem->size.y=y;
        return TRUE;
}

BOOL Control::RotateQuaternion(double x,double y,double z)
{
        if (!faceNode) return FALSE;
        Point3D<double> angle(-y,-x,z);
        faceNode->elem->angle+=angle.QuaternionRotate(angle);
        return TRUE;
}

BOOL Control::Rotate(double x,double y,double z)
{
        if (!faceNode) return FALSE;
        Point3D<double> pt(x,y,z);
        faceNode->elem->angle+=pt;
        return TRUE;
}

BOOL Control::RotateTo(double x,double y,double z)
{
        if (!faceNode) return FALSE;
        Point3D<double> pt(x,y,z);
        faceNode->elem->angle=pt;
        return TRUE;
}

#define DOCK_INIT \
        if (!faceNode) return FALSE; \
        Face *father,*child; \
        child = faceNode->elem; \
        father = faceNode->parent->elem; \
        if (!child||!father) return FALSE; \

BOOL Control::YDockTop(double margeY,double sizeY,BOOL isCenter)
{
        DOCK_INIT;
        child->center.y=isCenter?0:-1;
        child->position.y.Set(-margeY,0.5,&father->computeSize.y);
        child->size.y.Set(sizeY);
        return TRUE;
}

BOOL Control::YDockBottom(double margeY,double sizeY,BOOL isCenter)
{
        DOCK_INIT;
        child->center.y=isCenter?0:1;
        child->position.y.Set(margeY,-0.5,&father->computeSize.y);
        child->size.y=sizeY;
        return TRUE;
}

BOOL Control::XDockLeft(double margeX,double sizeX,BOOL isCenter)
{
        DOCK_INIT;
        child->center.x=isCenter?0:1;
        child->position.x.Set(margeX,-0.5,&father->computeSize.x);
        child->size.x=sizeX;
        return TRUE;
}

BOOL Control::XDockRight(double margeX,double sizeX,BOOL isCenter)
{
        DOCK_INIT;
        child->center.x=isCenter?0:-1;
        child->position.x.Set(-margeX,0.5,&father->computeSize.x);
        child->size.x=sizeX;
        return TRUE;
}

BOOL Control::XDockCenter(double sizeX)
{
        DOCK_INIT;
        child->center.x=0;
        child->position.x.Set(0);
        child->size.x.Set(sizeX);
        return TRUE;
}

BOOL Control::XDockCenter(double margeLeft,double margeRight)
{
        DOCK_INIT;
        child->center.x=0;
        child->position.x.Set((margeLeft-margeRight)/2.0);
        child->size.x.Set(-margeLeft-margeRight,1,&father->computeSize.x);
        return TRUE;
}

BOOL Control::YDockCenter(double sizeY)
{
        DOCK_INIT;
        child->center.y=0;
        child->position.y.Set(0);
        child->size.y.Set(sizeY);
        return TRUE;
}

BOOL Control::ChangeDirection()
{
        DOCK_INIT;
        Rotate(0,0,90);
        Face old = *child;
        //child->center.x=old.center.y;
        //child->center.y=old.center.x;
        child->position.x=old.position.y;
        child->position.y=old.position.x;
        child->size.x=old.size.y;
        child->size.y=old.size.x;
        return TRUE;
}

BOOL Control::YDockCenter(double margeTop,double margeBottom)
{
        DOCK_INIT;
        child->center.y=0;
        child->position.y.Set((margeTop-margeBottom)/2.0);
        child->size.y.Set(-margeTop-margeBottom,1,&father->computeSize.y);
        return TRUE;
}

void Control::ToString(MyString &str)
{
        str.AddFormat("name:%s isEnable:%d isView:%d",name,isEnable,isView);
}

Control * Control::Find(int idControl)
{
        Control *controlFind;
        MyListIterator<Control *> i(&Control::controls);
        for (i=0;i.More();i++)
        {
                controlFind = i.GetElem();
                if (controlFind->id==idControl) return controlFind;
        }
        return NULL;
}

int Control::OnAutoMouseWheel(Timer *timer)
{
        Debug0Param("Control::AutoMouseWheel");
        onControl.mouse.wheel(&ce.pickingCursor.mouse,ce.pickingCursor.faceHover);
        return 0;
}

int Control::OnMouseWheel(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnMouseWheel",mouse,face);
        if (mouse->midBtn) 
        {
                BindTimer(timerAutoWheel,OnAutoMouseWheel,40);
        }
        return onControl.mouse.wheel(mouse,face);
}

int Control::OnSleeped(Timer *timer)
{
        Debug0Param("Control::Sleeped");
        timerSleeped.Stop();
        onControl.sleeped();
        return 0;
}
int Control::OnMouseMove(StateMouse *mouse,int face)
{
        if (!this) return 0;
        //DebugMouse2("Control::OnMouseMove",mouse,face);
        // gestion du Sleeped
        if (sleepedDelay!=-1) 
        {
                timerSleeped.onTimer.disconnect_all();
                BindTimer(timerSleeped,OnSleeped,sleepedDelay);
        }

        // calcul du delta par rapport au dernier appel
        StateMouse * delta = ce.pickingCursor.mouse.GetDelta(&ce.pickingCursor.oldMouse);
        if (ce.enableInertia) inertia.Add(delta->pos); // gestion d'inertia
        return onControl.mouse.move(mouse,delta->pos.x,delta->pos.y,face);
}

void Control::OverIn(Control *oldControl,int face)
{
        Debug2Param("Control::OverIn(oldCtrl:%s,face:%d)",(char*)oldControl->name,face);
        leftDown = FALSE;
        rightDown = FALSE;
        midDown = FALSE;
        onControl.over.in(oldControl,face);
} 

void Control::OverOut(Control *newControl,int face)
{
        Debug2Param("Control::OverOut(newCtrl:%s,face:%d)",(char*)newControl->name,face);
        leftDown = FALSE;
        rightDown = FALSE;
        midDown = FALSE;
        onControl.over.out(newControl,face);
} 

void Control::FaceOverIn(int oldFace)
{
        Debug1Param("Control::FaceOverIn(oldFace:%d)",oldFace);
        onControl.faceOver.in(oldFace);
} 

void Control::FaceOverOut(int newFace)
{
        Debug1Param("Control::FaceOverOut(newFace:%d)",newFace);
        onControl.faceOver.out(newFace);
} 

int Control::OnLButtonDown(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnLButtonDown",mouse,face);
        leftDown = TRUE;
        return onControl.mouse.left.down(mouse,face);
}

int Control::OnMButtonDown(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnMButtonDown",mouse,face);
        midDown = TRUE;
        return onControl.mouse.mid.down(mouse,face);
}

int Control::OnRButtonDown(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnRButtonDown",mouse,face);
        rightDown = TRUE;
        return onControl.mouse.right.down(mouse,face);
}

int Control::OnClick(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnClick",mouse,face);
        return onControl.mouse.left.click(mouse,face);
}

BOOL Control::UseInertia(int numButton,StateMouse *mouse,int face)
{
        //MyDebug::SendLine("UseInertia","use");
        if (!ce.enableInertia) return FALSE;
        if (ce.eventInertia[numButton].enable)
        {
                ce.eventInertia[numButton].Stop();
        }
        Point2D<double> moyInertia = inertia.GetMoyValue();
        if (moyInertia.Power()>SEUIL_MIN_INERTIA) // seuil avant traitement
        {
                ce.eventInertia[numButton].enable=TRUE;
                ce.usingInertia++;
                ce.eventInertia[numButton].Start(face,moyInertia);
                return TRUE;
        }
        return FALSE;
}

int Control::OnLButtonUp(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnLButtonUp",mouse,face);
        int res = 0;
        if (!UseInertia(0,mouse,face)) 
        {
                res = onControl.mouse.left.up(mouse,face);
                if (leftDown) OnClick(mouse,face);
        }
        return res;
}

int Control::OnMButtonUp(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnMButtonUp",mouse,face);
        int res = 0;
        if (timerAutoWheel.isRuning) timerAutoWheel.StopAndUnBind();
        if (!UseInertia(1,mouse,face)) 
        {
                res = onControl.mouse.mid.up(mouse,face);
                if (midDown) onControl.mouse.mid.click(mouse,face);
        }
        return res;
}

int Control::OnRButtonUp(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnRButtonUp",mouse,face);
        int res = 0;
        if (!UseInertia(2,mouse,face)) 
        {
                res = onControl.mouse.right.up(mouse,face);
                if (rightDown) onControl.mouse.right.click(mouse,face);
        }
        return res;
}

int Control::OnLButtonDouble(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnLButtonDblClk",mouse,face);
        return onControl.mouse.left.doubleClick(mouse,face);
}

int Control::OnMButtonDouble(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnMButtonDblClk",mouse,face);
        return onControl.mouse.mid.doubleClick.emit(mouse,face);
}

int Control::OnRButtonDouble(StateMouse *mouse,int face)
{
        DebugMouse2("Control::OnRButtonDblClk",mouse,face);
        return onControl.mouse.right.doubleClick(mouse,face);
}

// ********************************************************************************

int Control::OnKeyUp(StateKey *key,int face)
{
        DebugKey2("Control::OnKeyUp",key,face);
        return onControl.key.up(key,face);
} 

int Control::OnKeyDown(StateKey *key,int face)
{
        DebugKey2("Control::OnKeyDown",key,face);
        return onControl.key.down(key,face);
} 

int Control::OnKeyDouble(StateKey *key,int face)
{
        DebugKey2("Control::OnKeyDblClk",key,face);
        return onControl.key.doubleClick(key,face);
} 

// ********************************************************************************

void Control::GetCorners(int face,Point3D<double> *points)
{
        ce.primitive.GetCorners(faceNode->childs.i[face],points);
}

Point2D<double> Control::GetLocalPos(int face,Point2D<double> absolutePos)
{
        return ce.primitive.GetLocalPos(faceNode->childs.i[face],absolutePos);
}

---