trackButton.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 "myList.h"
#include "texture.h"
#include "button.h"
#include "trackButton.h"

extern ControlEngine ce;

TrackButton::TrackButton()      
{
        // init variable
        name="TrackButton";
        orientation=(DockPos)0;
        onControl.over.out.connect(this,OnOverOut);
        SetResizeAndRotate(FALSE,FALSE);
        isMoving=FALSE;

        // gestion des evenements
}

TrackButton::~TrackButton()
{
}

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

BOOL TrackButton::Create(double depth)
{
        // si pas de mouvement de liberté possible ==> pas de trackBar
        if (!canResize&&!canRotate) return FALSE; 
        SetParent();

        // init general
        faceNode = ce.primitive.AddBox(name,id,depth,TRUE); 
        faceNode->elem->material.SetDS(0.4f,0.4f,0.4f);
        SetAlphaBlending(0.7f);
        ApplyMode();
        return TRUE;
}

void TrackButton::SetResizeAndRotate(BOOL resize,BOOL rotate)
{
        canResize = resize;
        canRotate = rotate;
}

void TrackButton::SetMode(DockPos newOrientation)
{
        if (orientation!=newOrientation)
        {
                orientation = newOrientation;
                ApplyMode();
        }
}


void TrackButton::ApplyMode()
{
        ce.Push(this);

        switch(orientation)
        {
        case left|top:          Config(OnClickLeftTop,&ce.texture.arrowOblique,0); break;
        case left|bottom:       Config(OnClickLeftBottom,&ce.texture.arrowOblique,90); break;
        case right|top:         Config(OnClickRightTop,&ce.texture.arrowOblique,-90); break;
        case right|bottom:      Config(OnClickRightBottom,&ce.texture.arrowOblique,180); break;
        case left:                      Config(OnClickLeft,&ce.texture.arrow,0); break;
        case right:                     Config(OnClickRight,&ce.texture.arrow,180); break;
        case top:                       Config(OnClickTop,&ce.texture.arrow,-90);       break;
        case bottom:            Config(OnClickBottom,&ce.texture.arrow,90); break;
        }
        ce.Pop();
}

void TrackButton::Config(int (TrackButton::*onClickFace)(StateMouse *,int),Texture *texture,double angleZ)
{
        if (!faceNode) return;
        for (int i=0;i<6;i++) faceNode->Elems(i)->texture=texture;
        RotateTo(0,0,angleZ);
        onControl.mouse.left.click.disconnect_all();
        if (canRotate) onControl.mouse.left.click.connect(this,onClickFace);
        onControl.mouse.move.disconnect_all();
        if (canResize) onControl.mouse.move.connect(this,OnMouseMove);
}

int TrackButton::OnClickLeft(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickLeft",mouse,face);
        if (!isMoving&&parent) parent->Rotate(0,-90,0);
        return 1;
}

int TrackButton::OnClickRight(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickRight",mouse,face);
        if (!isMoving&&parent) parent->Rotate(0,90,0);
        return 1;
}

int TrackButton::OnClickTop(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickTop",mouse,face);
        if (!isMoving&&parent) parent->Rotate(-90,0,0);
        return 1;
}

int TrackButton::OnClickBottom(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickBottom",mouse,face);
        if (!isMoving&&parent) parent->Rotate(90,0,0);
        return 1;
}

int TrackButton::OnClickLeftTop(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickLeftTop",mouse,face);
        if (!isMoving&&parent) parent->Rotate(-90,-90,0);
        return 1;
}

int TrackButton::OnClickLeftBottom(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickLeftBottom",mouse,face);
        if (!isMoving&&parent) parent->Rotate(90,-90,0);
        return 1;
}

int TrackButton::OnClickRightTop(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickRightTop",mouse,face);
        if (!isMoving&&parent) parent->Rotate(-90,90,0);
        return 1;
}

int TrackButton::OnClickRightBottom(StateMouse *mouse,int face)
{
        DebugMouse2("TrackButton::OnClickRightBottom",mouse,face);
        if (!isMoving&&parent) parent->Rotate(-90,90,0);
        return 1;
}

int TrackButton::OnMouseMove(StateMouse *mouse,int deltaX,int deltaY,int face)
{
        //DebugMouse2("TrackButton::OnMouseMove",mouse,face);
        if (!parent) return 0;
        isMoving=FALSE;
        if (mouse->leftBtn) 
        {
                isMoving=TRUE;
                switch(orientation)
                {
                case left|top:          parent->ReSize(deltaX*2,deltaY*2); break;
                case left|bottom:       parent->ReSize(deltaX*2,-deltaY*2); break;
                case right|top:         parent->ReSize(-deltaX*2,deltaY*2); break;
                case right|bottom:      parent->ReSize(-deltaX*2,-deltaY*2); break;
                case left:                      parent->ReSize(deltaX*2,0); break;
                case right:                     parent->ReSize(-deltaX*2,0); break;
                case top:                       parent->ReSize(0,deltaY*2); break;
                case bottom:            parent->ReSize(0,-deltaY*2); break;
                }
        }
        if (mouse->rightBtn) 
        {
                isMoving=TRUE;
                switch(orientation)
                {
                case left|top:          
                case left|bottom:       
                case right|top:         
                case right|bottom:      
                        parent->Move(-deltaX,deltaY,0); break;
                case left:                      
                case right:                     
                        parent->Move(-deltaX,0,0); break;
                case top:                       
                case bottom:            
                        parent->Move(0,deltaY,0); break;
                }
        }
        return 0; // heritage au parent pour mouvement du control eventuel
}

int TrackButton::OnOverOut(Control *newControl,int face)
{
        Debug2Param("TrackButton::OnOverOut(newCtrl:%s,%d)",(char *)newControl->name,face);
        orientation=(DockPos)0;
        isMoving = FALSE;
        return 0;
}

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

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

---