void CGridDefaultCell::SetFont(const LOGFONT* plf)
{
ASSERT(plf);
if (!plf) return;
m_Font.DeleteObject();
m_Font.CreateFontIndirect(plf);
CGridCell::SetFont(plf);
// Get the font size and hence the default cell size
CDC* pDC = CDC::FromHandle(::GetDC(NULL));
if (pDC)
{
CFont* pOldFont = pDC->SelectObject(&m_Font);
SetMargin(pDC->GetTextExtent(_T(" "), 1).cx);
m_Size = pDC->GetTextExtent(_T(" XXXXXXXXXXXX "), 14);
m_Size.cy = (m_Size.cy * 3) / 2;
pDC->SelectObject(pOldFont);
ReleaseDC(NULL, pDC->GetSafeHdc());
}
else
{
SetMargin(3);
m_Size = CSize(40,16);
}
}
BOOL CTestClockDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// 이 대화 상자의 아이콘을 설정합니다. 응용 프로그램의 주 창이 대화 상자가 아닐 경우에는
// 프레임워크가 이 작업을 자동으로 수행합니다.
SetIcon(m_hIcon, TRUE); // 큰 아이콘을 설정합니다.
SetIcon(m_hIcon, FALSE); // 작은 아이콘을 설정합니다.
// TODO: 여기에 추가 초기화 작업을 추가합니다.
// Get the margin information of the 'OK' and 'Cancel' button.
CRect rectOrg;
CRect rectOrgBtnOk;
CRect rectOrgBtnCancel;
GetClientRect(rectOrg);
m_rectOrg = rectOrg;
ClientToScreen(rectOrg);
m_btnOk.GetWindowRect(rectOrgBtnOk);
m_btnCancel.GetWindowRect(rectOrgBtnCancel);
SetMargin(rectOrgBtnOk, rectOrg, m_marginBtnOk);
SetMargin(rectOrgBtnCancel, rectOrg, m_marginBtnCancel);
m_nBtnAreaHeight = m_marginBtnCancel.bottom * 2 + rectOrgBtnCancel.Height(); // Set the height of the button area
SetRadius(rectOrg.Width(), rectOrg.Height());
m_nRadiusOrg = m_nRadius;
SetCenterPoint(rectOrg.Width(), rectOrg.Height());
SetGradationPoints();
m_nHourGradSize = DEFAULT_HOUR_GRAD_SIZE;
m_nMinuteGradSize = DEFAULT_MINUTE_GRAD_SIZE;
m_nSecondHandSize = DEFAULT_SECOND_HAND_SIZE;
m_nCenterPointSize = DEFAULT_CENTER_POINT_SIZE;
m_timeCurrent = CTime::GetCurrentTime();
SetClockHandPoints();
m_bInit = TRUE;
m_nTimerId = SetTimer(TIMER_ID, TIMER_INTERVAL, NULL);
return TRUE; // 포커스를 컨트롤에 설정하지 않으면 TRUE를 반환합니다.
}
EBox::EBox(float x, float y, float w,float h, float marginL, float marginR, float marginU, float marginD) {
_nIterIndice = 0;
_minInnerWidth = 0;
_minInnerHeight = 0;
_lpParent = NULL;
_fMaxBlend = 1;
_fBlend = 1;
_x = 0;
_y = 0;
_nNumMaximizeChild = 0;
SetVerticalPolicy(VCENTER);
SetHorisontalPolicy(HCENTER);
SetSizePolicy(INHERIT);
SetCentered(false);
SetGeometry(x,y,w,h);
SetMargin(marginL,marginR,marginU,marginD);
_layoutType = VERTICAL;
if (bg == NULL)
bg = KPTK::createKGraphic();
refCount++;
}
int CToolTipCtrlEx::OnCreate(LPCREATESTRUCT lpCreateStruct) {
if (CToolTipCtrl::OnCreate(lpCreateStruct) == -1) {
return -1;
}
SetTipBkColor(RGB(0x40, 0x40, 0x40));
SetTipTextColor(EDIT_TEXT_COLOR);
SetMargin(CRect(0, 0, 2, 2));
return 0;
}
int CToolTipCtrlZ::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CToolTipCtrl::OnCreate(lpCreateStruct) == -1)
return -1;
// TODO: 在此添加您专用的创建代码
GetParent()->EnableToolTips();
Activate(TRUE);
SetMaxTipWidth(SHRT_MAX);
SetMargin(CRect(4, 4, 4, 4));
return 0;
}
void CGridCellBase::operator=(const CGridCellBase& cell)
{
SetGrid(cell.GetGrid()); // do first in case of dependencies
SetText(cell.GetText());
SetImage(cell.GetImage());
SetData(cell.GetData());
SetState(cell.GetState());
SetFormat(cell.GetFormat());
SetTextClr(cell.GetTextClr());
SetBackClr(cell.GetBackClr());
SetFont(cell.IsDefaultFont()? NULL : cell.GetFont());
SetMargin(cell.GetMargin());
}
QgraphicsItemTable::QgraphicsItemTable(QTableManager* visualRef,QDTable* table,qreal x, qreal y, qreal width, qreal height,Grabber* grab,QColor back, QColor select)
:QGraphicsItemResizable(x,y,width, height, back, select)
{
VisRef = visualRef;
TableData = table;
SetMargin(-10,-10,15,15);
menu = new QMenu(0);
grabRefer = grab; // setto il grabber .
QAction *AddAtr = menu->addAction("Nuovo attributo");
QAction *act = menu->addAction("Cancella la tabella ");
connect(act,SIGNAL(triggered()),this,SLOT(DeleteTable()));
connect(AddAtr,SIGNAL(triggered()),this,SLOT(NewAttribute()));
}
void XDomTable::LayeroutCells(DRAWCONTEXT*pDraw,CELLDATA*pData)
{
//if(!pData->bReturn)
//pDraw->PADDING=1;
//pDraw->SPACING=1;
LAYEROUTDATA margin;
CELLDATA data;
data.Reset(pData->cur.x,pData->cur.y,XTRUE);
PreLayerout(pDraw,&data,&margin);
//XU8 bCollapse=pDraw->bCollapse;
pDraw->bCollapse=FindAttrib(XEAB::BORDER_COLLAPSE,0);
data.pData=XNULL;
XU8 bInline=IsFingerInline();
XRect rt=pDraw->win;
InitMargin(pDraw,&data,&margin,m_nPosX,m_nPosY,m_nWidth,m_nHeight,XTRUE);
if(m_nWidth>0&&m_nWidth==pDraw->win.Width()&&m_bFinal)
{
//bSet=XTRUE;
data.max.cx=m_nWidth;
data.max.cy=m_nHeight;
data.nMin=m_nMin;
}
else
{
//m_nWin=pDraw->win.Width();
LayeroutTable(pDraw,data);
m_rows.DataFrom(data.rowws);
m_nMin=data.nMin;
}
XSize size(m_nWidth,m_nHeight);
SetMargin(&margin,m_nWidth,m_nHeight,size);
//SetMargin(&margin,m_nWidth,m_nHeight,size);
pDraw->win=rt;
// XU8 bInline=IsFingerInline();
if(!bInline)
m_bReturn=NewRowIfMust(pDraw,pData,m_nWidth);
SetRowSize(pDraw,pData,size,data.nMin,XTRUE);
if(!bInline)
NewRow(0,pDraw,pData,pDraw->IND);
//pDraw->bCollapse=
EndLayerout(pDraw,pData);
//pDraw->win=rect;
}
/// Creates a header row
SaveFileRow() :
m_type ( HEADER )
{
SetMargin ( ROW_MARGIN );
CalculateColumnWidths();
boost::shared_ptr<GG::Font> font = ClientUI::GetFont();
GG::Clr head_clr = ClientUI::TextColor();
push_back ( new GG::TextControl ( GG::X0, GG::Y0, UserString ( "SAVE_TIME_TITLE" ), font, head_clr ) );
push_back ( new GG::TextControl ( GG::X0, GG::Y0, UserString ( "SAVE_TURN_TITLE" ), font, head_clr ) );
push_back ( new GG::TextControl ( GG::X0, GG::Y0, UserString ( "SAVE_PLAYER_TITLE" ), font, head_clr ) );
push_back ( new GG::TextControl ( GG::X0, GG::Y0, UserString ( "SAVE_EMPIRE_TITLE" ), font, head_clr ) );
push_back ( new GG::TextControl ( GG::X0, GG::Y0, UserString ( "SAVE_FILE_TITLE" ), font, head_clr ) );
}
EImgExpendableBox::EImgExpendableBox(KGraphic *imgBox, float wLUCorner, float hLUCorner, float wRDCorner, float hRDCorner, float margin, float x, float y):
EBox(x,y,imgBox->getWidth(),imgBox->getHeight(),margin,margin,margin,margin) {
_lpImgBox = imgBox;
_fImgWidth = _lpImgBox->getWidth();
_fImgHeight = _lpImgBox->getHeight();
_wLUCorner = wLUCorner;
_wRDCorner = wRDCorner;
_wCenter = _fImgWidth -(_wLUCorner+_wRDCorner);
_hLUCorner = hLUCorner;
_hRDCorner = hRDCorner;
_hCenter = _fImgHeight -(_hLUCorner+_hRDCorner);
SetMargin(_wLUCorner,_wRDCorner,_hLUCorner,_hRDCorner);
}
void CGridCellBase::operator=( CGridCellBase& cell)
{
if (this == &cell) return;
SetGrid(cell.GetGrid()); // do first in case of dependencies
SetText(cell.GetText());
SetImage(cell.GetImage());
SetData(cell.GetData());
SetState(cell.GetState());
SetFormat(cell.GetFormat());
SetTextClr(cell.GetTextClr());
SetBackClr(cell.GetBackClr());
SetFont(cell.IsDefaultFont()? NULL : cell.GetFont());
SetMargin(cell.GetMargin());
//Used for merge cells
//by Huang Wei
SetMergeCellID(cell.GetMergeCellID());
SetMergeRange(cell.GetMergeRange());
Show(cell.IsShow());
}
GWEN_CONTROL_CONSTRUCTOR(ComboBox, Button)
{
_menu = new Menu(this);
_menu->SetHidden(true);
_menu->SetIconMarginDisabled(true);
_menu->SetTabable(false);
ControlsInternal::ComboBoxDownArrow* down_arrow = new ControlsInternal::ComboBoxDownArrow(this);
down_arrow->SetComboBox(this);
_button = down_arrow;
_selected_item = nullptr;
SetAlignment(Position::LEFT | Position::CENTER_V);
SetKeyboardInputEnabled(true);
SetMargin(Margin(3, 0, 0, 0));
SetSize(100, 20);
SetTabable(true);
SetText("");
SetTextPadding(Padding(4, 0, 0, 0));
}
WebListBox::WebListBox ()
{
miMouseOver = 0;
miSelected = 0;
mppOption = WEBC_NULL;
miNumOptions = 0;
mpVScroll = WEBC_NULL;
mpHScroll = WEBC_NULL;
miSliderWidth = webc_GetDefaultDisplayInt(WEBC_DEFAULT_SLIDER_WIDTH);
miTextHeight = miTotalTextHeight = miTotalTextWidth = -1;
miLongestOption = 0;
mpListener = WEBC_NULL;
mStyle = 0;
SetFlag(DISPLAY_FLAG_ACCEPTS_FOCUS);
SetMargin(LISTBOX_MARGIN);
SetPadding(LISTBOX_PADDING);
SetBorder(LISTBOX_BORDER);
SetSpacing(LISTBOX_SPACING);
}
/// Creates a row for the given savefile
SaveFileRow ( const std::string& filename, const SaveGamePreviewData& preview ) :
m_type ( PREVIEW )
{
SetMargin ( ROW_MARGIN );
this->m_filename = filename;
CalculateColumnWidths();
boost::shared_ptr<GG::Font> font = ClientUI::GetFont();
GG::Clr item_clr = ClientUI::TextColor();
std::string save_time = split_time ( preview.save_time );
push_back ( new GG::TextControl ( GG::X0, GG::Y0, m_time_column_width, font->Height(),
save_time, font, item_clr,
GG::FORMAT_LEFT ) );
push_back ( new GG::TextControl ( GG::X0, GG::Y0, m_turn_column_width, font->Height(),
std::string ( " " ) + boost::lexical_cast<std::string> ( preview.current_turn ), font, item_clr,
GG::FORMAT_LEFT ) );
push_back ( CreateResizingText(preview.main_player_name, font, item_clr) );
push_back ( CreateResizingText(preview.main_player_empire_name, font, preview.main_player_empire_colour) );
push_back ( CreateResizingText(filename, font, item_clr) );
}
void XDomTable::LayeroutCell(DRAWCONTEXT*pDraw,CELLDATA*pData)
{
if(m_nWidth<=0) return;
int aw=pDraw->ALIGNW;
pDraw->ALIGNW=XEA::LEFT;
LAYEROUTDATA margin;
CELLDATA data;
data.Reset(pData->cur.x,pData->cur.y,XTRUE);
PreLayerout(pDraw,&data,&margin);
data.pData=XNULL;
pDraw->bCollapse=FindAttrib(XEAB::BORDER_COLLAPSE,0);
//if(!pData->bReturn)
//if(m_bReturn)
XU8 bInline=IsFingerInline();
//if(pDraw->SETWIDTH==-92)
// int a=0;
if(!bInline)//&&m_bReturn)
{
AlignRow(pDraw,pData);
NewRowMust(pDraw,pData,m_bReturn);
}
//else
m_nPosX=pData->cur.x;//+margin.nMargin[BORDERDATA::LEFT];
m_nPosY=pData->cur.y;//+margin.nMargin[BORDERDATA::TOP];
int bd=FindAttrib(XEAB::BORDER,0);
int cs=pDraw->PADDING;//XMAX(FindAttrib(XEAB::CELLPADDING,1),0);
int cp=pDraw->SPACING;//XMAX(FindAttrib(XEAB::CELLSPACING,1),0);
/*int bdx=margin.nMargin[BORDERDATA::LEFT]+
margin.nPadding[BORDERDATA::LEFT]+
margin.nBorderWidth[BORDERDATA::LEFT];
int bdy=margin.nMargin[BORDERDATA::RIGHT]+
margin.nPadding[BORDERDATA::RIGHT]+
margin.nBorderWidth[BORDERDATA::RIGHT];*/
XU8 bCollapse=FindAttrib(XEAB::BORDER_COLLAPSE,0);
if(bCollapse)
bd+=2;
//XU8 nType=FindAttrib(XEAB::FRAME,XEnumFrame::BOX);
//if(nType==XEF::VOID_X) bd=0;
//
XRect rt=pDraw->win;
//if(bd>0)
{
pDraw->win.left=m_nPosX+bd;
pDraw->win.right=m_nPosX+m_nWidth-(bd+cs);
}
//else pDraw->win.right--;
//if(m_bFinal&&m_nWidth==pDraw->win.Width())
data.rowws.DataFrom(m_rows);
data.Reset(pData->cur.x+bd,pData->cur.y+bd,XFALSE);
//if(margin.nBorderWidth[0]&&m_nPosX==3)
// int a=0;
InitMargin(pDraw,&data,&margin,m_nPosX,m_nPosY,m_nWidth,m_nHeight,XTRUE);
m_nPosX-=bd;
m_nPosY-=bd;
HandleChild(XDO_LAYEROUT_TAB,(XU32)pDraw,(XU32)&data);
XSize size(m_nWidth,m_nHeight);
SetMargin(&margin,m_nWidth,m_nHeight,size);
m_rows.DataFrom(data.rowws);
// pDraw->PADDING=nPad;
// pDraw->SPACING=nSpa;
pDraw->win=rt;
// pData->alignw=aw;
//data.max.cx-=pData->cur.x;
//data.max.cy-=pData->cur.y;
EndLayerout(pDraw,pData);
pDraw->ALIGNW=aw;
SetRowSize(pDraw,pData,size,data.nMin,XFALSE);
NewRow(0,pDraw,pData,pDraw->IND);
//pDraw->win=rect;
}
XU32 XHTMLBody::Handle(XU32 nOpera, XU32 pData1, XU32 pData2)
{
XU32 i;
switch(nOpera)
{
//case XDO_SET_START:
// return StartEvent((DRAWCONTEXT*)pData1);
/*case XDO_LAYEROUT_CELLS:
{
CELLDATA*p=(CELLDATA*)pData2;
DRAWCONTEXT*pd=(DRAWCONTEXT*)pData1;
XU32 ss=PreLayerout(pd,p);
XDomCard::Handle(nOpera,pData1,pData2);
EndLayerout(pd,p);
}return 1;*/
case XDO_LAYEROUT_CELL:
{
CELLDATA data;
LAYEROUTDATA margin;
//data.Reset(pData->cur.x,pData->cur.y,XTRUE);
CELLDATA*pData=&data;//(CELLDATA*)pData2;
DRAWCONTEXT*pDraw=(DRAWCONTEXT*)pData1;
pDraw->Init();
pData->Reset(pDraw->win.left,pDraw->win.top,XTRUE);
PreLayerout(pDraw,pData,&margin);
if(m_nWidth>0)
{
if(margin.nMargin[BORDERDATA::LEFT]>0&&
margin.nMargin[BORDERDATA::LEFT]+m_nWidth>pDraw->view.Width())
{
margin.nMargin[BORDERDATA::LEFT]=XMAX(
(pDraw->view.Width()-m_nWidth)>>1,0);
}
if(m_nWidth>pDraw->win.Width())
pDraw->win.right=pDraw->win.left+m_nWidth;
}
//pData->Init();
InitMargin(pDraw,pData,&margin,m_nPosX,m_nPosY,m_nWidth,m_nHeight);
XPoint pt=pData->cur;
for(i=0;i<m_childs.GetSize();i++)
m_childs[i]->LayeroutItem(pDraw,pData,XTRUE);//Handle(XDO_LAYEROUT_CELLS,(XU32)pDraw,(XU32)&data);
pData->Reset(pt.x,pt.y,XFALSE);
NewRow(0,pDraw,pData,pDraw->IND);
pData->bEmpty=XTRUE;
for(i=0;i<m_childs.GetSize();i++)
m_childs[i]->LayeroutItem(pDraw,pData,XFALSE);//Handle(XDO_LAYEROUT_CELL,(XU32)pDraw,(XU32)&data);
//data.max.cx-=pData->cur.x;
//data.max.cy-=pData->cur.y;
m_nWidth=pData->max.cx-pt.x;
m_nHeight=pData->max.cy-pt.y;
if(m_nWidth<pDraw->view.Width())
m_nWidth=pDraw->view.Width();
if(m_nHeight<pDraw->view.Height())
m_nHeight=pDraw->view.Height();
XSize size(m_nWidth,m_nHeight);
SetMargin(&margin,m_nWidth,m_nHeight,size);
//m_nWidth=data.max.cx-pData->cur.x;
pData=(CELLDATA*)pData2;
SetRowSize(pDraw,pData,size,m_nWidth,XFALSE);
NewRow(0,pDraw,pData,pDraw->IND);
/*CELLDATA*p=(CELLDATA*)pData2;
DRAWCONTEXT*pd=(DRAWCONTEXT*)pData1;
LAYEROUTDATA margin;
XU32 ss=PreLayerout(pd,p,margin);
// StartMargin(pd,p,XTRUE);
//BeginMargin(pd,p);
m_nPosX=p->cur.x;
m_nPosY=p->cur.y;
XDomCard::Handle(nOpera,pData1,pData2);
EndLayerout(pd,p);
m_nWidth=XMAX(p->max.cx-m_nPosX,pd->view.Width()-(m_nPosX<<1)-1);
m_nHeight=XMAX(p->max.cy-m_nPosY,pd->view.Height()-(m_nPosY<<1)-1);*/
}return 1;
case XDO_PAINT:
{
XRect rect(m_nPosX,m_nPosY,m_nPosX+m_nWidth,m_nPosY+m_nHeight);
PaintBack((DRAWCONTEXT*)pData1,rect);
XU32 s=XDomCard::Handle(nOpera,pData1,pData2);
PaintBorder((DRAWCONTEXT*)pData1,rect);
return s;
};
case XDO_EVENT_ONTIMER:
{
XRect rect(0,0,m_nWidth,m_nHeight);
return OnTimer((XEVENTDATA*)pData1,rect)|
XDomCard::Handle(nOpera,pData1,pData2);
}break;
/* case XDO_SET_ATTR:
case XDO_ADD_ATTR:
SetBodyAttrib((XVar*)pData1);
break; */
//return XTRUE;
}
TeamBox::TeamBox(const std::string& _player_name, const Point2i& _size) :
HBox(_size.y, false, false, false),
ai_name(NO_AI_NAME)
{
associated_team = NULL;
SetMargin(2);
SetNoBorder();
Widget::SetBackgroundColor(transparent_color);
Profile *res = GetResourceManager().LoadXMLProfile("graphism.xml", false);
/******** Logos: team mascott, player type icon ********/
Box * tmp_logo_box = new VBox(W_UNDEF, false, false, false);
tmp_logo_box->SetMargin(1);
tmp_logo_box->SetNoBorder();
team_logo = new PictureWidget(Point2i(38, 38));
tmp_logo_box->AddWidget(team_logo);
player_local_ai_surf = GetResourceManager().LoadImage(res, "menu/player_local_ai");
player_local_human_surf = GetResourceManager().LoadImage(res, "menu/player_local_human");
player_remote_ai_surf = GetResourceManager().LoadImage(res, "menu/player_remote_ai");
player_remote_human_surf = GetResourceManager().LoadImage(res, "menu/player_remote_human");
player_type = new PictureWidget(Point2i(38, 30));
player_type->SetSurface(player_local_ai_surf);
tmp_logo_box->AddWidget(player_type);
AddWidget(tmp_logo_box);
/******** Center box: team name, commander *********/
int width = _size.x - (2*2+(38+2*2)+(110+2*2));
Box * tmp_player_box = new VBox(_size.y, false, false, false);
tmp_player_box->SetMargin(0);
tmp_player_box->SetNoBorder();
previous_player_name = "team";
team_name = new Label(previous_player_name, width,
Font::FONT_MEDIUM, Font::FONT_BOLD);
tmp_player_box->AddWidget(team_name);
/******** Names: "Head commander" + text/custom team *******/
tmp_player_box->AddWidget(new Label(_("Head commander"), width,
Font::FONT_SMALL, Font::FONT_BOLD));
custom_team_list = GetCustomTeamsList().GetList();
custom_team_current_id = 0;
if (custom_team_list.empty()) {
player_name = new TextBox(_player_name, width,
Font::FONT_SMALL, Font::FONT_BOLD);
tmp_player_box->AddWidget(player_name);
next_custom_team = NULL;
previous_custom_team = NULL;
} else {
next_custom_team = new Button(res, "menu/plus");
previous_custom_team = new Button(res, "menu/minus");
player_name = new TextBox(_player_name, width - 2 * (next_custom_team->GetSizeY() + 2),
Font::FONT_SMALL, Font::FONT_BOLD);
Box * tmp_name_box = new HBox(player_name->GetSizeY(), false, false, false);
tmp_name_box->SetNoBorder();
tmp_name_box->SetMargin(2);
tmp_name_box->AddWidget(previous_custom_team);
tmp_name_box->AddWidget(player_name);
tmp_name_box->AddWidget(next_custom_team);
tmp_player_box->AddWidget(tmp_name_box);
}
AddWidget(tmp_player_box);
/********** Number of characters **********/
nb_characters = new SpinButtonWithPicture(_("Number of characters"), "menu/ico_play",
Point2i(110, 120), 6, 1, 1, 10);
AddWidget(nb_characters);
}
TeamBox::TeamBox(const std::string& _player_name, const Point2i& _size, uint g)
: HBox(_size.y, false, false, false)
, ai_level(0)
, group(g)
{
associated_team = NULL;
SetMargin(2);
SetBorder(transparent_color, 4);
Widget::SetBackgroundColor(transparent_color);
Profile *res = GetResourceManager().LoadXMLProfile("graphism.xml", false);
player_local[0] = LOAD_RES_IMAGE("menu/player_local_human");
player_local[1] = LOAD_RES_IMAGE("menu/player_local_ai");
player_local[2] = LOAD_RES_IMAGE("menu/player_local_ai_dumb");
player_local[3] = LOAD_RES_IMAGE("menu/player_local_ai_strong");
player_remote[0] = LOAD_RES_IMAGE("menu/player_remote_human");
player_remote[1] = LOAD_RES_IMAGE("menu/player_remote_ai");
player_remote[2] = LOAD_RES_IMAGE("menu/player_remote_ai_dumb");
player_remote[3] = LOAD_RES_IMAGE("menu/player_remote_ai_strong");
int width = _size.x - (CHAR_COUNT_WIDGET_SIZE+2*margin+2*border_size);
Box * tmp_player_box = new VBox(_size.y-2*border_size, false, false, false);
tmp_player_box->SetMargin(4);
tmp_player_box->SetNoBorder();
AddWidget(tmp_player_box);
tmp_player_box->AddWidget(new NullWidget(Point2i(width, 20)));
/******** Box for team logo, commander, custom team, ai & group *******/
HBox *hbox = new HBox(W_UNDEF, false, false, false);
hbox->SetMargin(0);
hbox->SetNoBorder();
tmp_player_box->AddWidget(hbox);
/**** AI ****/
player_type = new PictureWidget(Point2i(40, 40));
player_type->SetSurface(player_local[ai_level]);
hbox->AddWidget(player_type);
/**** Team Logo ****/
team_logo = new PictureWidget(Point2i(40, 40));
hbox->AddWidget(team_logo);
/**** Team name/commander ****/
VBox *vbox = new VBox(W_UNDEF, false, false, false);
vbox->SetMargin(0);
vbox->SetNoBorder();
hbox->AddWidget(vbox);
previous_player_name = "team";
team_name = new Label(previous_player_name, width - (40*2 + 60),
Font::FONT_MEDIUM, Font::FONT_BOLD);
vbox->AddWidget(team_name);
/**** Names: "Head commander" + text/custom team ****/
vbox->AddWidget(new Label(_("Head commander"), width - (40*2 + 60),
Font::FONT_SMALL, Font::FONT_BOLD));
/**** Group selection box ****/
nullw = new NullWidget(Point2i(60, 40));
nullw->SetBackgroundColor(TeamGroup::Colors[g]);
hbox->AddWidget(nullw);
custom_team_list = GetCustomTeamsList().GetList();
custom_team_current_id = 0;
if (custom_team_list.empty()) {
player_name = new TextBox(_player_name, width,
Font::FONT_SMALL, Font::FONT_BOLD);
tmp_player_box->AddWidget(player_name);
next_custom_team = NULL;
previous_custom_team = NULL;
} else {
next_custom_team = new Button(res, "menu/big_plus");
previous_custom_team = new Button(res, "menu/big_minus");
player_name = new TextBox(_player_name, width - 2 * (next_custom_team->GetSizeX() + 2),
Font::FONT_SMALL, Font::FONT_BOLD);
Box * tmp_name_box = new HBox(player_name->GetSizeY(), false, false, false);
tmp_name_box->SetNoBorder();
tmp_name_box->SetMargin(2);
tmp_name_box->AddWidget(previous_custom_team);
tmp_name_box->AddWidget(player_name);
tmp_name_box->AddWidget(next_custom_team);
tmp_player_box->AddWidget(tmp_name_box);
}
/********** Number of characters **********/
nb_characters = new SpinButtonWithPicture(_("Number of characters"), "menu/ico_play",
Point2i(CHAR_COUNT_WIDGET_SIZE, 110), 6, 1, 1, 10);
AddWidget(nb_characters);
Pack();
}
void XDomTD::LayeroutCells(DRAWCONTEXT*pDraw,CELLDATA*pData,int span)
{
CELLDATA data;
LAYEROUTDATA margin;
SpanCol(pData);
data.Reset(pData->cur.x,pData->cur.y,XTRUE);
PreLayerout(pDraw,&data,&margin);
data.pData=XNULL;
int cspan=//pDraw->DCOLSPAN;//
//span==0?XMAX(FindAttrib(XEAB::COLSPAN,1),1):span;
span==0?pDraw->DCOLSPAN:span;
int rspan=pDraw->DROWSPAN;//
//XMAX(FindAttrib(XEAB::ROWSPAN,1),1);
//for debug
XRect rw=pDraw->win;
// if(pDraw->SETWIDTH==663)
// int a=0;
XSize sz;
if(pData->bFinal)
{
int w=pData->fixCols[pData->nCol];
for(int i=1;i<cspan;i++)
{
if(pData->nCol+i>=(int)pData->fixCols.GetSize()) break;
w+=pData->fixCols[pData->nCol+i];
}
InitMargin(pDraw,&data,&margin,m_nPosX,m_nPosY,w,m_nHeight);
XPoint pt=data.cur;
if(InitSize(pDraw,&data,w,XFALSE))
m_nFixHeight=data.max.cy-pt.y;
//XSize sz;
sz=XSize(m_nWidth,m_nHeight);
SetMargin(&margin,m_nWidth,m_nHeight,sz);
SaveData(&data);
//pDraw->win=rt;
//m_nFixHeight=m_nHeight;
}
else
{
//data.Reset(pData->cur.x,pData->cur.y,XTRUE);
int w=0;
//if(pData->nCol+cspan<(XINT)pData->setCols.GetSize())
{
//w=pData->setCols[pData->nCol];
for(int i=0;i<cspan;i++)
{
if(pData->nCol+i>=(int)pData->setCols.GetSize()) break;
w+=pData->setCols[pData->nCol+i];
}
//int w1=0;
/*for(int i=0;i<cspan;i++)
{
if(pData->nCol+i>=(int)pData->cols[i]
}*/
}
InitMargin(pDraw,&data,&margin,m_nPosX,m_nPosY,w,m_nHeight);
XPoint pt=data.cur;
XU8 bFix=InitFixed(pDraw,&data,w);
sz=XSize(m_nWidth,m_nHeight);
SetMargin(&margin,m_nWidth,m_nHeight,sz);
//pDraw->win=rt;
//m_nHeight=XMAX(m_nHeight,pDraw->SETHEIGHT);//m_nHeight;//XMAX(m_nHeight,pDraw->SPACE);
//w=m_nWidth;
if(bFix)
{
m_nFixWidth=m_nWidth;
m_nFixHeight=data.max.cy-pt.y;
}
if(span==0)
{
int nMin=m_nMin;
//if(bFix) m_nFixWidth=data.max.cx-
w=m_nFixWidth;
for(int i=0;i<cspan;i++)
{
XU16 id=pData->nCol+i;
if(id>=pData->cols.GetSize())
{
pData->tabs.Add(bFix==1);
pData->cols.Add(nMin/(cspan-i));
pData->fixCols.Add(w/(cspan-i));
nMin-=nMin/(cspan-i);
w-=w/(cspan-i);
//break;
}
else if(i+1<cspan)
{
pData->tabs[id]|=bFix;
nMin=XMAX(nMin-pData->cols[id],0);
w=XMAX(w-pData->fixCols[id],0);
}
else
{
pData->tabs[id]|=bFix;
if(pData->cols[id]<nMin)
pData->cols[id]=nMin;
if(pData->fixCols[id]<w)
pData->fixCols[id]=w;
}
}
}
}
//m_rows.DataFrom(data.rowws);
//m_cols.DataFrom(data.fixCols);
//XSize size(m_nWidth,m_nHeight);
//SetMargin(&margin,m_nWidth,m_nHeight,size);
/* XString8 str=FindAttrib(XEAB::ID,"");
if(str=="999")
int a=0;*/
if(pDraw->bCollapse)
{
//m_nWidth-=2;
//m_nHeight-=2;
//sz.cx-=2;
sz.cy-=2;
} //*///*/
if(rspan<=1)
SetTabRow(pDraw,pData,sz.cx,sz.cy);//m_nWidth,m_nHeight);//XSize(m_nWidth,m_nHeight),m_nMin,XTRUE);
else
{
SetTabRow(pDraw,pData,sz.cx,pDraw->SPACE);//XSize(m_nWidth,pDraw->nRowSpace),m_nMin,XTRUE);
pData->spans.Add(rspan);
pData->spans.Add(pData->nCol);
pData->spans.Add(m_nWidth);
pData->spans.Add(m_nFixHeight);
pData->spans.Add(cspan);
}
pDraw->win=rw;
pData->nCol+=cspan;
EndLayerout(pDraw,&data);
}
void XDomTD::LayeroutCell(DRAWCONTEXT*pDraw,CELLDATA*pData,int span)
{
SpanCol(pData);
//if(pDraw->win.Width()<6) return;
if(pData->nRow>=(XINT)pData->rowws.GetSize()) return;
XU8 ah=pDraw->ALIGNH;
pDraw->ALIGNH=XEA::MIDDLE;
LAYEROUTDATA margin;
CELLDATA data;
data.Reset(pData->cur.x,pData->cur.y,XTRUE);
PreLayerout(pDraw,&data,&margin);
data.pData=XNULL;
XRect rect=pDraw->win;
m_nPosX=pData->cur.x;
m_nPosY=pData->cur.y;
// if(pDraw->SETHEIGHT==180)
// int a=0;
int rspan=pDraw->DROWSPAN;//XMAX(FindAttrib(XEAB::ROWSPAN,1),1);
int cspan=span==0?pDraw->DCOLSPAN:span;//XMAX(FindAttrib(XEAB::COLSPAN,1),1):span;
int h=pData->rowws[pData->nRow];
for(int i=1;i<rspan;i++)
{
if(pData->nRow+i>=(int)pData->rowws.GetSize()) break;
h+=pData->rowws[pData->nRow+i];
}
if(h>m_nHeight) m_nHeight=h;
InitMargin(pDraw,&data,&margin,m_nPosX,m_nPosY,m_nWidth,m_nHeight,XFALSE);
//if(pDraw->bCollapse)
//{data.cur.y+=2;m_nPosY+=2;}
switch(pDraw->ALIGNH)
{
case XEA::MIDDLE:data.cur.y+=(m_nHeight-m_nFixHeight)>>1;break;
case XEA::BOTTOM:data.cur.y+=(m_nHeight-m_nFixHeight);break;
}
//data.cur.y=AlignCol(pDraw,pData,m_nFixHeight+(pDraw->PADDING<<1),pDraw->ALIGNH,m_nHeight)+
// pDraw->SPACING;//pDraw->nRowSpace;
//int px=data.cur.x;//+dd;//pDraw->nColSpace;
//data.cur.x=px;
//data.cur.y=py;
//data.bReturn=XTRUE;
//InitMargin(pDraw,
InitSize(pDraw,&data,m_nWidth,XTRUE);
// XDomNode::Handle(XDO_LAYEROUT_CELLS,(XU32)pDraw,(XU32)&data);
//
// data.Reset(px,py,data.alignw,data.alignh,data.nowrap);
// data.bReturn=XTRUE;
// AlignRow(pDraw,&data);
NewRow(0,pDraw,&data,0);
data.bEmpty=XTRUE;
if(pDraw->bCollapse)
{
data.cur.y+=2;
data.cur.x+=2;
//m_nWidth+=2;
//m_nHeight+=2;
}
HandleChild(XDO_LAYEROUT_CELL,(XU32)pDraw,(XU32)&data);
XSize size(m_nWidth,m_nHeight);
SetMargin(&margin,m_nWidth,m_nHeight,size);
/*if(pData->bCollapse)
{
m_nWidth+=2;
m_nHeight+=2;
}*/
pDraw->win=rect;
SaveData(&data);
EndLayerout(pDraw,&data);
pDraw->ALIGNH=ah;
//int rspan=FindAttrib(XEAB::ROWSPAN,1);
if(rspan<=1)
SetTabRow(pDraw,pData,size.cx,size.cy);//m_nWidth,m_nHeight);//XSize(m_nWidth,m_nHeight),m_nMin,XFALSE);
//else
else //if(rspan>1)
{
SetTabRow(pDraw,pData,size.cx,pDraw->SPACE);//XSize(m_nWidth,pDraw->nRowSpace),m_nMin,XFALSE);
pData->spans.Add(rspan);
pData->spans.Add(pData->nCol);
pData->spans.Add(m_nWidth);
pData->spans.Add(m_nFixHeight);
pData->spans.Add(cspan);
}
//SetRow(pDraw,pData,XSize(m_nWidth,m_nHeight),data.nMin,XFALSE,XFALSE);
//pData->cur.x+=m_nWidth;////pData->fixCols[pData->nCol];
pData->nCol+=cspan;//=cspan;
//if(pData->max.cx<m_nPosX+m_nWidth)
// pData->max.cx=m_nPosX+m_nWidth;
//if(pData->max.cy<m_nPosY+m_nHeight)
// pData->max.cy=m_nPosY+m_nHeight;
}
void UKUIInterfaceElement::SetMarginStruct( const FVector4& v4Margin )
{
SetMargin( v4Margin.X, v4Margin.Y, v4Margin.Z, v4Margin.W );
}
TeamsSelectionBox::TeamsSelectionBox(const Point2i &_size, bool network, bool w_border) :
HBox(_size.y, w_border, false)
{
if (!w_border)
SetNoBorder();
SetMargin(0);
// How many teams ?
VBox *tmp = new VBox(120, false, false, true);
if (network) {
local_teams_nb =
new SpinButtonWithPicture(_("Local teams:"), "menu/team_number",
Point2i(100, 130), 0, 1, 0, MAX_NB_TEAMS);
} else {
local_teams_nb =
new SpinButtonWithPicture(_("Number of teams:"), "menu/team_number",
Point2i(100, 130), 2, 1, 2, MAX_NB_TEAMS);
}
tmp->AddWidget(local_teams_nb);
//tmp->AddWidget(new NullWidget(Point2i(120, 120)));
AddWidget(tmp);
uint box_w = _size.x - local_teams_nb->GetSizeX() - 10;
Point2i grid_size = Point2i(box_w, _size.y);
Point2i grid_dim = grid_size / Point2i(300 + 10, 130 + 10);
Point2i box_size;
bool use_list;
if (grid_dim.x*grid_dim.y < (int)MAX_NB_TEAMS) {
use_list = true;
box_size.SetValues(box_w - 40, 120);
} else {
use_list = false;
box_size.SetValues((grid_size / grid_dim) - 10);
}
for (uint i=0; i < MAX_NB_TEAMS; i++) {
std::string player_name = _("Player") ;
char num_player[4];
sprintf(num_player, " %d", i+1);
player_name += num_player;
teams_selections.push_back(new TeamBox(player_name, box_size));
}
// If the intended gridbox would be too big for the intended size,
// instead create a listbox
if (use_list) {
// Warning: this box takes the ownership of the widgets in teams_selections:
// while any other Box will delete the ones it contains, TeamScrollBox
// doesn't really contain them as widgets. They therefore aren't released
// through this mechanism, but with a manual one. This manual mechanism
// requires we have a *real* copy of the vector for when it is destroyed.
list_box = new TeamScrollBox(teams_selections, Point2i(box_w-20, _size.y-10));
list_box->SetNbTeams(0);
AddWidget(list_box);
} else {
list_box = NULL;
Box * teams_grid_box = new GridBox(grid_dim.y, grid_dim.x, 10, false);
teams_grid_box->SetNoBorder();
for (uint i=0; i<MAX_NB_TEAMS; i++)
teams_grid_box->AddWidget(teams_selections[i]);
AddWidget(teams_grid_box);
}
// Load Teams' list
GetTeamsList().full_list.sort(compareTeams);
}
