colobot/src/ui/editvalue.cpp

381 lines
7.3 KiB
C++
Raw Normal View History

2012-03-19 11:44:39 +00:00
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * 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 3 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.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// editvalue.cpp
#define STRICT
#define D3D_OVERLOADS
#include <windows.h>
#include <stdio.h>
#include <d3d.h>
#include "common/struct.h"
#include "graphics/d3d/d3dengine.h"
#include "math/old/math3d.h"
#include "common/event.h"
#include "common/misc.h"
#include "common/iman.h"
#include "ui/edit.h"
#include "ui/button.h"
#include "ui/editvalue.h"
// Object's constructor.
CEditValue::CEditValue(CInstanceManager* iMan) : CControl(iMan)
{
m_edit = 0;
m_buttonUp = 0;
m_buttonDown = 0;
m_type = EVT_100; // %
m_stepValue = 0.1f; // 10%
m_minValue = 0.0f; // 0%
m_maxValue = 1.0f; // 100%
}
// Object's destructor.
CEditValue::~CEditValue()
{
delete m_edit;
delete m_buttonUp;
delete m_buttonDown;
}
// Creates a new button.
bool CEditValue::Create(FPOINT pos, FPOINT dim, int icon, EventMsg eventMsg)
{
CEdit* pe;
CButton* pc;
if ( eventMsg == EVENT_NULL ) eventMsg = GetUniqueEventMsg();
CControl::Create(pos, dim, icon, eventMsg);
GlintDelete();
m_edit = new CEdit(m_iMan);
pe = (CEdit*)m_edit;
pe->Create(pos, dim, 0, EVENT_NULL);
pe->SetMaxChar(4);
m_buttonUp = new CButton(m_iMan);
pc = (CButton*)m_buttonUp;
pc->Create(pos, dim, 49, EVENT_NULL); // ^
pc->SetRepeat(true);
m_buttonDown = new CButton(m_iMan);
pc = (CButton*)m_buttonDown;
pc->Create(pos, dim, 50, EVENT_NULL); // v
pc->SetRepeat(true);
MoveAdjust();
return true;
}
void CEditValue::SetPos(FPOINT pos)
{
CControl::SetPos(pos);
MoveAdjust();
}
void CEditValue::SetDim(FPOINT dim)
{
CControl::SetDim(dim);
MoveAdjust();
}
void CEditValue::MoveAdjust()
{
FPOINT pos, dim;
if ( m_edit != 0 )
{
pos.x = m_pos.x;
pos.y = m_pos.y;
dim.x = m_dim.x-m_dim.y*0.6f;
dim.y = m_dim.y;
m_edit->SetPos(pos);
m_edit->SetDim(dim);
}
if ( m_buttonUp != 0 )
{
pos.x = m_pos.x+m_dim.x-m_dim.y*0.6f;
pos.y = m_pos.y+m_dim.y*0.5f;
dim.x = m_dim.y*0.6f;
dim.y = m_dim.y*0.5f;
m_buttonUp->SetPos(pos);
m_buttonUp->SetDim(dim);
}
if ( m_buttonDown != 0 )
{
pos.x = m_pos.x+m_dim.x-m_dim.y*0.6f;
pos.y = m_pos.y;
dim.x = m_dim.y*0.6f;
dim.y = m_dim.y*0.5f;
m_buttonDown->SetPos(pos);
m_buttonDown->SetDim(dim);
}
}
// Management of an event.
bool CEditValue::EventProcess(const Event &event)
{
float value;
CControl::EventProcess(event);
if ( (m_state & STATE_VISIBLE) == 0 ) return true;
if ( (m_state & STATE_ENABLE) == 0 ) return true;
if ( m_edit != 0 )
{
if ( m_edit->RetFocus() &&
event.event == EVENT_KEYDOWN &&
event.param == VK_RETURN )
{
value = RetValue();
if ( value > m_maxValue ) value = m_maxValue;
if ( value < m_minValue ) value = m_minValue;
SetValue(value, true);
HiliteValue(event);
}
if ( !m_edit->EventProcess(event) ) return false;
if ( event.event == m_edit->RetEventMsg() )
{
Event newEvent;
m_event->MakeEvent(newEvent, m_eventMsg);
m_event->AddEvent(newEvent);
}
}
if ( m_buttonUp != 0 )
{
if ( event.event == m_buttonUp->RetEventMsg() )
{
value = RetValue()+m_stepValue;
if ( value > m_maxValue ) value = m_maxValue;
SetValue(value, true);
HiliteValue(event);
}
if ( !m_buttonUp->EventProcess(event) ) return false;
}
if ( m_buttonDown != 0 )
{
if ( event.event == m_buttonDown->RetEventMsg() )
{
value = RetValue()-m_stepValue;
if ( value < m_minValue ) value = m_minValue;
SetValue(value, true);
HiliteValue(event);
}
if ( !m_buttonDown->EventProcess(event) ) return false;
}
if ( event.event == EVENT_KEYDOWN &&
event.param == VK_WHEELUP &&
Detect(event.pos) )
{
value = RetValue()+m_stepValue;
if ( value > m_maxValue ) value = m_maxValue;
SetValue(value, true);
HiliteValue(event);
}
if ( event.event == EVENT_KEYDOWN &&
event.param == VK_WHEELDOWN &&
Detect(event.pos) )
{
value = RetValue()-m_stepValue;
if ( value < m_minValue ) value = m_minValue;
SetValue(value, true);
HiliteValue(event);
}
return true;
}
// Puts in evidence the edited value.
void CEditValue::HiliteValue(const Event &event)
{
int pos;
if ( m_edit == 0 ) return;
pos = m_edit->RetTextLength();
if ( m_type == EVT_100 && pos > 0 )
{
pos --; // not only selects the "%"
}
m_edit->SetCursor(pos, 0);
m_edit->SetFocus(true);
Event newEvent = event;
newEvent.event = EVENT_FOCUS;
newEvent.param = m_edit->RetEventMsg();
m_event->AddEvent(newEvent); // defocus the other objects
}
// Draw button.
void CEditValue::Draw()
{
if ( (m_state & STATE_VISIBLE) == 0 ) return;
if ( m_state & STATE_SHADOW )
{
DrawShadow(m_pos, m_dim);
}
if ( m_edit != 0 )
{
m_edit->Draw();
}
if ( m_buttonUp != 0 )
{
m_buttonUp->Draw();
}
if ( m_buttonDown != 0 )
{
m_buttonDown->Draw();
}
}
// Choosing the type of value.
void CEditValue::SetType(EditValueType type)
{
m_type = type;
}
EditValueType CEditValue::RetType()
{
return m_type;
}
// Changes the value.
void CEditValue::SetValue(float value, bool bSendMessage)
{
char text[100];
if ( m_edit == 0 ) return;
text[0] = 0;
if ( m_type == EVT_INT )
{
sprintf(text, "%d", (int)value);
}
if ( m_type == EVT_FLOAT )
{
sprintf(text, "%.2f", value);
}
if ( m_type == EVT_100 )
{
sprintf(text, "%d%%", (int)(value*100.0f));
}
m_edit->SetText(text);
if ( bSendMessage )
{
Event newEvent;
m_event->MakeEvent(newEvent, m_eventMsg);
m_event->AddEvent(newEvent);
}
}
// Return the edited value.
float CEditValue::RetValue()
{
char text[100];
float value;
if ( m_edit == 0 ) 0.0f;
m_edit->GetText(text, 100);
sscanf(text, "%f", &value);
if ( m_type == EVT_100 )
{
value = (value+0.5f)/100.0f;
if ( value < 0.01f ) value = 0.0f; // less than 1%?
}
return value;
}
// Management not for buttons.
void CEditValue::SetStepValue(float value)
{
m_stepValue = value;
}
float CEditValue::RetStepValue()
{
return m_stepValue;
}
// Management of the minimum value.
void CEditValue::SetMinValue(float value)
{
m_minValue = value;
}
float CEditValue::RetMinValue()
{
return m_minValue;
}
// Management of the maximum value.
void CEditValue::SetMaxValue(float value)
{
m_maxValue = value;
}
float CEditValue::RetMaxValue()
{
return m_maxValue;
}