aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-07 15:59:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/ryzom/client/src/interfaces_manager/osd.cpp
acemtp 1792297c93 initial version
2010-05-06 02:08:41 +02:00

3234 lines
79 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
//////////////
// Includes //
//////////////
// Misc.
#include "nel/misc/path.h"
// 3D Interface.
#include "nel/3d/u_driver.h"
// Client.
#include "osd.h"
#include "text.h"
#include "capture.h"
#include "button.h"
#include "radio_button.h"
#include "radio_controller.h"
#include "bitmap.h"
#include "interfaces_manager.h"
#include "interf_list.h"
#include "multi_list.h"
#include "interf_script.h"
#include "chat_control.h"
#include "chat_input.h"
#include "choice_list.h"
#include "candidate_list.h"
#include "horizontal_list.h"
#include "control_list.h"
#include "spell_list.h"
#include "progress_bar.h"
#include "casting_bar.h"
#include "brick_control.h"
// Std
#include <string>
///////////
// Using //
///////////
using namespace NLMISC;
using namespace NL3D;
using namespace std;
/////////////
// Externs //
/////////////
extern UDriver *Driver;
extern UTextContext *TextContext;
static std::list< uint16 > elts;
///////////
// MACRO //
///////////
// Macro pour toute la partie commune de lecture des scripts pour les controls.
#define CONTROL_SCRIPT_MACRO(UserScript) \
\
CControl::THotSpot hs = CControl::HS_MM; \
CControl::THotSpot origin = CControl::HS_MM;\
uint idParent = 0; \
float x = 0.f; \
float y = 0.f; \
float xPixel = 0.f; \
float yPixel = 0.f; \
float w = 0.f; \
float h = 0.f; \
float wPixel = 0.f; \
float hPixel = 0.f; \
\
elts.clear(); \
char delimiter[] = "[] \t"; \
char *ptr = strtok(NULL, delimiter); \
while(ptr != NULL) \
{ \
if(strcmp(ptr, "HotSpot:") == 0) \
hs = getHotSpot(); \
else if(strcmp(ptr, "Origin:") == 0) \
origin = getHotSpot(); \
else if(strcmp(ptr, "Parent:") == 0) \
idParent = getInt(); \
else if(strcmp(ptr, "X:") == 0) \
x = getFloat(); \
else if(strcmp(ptr, "Y:") == 0) \
y = getFloat(); \
else if(strcmp(ptr, "X_Pixel:") == 0) \
xPixel = getFloat(); \
else if(strcmp(ptr, "Y_Pixel:") == 0) \
yPixel = getFloat(); \
else if(strcmp(ptr, "W:") == 0) \
w = getFloat(); \
else if(strcmp(ptr, "H:") == 0) \
h = getFloat(); \
else if(strcmp(ptr, "W_Pixel:") == 0) \
wPixel = getFloat(); \
else if(strcmp(ptr, "H_Pixel:") == 0) \
hPixel = getFloat(); \
\
UserScript \
\
ptr = strtok(NULL, delimiter); \
}
//-----------------------------------------------
// COSD :
// Constructor.
//-----------------------------------------------
COSD::COSD(bool popUp)
{
// Common init for all constructors.
init(0, 0.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.0f, 0.0f, popUp);
}// COSD //
//-----------------------------------------------
// COSD :
// Constructor.
//-----------------------------------------------
COSD::COSD(uint id, float x, float y, float x_pixel, float y_pixel, float w, float h, float w_pixel, float h_pixel, float minWidth, float minHeight, bool popUp)
{
// Common init for all constructors.
init(id, x, y, x_pixel, y_pixel, w, h, w_pixel, h_pixel, minWidth, minHeight, popUp);
}// COSD //
//-----------------------------------------------
// init :
// Initialize the OSD (1 function called for all constructors -> easier).
//-----------------------------------------------
void COSD::init(uint id, float x, float y, float x_pixel, float y_pixel, float w, float h, float w_pixel, float h_pixel, float minWidth, float minHeight, bool popUp)
{
_Id = id;
_PopUp = popUp;
// pop up are never resizable
if (_PopUp == true)
_OSD_Mode = TMode::locked;
// Default is OSD visible.
_Show = true;
_W_Min = minWidth; // minimal width of the OSD
_H_Min = minHeight; // minimal height of the OSD
_X = x; // Position X of the OSD (between 0-1).
_Y = y; // Position Y of the OSD (between 0-1).
_X_Pixel = x_pixel; // Position X of the OSD (in Pixel).
_Y_Pixel = y_pixel; // Position Y of the OSD (in Pixel).
_W = w; // Width of the OSD (between 0-1).
_H = h; // Height of the OSD (between 0-1).
_W_Pixel = w_pixel; // Width of the OSD (in Pixel).
_H_Pixel = h_pixel; // Height of the OSD (in Pixel).
// How to display the OSD.
_OSD_Mode = none;
// Name of the OSD;
_OSD_Name = ucstring("");
// NO Background
_BG_Mode = BG_none;
// NO Title Bar
_TB_Mode = TB_none;
// Height of the move zone.
_TB_H = 20;
// Pen for the OSD Name.
_TB_Pen = CPen(15, CRGBA(255,0,150,255), true);
// HighLight size in pixel.
_HL_Size = 1;
// Resize
_RS_Mode = no_resize;
// Color of the Move zone.
_RS_Color = CRGBA(200,200,200,128);
// Width of the resize zone.
_RS_Size = 4;
// NO update Function.
_OSD_Update_Func = 0;
// Calculate others variables.
// calculateDisplay(); // done into the 'resize' method, called by the 'open' method
}// init //
//-----------------------------------------------
// ~COSD :
// Destructor.
//-----------------------------------------------
COSD::~COSD()
{
// Get all the controls and destroy them.
for(TMapControls::iterator it = _Controls.begin(); it != _Controls.end(); it++)
{
// Delete the control if still allocated.
if((*it).second != NULL)
{
delete ((*it).second);
(*it).second = 0;
}
}
// Clear all the control.
_Controls.clear();
_Children.clear();
}// ~COSD //
//-----------------------------------------------
// display :
// Display the OSD.
//-----------------------------------------------
void COSD::display()
{
// Is the OSD is not visible -> return;
if(!_Show)
return;
// Draw the background
drawBG();
// Backup scissor and change scissor to clip the list correctly.
CScissor oldScissor = Driver->getScissor();
CScissor scissor;
scissor.init(_X_Display, _Y_Display, _W_Display, _H_Display);
Driver->setScissor(scissor);
// Draw controls in the OSD.
for(TListControl::reverse_iterator it = _Children.rbegin(); it != _Children.rend(); it++)
(*it)->display();
// Restore Scissor.
Driver->setScissor(oldScissor);
// How to display the OSD.
switch(_OSD_Mode)
{
// OSD HighLighted
case selected:
// Draw Borders.
drawBorders(_HL_W, _HL_H, _X_Display, _Y_Display, _X_Display+_W_Display, _Y_Display+_H_Display, _HL_Color);
break;
// OSD with a Border to resize.
case resizable:
// Draw big Borders.
drawBorders(_RS_W, _RS_H, _X_Display, _Y_Display, _X_Display+_W_Display, _Y_Display+_H_Display, _RS_Color);
break;
// OSD with a Border and an Area to move the OSD.
case movable:
// Draw the Title Bar.
drawTB();
// Draw Big Borders.
drawBorders(_RS_W, _RS_H, _X_Display, _Y_Display, _X_Display+_W_Display, _Y_Display+_H_Display, _RS_Color);
// Draw the OSD Name -> if the text is not empty.
if(!_OSD_Name.empty())
drawText(_X_Display+_W_Display/2, _Y_Display+_H_Display-_RS_H-_TB_H_Display/2, _OSD_Name, _TB_Pen);
break;
}
}// display //
//-----------------------------------------------
// drawBG :
// Function to draw the background according to the mode.
//-----------------------------------------------
void COSD::drawBG()
{
// Display the Background.
switch(_BG_Mode)
{
// Backgroung is only made by 1 color (RGBA).
case BG_plain:
Driver->drawQuad(_X_Display, _Y_Display, _X_Display+_W_Display, _Y_Display+_H_Display, _BG_Color);
break;
// Background is stretch at the OSD size.
case BG_stretch:
Driver->drawBitmap(_X_Display, _Y_Display, _W_Display, _H_Display, *CInterfMngr::getTexture(_BG), true, _BG_Color);
break;
// No Background.
default:
break;
}
}// drawBG //
//-----------------------------------------------
// drawTB :
// Function to draw the Title Bar according to the mode.
//-----------------------------------------------
void COSD::drawTB()
{
// Display Title Bar.
switch(_TB_Mode)
{
// Backgroung is only made by 1 color (RGBA).
case TB_plain:
Driver->drawQuad(_X_Display+_RS_W, _Y_Display+_H_Display-_RS_H-_TB_H_Display, _X_Display+_W_Display-_RS_W, _Y_Display+_H_Display-_RS_H, _TB_Color);
break;
// Background is stretch at the OSD size.
case TB_stretch:
Driver->drawBitmap(_X_Display+_RS_W, _Y_Display+_H_Display-_RS_H-_TB_H_Display, _W_Display-2*_RS_W, _TB_H_Display, *CInterfMngr::getTexture(_TB), true, _TB_Color);
break;
// No Background.
default:
break;
}
}// drawTB //
//-----------------------------------------------
// drawBorders :
// Draw the resize borders.
//-----------------------------------------------
void COSD::drawBorders(float bSizeW, float bSizeH, float x0, float y0, float x1, float y1, const CRGBA &color)
{
Driver->drawQuad(x0, y0, x0+bSizeW, y1, color);
Driver->drawQuad(x1-bSizeW, y0, x1, y1, color);
Driver->drawQuad(x0, y0, x1, y0+bSizeH, color);
Driver->drawQuad(x0, y1-bSizeH, x1, y1, color);
}// drawBorders //
//-----------------------------------------------
// drawText :
// Draw a text with all informations needed.
//-----------------------------------------------
void COSD::drawText(float x, float y, const ucstring &text, const CPen &pen)
{
TextContext->setHotSpot(UTextContext::MiddleMiddle);
TextContext->setColor(pen.color());
TextContext->setFontSize(pen.fontSize());
TextContext->setShaded(pen.shadow());
TextContext->printAt(x, y, text);
}// drawText //
//-----------------------------------------------
// resize :
// The OSD size has changed -> resize controls.
//-----------------------------------------------
void COSD::resize(uint32 width, uint32 height)
{
// Update variables because of the resize.
calculateDisplay();
// resize the other controls.
for(TMapControls::iterator it = _Controls.begin(); it != _Controls.end(); it++)
{
// If the control as a reference different than the OSD -> the Reference will resize this control.
if((*it).second->parent() == 0)
{
float x, y;
(*it).second->resize(width, height);
calculatePos(x, y, (*it).second->origin());
(*it).second->ref(x, y, _W_Display, _H_Display);
}
}
}// resize //
//-----------------------------------------------
// update :
// Update the OSD (for timer, etc.).
//-----------------------------------------------
bool COSD::update(float x, float y, bool fullUse)
{
bool used = false;
// Function called every frame.
CInterfMngr::runFuncCtrl(_OSD_Update_Func, 0);
//
if(fullUse)
{
if(_RS_Mode != no_resize)
{
// Get the window size.
uint32 w, h;
CInterfMngr::getWindowSize(w, h);
// Resize correctly the OSD.
switch(_RS_Mode)
{
// Resize Bottom OSD Border.
case resize_B:
resizeB(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_B;
break;
// Resize Top OSD Border.
case resize_T:
resizeT(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_T;
break;
// Resize Left OSD Border.
case resize_L:
resizeL(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_L;
break;
// Resize Right OSD Border.
case resize_R:
resizeR(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_R;
break;
// Resize Bottom Left OSD Border.
case resize_BL:
resizeB(x, y);
resizeL(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_BL;
break;
// Resize Top Left OSD Border.
case resize_TL:
resizeT(x, y);
resizeL(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_TL;
break;
// Resize Bottom Right OSD Border.
case resize_BR:
resizeB(x, y);
resizeR(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_BR;
break;
// Resize Top Right OSD Border.
case resize_TR:
resizeT(x, y);
resizeR(x, y);
// Resize -> resize cursor.
_Cursor = Cur_Resize_TR;
break;
// Move the OSD.
case resize_move:
move(x, y);
// Move -> move cursor.
_Cursor = Cur_Move;
break;
default:
_Cursor = Cur_None;
break;
}
// Give the new OSD size to controls.
for(TMapControls::iterator it = _Controls.begin(); it != _Controls.end(); it++)
{
if((*it).second->parent() == 0)
{
float x, y;
calculatePos(x, y, (*it).second->origin());
(*it).second->ref(x, y, _W_Display, _H_Display);
}
}
//
used = true;
}
else
{
switch(_OSD_Mode)
{
// In Locked mode, the OSD mode can't change.
case locked:
// OSD locked -> no cursor needed by the OSD.
_Cursor = Cur_None;
break;
// Else the OSD mode changes according to the mouse position.
default:
// Check the cursor is inside the OSD.
if(x>=_X_Display && x<_X_Display+_W_Display && y>=_Y_Display && y<_Y_Display+_H_Display)
{
// Change the cursor look according to its position.
// Get the window size.
uint32 w, h;
CInterfMngr::getWindowSize(w, h);
float cornerSizeX = _RS_W+_TB_H/(float)w;
float cornerSizeY = _RS_H+_TB_H/(float)h;
enum TXState
{
X_0 = 0x00,
X_1 = 0x01,
X_2 = 0x02,
X_3 = 0x03,
X_4 = 0x04
};
enum TYState
{
Y_0 = 0x00,
Y_1 = 0x10,
Y_2 = 0x20,
Y_3 = 0x30,
Y_4 = 0x40
};
TXState x_State;
TYState y_State;
// X POSITION in the OSD.
// X is in the right part of the OSD (move, resize right, or resize right corners)
if(x >= _X_Display+_W_Display-cornerSizeX)
{
// Resize right or right corners.
if(x >= _X_Display+_W_Display-_RS_W)
x_State = X_4;
// Move or resize right corners.
else
x_State = X_3;
}
// X is in the left part of the OSD (move, resize left, or resize left corners)
else if(x < _X_Display+cornerSizeX)
{
// Resize left or left corners.
if(x < _X_Display+_RS_W)
x_State = X_0;
// Move or resize left corners.
else
x_State = X_1;
}
// X is in the middle part of the OSD (move, resize top or bottom).
else
x_State = X_2;
// Y POSITION in the OSD.
// Y is in the Top part of the OSD (move, resize top, or resize top corners)
if(y >= _Y_Display+_H_Display-cornerSizeY)
{
// Resize top or top corners.
if(y >= _Y_Display+_H_Display-_RS_H)
y_State = Y_4;
// Move or resize top corners.
else
y_State = Y_3;
}
// Y is in the bottom part of the OSD (move, resize bottom, or resize bottom corners)
else if(y < _Y_Display+cornerSizeY)
{
// Resize bottom or bottm corners.
if(y < _Y_Display+_RS_H)
y_State = Y_0;
// Move or resize bottom corners.
else
y_State = Y_1;
}
// Y is in the middle part of the OSD (move, resize left or right).
else
y_State = Y_2;
// Determine the Resize Mode.
switch(x_State | y_State)
{
// Left Bottom corner
case X_1|Y_0:
case X_0|Y_0:
case X_0|Y_1:
_Cursor = Cur_Resize_BL;
break;
// Left side
case X_0|Y_2:
_Cursor = Cur_Resize_L;
break;
// Left Top corner
case X_0|Y_3:
case X_0|Y_4:
case X_1|Y_4:
_Cursor = Cur_Resize_TL;
break;
// Top Side.
case X_2|Y_4:
_Cursor = Cur_Resize_T;
break;
// Right Top Corner.
case X_3|Y_4:
case X_4|Y_4:
case X_4|Y_3:
_Cursor = Cur_Resize_TR;
break;
// Right Side.
case X_4|Y_2:
_Cursor = Cur_Resize_R;
break;
// Right Bottom Corner.
case X_4|Y_1:
case X_4|Y_0:
case X_3|Y_0:
_Cursor = Cur_Resize_BR;
break;
// Bottom Side.
case X_2|Y_0:
_Cursor = Cur_Resize_B;
break;
// Move Area
case X_1|Y_3:
case X_2|Y_3:
case X_3|Y_3:
_Cursor = Cur_Move;
break;
// Inside Area
default:
_Cursor = Cur_None;
break;
}
// Change the display of the OSD according to the cursor position.
testMode(x, y, _X_Display+_RS_W*2, _Y_Display+_RS_H*2, _X_Display+_W_Display-_RS_W*2, _Y_Display+_H_Display-_TB_H_Display-_RS_H*2);
// ...
used = true;
}
else
{
_OSD_Mode = none;
// Cursor outside the OSD -> no cursor needed by the OSD.
_Cursor = Cur_None;
}
break;
}
}
}
else
{
// Manage the OSD mode when the OSD do not have the Focus.
switch(_OSD_Mode)
{
// In locked mode the mode do not change.
case locked:
break;
// Else the OSD mode changes to "none".
default:
_OSD_Mode = none;
break;
}
// OSD do not have any interaction -> no cursor.
_Cursor = Cur_None;
}
// call the mouseMove() method on every child control
TListControl::iterator itControl;
const TListControl::iterator itControlEnd = _Children.end();
for (itControl = _Children.begin() ; itControl != itControlEnd ; ++itControl)
{
nlassert(*itControl);
// only send the mouse move event to controls with show = true
if ( (*itControl)->show() )
(*itControl)->mouseMove( x, y );
}
// Return if the OSD as react.
return used;
}// update //
//-----------------------------------------------
// cursor :
// Return the cursor used by the OSD at the moment.
// \return ECursor : 'Cur_None' if no cursor needed for the OSD.
// \warning This method should be called after the update one to be up to date.
//-----------------------------------------------
COSD::ECursor COSD::cursor()
{
// Is the OSD is not visible -> no cursor needed;
if(!_Show)
return Cur_None;
// Return the cursor used for the OSD at the moment.
return _Cursor;
}// cursor //
//-----------------------------------------------
// click :
// Manage the mouse click.
//-----------------------------------------------
void COSD::click(float x, float y, bool &taken)
{
// Is the OSD is not visible -> return;
if(!_Show)
return;
// if pop_up and cick was outside the window bounds: destroy that window
if ( _PopUp )
{
if ( (x < _X_Display) || (x >= _X_Display + _W_Display) || (y < _Y_Display) || (y >= _Y_Display + _H_Display) )
{
CInterfMngr::deleteOSD( this->_Id);
return;
}
}
_OffsetX = x-_X_Display;
_OffsetY = y-_Y_Display;
_OffsetW = x-(_X_Display+_W_Display);
_OffsetH = y-(_Y_Display+_H_Display);
// If some resize operations are in progress -> Stop resize.
if(_RS_Mode != no_resize)
{
_RS_Mode = no_resize;
taken = true;
}
else if (!taken)
{
// Look if the OSD will be resized.
switch(_OSD_Mode)
{
// In some _OSD_Mode the aspect OSD can change -> test if it changes.
case resizable:
case movable:
// Select the right resize mode -> mode != no_resize -> click = true.
if(resizeMode(x, y) != TResize::no_resize)
taken = true;
break;
}
}
// Dispatch the click in the controls.
const TListControl::iterator itE = _Children.end();
for(TListControl::iterator it = _Children.begin(); it != itE ; ++it)
{
// only send the click event to controls with show = true
if ( (*it)->show() )
(*it)->click(x, y, taken);
}
}// click //
//-----------------------------------------------
// clickRight :
// Manage the mouse right click.
//-----------------------------------------------
void COSD::clickRight(float x, float y, bool &taken)
{
// Is the OSD is not visible -> return;
if(!_Show)
return;
// if pop_up and cick was outside the window bounds: destroy that window
if ( _PopUp && ( (x < _X_Display) || (x >= _X_Display + _W_Display) || (y < _Y_Display) || (y >= _Y_Display + _H_Display) ) )
{
CInterfMngr::deleteOSD( this->_Id);
return;
}
_OffsetX = x-_X_Display;
_OffsetY = y-_Y_Display;
_OffsetW = x-(_X_Display+_W_Display);
_OffsetH = y-(_Y_Display+_H_Display);
// If some resize operations are in progress -> Stop resize.
if(_RS_Mode != no_resize)
{
_RS_Mode = no_resize;
_OSD_Mode = locked;
taken = true;
}
// Dispatch the click in the controls.
const TListControl::iterator itE = _Children.end();
for(TListControl::iterator it = _Children.begin(); it != itE ; ++it)
{
// only send the click event to controls with show = true
if ( (*it)->show() )
(*it)->clickRight(x, y, taken);
}
// Lock/Unlock the OSD
if(!taken)
{
// Check that the cursor is in the OSD.
if((x >= _X_Display) && (x < _X_Display + _W_Display) && (y >= _Y_Display) && (y < _Y_Display + _H_Display) )
{
if(_OSD_Mode != locked)
_OSD_Mode = locked;
else
_OSD_Mode = none;
taken = true;
}
}
}// clickRight //
//-----------------------------------------------
// resizeL :
// Resize the Left border of the OSD.
//-----------------------------------------------
void COSD::resizeL(float x, float y)
{
uint32 width, height;
CInterfMngr::getWindowSize(width, height);
const float wMin = _W_Min / width;
float xTmp = _X_Display + _W_Display;
_X_Display = x - _OffsetX;
if( _X_Display > xTmp - wMin )
_X_Display = xTmp - wMin;
_X = _X_Display;
_W_Display = xTmp - _X_Display;
_W_Pixel = _W_Display*width;
}// resizeL //
//-----------------------------------------------
// resizeR :
// Resize the Right border of the OSD.
//-----------------------------------------------
void COSD::resizeR(float x, float y)
{
uint32 width, height;
CInterfMngr::getWindowSize(width, height);
const float wMin = _W_Min / width;
_W_Display = x - _OffsetW - _X_Display;
if(_W_Display < wMin )
_W_Display = wMin;
_W_Pixel = _W_Display*width;
}// resizeR //
//-----------------------------------------------
// resizeB :
// Resize the Bottom border of the OSD.
//-----------------------------------------------
void COSD::resizeB(float x, float y)
{
uint32 width, height;
CInterfMngr::getWindowSize(width, height);
const float hMin = _H_Min / height;
float yTmp = _Y_Display + _H_Display;
_Y_Display = y-_OffsetY;
if(_Y_Display > yTmp - hMin )
_Y_Display = yTmp - hMin;
_Y = _Y_Display;
_H_Display = yTmp - _Y_Display;
_H_Pixel = _H_Display*height;
}// resizeB //
//-----------------------------------------------
// resizeT :
// Resize the Top border of the OSD.
//-----------------------------------------------
void COSD::resizeT(float x, float y)
{
uint32 width, height;
CInterfMngr::getWindowSize(width, height);
const float hMin = _H_Min / height;
_H_Display = y - _OffsetH - _Y_Display;
if(_H_Display < hMin )
_H_Display = hMin;
_H_Pixel = _H_Display*height;
}// resizeT //
//-----------------------------------------------
// move :
// Move the OSD.
//-----------------------------------------------
void COSD::move(float x, float y)
{
_X_Display = x-_OffsetX;
_Y_Display = y-_OffsetY;
_X = _X_Display;
_Y = _Y_Display;
}// move //
//-----------------------------------------------
// testMode :
// Test the mode of the OSD.
//-----------------------------------------------
void COSD::testMode(float x, float y, float rectX0, float rectY0, float rectX1, float rectY1)
{
if(y>rectY1)
_OSD_Mode = movable;
else
{
if(x < rectX0 || x > rectX1 || y < rectY0)
_OSD_Mode = resizable;
else
_OSD_Mode = selected;
}
}// testMode //
/////////
// OSD //
//-----------------------------------------------
// osdSetPosition :
// Change the OSD Position.
//-----------------------------------------------
void COSD::osdSetPosition(float x, float y)
{
_X = _X_Display = x;
_Y = _Y_Display = y;
// resize the other controls.
for(TMapControls::iterator it = _Controls.begin(); it != _Controls.end(); it++)
{
// If the control as a reference different than the OSD -> the Reference will resize this control.
if((*it).second->parent() == 0)
{
float x0, y0;
calculatePos(x0, y0, (*it).second->origin());
(*it).second->ref(x0, y0, _W_Display, _H_Display);
}
}
}// osdSetPosition //
//-----------------------------------------------
// osdGetPosition :
// Return the OSD Position.
//-----------------------------------------------
void COSD::osdGetPosition(float &x, float &y) const
{
x = _X_Display;
y = _Y_Display;
}// osdGetPosition //
//-----------------------------------------------
// osdGetSize :
// Change the OSD Size (between 0-1).
//-----------------------------------------------
void COSD::osdSetSize(float w, float h)
{
uint32 width, height;
CInterfMngr::getWindowSize(width, height);
_W_Display = w;
_H_Display = h;
_W_Pixel = _W_Display*width;
_H_Pixel = _H_Display*height;
// resize the other controls.
for(TMapControls::iterator it = _Controls.begin(); it != _Controls.end(); it++)
{
// If the control as a reference different than the OSD -> the Reference will resize this control.
if((*it).second->parent() == 0)
{
float x0, y0;
calculatePos(x0, y0, (*it).second->origin());
(*it).second->ref(x0, y0, _W_Display, _H_Display);
}
}
}// osdGetSize //
//-----------------------------------------------
// osdGetSize :
// Return the OSD Size (between 0-1).
//-----------------------------------------------
void COSD::osdGetSize(float &w, float &h) const
{
w = _W_Display;
h = _H_Display;
}// osdGetSize //
//-----------------------------------------------
// osdMode :
// Change the OSD Mode (locked, resize, selected, etc.)
//-----------------------------------------------
void COSD::osdMode(TMode osdMode)
{
_OSD_Mode = osdMode;
}// osdMode //
//-----------------------------------------------
// osdMode :
// Return the current OSD Mode.
//-----------------------------------------------
COSD::TMode COSD::osdMode() const
{
return _OSD_Mode;
}// osdMode //
//-----------------------------------------------
// osdName :
// Change the OSD Name.
//-----------------------------------------------
void COSD::osdName(const ucstring &osdName)
{
_OSD_Name = osdName;
}// osdName //
//-----------------------------------------------
// osdName :
// Return the OSD Name.
//-----------------------------------------------
ucstring COSD::osdName() const
{
return _OSD_Name;
}// osdName //
//-----------------------------------------------
// updateFunc :
// Set the update Function.
//-----------------------------------------------
void COSD::osdUpdateFunc(uint updateFunc)
{
_OSD_Update_Func = osdUpdateFunc;
}// updateFunc //
//-----------------------------------------------
// updateFunc :
// Get the update Function.
//-----------------------------------------------
uint COSD::osdUpdateFunc() const
{
return _OSD_Update_Func;
}// updateFunc //
////////////////
// BACKGROUND //
//-----------------------------------------------
// bgMode :
// Set the Background display mode.
void COSD::bgMode(TBG mode)
//-----------------------------------------------
{
_BG_Mode = mode;
}// bgMode //
//-----------------------------------------------
// bgMode :
// Get the Background display mode.
//-----------------------------------------------
COSD::TBG COSD::bgMode() const
{
return _BG_Mode;
}// bgMode //
//-----------------------------------------------
// bg :
// Set the texture Id for the Background.
//-----------------------------------------------
void COSD::bg(uint b)
{
_BG = b;
}// bg //
//-----------------------------------------------
// bg :
// Get background Id.
//-----------------------------------------------
uint COSD::bg() const
{
return _BG;
}// bg //
//-----------------------------------------------
// bgColor :
// Set the Background RGBA.
//-----------------------------------------------
void COSD::bgColor(const CRGBA &bRGBA)
{
_BG_Color = bRGBA;
}// bgColor //
//-----------------------------------------------
// bgColor :
// Get the background RGBA.
//-----------------------------------------------
CRGBA COSD::bgColor() const
{
return _BG_Color;
}// bgColor //
///////////////
// TITLE BAR //
//-----------------------------------------------
// tbMode :
// Set the Title Bar display mode.
//-----------------------------------------------
void COSD::tbMode(TTB mode)
{
_TB_Mode = mode;
}// tbMode //
//-----------------------------------------------
// tbMode :
// Get the Title Bar display mode.
//-----------------------------------------------
COSD::TTB COSD::tbMode() const
{
return _TB_Mode;
}// tbMode //
//-----------------------------------------------
// tb :
// Set the texture Id for the Title Bar.
//-----------------------------------------------
void COSD::tb(uint t)
{
_TB = t;
}// tb //
//-----------------------------------------------
// tb :
// Get Title Bar Id.
//-----------------------------------------------
uint COSD::tb() const
{
return _TB;
}// tb //
//-----------------------------------------------
// tbColor :
// Set the Title Bar RGBA.
//-----------------------------------------------
void COSD::tbColor(const CRGBA &tRGBA)
{
_TB_Color = tRGBA;
}// tbColor //
//-----------------------------------------------
// tbColor :
// Get the Title Bar RGBA.
//-----------------------------------------------
CRGBA COSD::tbColor() const
{
return _TB_Color;
}// tbColor //
//-----------------------------------------------
// tbHeight :
// Set Title Bar Height (in Pixel)
//-----------------------------------------------
void COSD::tbHeight(float height)
{
uint32 w, h;
CInterfMngr::getWindowSize(w, h);
_TB_H = height;
// Calculate the Title Bar height for Display.
_TB_H_Display = _TB_H/h;
}// tbHeight //
//-----------------------------------------------
// tbHeight :
// Get Title Bar Height (in Pixel)
//-----------------------------------------------
float COSD::tbHeight() const
{
return _TB_H;
}// tbHeight //
//-----------------------------------------------
// pen :
// Set the Pen for the Title Bar.
//-----------------------------------------------
void COSD::tbPen(const CPen &pen)
{
_TB_Pen = pen;
}// pen //
//-----------------------------------------------
// pen :
// Get the Pen of the Title Bar.
//-----------------------------------------------
CPen COSD::tbPen() const
{
return _TB_Pen;
}// pen //
///////////////
// HIGHLIGHT //
//-----------------------------------------------
// hlColor :
// Set the HighLight Color.
//-----------------------------------------------
void COSD::hlColor(const CRGBA &hlColor)
{
_HL_Color = hlColor;
}// hlColor //
//-----------------------------------------------
// hlColor :
// Get the HighLight Color.
//-----------------------------------------------
CRGBA COSD::hlColor() const
{
return _HL_Color;
}// hlColor //
//-----------------------------------------------
// hlSize :
// Set the HighLight Size (in Pixel).
//-----------------------------------------------
void COSD::hlSize(float hlSize)
{
uint32 w, h;
CInterfMngr::getWindowSize(w, h);
_HL_Size = hlSize;
// Calculate borders for the HighLight.
_HL_W = _HL_Size/w; // Left and Right.
_HL_H = _HL_Size/h; // Bottom and Top.
}// hlSize //
//-----------------------------------------------
// hlSize :
// Get the HighLight Size (in Pixel).
//-----------------------------------------------
float COSD::hlSize() const
{
return _HL_Size;
}// hlSize //
////////////
// RESIZE //
//-----------------------------------------------
// rsMode :
// Set the Resize Mode.
//-----------------------------------------------
void COSD::rsMode(TResize rsMode)
{
_RS_Mode = rsMode;
}// rsMode //
//-----------------------------------------------
// rsMode :
// Get the Resize Mode.
//-----------------------------------------------
COSD::TResize COSD::rsMode() const
{
return _RS_Mode;
}// rsMode //
//-----------------------------------------------
// rsColor :
// Set Resize borders Color
//-----------------------------------------------
void COSD::rsColor(CRGBA rsColor)
{
_RS_Color = rsColor;
}// rsColor //
//-----------------------------------------------
// rsColor :
// Get Resize borders Color
//-----------------------------------------------
CRGBA COSD::rsColor() const
{
return _RS_Color;
}// rsColor //
//-----------------------------------------------
// rsSize :
// Set Resize size (in pixel).
//-----------------------------------------------
void COSD::rsSize(float rsSize)
{
uint32 w, h;
CInterfMngr::getWindowSize(w, h);
_RS_Size = rsSize;
// Calculate borders for the Resize.
_RS_W = _RS_Size/w; // Left and Right.
_RS_H = _RS_Size/h; // Bottom and Top.
}// rsSize //
//-----------------------------------------------
// rsSize :
// Get Resize size (in pixel).
//-----------------------------------------------
float COSD::rsSize() const
{
return _RS_Size;
}// rsSize //
//-----------------------------------------------
// getCtrl :
// Return the pointer of the control "id".
//-----------------------------------------------
CControl * COSD::getCtrl(uint id)
{
TMapControls::iterator it = _Controls.find(id);
if(it != _Controls.end())
return (*it).second;
else
return 0;
}// getCtrl //
//-----------------------------------------------
// addChild :
// Add a control.
//-----------------------------------------------
void COSD::addChild(uint idCtrl, CControl *ctrl)
{
// ...
_Controls.insert(TMapControls::value_type(idCtrl, ctrl));
// The list of control in order to display.
_Children.push_front(ctrl);
}// addChild //
//-----------------------------------------------
// delChild :
// Delete a control by the Id.
//-----------------------------------------------
void COSD::delChild(uint idCtrl)
{
TMapControls::iterator it = _Controls.find(idCtrl);
if(it != _Controls.end())
{
CControl *ctrl = (*it).second;
// Erase control.
_Controls.erase(it);
// Check if the control is allocated.
if(ctrl)
{
// Erase Control.
for(TListControl::iterator itChild = _Children.begin(); itChild != _Children.end(); ++itChild)
{
if((*itChild) == ctrl)
{
_Children.erase(itChild);
break;
}
}
// Delete Control.
// delete ctrl;
// ctrl = 0;
}
}
}// delChild //
//-----------------------------------------------
// removeFromChildren :
// Add a control.
//-----------------------------------------------
void COSD::removeFromChildren(uint idCtrl)
{
TMapControls::iterator it = _Controls.find(idCtrl);
if(it != _Controls.end())
{
CControl *ctrl = (*it).second;
// Check if the control is allocated.
if(ctrl)
{
// Erase Control.
for(TListControl::iterator itChild = _Children.begin(); itChild != _Children.end(); ++itChild)
{
if((*itChild) == ctrl)
{
_Children.erase(itChild);
break;
}
}
}
}
}// removeFromChildren //
//-----------------------------------------------
// calculatePos :
// Calculate a position according to the origin.
//-----------------------------------------------
void COSD::calculatePos(float &x, float &y, CControl::THotSpot origin)
{
switch(origin)
{
case CControl::HS_TL:
x = _X_Display;
y = _Y_Display+_H_Display;
break;
case CControl::HS_TM:
x = _X_Display+_W_Display/2.f;
y = _Y_Display+_H_Display;
break;
case CControl::HS_TR:
x = _X_Display+_W_Display;
y = _Y_Display+_H_Display;
break;
case CControl::HS_ML:
x = _X_Display;
y = _Y_Display+_H_Display/2.f;
break;
case CControl::HS_MM:
x = _X_Display+_W_Display/2.f;
y = _Y_Display+_H_Display/2.f;
break;
case CControl::HS_MR:
x = _X_Display+_W_Display;
y = _Y_Display+_H_Display/2.f;
break;
case CControl::HS_BL:
x = _X_Display;
y = _Y_Display;
break;
case CControl::HS_BM:
x = _X_Display+_W_Display/2.f;
y = _Y_Display;
break;
case CControl::HS_BR:
x = _X_Display+_W_Display;
y = _Y_Display;
break;
}
}// calculatePos //
//-----------------------------------------------
// calculateDisplay :
// Calculate the Display X, Y, Width, Height.
//-----------------------------------------------
void COSD::calculateDisplay()
{
uint32 w, h;
CInterfMngr::getWindowSize(w, h);
// Calculate the Title Bar height for Display.
_TB_H_Display = _TB_H/h;
// Calculate borders for the Resize.
_RS_W = _RS_Size/w; // Left and Right.
_RS_H = _RS_Size/h; // Bottom and Top.
// Calculate borders for the HighLight.
_HL_W = _HL_Size/w; // Left and Right.
_HL_H = _HL_Size/h; // Bottom and Top.
// Calculate the display Width and Height.
if(w!=0)
_W_Display = _W_Pixel/w; //_W*_W_Ref + _W_Pixel/w;
else
_W_Display = 0.f; //_W*_W_Ref;
if(h!=0)
_H_Display = _H_Pixel/h; //_H*_H_Ref + _H_Pixel/h;
else
_H_Display = 0.f; //_H*_H_Ref;
// // Calculate the HotSpot.
// calculateHS();
_X_Display = _X; //_X_Ref + _X*_W_Ref + _X_Pixel/w + _X_HotSpot;
_Y_Display = _Y; //_Y_Ref + _Y*_H_Ref + _Y_Pixel/h + _Y_HotSpot;
}// calculateDisplay //
///////////////////////////
// OPERATIONS ON THE OSD //
///////////////////////////
//-----------------------------------------------
// testInRect :
// Function to test if a coordinate is in the rect.
//-----------------------------------------------
bool COSD::testInRect(float x, float y, float rectX0, float rectY0, float rectX1, float rectY1)
{
if(x>=rectX0 && x<rectX1 && y>=rectY0 && y<rectY1)
return true;
return false;
}// testInRect //
//-----------------------------------------------
// resizeMode :
// Determine the Resize Mode.
//-----------------------------------------------
bool COSD::resizeMode(float x, float y)
{
// Get the window size.
uint32 w, h;
CInterfMngr::getWindowSize(w, h);
float cornerSizeX = _RS_W+_TB_H/(float)w;
float cornerSizeY = _RS_H+_TB_H/(float)h;
enum TXState
{
X_0 = 0x00,
X_1 = 0x01,
X_2 = 0x02,
X_3 = 0x03,
X_4 = 0x04
};
enum TYState
{
Y_0 = 0x00,
Y_1 = 0x10,
Y_2 = 0x20,
Y_3 = 0x30,
Y_4 = 0x40
};
TXState x_State;
TYState y_State;
// X POSITION in the OSD.
// X is in the right part of the OSD (move, resize right, or resize right corners)
if(x >= _X_Display+_W_Display-cornerSizeX)
{
// Resize right or right corners.
if(x >= _X_Display+_W_Display-_RS_W)
x_State = X_4;
// Move or resize right corners.
else
x_State = X_3;
}
// X is in the left part of the OSD (move, resize left, or resize left corners)
else if(x < _X_Display+cornerSizeX)
{
// Resize left or left corners.
if(x < _X_Display+_RS_W)
x_State = X_0;
// Move or resize left corners.
else
x_State = X_1;
}
// X is in the middle part of the OSD (move, resize top or bottom).
else
x_State = X_2;
// Y POSITION in the OSD.
// Y is in the Top part of the OSD (move, resize top, or resize top corners)
if(y >= _Y_Display+_H_Display-cornerSizeY)
{
// Resize top or top corners.
if(y >= _Y_Display+_H_Display-_RS_H)
y_State = Y_4;
// Move or resize top corners.
else
y_State = Y_3;
}
// Y is in the bottom part of the OSD (move, resize bottom, or resize bottom corners)
else if(y < _Y_Display+cornerSizeY)
{
// Resize bottom or bottm corners.
if(y < _Y_Display+_RS_H)
y_State = Y_0;
// Move or resize bottom corners.
else
y_State = Y_1;
}
// Y is in the middle part of the OSD (move, resize left or right).
else
y_State = Y_2;
bool resize = true;
// Determine the Resize Mode.
switch(x_State | y_State)
{
// Left Bottom corner
case X_1|Y_0:
case X_0|Y_0:
case X_0|Y_1:
_RS_Mode = resize_BL;
break;
// Left side
case X_0|Y_2:
_RS_Mode = resize_L;
break;
// Left Top corner
case X_0|Y_3:
case X_0|Y_4:
case X_1|Y_4:
_RS_Mode = resize_TL;
break;
// Top Side.
case X_2|Y_4:
_RS_Mode = resize_T;
break;
// Right Top Corner.
case X_3|Y_4:
case X_4|Y_4:
case X_4|Y_3:
_RS_Mode = resize_TR;
break;
// Right Side.
case X_4|Y_2:
_RS_Mode = resize_R;
break;
// Right Bottom Corner.
case X_4|Y_1:
case X_4|Y_0:
case X_3|Y_0:
_RS_Mode = resize_BR;
break;
// Bottom Side.
case X_2|Y_0:
_RS_Mode = resize_B;
break;
// Move Area
case X_1|Y_3:
case X_2|Y_3:
case X_3|Y_3:
_RS_Mode = resize_move;
break;
// Inside Area
default:
_RS_Mode = no_resize;
resize = false;
break;
}
return resize;
}// resizeMode //
////////////
// SCRIPT //
////////////
//-----------------------------------------------
// getText :
//
//-----------------------------------------------
void COSD::getText(uint idCtrl)
{
uint idTxt = 0;
uint idPen = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Text.
else if(strcmp(ptr, "Text:") == 0)
idTxt = getInt();
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
)
// Create the list.
CText *text = new CText(idCtrl, x, y, xPixel, yPixel, CInterfMngr::getText(idTxt), CInterfMngr::getPen(idPen));
if(text)
{
text->origin(origin);
text->hotSpot(hs);
text->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(text);
text->parent(parent);
}
}
addChild(idCtrl, text);
}
}// getText //
//-----------------------------------------------
// getCapture :
//
//-----------------------------------------------
void COSD::getCapture(uint idCtrl)
{
uint idtexture = 2;
CRGBA rgba(255,255,255,128);
uint numFunc = 0;
uint idPen = 0;
uint idPrompt = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Function.
else if(strcmp(ptr, "Function:") == 0)
numFunc = getInt();
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the Prompt.
else if(strcmp(ptr, "Prompt:") == 0)
idPrompt = getInt();
)
// Create the list.
CCapture *capture = new CCapture(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, numFunc, CInterfMngr::getPen(idPen));
if(capture)
{
capture->origin(origin);
capture->hotSpot(hs);
capture->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
capture->setPrompt( CInterfMngr::getText(idPrompt) );
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(capture);
capture->parent(parent);
}
}
addChild(idCtrl, capture);
}
}// getCapture //
//-----------------------------------------------
// getButton :
//
//-----------------------------------------------
void COSD::getButton(uint idCtrl)
{
uint numFunc = 0;
uint numFuncR = 0;
uint numFuncD = 0;
uint idTxt = 0;
uint idPen = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Function for left click
else if(strcmp(ptr, "Function:") == 0)
numFunc = getInt();
// Get the Function for Right click
else if(strcmp(ptr, "FunctionRight:") == 0)
numFuncR = getInt();
// Get the Function for double click
else if(strcmp(ptr, "FunctionDouble:") == 0)
numFuncD = getInt();
// Get the Text.
else if(strcmp(ptr, "Text:") == 0)
idTxt = getInt();
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
)
// Create the button.
CButton *button = new CButton(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, numFunc, numFuncR, numFuncD, CInterfMngr::getButton(idCtrl));
if(button)
{
button->origin(origin);
button->hotSpot(hs);
button->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
button->pen(CInterfMngr::getPen(idPen));
if(idTxt != 0)
button->text(CInterfMngr::getText(idTxt));
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(button);
button->parent(parent);
}
}
addChild(idCtrl, button);
}
}// getButton //
//-----------------------------------------------
// getRadioButton :
//
//-----------------------------------------------
void COSD::getRadioButton(uint idCtrl)
{
uint numFunc = 0;
uint numFuncR = 0;
uint numFuncD = 0;
uint idTxt = 0;
uint idPen = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Function for left click
else if(strcmp(ptr, "Function:") == 0)
numFunc = getInt();
// Get the Function for Right click
else if(strcmp(ptr, "FunctionRight:") == 0)
numFuncR = getInt();
// Get the Function for double click
else if(strcmp(ptr, "FunctionDouble:") == 0)
numFuncD = getInt();
// Get the Text.
else if(strcmp(ptr, "Text:") == 0)
idTxt = getInt();
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
)
// Create the button.
CRadioButton *button = new CRadioButton(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, numFunc, numFuncR, numFuncD, CInterfMngr::getButton(idCtrl));
if(button)
{
button->origin(origin);
button->hotSpot(hs);
button->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
button->pen(CInterfMngr::getPen(idPen));
if(idTxt != 0)
button->text(CInterfMngr::getText(idTxt));
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(button);
button->parent(parent);
}
}
addChild(idCtrl, button);
}
}// getRadioButton //
//-----------------------------------------------
// getRadioController :
//
//-----------------------------------------------
void COSD::getRadioController(uint idCtrl)
{
char delimiter[] = "[] \t";
// Create the radio controller.
CRadioController *radioController = new CRadioController(idCtrl);
if(radioController)
{
uint buttonId;
TMapControls::iterator it;
char *ptr = strtok(NULL, delimiter);
while(ptr != NULL)
{
// Get all buttons.
if(strcmp(ptr, "Buttons:") == 0)
{
ptr = strtok(NULL, delimiter);
while((ptr != NULL) && (strcmp(ptr, "End")!=0))
{
buttonId = atoi(ptr);
it = _Controls.find(buttonId);
if(it != _Controls.end())
{
if(radioController->add(dynamic_cast<CRadioButton*>((*it).second)) == false)
{
nlerror("Interface Error : control %d can't be add in the radio button %d", buttonId, idCtrl);
}
}
// Next Id.
ptr = strtok(NULL, delimiter);
}
}
// Next Token
ptr = strtok(NULL, delimiter);
}
// Test if there is at least 1 button)
if( radioController->size() > 0)
{
// Insert the radio controller in the control list.
addChild(idCtrl, radioController);
}
// No Button -> Destroy Radio Button.
else
{
delete radioController;
radioController = 0;
}
}
}// getRadioController //
//-----------------------------------------------
// getBitmap :
//
//-----------------------------------------------
void COSD::getBitmap(uint idCtrl)
{
uint idtexture = 0;
bool tiled = false;
CRGBA rgba;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Texture.
else if(strcmp(ptr, "Texture:") == 0)
idtexture = getInt();
// Get the RGBA.
else if(strcmp(ptr, "RGBA:") == 0)
rgba = getRGBA();
// tiled or stretched
else if(strcmp(ptr, "Tiled:") == 0)
{
if (getInt() ==1)
tiled = true;
}
)
// Create the list.
CBitm *bitmap = new CBitm(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, idtexture, rgba);
if(bitmap)
{
bitmap->tiled( tiled );
bitmap->origin(origin);
bitmap->hotSpot(hs);
bitmap->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(bitmap);
bitmap->parent(parent);
}
}
addChild(idCtrl, bitmap);
}
}// getBitmap //
//-----------------------------------------------
// getList :
//
//-----------------------------------------------
void COSD::getList(uint idCtrl)
{
uint idPen = 0;
uint upTexture = 0;
uint downTexture = 0;
uint scrollBarTexture = 0;
CRGBA scrollBarRgba(255,255,255,255);
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the Texture for the 'up' arrow
else if(strcmp(ptr, "UpTexture:") == 0)
upTexture = getInt();
// Get the Texture for the 'down' arrow
else if(strcmp(ptr, "DownTexture:") == 0)
downTexture = getInt();
// Get the Texture for the scroll bar body
else if(strcmp(ptr, "ScrollBarTexture:") == 0)
scrollBarTexture = getInt();
// Get the RGBA for the scroll bar
else if(strcmp(ptr, "ScrollBarRGBA:") == 0)
scrollBarRgba = getRGBA();
)
// Create the list.
CList *list = new CList(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, CInterfMngr::getPen(idPen));
if(list)
{
list->origin(origin);
list->hotSpot(hs);
list->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
CScrollBar *scroll = list->getVScroll();
if(scroll)
{
scroll->setDownArrowTextureOn( downTexture );
scroll->setUpArrowTextureOn( upTexture );
scroll->textureOn( scrollBarTexture );
scroll->setDownArrowTextureOff( downTexture );
scroll->setUpArrowTextureOff( upTexture );
scroll->textureDisable( scrollBarTexture );
scroll->colorOn( scrollBarRgba );
scroll->enable(true);
}
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(list);
list->parent(parent);
}
}
addChild(idCtrl, list);
}
}// getList //
//-----------------------------------------------
// getMultiList :
//
//-----------------------------------------------
void COSD::getMultiList(uint idCtrl)
{
uint idtexture = 0;
uint upTexture = 0;
uint downTexture = 0;
uint scrollBarTexture = 0;
uint nbCol = 2;
uint16 spacing = 0;
uint16 lineHeight = 0;
std::vector<float> colSize;
CRGBA rgba(255,255,255,255);
CRGBA scrollBarRgba(255,255,255,255);
uint idPen = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the number of columns
else if(strcmp(ptr, "NbColumns:") == 0)
nbCol = getInt();
// Get the columns size.
else if(strcmp(ptr, "ColSize:") == 0)
colSize = getVectorOfFloat(nbCol);
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the Spacing.
else if(strcmp(ptr, "Spacing:") == 0)
spacing = getInt();
// Get the specified Line Height.
else if(strcmp(ptr, "LineHeight:") == 0)
lineHeight = getInt();
// Get the Texture for the 'up' arrow
else if(strcmp(ptr, "UpTexture:") == 0)
upTexture = getInt();
// Get the Texture for the 'down' arrow
else if(strcmp(ptr, "DownTexture:") == 0)
downTexture = getInt();
// Get the Texture for the scroll bar body
else if(strcmp(ptr, "ScrollBarTexture:") == 0)
scrollBarTexture = getInt();
// Get the RGBA for the scroll bar
else if(strcmp(ptr, "ScrollBarRGBA:") == 0)
scrollBarRgba = getRGBA();
)
// Create the list.
CMultiList *list = new CMultiList(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, CInterfMngr::getPen(idPen), nbCol);
if(list)
{
list->origin(origin);
list->hotSpot(hs);
list->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if ( nbCol == colSize.size() )
list->setColSize( colSize );
list->setSpacing( spacing );
list->setLineHeight( lineHeight );
CScrollBar *scroll = list->getVScroll();
if (scroll)
{
scroll->setDownArrowTextureOn( downTexture );
scroll->setUpArrowTextureOn( upTexture );
scroll->textureOn( scrollBarTexture );
scroll->setDownArrowTextureOff( downTexture );
scroll->setUpArrowTextureOff( upTexture );
scroll->textureDisable( scrollBarTexture );
scroll->colorOn( scrollBarRgba );
scroll->enable(true);
}
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(list);
list->parent(parent);
}
}
addChild(idCtrl, list);
}
}// getMultiList //
//-----------------------------------------------
// getChatBox :
//
//-----------------------------------------------
void COSD::getChatBox(uint idCtrl)
{
uint idtexture = 0;
uint upTexture = 0;
uint downTexture = 0;
uint scrollBarTexture = 0;
CRGBA rgba(255,255,255,255);
CRGBA scrollBarRgba(255,255,255,255);
uint idPen = 0;
uint leftFunc = 0;
uint rightFunc = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the function to execute on left click on player name
else if(strcmp(ptr, "LeftClickFunction:") == 0)
leftFunc = getInt();
// Get the function to execute on left click on player name
else if(strcmp(ptr, "RightClickFunction:") == 0)
rightFunc = getInt();
// Get the Texture for the 'up' arrow
else if(strcmp(ptr, "UpTexture:") == 0)
upTexture = getInt();
// Get the Texture for the 'down' arrow
else if(strcmp(ptr, "DownTexture:") == 0)
downTexture = getInt();
// Get the Texture for the scroll bar body
else if(strcmp(ptr, "ScrollBarTexture:") == 0)
scrollBarTexture = getInt();
// Get the RGBA for the scroll bar
else if(strcmp(ptr, "ScrollBarRGBA:") == 0)
scrollBarRgba = getRGBA();
)
// Create the list.
CChatControl *chat = new CChatControl(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, leftFunc, rightFunc, CInterfMngr::getPen(idPen));
if(chat)
{
chat->origin(origin);
chat->hotSpot(hs);
chat->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
CScrollBar *scroll = chat->getVScroll();
if (scroll)
{
scroll->setDownArrowTextureOn( downTexture );
scroll->setUpArrowTextureOn( upTexture );
scroll->textureOn( scrollBarTexture );
scroll->setDownArrowTextureOff( downTexture );
scroll->setUpArrowTextureOff( upTexture );
scroll->textureDisable( scrollBarTexture );
scroll->colorOn( scrollBarRgba );
scroll->enable(true);
}
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(chat);
chat->parent(parent);
}
}
addChild(idCtrl, chat);
}
}// getChatBox //
//-----------------------------------------------
// getCandidateList :
//
//-----------------------------------------------
void COSD::getCandidateList(uint idCtrl)
{
uint idtexture = 0;
uint upTexture = 0;
uint downTexture = 0;
uint scrollBarTexture = 0;
uint spacing = 0;
uint lineHeight = 0;
uint leftFunc = 0;
uint rightFunc = 0;
std::vector<float> colSize;
CRGBA rgba(255,255,255,255);
CRGBA selRgba(0,0,0,255);
CRGBA scrollBarRgba(255,255,255,255);
uint idPen = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the columns size.
else if(strcmp(ptr, "ColSize:") == 0)
colSize = getVectorOfFloat(2);
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the Spacing.
else if(strcmp(ptr, "Spacing:") == 0)
spacing = getInt();
// Get the function to execute on left click on candidate name
else if(strcmp(ptr, "LeftClickFunction:") == 0)
leftFunc = getInt();
// Get the function to execute on left click on candidate name
else if(strcmp(ptr, "RightClickFunction:") == 0)
rightFunc = getInt();
// Get the specified Line Height.
else if(strcmp(ptr, "LineHeight:") == 0)
lineHeight = getInt();
// Get the Texture for the 'up' arrow
else if(strcmp(ptr, "UpTexture:") == 0)
upTexture = getInt();
// Get the Texture for the 'down' arrow
else if(strcmp(ptr, "DownTexture:") == 0)
downTexture = getInt();
// Get the Texture for the scroll bar body
else if(strcmp(ptr, "ScrollBarTexture:") == 0)
scrollBarTexture = getInt();
// Get the RGBA for the scroll bar
else if(strcmp(ptr, "ScrollBarRGBA:") == 0)
scrollBarRgba = getRGBA();
// Get the RGBA for the selection box
else if(strcmp(ptr, "SelectionRGBA:") == 0)
selRgba = getRGBA();
)
// Create the list.
CCandidateList *list = new CCandidateList(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, CInterfMngr::getPen(idPen));
if(list)
{
list->origin(origin);
list->hotSpot(hs);
list->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if( 2 == colSize.size() )
list->setColSize( colSize );
list->setSpacing( spacing );
list->setLineHeight( lineHeight );
list->setSelectedColor( selRgba );
list->setLeftClickFunction( leftFunc );
list->setRightClickFunction( rightFunc );
CScrollBar *scroll = list->getVScroll();
if (scroll)
{
scroll->setDownArrowTextureOn( downTexture );
scroll->setUpArrowTextureOn( upTexture );
scroll->textureOn( scrollBarTexture );
scroll->setDownArrowTextureOff( downTexture );
scroll->setUpArrowTextureOff( upTexture );
scroll->textureDisable( scrollBarTexture );
scroll->colorOn( scrollBarRgba );
scroll->enable(true);
}
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(list);
list->parent(parent);
}
}
addChild(idCtrl, list);
}
}// getCandidateList //
//-----------------------------------------------
// getChatInput :
//
//-----------------------------------------------
void COSD::getChatInput(uint idCtrl)
{
uint idtexture = 0;
CRGBA rgba;
uint numFunc = 0;
uint idPen = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Function.
else if(strcmp(ptr, "Function:") == 0)
numFunc = getInt();
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
)
// Create the chat input
CChatInput *chat = new CChatInput(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, numFunc, CInterfMngr::getPen(idPen));
if(chat)
{
chat->origin(origin);
chat->hotSpot(hs);
chat->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(chat);
chat->parent(parent);
}
}
addChild(idCtrl, chat);
}
}// getChatInput //
//-----------------------------------------------
// getChatInput :
//
//-----------------------------------------------
void COSD::getChoiceList(uint idCtrl)
{
uint idPen = 0;
uint upTexture = 0;
uint downTexture = 0;
uint scrollBarTexture = 0;
CRGBA scrollBarRgba(255,255,255,255);
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the Texture for the 'up' arrow
else if(strcmp(ptr, "UpTexture:") == 0)
upTexture = getInt();
// Get the Texture for the 'down' arrow
else if(strcmp(ptr, "DownTexture:") == 0)
downTexture = getInt();
// Get the Texture for the scroll bar body
else if(strcmp(ptr, "ScrollBarTexture:") == 0)
scrollBarTexture = getInt();
// Get the RGBA for the scroll bar
else if(strcmp(ptr, "ScrollBarRGBA:") == 0)
scrollBarRgba = getRGBA();
)
// Create the chat input
CChoiceList *choiceList = new CChoiceList(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, CInterfMngr::getPen(idPen));
if(choiceList)
{
choiceList->origin(origin);
choiceList->hotSpot(hs);
choiceList->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
CScrollBar *scroll = choiceList->getVScroll();
if (scroll)
{
scroll->setDownArrowTextureOn( downTexture );
scroll->setUpArrowTextureOn( upTexture );
scroll->textureOn( scrollBarTexture );
scroll->setDownArrowTextureOff( downTexture );
scroll->setUpArrowTextureOff( upTexture );
scroll->textureDisable( scrollBarTexture );
scroll->colorOn( scrollBarRgba );
scroll->enable(true);
}
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(choiceList);
choiceList->parent(parent);
}
}
addChild(idCtrl, choiceList);
}
}// getChatInput //
//-----------------------------------------------
// getHorizontalList :
//
//-----------------------------------------------
void COSD::getHorizontalList(uint idCtrl)
{
uint16 spacing = 0;
uint scrollLeftId = 0;
uint scrollRightId = 0;
uint idtexture = 0;
CRGBA rgba(255,255,255,255);
bool tiled = false;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Spacing.
else if(strcmp(ptr, "Spacing:") == 0)
spacing = getInt();
else if(strcmp(ptr, "ScrollLeft:") == 0)
scrollLeftId = getInt();
else if(strcmp(ptr, "ScrollRight:") == 0)
scrollRightId = getInt();
else if(strcmp(ptr, "Controls:") == 0)
{
ptr = strtok(NULL, delimiter);
while((ptr != NULL) && (strcmp(ptr, "End")!=0))
{
elts.push_back( atoi(ptr) );
ptr = strtok(NULL, delimiter);
}
}
// Get the Texture.
else if(strcmp(ptr, "Texture:") == 0)
idtexture = getInt();
// Get the RGBA.
else if(strcmp(ptr, "RGBA:") == 0)
rgba = getRGBA();
else if(strcmp(ptr, "Tiled:") == 0)
{
if ( getInt() == 1 )
tiled = true;
}
)
// Create the list.
CHorizontalList *list = new CHorizontalList(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, spacing, idtexture, rgba);
if(list)
{
list->tiled( tiled );
std::list< uint16 >::iterator itElts, itEltsEnd = elts.end();
TMapControls::iterator it;
for (itElts = elts.begin() ; itElts != itEltsEnd ; ++itElts )
{
it = _Controls.find( *itElts );
if(it != _Controls.end())
{
CControl *ctrl = (*it).second;
// Erase control.
_Controls.erase(it);
// Check if the control is allocated.
if(ctrl)
{
// add control to the list
list->add( ctrl );
// Erase Control.
for(TListControl::iterator itChild = _Children.begin(); itChild != _Children.end(); ++itChild)
{
if((*itChild) == ctrl)
{
_Children.erase(itChild);
break;
}
}
}
}
}
// get left scroll bitmap
if (scrollLeftId != 0)
{
it = _Controls.find( scrollLeftId );
if(it != _Controls.end())
{
CControl *ctrl = (*it).second;
// Erase control.
//_Controls.erase(it);
if(ctrl)
{
// add control to the list
list->setLeftScrollBitmap( safe_cast<CBitm*> (ctrl) );
// Erase Control.
for(TListControl::iterator itChild = _Children.begin(); itChild != _Children.end(); ++itChild)
{
if((*itChild) == ctrl)
{
_Children.erase(itChild);
break;
}
}
}
}
}
// get right scroll bitmap
if (scrollRightId != 0)
{
it = _Controls.find( scrollRightId );
if(it != _Controls.end())
{
CControl *ctrl = (*it).second;
// Erase control.
//_Controls.erase(it);
if(ctrl)
{
// add control to the list
list->setRightScrollBitmap( safe_cast<CBitm*> (ctrl) );
// Erase Control.
for(TListControl::iterator itChild = _Children.begin(); itChild != _Children.end(); ++itChild)
{
if((*itChild) == ctrl)
{
_Children.erase(itChild);
break;
}
}
}
}
}
list->origin(origin);
list->hotSpot(hs);
list->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(list);
list->parent(parent);
}
}
addChild(idCtrl, list);
}
}// getHorizontalList //
//-----------------------------------------------
// getControlList :
//
//-----------------------------------------------
void COSD::getControlList(uint idCtrl)
{
uint16 spacing = 0;
uint upTexture = 0;
uint downTexture = 0;
uint scrollBarTexture = 0;
CRGBA scrollBarRgba(255,255,255,255);
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Spacing.
else if(strcmp(ptr, "Spacing:") == 0)
spacing = getInt();
else if(strcmp(ptr, "Controls:") == 0)
{
ptr = strtok(NULL, delimiter);
while((ptr != NULL) && (strcmp(ptr, "End")!=0))
{
elts.push_back( atoi(ptr) );
ptr = strtok(NULL, delimiter);
}
}
// Get the Texture for the 'up' arrow
else if(strcmp(ptr, "UpTexture:") == 0)
upTexture = getInt();
// Get the Texture for the 'down' arrow
else if(strcmp(ptr, "DownTexture:") == 0)
downTexture = getInt();
// Get the Texture for the scroll bar body
else if(strcmp(ptr, "ScrollBarTexture:") == 0)
scrollBarTexture = getInt();
// Get the RGBA for the scroll bar
else if(strcmp(ptr, "ScrollBarRGBA:") == 0)
scrollBarRgba = getRGBA();
)
// Create the list.
CControlList *list = new CControlList(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, spacing);
if(list)
{
CScrollBar *scroll = list->getVScroll();
if (scroll)
{
scroll->setDownArrowTextureOn( downTexture );
scroll->setUpArrowTextureOn( upTexture );
scroll->textureOn( scrollBarTexture );
scroll->setDownArrowTextureOff( downTexture );
scroll->setUpArrowTextureOff( upTexture );
scroll->textureDisable( scrollBarTexture );
scroll->colorOn( scrollBarRgba );
scroll->enable(true);
}
std::list< uint16 >::iterator itElts, itEltsEnd = elts.end();
TMapControls::iterator it;
for (itElts = elts.begin() ; itElts != itEltsEnd ; ++itElts )
{
it = _Controls.find( *itElts );
if(it != _Controls.end())
{
CControl *ctrl = (*it).second;
// Erase control.
//_Controls.erase(it);
// Check if the control is allocated.
if(ctrl)
{
// add control to the list
list->add( ctrl );
// Erase Control.
for(TListControl::iterator itChild = _Children.begin(); itChild != _Children.end(); ++itChild)
{
if((*itChild) == ctrl)
{
_Children.erase(itChild);
break;
}
}
}
}
}
list->origin(origin);
list->hotSpot(hs);
list->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(list);
list->parent(parent);
}
}
addChild(idCtrl, list);
}
}// getControlList //
//-----------------------------------------------
// getSpellList :
//
//-----------------------------------------------
void COSD::getSpellList(uint idCtrl)
{
uint16 spacing = 0;
uint idSpellPen = 0 ;
uint idCommentPen = 0 ;
float buttonW = 0;
float buttonH = 0;
uint leftFunc = 0;
uint rightFunc = 0;
float line_H = 0;
float line_H_Pixel = 0;
uint upTexture = 0;
uint downTexture = 0;
uint scrollBarTexture = 0;
CRGBA scrollBarRgba(255,255,255,255);
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Spacing.
else if(strcmp(ptr, "Spacing:") == 0)
spacing = getInt();
// Get the Pen.
else if(strcmp(ptr, "SpellPen:") == 0)
idSpellPen = getInt();
// Get the Pen.
else if(strcmp(ptr, "CommentPen:") == 0)
idCommentPen = getInt();
// Get the button width
else if(strcmp(ptr, "ButtonW:") == 0)
buttonW = getFloat();
// Get the button width
else if(strcmp(ptr, "ButtonH:") == 0)
buttonH = getFloat();
// Get the function to execute on left click on candidate name
else if(strcmp(ptr, "LeftClickFunction:") == 0)
leftFunc = getInt();
// Get the function to execute on left click on candidate name
else if(strcmp(ptr, "RightClickFunction:") == 0)
rightFunc = getInt();
// Get the height of a line in the control (relative to the size of the list)
else if(strcmp(ptr, "Line_H:") == 0)
line_H = getFloat();
// Get the height of a line in the control (in pixels)
else if(strcmp(ptr, "Line_H_Pixel:") == 0)
line_H_Pixel = getFloat();
// Get the Texture for the 'up' arrow
else if(strcmp(ptr, "UpTexture:") == 0)
upTexture = getInt();
// Get the Texture for the 'down' arrow
else if(strcmp(ptr, "DownTexture:") == 0)
downTexture = getInt();
// Get the Texture for the scroll bar body
else if(strcmp(ptr, "ScrollBarTexture:") == 0)
scrollBarTexture = getInt();
// Get the RGBA for the scroll bar
else if(strcmp(ptr, "ScrollBarRGBA:") == 0)
scrollBarRgba = getRGBA();
)
// Create the list.
CSpellList *list = new CSpellList(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, spacing , leftFunc, rightFunc);
if(list)
{
CScrollBar *scroll = list->getVScroll();
if (scroll)
{
scroll->setDownArrowTextureOn( downTexture );
scroll->setUpArrowTextureOn( upTexture );
scroll->textureOn( scrollBarTexture );
scroll->setDownArrowTextureOff( downTexture );
scroll->setUpArrowTextureOff( upTexture );
scroll->textureDisable( scrollBarTexture );
scroll->colorOn( scrollBarRgba );
scroll->enable(true);
}
list->setLineHeight( line_H, line_H_Pixel);
list->setButtonParam( buttonW, buttonH, CInterfMngr::getButton(idCtrl) );
list->setCommentPen( CInterfMngr::getPen(idCommentPen) );
list->setSpellPen( CInterfMngr::getPen(idSpellPen) );
list->origin(origin);
list->hotSpot(hs);
list->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(list);
list->parent(parent);
}
}
addChild(idCtrl, list);
}
}// getSpellList //
//-----------------------------------------------
// getProgressBar :
//-----------------------------------------------
void COSD::getProgressBar(uint idCtrl)
{
uint bkgTexture = 0;
uint barTexture = 0;
uint idPen = 0;
uint idText = 0;
uint32 range = 100;
uint32 step = 0;
CRGBA bkgRgba(255,255,255,255);
CRGBA barRgba(255,255,255,255);
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Texture for the progress bar
else if(strcmp(ptr, "BarTexture:") == 0)
barTexture = getInt();
// Get the Texture for the background
else if(strcmp(ptr, "BackgroundTexture:") == 0)
bkgTexture = getInt();
// Get the RGBA for the progress bar
else if(strcmp(ptr, "BarRGBA:") == 0)
barRgba = getRGBA();
// Get the RGBA for the background
else if(strcmp(ptr, "BackgroundRGBA:") == 0)
bkgRgba = getRGBA();
// get the range
else if(strcmp(ptr, "Range:") == 0)
range = getInt();
// get the step inc
else if(strcmp(ptr, "Step:") == 0)
step = getInt();
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the Text
else if (strcmp(ptr, "Text:") == 0)
idText = getInt();
)
// Create the control
CProgressBar *ctrl = new CProgressBar(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, range);
if(ctrl)
{
ctrl->origin(origin);
ctrl->hotSpot(hs);
ctrl->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
ctrl->setStep( step );
ctrl->setBackgroundColor( bkgRgba );
ctrl->setBackgroundTexture( bkgTexture );
ctrl->setProgressBarColor( barRgba );
ctrl->setProgressBarTexture( barTexture );
CPen pen = CInterfMngr::getPen(idPen);
ctrl->shadow( pen.shadow() );
ctrl->fontSize( pen.fontSize() );
ctrl->color( pen.color() );
if (idText !=0)
ctrl->setText( CInterfMngr::getText(idText).toString() );
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(ctrl);
ctrl->parent(parent);
}
}
addChild(idCtrl, ctrl);
}
}// getProgressBar //
//-----------------------------------------------
// getCastingBar :
//-----------------------------------------------
void COSD::getCastingBar(uint idCtrl)
{
uint bkgTexture = 0;
uint barTexture = 0;
uint idPen = 0;
uint idText = 0;
uint32 range = 100;
uint32 step = 0;
CRGBA bkgRgba(255,255,255,255);
CRGBA barRgba(255,255,255,255);
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Texture for the progress bar
else if(strcmp(ptr, "BarTexture:") == 0)
barTexture = getInt();
// Get the Texture for the background
else if(strcmp(ptr, "BackgroundTexture:") == 0)
bkgTexture = getInt();
// Get the RGBA for the progress bar
else if(strcmp(ptr, "BarRGBA:") == 0)
barRgba = getRGBA();
// Get the RGBA for the background
else if(strcmp(ptr, "BackgroundRGBA:") == 0)
bkgRgba = getRGBA();
// get the range
else if(strcmp(ptr, "Range:") == 0)
range = getInt();
// get the step inc
else if(strcmp(ptr, "Step:") == 0)
step = getInt();
// Get the Pen.
else if(strcmp(ptr, "Pen:") == 0)
idPen = getInt();
// Get the Text
else if (strcmp(ptr, "Text:") == 0)
idText = getInt();
)
// Create the control
CCastingBar *ctrl = new CCastingBar(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, range);
if(ctrl)
{
ctrl->origin(origin);
ctrl->hotSpot(hs);
ctrl->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
ctrl->setStep( step );
ctrl->setBackgroundColor( bkgRgba );
ctrl->setBackgroundTexture( bkgTexture );
ctrl->setProgressBarColor( barRgba );
ctrl->setProgressBarTexture( barTexture );
CPen pen = CInterfMngr::getPen(idPen);
ctrl->shadow( pen.shadow() );
ctrl->fontSize( pen.fontSize() );
ctrl->color( pen.color() );
if (idText !=0)
ctrl->setText( CInterfMngr::getText(idText).toString() );
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(ctrl);
ctrl->parent(parent);
}
}
addChild(idCtrl, ctrl);
}
}// getCastingBar //
//-----------------------------------------------
// getBrickControl :
//
//-----------------------------------------------
void COSD::getBrickControl(uint idCtrl)
{
uint idtexture = 0;
bool tiled = false;
CRGBA rgba;
uint idText = 0;
uint leftFunc = 0;
uint rightFunc = 0;
// Lecture de la partie commune du script de control.
CONTROL_SCRIPT_MACRO
(
// Get the Texture.
else if(strcmp(ptr, "Texture:") == 0)
idtexture = getInt();
// Get the RGBA.
else if(strcmp(ptr, "RGBA:") == 0)
rgba = getRGBA();
/* // Get the function to execute on left click
else if(strcmp(ptr, "LeftClickFunction:") == 0)
leftFunc = getInt();
// Get the function to execute on left click
else if(strcmp(ptr, "RightClickFunction:") == 0)
rightFunc = getInt();
// tiled or stretched
else if(strcmp(ptr, "Tiled:") == 0)
{
if (getInt() ==1)
tiled = true;
}
*/
)
// Create the control.
CBrickControl *brick = new CBrickControl(idCtrl, x, y, xPixel, yPixel, w, h, wPixel, hPixel, leftFunc, rightFunc);
if(brick)
{
brick->origin(origin);
brick->hotSpot(hs);
brick->ref(_X_Display, _Y_Display, _W_Display, _H_Display);
if(idParent != 0)
{
CControl *parent = CInterfMngr::getCtrl(idParent);
if(parent)
{
parent->addChild(brick);
brick->parent(parent);
}
}
addChild(idCtrl, brick);
}
}// getBrickControl //
//-----------------------------------------------
// open :
//
//-----------------------------------------------
void COSD::open(ifstream &file)
{
char tmpBuff[_MAX_LINE_SIZE];
char delimiter[] = "[] \t";
uint line = 0;
// While it's not the end of the file.
while(!file.eof())
{
file.getline(tmpBuff, _MAX_LINE_SIZE);
line++;
char *key = strtok(tmpBuff, delimiter);
// if the first char is a / then this is a comment line, skip it and go to next line
if ((key != NULL) && (*key) != '/' )
{
// Make the id.
uint idCtrl = atoi(key);
switch(CInterfMngr::getType(idCtrl))
{
// The control is a Text.
case CInterfMngr::CtrlText:
getText(idCtrl);
break;
// The control is a Capture.
case CInterfMngr::CtrlCapture:
getCapture(idCtrl);
break;
// The control is a Button.
case CInterfMngr::CtrlButton:
getButton(idCtrl);
break;
// The control is a Radio Button.
case CInterfMngr::CtrlRadioButton:
getRadioButton(idCtrl);
break;
// The control is a Radio Controller
case CInterfMngr::CtrlRadioController:
getRadioController(idCtrl);
break;
// The control is a Bitmap.
case CInterfMngr::CtrlBitmap:
getBitmap(idCtrl);
break;
// The control is a List.
case CInterfMngr::CtrlList:
getList(idCtrl);
break;
// The control is a MultiList.
case CInterfMngr::CtrlMultiList:
getMultiList(idCtrl);
break;
// The control is a ChatBox.
case CInterfMngr::CtrlChat:
getChatBox(idCtrl);
break;
// The control is a ChatInput.
case CInterfMngr::CtrlChatInput:
getChatInput(idCtrl);
break;
// The control is a ChoiceList
case CInterfMngr::CtrlChoiceList:
getChoiceList(idCtrl);
break;
// The control is a CandidateList
case CInterfMngr::CtrlCandidateList:
getCandidateList(idCtrl);
break;
// The control is an HorizontalList
case CInterfMngr::CtrlHorizontalList:
getHorizontalList(idCtrl);
break;
// The control is an ControlList
case CInterfMngr::CtrlControlList:
getControlList(idCtrl);
break;
// The control is an SpellList
case CInterfMngr::CtrlSpellList:
getSpellList(idCtrl);
break;
// The control is an ProgressBar
case CInterfMngr::CtrlProgressBar:
getProgressBar(idCtrl);
break;
// The control is an CastingBar
case CInterfMngr::CtrlCastingBar:
getCastingBar(idCtrl);
break;
// The control is a brick control
case CInterfMngr::CtrlBrick:
getBrickControl(idCtrl);
break;
// The control is a Unknown.
default:
nlerror("Line %d : ID %d is undeclared in \"ctrls.txt\" OR the type is unknown !!", line, idCtrl);
break;
}
}
}
uint32 width, height;
CInterfMngr::getWindowSize(width, height);
resize(width, height);
}// open //
Reference in a new issue View git blame Copy permalink