void CBasicAnimation::FrameChanged(void)
{
if (!m_animationSheet)
return;
ColRow cr = GetColRow(GetCols(), GetCurrentFrame());
size_t x((cr.col - 1) * m_frameW);
size_t y((cr.row - 1) * m_frameH);
if (m_frame)
{
m_frame.Reset();
//al_destroy_bitmap(m_frame);
//m_frame = nullptr;
}
m_frame = CBitmap(m_animationSheet, x, y, m_frameW, m_frameH);
//m_frame = al_create_sub_bitmap(m_animationSheet, x, y, m_frameW, m_frameH);
}
FX_FLOAT CFWL_GridImp::ProcessUnCertainRows() {
int32_t iRows = m_Rows.GetSize();
if (iRows < 1) {
CFWL_GridColRow* pColRow = new CFWL_GridColRow;
pColRow->m_Size.eUnit = FWL_GRIDUNIT_Auto;
ProcAutoColRow(pColRow, 0, FALSE);
FX_FLOAT fWidth = pColRow->m_fActualSize;
delete pColRow;
return fWidth;
}
FX_FLOAT fFixedHeight = 0;
CFX_PtrArray autoRows;
CFX_PtrArray scaledRows;
FX_FLOAT fScaledRowNum = 0;
FX_FLOAT fScaledMaxPerHeight = 0;
for (int32_t i = 0; i < iRows; i++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[i]);
if (!pColRow) {
continue;
}
switch (pColRow->m_Size.eUnit) {
case FWL_GRIDUNIT_Fixed: {
SetColRowActualSize(pColRow, pColRow->m_Size.fLength);
fFixedHeight += pColRow->m_fActualSize;
break;
}
case FWL_GRIDUNIT_Auto: {
ProcAutoColRow(pColRow, i, FALSE);
autoRows.Add(pColRow);
break;
}
case FWL_GRIDUNIT_Scaled:
default: {
ProcAutoColRow(pColRow, i, FALSE);
fScaledRowNum += pColRow->m_Size.fLength;
scaledRows.Add(pColRow);
if (pColRow->m_Size.fLength > 0) {
FX_FLOAT fPerHeight =
pColRow->m_fActualSize / pColRow->m_Size.fLength;
if (fPerHeight > fScaledMaxPerHeight) {
fScaledMaxPerHeight = fPerHeight;
}
}
break;
}
}
}
iRows = scaledRows.GetSize();
for (int32_t j = 0; j < iRows; j++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(scaledRows[j]);
if (!pColRow) {
continue;
}
SetColRowActualSize(pColRow, fScaledMaxPerHeight * pColRow->m_Size.fLength);
}
FX_POSITION ps = m_mapWidgetInfo.GetStartPosition();
while (ps) {
void* key = nullptr;
void* value = nullptr;
m_mapWidgetInfo.GetNextAssoc(ps, key, value);
IFWL_Widget* pWidget = static_cast<IFWL_Widget*>(key);
CFWL_GridWidgetInfo* pInfo = static_cast<CFWL_GridWidgetInfo*>(value);
if (pInfo->m_iRowSpan < 2) {
continue;
}
CFX_PtrArray spanAutoRows;
CFX_PtrArray spanScaledRows;
FX_FLOAT fSpanSize = 0;
FX_FLOAT fScaledSum = 0;
int32_t iAutoColRows = 0;
int32_t iScaledColRows = 0;
for (int32_t i = 0; i < pInfo->m_iRowSpan; i++) {
CFWL_GridColRow* pRow = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(FALSE, pInfo->m_iRow + i));
if (!pRow) {
break;
}
fSpanSize += pRow->m_fActualSize;
if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Auto) {
iAutoColRows++;
spanAutoRows.Add(pRow);
} else if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Scaled) {
iScaledColRows++;
fScaledSum += pRow->m_Size.fLength;
spanScaledRows.Add(pRow);
}
}
if (iAutoColRows < 1 && iScaledColRows < 1) {
continue;
}
FX_FLOAT fWidgetHeight = CalcAutoColumnWidgetHeight(pWidget, pInfo);
if (fWidgetHeight > fSpanSize) {
if (iScaledColRows > 0) {
if (fScaledSum <= 0) {
continue;
}
SetSpanScaledColRowSize(spanScaledRows, fWidgetHeight - fSpanSize,
fScaledSum);
} else {
SetSpanAutoColRowSize(spanAutoRows, fWidgetHeight - fSpanSize);
}
}
}
FX_FLOAT fAutoHeigt = 0;
int32_t iAutoRows = autoRows.GetSize();
for (int32_t m = 0; m < iAutoRows; m++) {
fAutoHeigt += static_cast<CFWL_GridColRow*>(autoRows[m])->m_fActualSize;
}
FX_FLOAT fScaledHeight = 0;
iRows = scaledRows.GetSize();
for (int32_t n = 0; n < iRows; n++) {
fScaledHeight +=
static_cast<CFWL_GridColRow*>(scaledRows[n])->m_fActualSize;
}
return fFixedHeight + fAutoHeigt + fScaledHeight;
}
FX_FLOAT CFWL_GridImp::ProcessUnCertainColumns() {
int32_t iColumns = m_Columns.GetSize();
if (iColumns < 1) {
CFWL_GridColRow* pColRow = new CFWL_GridColRow;
pColRow->m_Size.eUnit = FWL_GRIDUNIT_Auto;
ProcAutoColRow(pColRow, 0, TRUE);
FX_FLOAT fWidth = pColRow->m_fActualSize;
delete pColRow;
return fWidth;
}
FX_FLOAT fFixedWidth = 0;
CFX_PtrArray autoColumns;
CFX_PtrArray scaledColumns;
FX_FLOAT fScaledColumnNum = 0;
FX_FLOAT fScaledMaxPerWidth = 0;
for (int32_t i = 0; i < iColumns; i++) {
CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(m_Columns[i]);
if (!pColRow) {
continue;
}
switch (pColRow->m_Size.eUnit) {
case FWL_GRIDUNIT_Fixed: {
SetColRowActualSize(pColRow, pColRow->m_Size.fLength);
fFixedWidth += pColRow->m_fActualSize;
break;
}
case FWL_GRIDUNIT_Auto: {
ProcAutoColRow(pColRow, i, TRUE);
autoColumns.Add(pColRow);
break;
}
case FWL_GRIDUNIT_Scaled:
default: {
ProcAutoColRow(pColRow, i, TRUE);
fScaledColumnNum += pColRow->m_Size.fLength;
scaledColumns.Add(pColRow);
if (pColRow->m_Size.fLength <= 0) {
break;
}
FX_FLOAT fPerWidth = pColRow->m_fActualSize / pColRow->m_Size.fLength;
if (fPerWidth > fScaledMaxPerWidth) {
fScaledMaxPerWidth = fPerWidth;
}
}
}
}
iColumns = scaledColumns.GetSize();
for (int32_t j = 0; j < iColumns; j++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(scaledColumns[j]);
if (!pColRow) {
continue;
}
SetColRowActualSize(pColRow, fScaledMaxPerWidth * pColRow->m_Size.fLength);
}
FX_POSITION ps = m_mapWidgetInfo.GetStartPosition();
while (ps) {
IFWL_Widget* pWidget = NULL;
CFWL_GridWidgetInfo* pInfo = NULL;
m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo);
if (!pInfo || pInfo->m_iColumnSpan < 2) {
continue;
}
CFX_PtrArray spanAutoColumns;
CFX_PtrArray spanScaledColumns;
FX_FLOAT fSpanSize = 0;
FX_FLOAT fScaledSum = 0;
int32_t iAutoColRows = 0;
int32_t iScaledColRows = 0;
for (int32_t i = 0; i < pInfo->m_iColumnSpan; i++) {
CFWL_GridColRow* pColumn = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(TRUE, pInfo->m_iColumn + i));
if (!pColumn) {
break;
}
fSpanSize += pColumn->m_fActualSize;
if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Auto) {
iAutoColRows++;
spanAutoColumns.Add(pColumn);
} else if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Scaled) {
iScaledColRows++;
fScaledSum += pColumn->m_Size.fLength;
spanScaledColumns.Add(pColumn);
}
}
if (iAutoColRows < 1 && iScaledColRows < 1) {
continue;
}
FX_FLOAT fWidgetWidth = CalcAutoColumnWidgetWidth(pWidget, pInfo);
if (fWidgetWidth > fSpanSize) {
if (iScaledColRows > 0) {
if (fScaledSum <= 0) {
continue;
}
SetSpanScaledColRowSize(spanScaledColumns, fWidgetWidth - fSpanSize,
fScaledSum);
} else {
SetSpanAutoColRowSize(spanAutoColumns, fWidgetWidth - fSpanSize);
}
}
}
FX_FLOAT fAutoWidth = 0;
int32_t iAutoCols = autoColumns.GetSize();
for (int32_t m = 0; m < iAutoCols; m++) {
fAutoWidth += static_cast<CFWL_GridColRow*>(autoColumns[m])->m_fActualSize;
}
FX_FLOAT fScaledWidth = 0;
iColumns = scaledColumns.GetSize();
for (int32_t n = 0; n < iColumns; n++) {
fScaledWidth +=
static_cast<CFWL_GridColRow*>(scaledColumns[n])->m_fActualSize;
}
return fFixedWidth + fAutoWidth + fScaledWidth;
}
FX_FLOAT CFWL_GridImp::ProcessRows(FX_FLOAT fHeight) {
if (fHeight <= 0) {
return ProcessUnCertainRows();
}
int32_t iRows = m_Rows.GetSize();
if (iRows < 1) {
return fHeight;
}
FX_FLOAT fFixedHeight = 0;
FX_FLOAT fAutoHeigt = 0;
CFX_PtrArray autoRows;
CFX_PtrArray scaledRows;
FX_FLOAT fScaledRowNum = 0;
for (int32_t i = 0; i < iRows; i++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[i]);
if (!pColRow) {
continue;
}
switch (pColRow->m_Size.eUnit) {
case FWL_GRIDUNIT_Fixed: {
SetColRowActualSize(pColRow, pColRow->m_Size.fLength);
fFixedHeight += pColRow->m_fActualSize;
break;
}
case FWL_GRIDUNIT_Auto: {
ProcAutoColRow(pColRow, i, FALSE);
autoRows.Add(pColRow);
break;
}
case FWL_GRIDUNIT_Scaled:
default: {
fScaledRowNum += pColRow->m_Size.fLength;
scaledRows.Add(pColRow);
SetColRowActualSize(pColRow, 0);
break;
}
}
}
FX_POSITION ps = m_mapWidgetInfo.GetStartPosition();
while (ps) {
IFWL_Widget* pWidget = NULL;
CFWL_GridWidgetInfo* pInfo = NULL;
m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo);
if (!pInfo || pInfo->m_iRowSpan < 2) {
continue;
}
CFX_PtrArray spanAutoRows;
FX_FLOAT fSpanSize = 0;
int32_t iAutoColRows = 0;
int32_t iScaledColRows = 0;
for (int32_t i = 0; i < pInfo->m_iRowSpan; i++) {
CFWL_GridColRow* pRow = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(FALSE, pInfo->m_iRow + i));
if (!pRow) {
break;
}
fSpanSize += pRow->m_fActualSize;
if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Auto) {
iAutoColRows++;
spanAutoRows.Add(pRow);
} else if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Scaled) {
iScaledColRows++;
}
}
if (iAutoColRows < 1) {
continue;
}
FX_FLOAT fWidgetHeight = CalcAutoColumnWidgetHeight(pWidget, pInfo);
if (fWidgetHeight > fSpanSize) {
if (iScaledColRows > 0) {
} else {
SetSpanAutoColRowSize(spanAutoRows, fWidgetHeight - fSpanSize);
}
}
}
int32_t iAutoRows = autoRows.GetSize();
for (int32_t k = 0; k < iAutoRows; k++) {
fAutoHeigt +=
reinterpret_cast<CFWL_GridColRow*>(autoRows[k])->m_fActualSize;
}
FX_FLOAT fScaledHeight = fHeight - fFixedHeight - fAutoHeigt;
if (fScaledHeight > 0 && fScaledRowNum > 0) {
SetScaledColRowsSize(scaledRows, fScaledHeight, fScaledRowNum);
}
return fHeight;
}
void CFWL_GridImp::SetAllWidgetsRect() {
FX_FLOAT fStartLeft = 0;
int32_t iColumns = m_Columns.GetSize();
for (int32_t i = 0; i < iColumns; i++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Columns[i]);
if (!pColRow) {
continue;
}
pColRow->m_fActualPos = fStartLeft;
fStartLeft += pColRow->m_fActualSize;
}
FX_FLOAT fStartTop = 0;
int32_t iRows = m_Rows.GetSize();
for (int32_t j = 0; j < iRows; j++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[j]);
if (!pColRow) {
continue;
}
pColRow->m_fActualPos = fStartTop;
fStartTop += pColRow->m_fActualSize;
}
FX_POSITION ps = m_mapWidgetInfo.GetStartPosition();
while (ps) {
IFWL_Widget* pWidget = NULL;
CFWL_GridWidgetInfo* pInfo = NULL;
m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo);
if (!pWidget || !pInfo) {
continue;
}
FX_FLOAT fColumnStart = 0;
CFWL_GridColRow* pColumn =
reinterpret_cast<CFWL_GridColRow*>(GetColRow(TRUE, pInfo->m_iColumn));
if (pColumn) {
fColumnStart = pColumn->m_fActualPos;
}
FX_FLOAT fRowStart = 0;
CFWL_GridColRow* pRow =
reinterpret_cast<CFWL_GridColRow*>(GetColRow(FALSE, pInfo->m_iRow));
if (pRow) {
fRowStart = pRow->m_fActualPos;
}
FX_FLOAT fColumnWidth = 0;
if (iColumns > 0) {
for (int32_t j = 0; j < pInfo->m_iColumnSpan; j++) {
CFWL_GridColRow* pCol = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(TRUE, pInfo->m_iColumn + j));
if (!pCol) {
break;
}
fColumnWidth += pCol->m_fActualSize;
}
} else {
fColumnWidth = m_pProperties->m_rtWidget.width;
}
FX_FLOAT fRowHeight = 0;
if (iRows > 0) {
for (int32_t k = 0; k < pInfo->m_iRowSpan; k++) {
CFWL_GridColRow* pR = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(FALSE, pInfo->m_iRow + k));
if (!pR) {
break;
}
fRowHeight += pR->m_fActualSize;
}
} else {
fRowHeight = m_pProperties->m_rtWidget.height;
}
FX_FLOAT fLeftMargin = 0, fRightMargin = 0;
FX_BOOL bLeftMargin =
GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Left, fLeftMargin);
FX_BOOL bRightMargin =
GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Right, fRightMargin);
FX_FLOAT fTopMargin = 0, fBottomMargin = 0;
FX_BOOL bTopMargin =
GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Top, fTopMargin);
FX_BOOL bBottomMargin =
GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Bottom, fBottomMargin);
if (pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) {
SetWidgetActualWidth(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Width].fLength);
} else {
if (bLeftMargin && bRightMargin) {
SetWidgetActualWidth(pInfo, fColumnWidth - fLeftMargin - fRightMargin);
} else {
CFX_RectF rtAuto;
pWidget->GetWidgetRect(rtAuto, TRUE);
SetWidgetActualWidth(pInfo, rtAuto.width);
}
}
if (pInfo->m_Size[FWL_GRIDSIZE_Height].eUnit == FWL_GRIDUNIT_Fixed) {
SetWidgetActualHeight(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Height].fLength);
} else {
if (bTopMargin && bBottomMargin) {
SetWidgetActualHeight(pInfo, fRowHeight - fTopMargin - fBottomMargin);
} else {
CFX_RectF rtAuto;
pWidget->GetWidgetRect(rtAuto, TRUE);
SetWidgetActualHeight(pInfo, rtAuto.height);
}
}
if (bLeftMargin && bRightMargin &&
pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) {
fLeftMargin =
fColumnStart + fLeftMargin +
(fColumnWidth - fLeftMargin - fRightMargin - pInfo->m_fActualWidth) /
2;
} else if (bLeftMargin) {
fLeftMargin = fColumnStart + fLeftMargin;
} else if (bRightMargin) {
fLeftMargin =
fColumnStart + fColumnWidth - fRightMargin - pInfo->m_fActualWidth;
} else {
fLeftMargin = fColumnStart;
}
if (bTopMargin && bBottomMargin &&
pInfo->m_Size[FWL_GRIDSIZE_Height].eUnit == FWL_GRIDUNIT_Fixed) {
fTopMargin =
fRowStart + fTopMargin +
(fRowHeight - fTopMargin - fBottomMargin - pInfo->m_fActualHeight) /
2;
} else if (bTopMargin) {
fTopMargin = fRowStart + fTopMargin;
} else if (bBottomMargin) {
fTopMargin =
fRowStart + fRowHeight - fBottomMargin - pInfo->m_fActualHeight;
} else {
fTopMargin = fRowStart;
}
CFX_RectF rtWidget, rtOld;
rtWidget.Set(fLeftMargin, fTopMargin, pInfo->m_fActualWidth,
pInfo->m_fActualHeight);
pWidget->GetWidgetRect(rtOld);
if (rtWidget == rtOld) {
continue;
}
pWidget->SetWidgetRect(rtWidget);
if (rtWidget.width == rtOld.width && rtWidget.height == rtOld.height) {
continue;
}
pWidget->Update();
}
}
