slider.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 "slider.h"

extern ControlEngine ce;

Slider::Slider()        
{
        // init variable
        name="Slider";
        Init(0,100,30,70);
        Step(5);
        useButtons = TRUE;

        body.onControl.mouse.move.connect(this,OnMouseMove);
        body.onControl.mouse.left.down.connect(this,OnLMouseDown);
        btnMinus.onControl.mouse.left.down.connect(this,OnMinusLMouseDown);
        btnPlus.onControl.mouse.left.down.connect(this,OnPlusLMouseDown);
        btnMinus.onControl.over.out.connect(this,OnButtonsOverOut);
        btnPlus.onControl.over.out.connect(this,OnButtonsOverOut);
        btnMinus.onControl.mouse.left.up.connect(this,OnButtonsLMouseUp);
        btnPlus.onControl.mouse.left.up.connect(this,OnButtonsLMouseUp);
}

Slider::~Slider()
{
}

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

void Slider::Create(double depth)
{
        SetParent();

        // init general
        faceNode = ce.primitive.AddFace("Slider",id,-1,FALSE);

        ce.Push(this);
                // dessin du corps
                body.faceNode = ce.primitive.AddBox("Body",body.id,depth,FALSE);
                body.SetBlending(TRUE);
                body.faceNode->elem->material.SetDS(0,0,1,0.25f);

                if (useButtons)
                {
                        btnMinus.Create(depth);
                        btnMinus.XDockLeft(0,SIZE_BUTTON);
                        btnMinus.YDockCenter(0,0);
                        btnMinus.depth_min=btnMinus.depth_max; // ne peut pas etre appyé
                        ConfigFaces(&btnMinus,&ce.texture.arrow);
                        btnPlus.Create(depth);
                        btnPlus.XDockRight(0,SIZE_BUTTON,TRUE);
                        btnPlus.YDockCenter(0,0);
                        btnPlus.depth_min=btnPlus.depth_max; // ne peut pas etre appyé
                        btnPlus.Rotate(0,180,0);
                        btnPlus.Move(-SIZE_BUTTON/2.0,0,depth);
                        btnPlus.faceNode->Elems(FACE_BACK)->view=TRUE;
                        ConfigFaces(&btnPlus,&ce.texture.arrow);
                        body.XDockCenter(SIZE_BUTTON,SIZE_BUTTON);
                        body.YDockCenter(0,0);
                }
                else
                {
                        body.XDockCenter(0,0);
                        body.YDockCenter(0,0);
                }

                ce.Push(this);
                        cursor.faceNode = ce.primitive.AddBox("Cursor",cursor.id,depth-4,FALSE);
                        cursor.YDockCenter(2,2);
                        cursor.Move(0,0,2);
                        cursor.faceNode->elem->material.SetDS(1,1,1);
                        ConfigFaces(&cursor,&ce.texture.grip);
                        cursor.faceNode->MoveToFirstChild(); // pour que la transparence puisse s'applique au body qui est contien
                        Refresh();
                ce.Pop();
        ce.Pop();
}

int Slider::OnAutoMinus(Timer *)
{
        Current(-stepButton);
        SendMoving();
        return 0;
}

void Slider::SendMoving()
{
        double deltaRang = maximum-minimum;
        double percentMin = (curMin-minimum)/deltaRang; 
        double percentMax = (maximum-curMax)/deltaRang;
        double percent = percentMin/(percentMin+percentMax);
        onSlidder.moving(curMin,curMax,percent);
}

int Slider::OnButtonsOverOut(Control *,int)
{
        timerAutoButton.StopAndUnBind();
        return 0;
}

int Slider::OnButtonsLMouseUp(StateMouse *,int)
{
        timerAutoButton.StopAndUnBind();
        return 0;
}

int Slider::OnMinusLMouseDown(StateMouse *,int)
{
        BindTimer(timerAutoButton,OnAutoMinus,100);
        OnAutoMinus(NULL);
        return 0;
}

int Slider::OnAutoPlus(Timer *)
{
        Current(stepButton);
        SendMoving();
        return 0;
}

int Slider::OnPlusLMouseDown(StateMouse *,int)
{
        BindTimer(timerAutoButton,OnAutoPlus,100);
        OnAutoPlus(NULL);
        return 0;
}

int Slider::OnLMouseDown(StateMouse *mouse,int face)
{
        return OnMouseMove(mouse,0,0,face);
}

void Slider::ConfigFaces(Control *control,Texture *texture)
{
        for (control->faceNode->childs.i=0;control->faceNode->childs.i.More();control->faceNode->childs.i++)
        {
                control->faceNode->childs.i.GetElem()->elem->texture = texture;
        }
}

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

int Slider::OnMouseMove(StateMouse *mouse,int deltaX,int deltaY,int face)
{
        if (mouse->leftBtn)
        {
                Point2D<double> pos(mouse->pos.x,mouse->pos.y);
                Point2D<double> result;  
                result = body.GetLocalPos(face,pos);
                SetCurrentByPosition(result.x);
                Refresh();
                SendMoving();
        }
        return 0;
}

BOOL Slider::Step(double step)
{
        if (step<0) return FALSE;
        stepButton = step;
        return TRUE;
}

void Slider::Setup(double min,double max,double curMin,double curMax)
{
        Init(min,max,curMin,curMax);
        Refresh();
}

void Slider::Init(double min,double max,double curMin,double curMax)
{
        minimum=min;
        maximum=max;
        SetCurrent(curMin,curMax);
}

BOOL Slider::Min(double value)
{
        if (!SetMin(value)) return FALSE;
        Refresh();
        return TRUE;
}

BOOL Slider::SetMin(double value)
{
        if (value<=maximum) return FALSE;
        minimum=value;
        return TRUE;
}

BOOL Slider::Max(double value)
{
        if (!SetMax(value))return FALSE;
        Refresh();
        return TRUE;
}

BOOL Slider::SetMax(double value)
{
        if (value>=minimum) return FALSE;
        maximum=value;
        return TRUE;
}

BOOL Slider::Current(double min,double max)
{
        if (!SetCurrent(min,max))return FALSE;
        Refresh();
        return TRUE;
}

BOOL Slider::Current(double delta)
{
        SetCurrent(delta);
        Refresh();
        return TRUE;
}

BOOL Slider::SetCurrent(double min,double max)
{
        double tMin,tMax;
        tMin=min>maximum?maximum:min;
        tMin=min<minimum?minimum:min;

        tMax=max>maximum?maximum:max;
        tMax=max<minimum?minimum:max;

        if (tMin>=tMax) return FALSE; 
        curMin=tMin;
        curMax=tMax;
        return TRUE;
}

BOOL Slider::SetCurrent(double delta)
{
        if ((curMin+delta)<minimum) delta=minimum-curMin;
        if ((curMax+delta)>maximum) delta=maximum-curMax;
        curMin+=delta;
        curMax+=delta;
        return TRUE;
}

void Slider::SetCurrentByPosition(double x)
{
        double percent;
        percent = x/body.faceNode->elem->computeSize.x;
        double curValue = percent*(maximum-minimum)+minimum;
        double delta = (curValue-(curMax-curMin)/2.0)-curMin;
        SetCurrent(delta);
}

void Slider::Refresh()
{
        double percent;
        double deltaCur = curMax-curMin;
        double deltaSlider= maximum-minimum;
        double deltaBody = body.faceNode->elem->computeSize.x;
        if (!deltaBody) 
        {
                ce.primitive.ComputeLayout(body.faceNode);
                deltaBody = body.faceNode->elem->computeSize.x;
        }
        double deltaX = deltaCur/deltaSlider;
        if (deltaX>1) deltaX=1;
        if(deltaX*deltaBody<MIN_SIZE_CURSOR) 
        {
                deltaX=MIN_SIZE_CURSOR/deltaBody;
        }
        percent=((curMin-minimum)+deltaCur/2.0)/deltaSlider;
        cursor.XDockLeft(percent*deltaBody+SIZE_BUTTON,deltaX*deltaBody,TRUE);
}

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

void Slider::ToString(MyString &str)
{
        str.AddFormat("name: %s",name);
}

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

---