| // Copyright 2014 PDFium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| |
| #include "xfa/src/fwl/core/fwl_gridimp.h" |
| |
| #include "xfa/src/fwl/core/fwl_contentimp.h" |
| #include "xfa/src/fwl/core/fwl_noteimp.h" |
| #include "xfa/src/fwl/core/fwl_targetimp.h" |
| #include "xfa/src/fwl/core/fwl_threadimp.h" |
| #include "xfa/src/fwl/core/fwl_widgetimp.h" |
| |
| // static |
| IFWL_Grid* IFWL_Grid::Create(const CFWL_WidgetImpProperties& properties) { |
| IFWL_Grid* pGrid = new IFWL_Grid; |
| CFWL_GridImp* pGridImpl = new CFWL_GridImp(properties, nullptr); |
| pGrid->SetImpl(pGridImpl); |
| pGridImpl->SetInterface(pGrid); |
| return pGrid; |
| } |
| IFWL_Grid::IFWL_Grid() {} |
| FWL_HGRIDCOLROW IFWL_Grid::InsertColRow(FX_BOOL bColumn, int32_t nIndex) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->InsertColRow(bColumn, nIndex); |
| } |
| int32_t IFWL_Grid::CountColRows(FX_BOOL bColumn) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->CountColRows(bColumn); |
| } |
| FWL_HGRIDCOLROW IFWL_Grid::GetColRow(FX_BOOL bColumn, int32_t nIndex) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetColRow(bColumn, nIndex); |
| } |
| int32_t IFWL_Grid::GetIndex(FWL_HGRIDCOLROW hColRow) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetIndex(hColRow); |
| } |
| FX_FLOAT IFWL_Grid::GetSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetSize(hColRow, eUnit); |
| } |
| FWL_ERR IFWL_Grid::SetSize(FWL_HGRIDCOLROW hColRow, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->SetSize(hColRow, fSize, eUnit); |
| } |
| FX_FLOAT IFWL_Grid::GetMinSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetMinSize(hColRow, eUnit); |
| } |
| FWL_ERR IFWL_Grid::SetMinSize(FWL_HGRIDCOLROW hColRow, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->SetMinSize(hColRow, fSize, eUnit); |
| } |
| FX_FLOAT IFWL_Grid::GetMaxSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetMaxSize(hColRow, eUnit); |
| } |
| FWL_ERR IFWL_Grid::SetMaxSize(FWL_HGRIDCOLROW hColRow, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->SetMaxSize(hColRow, fSize, eUnit); |
| } |
| FX_BOOL IFWL_Grid::DeleteColRow(FWL_HGRIDCOLROW hColRow) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->DeleteColRow(hColRow); |
| } |
| FX_BOOL IFWL_Grid::IsColumn(FWL_HGRIDCOLROW hColRow) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->IsColumn(hColRow); |
| } |
| int32_t IFWL_Grid::GetWidgetPos(IFWL_Widget* pWidget, FX_BOOL bColumn) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetWidgetPos(pWidget, bColumn); |
| } |
| FWL_ERR IFWL_Grid::SetWidgetPos(IFWL_Widget* pWidget, |
| int32_t iPos, |
| FX_BOOL bColumn) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->SetWidgetPos(pWidget, iPos, bColumn); |
| } |
| int32_t IFWL_Grid::GetWidgetSpan(IFWL_Widget* pWidget, FX_BOOL bColumn) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetWidgetSpan(pWidget, bColumn); |
| } |
| FWL_ERR IFWL_Grid::SetWidgetSpan(IFWL_Widget* pWidget, |
| int32_t iSpan, |
| FX_BOOL bColumn) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->SetWidgetSpan(pWidget, iSpan, bColumn); |
| } |
| FX_FLOAT IFWL_Grid::GetWidgetSize(IFWL_Widget* pWidget, |
| FWL_GRIDSIZE eSize, |
| FWL_GRIDUNIT& eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->GetWidgetSize(pWidget, eSize, eUnit); |
| } |
| FWL_ERR IFWL_Grid::SetWidgetSize(IFWL_Widget* pWidget, |
| FWL_GRIDSIZE eSize, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUit) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->SetWidgetSize(pWidget, eSize, fSize, eUit); |
| } |
| FX_BOOL IFWL_Grid::GetWidgetMargin(IFWL_Widget* pWidget, |
| FWL_GRIDMARGIN eMargin, |
| FX_FLOAT& fMargin) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->GetWidgetMargin(pWidget, eMargin, fMargin); |
| } |
| FWL_ERR IFWL_Grid::SetWidgetMargin(IFWL_Widget* pWidget, |
| FWL_GRIDMARGIN eMargin, |
| FX_FLOAT fMargin) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->SetWidgetMargin(pWidget, eMargin, fMargin); |
| } |
| FWL_ERR IFWL_Grid::RemoveWidgetMargin(IFWL_Widget* pWidget, |
| FWL_GRIDMARGIN eMargin) { |
| return static_cast<CFWL_GridImp*>(GetImpl()) |
| ->RemoveWidgetMargin(pWidget, eMargin); |
| } |
| FX_FLOAT IFWL_Grid::GetGridSize(FWL_GRIDSIZE eSize, FWL_GRIDUNIT& eUnit) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->GetGridSize(eSize, eUnit); |
| } |
| FWL_ERR IFWL_Grid::SetGridSize(FWL_GRIDSIZE eSize, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUit) { |
| return static_cast<CFWL_GridImp*>(GetImpl())->SetGridSize(eSize, fSize, eUit); |
| } |
| |
| CFWL_GridImp::CFWL_GridImp(const CFWL_WidgetImpProperties& properties, |
| IFWL_Widget* pOuter) |
| : CFWL_ContentImp(properties, pOuter) { |
| m_Size[FWL_GRIDSIZE_Width].eUnit = FWL_GRIDUNIT_Auto; |
| m_Size[FWL_GRIDSIZE_Width].fLength = 0; |
| m_Size[FWL_GRIDSIZE_Height].eUnit = FWL_GRIDUNIT_Auto; |
| m_Size[FWL_GRIDSIZE_Height].fLength = 0; |
| m_Size[FWL_GRIDSIZE_MinWidth].eUnit = FWL_GRIDUNIT_Fixed; |
| m_Size[FWL_GRIDSIZE_MinWidth].fLength = 0; |
| m_Size[FWL_GRIDSIZE_MaxWidth].eUnit = FWL_GRIDUNIT_Infinity; |
| m_Size[FWL_GRIDSIZE_MaxWidth].fLength = 0; |
| m_Size[FWL_GRIDSIZE_MinHeight].eUnit = FWL_GRIDUNIT_Fixed; |
| m_Size[FWL_GRIDSIZE_MinHeight].fLength = 0; |
| m_Size[FWL_GRIDSIZE_MaxHeight].eUnit = FWL_GRIDUNIT_Infinity; |
| m_Size[FWL_GRIDSIZE_MaxHeight].fLength = 0; |
| } |
| CFWL_GridImp::~CFWL_GridImp() { |
| int32_t iCount = m_Columns.GetSize(); |
| for (int32_t i = 0; i < iCount; i++) { |
| delete static_cast<CFWL_GridColRow*>(m_Columns[i]); |
| } |
| m_Columns.RemoveAll(); |
| iCount = m_Rows.GetSize(); |
| for (int32_t j = 0; j < iCount; j++) { |
| delete static_cast<CFWL_GridColRow*>(m_Rows[j]); |
| } |
| m_Rows.RemoveAll(); |
| FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); |
| while (ps) { |
| IFWL_Widget* pWidget; |
| CFWL_GridWidgetInfo* pInfo; |
| m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo); |
| delete pInfo; |
| } |
| m_mapWidgetInfo.RemoveAll(); |
| delete m_pDelegate; |
| m_pDelegate = nullptr; |
| } |
| FWL_ERR CFWL_GridImp::GetClassName(CFX_WideString& wsClass) const { |
| wsClass = FWL_CLASS_Grid; |
| return FWL_ERR_Succeeded; |
| } |
| FX_DWORD CFWL_GridImp::GetClassID() const { |
| return FWL_CLASSHASH_Grid; |
| } |
| FWL_ERR CFWL_GridImp::Initialize() { |
| if (CFWL_ContentImp::Initialize() != FWL_ERR_Succeeded) |
| return FWL_ERR_Indefinite; |
| m_pDelegate = new CFWL_GridImpDelegate(this); |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::Finalize() { |
| if (CFWL_ContentImp::Finalize() != FWL_ERR_Succeeded) |
| return FWL_ERR_Indefinite; |
| delete m_pDelegate; |
| m_pDelegate = nullptr; |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) { |
| if (bAutoSize) { |
| rect.left = 0; |
| rect.top = 0; |
| rect.width = ProcessUnCertainColumns(); |
| rect.height = ProcessUnCertainRows(); |
| } else { |
| rect = m_pProperties->m_rtWidget; |
| } |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::SetWidgetRect(const CFX_RectF& rect) { |
| CFWL_WidgetImp::SetWidgetRect(rect); |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::Update() { |
| if (IsLocked()) { |
| return FWL_ERR_Indefinite; |
| } |
| ProcessColumns(m_pProperties->m_rtWidget.width); |
| ProcessRows(m_pProperties->m_rtWidget.height); |
| SetAllWidgetsRect(); |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::DrawWidget(CFX_Graphics* pGraphics, |
| const CFX_Matrix* pMatrix) { |
| if (!pGraphics) |
| return FWL_ERR_Indefinite; |
| if ((m_pProperties->m_dwStyleExes & FWL_GRIDSTYLEEXT_ShowGridLines) == 0) { |
| return FWL_ERR_Succeeded; |
| } |
| pGraphics->SaveGraphState(); |
| if (pMatrix) { |
| pGraphics->ConcatMatrix(pMatrix); |
| } |
| { |
| FX_BOOL bDrawLine = FALSE; |
| CFX_Path path; |
| path.Create(); |
| int32_t iColumns = m_Columns.GetSize(); |
| for (int32_t i = 1; i < iColumns; i++) { |
| CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Columns[i]); |
| if (!pColRow) { |
| continue; |
| } |
| bDrawLine = TRUE; |
| path.AddLine(pColRow->m_fActualPos, 0, pColRow->m_fActualPos, |
| m_pProperties->m_rtWidget.height); |
| } |
| int32_t iRows = m_Rows.GetSize(); |
| for (int32_t j = 1; j < iRows; j++) { |
| CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[j]); |
| if (!pColRow) { |
| continue; |
| } |
| bDrawLine = TRUE; |
| path.AddLine(0, pColRow->m_fActualPos, m_pProperties->m_rtWidget.width, |
| pColRow->m_fActualPos); |
| } |
| if (bDrawLine) { |
| CFX_Color cr(0xFFFF0000); |
| pGraphics->SetStrokeColor(&cr); |
| pGraphics->StrokePath(&path); |
| } |
| } |
| pGraphics->RestoreGraphState(); |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::InsertWidget(IFWL_Widget* pChild, int32_t nIndex) { |
| if (!pChild) |
| return FWL_ERR_Indefinite; |
| CFWL_ContentImp::InsertWidget(pChild, nIndex); |
| if (!m_mapWidgetInfo.GetValueAt(pChild)) { |
| CFWL_GridWidgetInfo* pInfo = new CFWL_GridWidgetInfo; |
| m_mapWidgetInfo.SetAt(pChild, pInfo); |
| m_Widgets.Add(pChild); |
| } |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::RemoveWidget(IFWL_Widget* pWidget) { |
| if (!pWidget) |
| return FWL_ERR_Indefinite; |
| CFWL_ContentImp::RemoveWidget(pWidget); |
| if (CFWL_GridWidgetInfo* pInfo = static_cast<CFWL_GridWidgetInfo*>( |
| m_mapWidgetInfo.GetValueAt(pWidget))) { |
| m_mapWidgetInfo.RemoveKey(pWidget); |
| delete pInfo; |
| int32_t nIndex = m_Widgets.Find(pWidget); |
| m_Widgets.RemoveAt(nIndex, 1); |
| } |
| return FWL_ERR_Succeeded; |
| } |
| FWL_HGRIDCOLROW CFWL_GridImp::InsertColRow(FX_BOOL bColumn, int32_t nIndex) { |
| if (bColumn) { |
| if (nIndex < 0 || nIndex > m_Columns.GetSize()) { |
| nIndex = m_Columns.GetSize(); |
| } |
| CFWL_GridColRow* pColumn = new CFWL_GridColRow; |
| m_Columns.InsertAt(nIndex, pColumn, 1); |
| return (FWL_HGRIDCOLROW)pColumn; |
| } |
| if (nIndex < 0 || nIndex > m_Rows.GetSize()) { |
| nIndex = m_Rows.GetSize(); |
| } |
| CFWL_GridColRow* pRow = new CFWL_GridColRow; |
| m_Rows.InsertAt(nIndex, pRow, 1); |
| return (FWL_HGRIDCOLROW)pRow; |
| } |
| int32_t CFWL_GridImp::CountColRows(FX_BOOL bColumn) { |
| if (bColumn) { |
| return m_Columns.GetSize(); |
| } |
| return m_Rows.GetSize(); |
| } |
| FWL_HGRIDCOLROW CFWL_GridImp::GetColRow(FX_BOOL bColumn, int32_t nIndex) { |
| if (bColumn) { |
| if (nIndex < 0 || nIndex >= m_Columns.GetSize()) { |
| return NULL; |
| } |
| return (FWL_HGRIDCOLROW)m_Columns[nIndex]; |
| } |
| if (nIndex < 0 || nIndex >= m_Rows.GetSize()) { |
| return NULL; |
| } |
| return (FWL_HGRIDCOLROW)m_Rows[nIndex]; |
| } |
| int32_t CFWL_GridImp::GetIndex(FWL_HGRIDCOLROW hColRow) { |
| if (IsColumn(hColRow)) { |
| return m_Columns.Find(hColRow); |
| } |
| return m_Rows.Find(hColRow); |
| } |
| FX_FLOAT CFWL_GridImp::GetSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { |
| if (!hColRow) |
| return -1; |
| CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| eUnit = pColRow->m_Size.eUnit; |
| return pColRow->m_Size.fLength; |
| } |
| FWL_ERR CFWL_GridImp::SetSize(FWL_HGRIDCOLROW hColRow, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUnit) { |
| if (!hColRow) |
| return FWL_ERR_Indefinite; |
| CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| pColRow->m_Size.eUnit = eUnit; |
| pColRow->m_Size.fLength = fSize; |
| return FWL_ERR_Succeeded; |
| } |
| FX_FLOAT CFWL_GridImp::GetMinSize(FWL_HGRIDCOLROW hColRow, |
| FWL_GRIDUNIT& eUnit) { |
| if (!hColRow) |
| return -1; |
| CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| eUnit = pColRow->m_MinSize.eUnit; |
| return pColRow->m_MinSize.fLength; |
| } |
| FWL_ERR CFWL_GridImp::SetMinSize(FWL_HGRIDCOLROW hColRow, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUnit) { |
| if (!hColRow) |
| return FWL_ERR_Indefinite; |
| CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| pColRow->m_MinSize.eUnit = eUnit; |
| pColRow->m_MinSize.fLength = fSize; |
| return FWL_ERR_Succeeded; |
| } |
| FX_FLOAT CFWL_GridImp::GetMaxSize(FWL_HGRIDCOLROW hColRow, |
| FWL_GRIDUNIT& eUnit) { |
| if (!hColRow) |
| return -1; |
| CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| eUnit = pColRow->m_MaxSize.eUnit; |
| return pColRow->m_MaxSize.fLength; |
| } |
| FWL_ERR CFWL_GridImp::SetMaxSize(FWL_HGRIDCOLROW hColRow, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUnit) { |
| if (!hColRow) |
| return FWL_ERR_Indefinite; |
| CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| pColRow->m_MaxSize.eUnit = eUnit; |
| pColRow->m_MaxSize.fLength = fSize; |
| return FWL_ERR_Succeeded; |
| } |
| FX_BOOL CFWL_GridImp::DeleteColRow(FWL_HGRIDCOLROW hColRow) { |
| int32_t nIndex = m_Columns.Find(hColRow); |
| if (nIndex >= 0) { |
| m_Columns.RemoveAt(nIndex); |
| delete reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| return TRUE; |
| } |
| nIndex = m_Rows.Find(hColRow); |
| if (nIndex >= 0) { |
| delete reinterpret_cast<CFWL_GridColRow*>(hColRow); |
| m_Rows.RemoveAt(nIndex); |
| return TRUE; |
| } |
| return FALSE; |
| } |
| FX_BOOL CFWL_GridImp::IsColumn(FWL_HGRIDCOLROW hColRow) { |
| return m_Columns.Find(hColRow) != -1; |
| } |
| int32_t CFWL_GridImp::GetWidgetPos(IFWL_Widget* pWidget, FX_BOOL bColumn) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| return bColumn ? pInfo->m_iColumn : pInfo->m_iRow; |
| } |
| return -1; |
| } |
| FWL_ERR CFWL_GridImp::SetWidgetPos(IFWL_Widget* pWidget, |
| int32_t iPos, |
| FX_BOOL bColumn) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| bColumn ? pInfo->m_iColumn = iPos : pInfo->m_iRow = iPos; |
| } |
| return FWL_ERR_Succeeded; |
| } |
| int32_t CFWL_GridImp::GetWidgetSpan(IFWL_Widget* pWidget, FX_BOOL bColumn) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| return bColumn ? pInfo->m_iColumnSpan : pInfo->m_iRowSpan; |
| } |
| return 0; |
| } |
| FWL_ERR CFWL_GridImp::SetWidgetSpan(IFWL_Widget* pWidget, |
| int32_t iSpan, |
| FX_BOOL bColumn) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| bColumn ? pInfo->m_iColumnSpan = iSpan : pInfo->m_iRowSpan = iSpan; |
| } |
| return FWL_ERR_Succeeded; |
| } |
| FX_FLOAT CFWL_GridImp::GetWidgetSize(IFWL_Widget* pWidget, |
| FWL_GRIDSIZE eSize, |
| FWL_GRIDUNIT& eUnit) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| eUnit = pInfo->m_Size[eSize].eUnit; |
| return pInfo->m_Size[eSize].fLength; |
| } |
| return 0; |
| } |
| FWL_ERR CFWL_GridImp::SetWidgetSize(IFWL_Widget* pWidget, |
| FWL_GRIDSIZE eSize, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUit) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| pInfo->m_Size[eSize].fLength = fSize; |
| pInfo->m_Size[eSize].eUnit = eUit; |
| } |
| return FWL_ERR_Succeeded; |
| } |
| FX_BOOL CFWL_GridImp::GetWidgetMargin(IFWL_Widget* pWidget, |
| FWL_GRIDMARGIN eMargin, |
| FX_FLOAT& fMargin) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| fMargin = pInfo->m_Margin[eMargin]; |
| return (pInfo->m_dwMarginFlag & (1 << eMargin)) != 0; |
| } |
| return FALSE; |
| } |
| FWL_ERR CFWL_GridImp::SetWidgetMargin(IFWL_Widget* pWidget, |
| FWL_GRIDMARGIN eMargin, |
| FX_FLOAT fMargin) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| pInfo->m_Margin[eMargin] = fMargin; |
| pInfo->m_dwMarginFlag |= (1 << eMargin); |
| } |
| return FWL_ERR_Succeeded; |
| } |
| FWL_ERR CFWL_GridImp::RemoveWidgetMargin(IFWL_Widget* pWidget, |
| FWL_GRIDMARGIN eMargin) { |
| CFWL_GridWidgetInfo* pInfo = |
| static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); |
| if (pInfo) { |
| pInfo->m_dwMarginFlag &= ~(1 << eMargin); |
| } |
| return FWL_ERR_Succeeded; |
| } |
| FX_FLOAT CFWL_GridImp::GetGridSize(FWL_GRIDSIZE eSize, FWL_GRIDUNIT& eUnit) { |
| eUnit = m_Size[eSize].eUnit; |
| return m_Size[eSize].fLength; |
| } |
| FWL_ERR CFWL_GridImp::SetGridSize(FWL_GRIDSIZE eSize, |
| FX_FLOAT fSize, |
| FWL_GRIDUNIT eUit) { |
| m_Size[eSize].fLength = fSize; |
| m_Size[eSize].eUnit = eUit; |
| return FWL_ERR_Succeeded; |
| } |
| CFWL_GridWidgetInfo* CFWL_GridImp::GetWidgetInfo(IFWL_Widget* pWidget) { |
| return static_cast<CFWL_GridWidgetInfo*>(m_mapWidgetInfo.GetValueAt(pWidget)); |
| } |
| void CFWL_GridImp::ProcFixedColRow(CFWL_GridColRow* pColRow, |
| int32_t nIndex, |
| FX_FLOAT fColRowSize, |
| FX_BOOL bColumn) { |
| pColRow->m_fActualSize = fColRowSize; |
| 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 (bColumn) { |
| if (pInfo->m_iColumn == nIndex && pInfo->m_iColumnSpan == 1) { |
| CalcWidgetWidth(pWidget, pInfo, pColRow->m_fActualSize); |
| } |
| } else { |
| if (pInfo->m_iRow == nIndex && pInfo->m_iRowSpan == 1) { |
| CalcWidgetHeigt(pWidget, pInfo, pColRow->m_fActualSize); |
| } |
| } |
| } |
| } |
| void CFWL_GridImp::ProcAutoColRow(CFWL_GridColRow* pColRow, |
| int32_t nIndex, |
| FX_BOOL bColumn) { |
| if (!pColRow) |
| return; |
| FX_FLOAT fMaxSize = 0, fWidgetSize = 0; |
| 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; |
| } |
| if (bColumn) { |
| if (pInfo->m_iColumn != nIndex || pInfo->m_iColumnSpan != 1) { |
| continue; |
| } |
| fWidgetSize = CalcAutoColumnWidgetWidth(pWidget, pInfo); |
| if (fMaxSize < fWidgetSize) { |
| fMaxSize = fWidgetSize; |
| } |
| } else { |
| if (pInfo->m_iRow != nIndex || pInfo->m_iRowSpan != 1) { |
| continue; |
| } |
| fWidgetSize = CalcAutoColumnWidgetHeight(pWidget, pInfo); |
| if (fMaxSize < fWidgetSize) { |
| fMaxSize = fWidgetSize; |
| } |
| } |
| } |
| SetColRowActualSize(pColRow, fMaxSize); |
| } |
| void CFWL_GridImp::ProcScaledColRow(CFWL_GridColRow* pColRow, |
| int32_t nIndex, |
| FX_FLOAT fColRowSize, |
| FX_BOOL bColumn) { |
| if (fColRowSize > 0) { |
| ProcFixedColRow(pColRow, nIndex, fColRowSize, bColumn); |
| } |
| } |
| void CFWL_GridImp::CalcWidgetWidth(IFWL_Widget* pWidget, |
| CFWL_GridWidgetInfo* pInfo, |
| FX_FLOAT fColunmWidth) { |
| if (pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) { |
| SetWidgetActualWidth(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Width].fLength); |
| } else { |
| FX_FLOAT fWidth = 0; |
| FX_FLOAT fLeftMargin = 0, fRightMargin = 0; |
| FX_BOOL bLeftMargin = |
| GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Left, fLeftMargin); |
| FX_BOOL bRightMargin = |
| GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Right, fRightMargin); |
| if (bLeftMargin && bRightMargin) { |
| fWidth = fColunmWidth - fLeftMargin - fRightMargin; |
| } else { |
| CFX_RectF rtAuto; |
| pWidget->GetWidgetRect(rtAuto, TRUE); |
| fWidth = rtAuto.Width(); |
| } |
| SetWidgetActualWidth(pInfo, fWidth); |
| } |
| } |
| void CFWL_GridImp::CalcWidgetHeigt(IFWL_Widget* pWidget, |
| CFWL_GridWidgetInfo* pInfo, |
| FX_FLOAT fRowHeigt) { |
| if (pInfo->m_Size[FWL_GRIDSIZE_Height].eUnit == FWL_GRIDUNIT_Fixed) { |
| SetWidgetActualHeight(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Height].fLength); |
| } else { |
| FX_FLOAT fHeight = 0; |
| 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 (bTopMargin && bBottomMargin) { |
| fHeight = fRowHeigt - fTopMargin - fBottomMargin; |
| } else { |
| CFX_RectF rtAuto; |
| pWidget->GetWidgetRect(rtAuto, TRUE); |
| fHeight = rtAuto.Height(); |
| } |
| SetWidgetActualHeight(pInfo, fHeight); |
| } |
| } |
| FX_FLOAT CFWL_GridImp::CalcAutoColumnWidgetWidth(IFWL_Widget* pWidget, |
| CFWL_GridWidgetInfo* pInfo) { |
| FX_FLOAT fLeftMargin = 0, fRightMargin = 0; |
| FX_BOOL bLeftMargin = |
| GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Left, fLeftMargin); |
| FX_BOOL bRightMargin = |
| GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Right, fRightMargin); |
| if (pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) { |
| SetWidgetActualWidth(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Width].fLength); |
| } else { |
| CFX_RectF rtAuto; |
| pWidget->GetWidgetRect(rtAuto, TRUE); |
| FX_FLOAT fWidth = rtAuto.width; |
| SetWidgetActualWidth(pInfo, fWidth); |
| } |
| FX_FLOAT fTotal = pInfo->m_fActualWidth; |
| if (bLeftMargin) { |
| fTotal += fLeftMargin; |
| } |
| if (bRightMargin) { |
| fTotal += fRightMargin; |
| } |
| return fTotal; |
| } |
| FX_FLOAT CFWL_GridImp::CalcAutoColumnWidgetHeight(IFWL_Widget* pWidget, |
| CFWL_GridWidgetInfo* pInfo) { |
| 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_Height].eUnit == FWL_GRIDUNIT_Fixed) { |
| SetWidgetActualHeight(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Height].fLength); |
| } else { |
| CFX_RectF rtAuto; |
| pWidget->GetWidgetRect(rtAuto, TRUE); |
| FX_FLOAT fHeight = rtAuto.height; |
| SetWidgetActualHeight(pInfo, fHeight); |
| } |
| FX_FLOAT fTotal = pInfo->m_fActualHeight; |
| if (bTopMargin) { |
| fTotal += fTopMargin; |
| } |
| if (bBottomMargin) { |
| fTotal += fBottomMargin; |
| } |
| return fTotal; |
| } |
| FX_FLOAT CFWL_GridImp::ProcessColumns(FX_FLOAT fWidth) { |
| if (fWidth <= 0) { |
| return ProcessUnCertainColumns(); |
| } |
| int32_t iColumns = m_Columns.GetSize(); |
| if (iColumns < 1) { |
| return fWidth; |
| } |
| FX_FLOAT fFixedWidth = 0; |
| FX_FLOAT fAutoWidth = 0; |
| CFX_PtrArray autoColumns; |
| CFX_PtrArray scaledColumns; |
| FX_FLOAT fScaledColumnNum = 0; |
| for (int32_t i = 0; i < iColumns; i++) { |
| CFWL_GridColRow* pColRow = static_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: { |
| fScaledColumnNum += pColRow->m_Size.fLength; |
| scaledColumns.Add(pColRow); |
| SetColRowActualSize(pColRow, 0); |
| } |
| } |
| } |
| 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; |
| FX_FLOAT fSpanSize = 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++; |
| } |
| } |
| if (iAutoColRows < 1) { |
| continue; |
| } |
| FX_FLOAT fWidgetWidth = CalcAutoColumnWidgetWidth(pWidget, pInfo); |
| if (fWidgetWidth > fSpanSize) { |
| if (iScaledColRows > 0) { |
| } else { |
| SetSpanAutoColRowSize(spanAutoColumns, fWidgetWidth - fSpanSize); |
| } |
| } |
| } |
| int32_t iAutoCols = autoColumns.GetSize(); |
| for (int32_t k = 0; k < iAutoCols; k++) { |
| fAutoWidth += static_cast<CFWL_GridColRow*>(autoColumns[k])->m_fActualSize; |
| } |
| FX_FLOAT fScaledWidth = fWidth - fFixedWidth - fAutoWidth; |
| if (fScaledWidth > 0 && fScaledColumnNum > 0) { |
| SetScaledColRowsSize(scaledColumns, fScaledWidth, fScaledColumnNum); |
| } |
| return fWidth; |
| } |
| 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; |
| } |
| 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::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_BOOL CFWL_GridImp::SetColRowActualSize(CFWL_GridColRow* pColRow, |
| FX_FLOAT fSize, |
| FX_BOOL bSetBeyond) { |
| if (pColRow->m_MinSize.eUnit == FWL_GRIDUNIT_Fixed && |
| fSize < pColRow->m_MinSize.fLength) { |
| pColRow->m_fActualSize = pColRow->m_MinSize.fLength; |
| return FALSE; |
| } |
| if (pColRow->m_MaxSize.eUnit == FWL_GRIDUNIT_Fixed && |
| fSize > pColRow->m_MaxSize.fLength) { |
| pColRow->m_fActualSize = pColRow->m_MaxSize.fLength; |
| return FALSE; |
| } |
| if (bSetBeyond) { |
| return TRUE; |
| } |
| pColRow->m_fActualSize = fSize; |
| return TRUE; |
| } |
| FX_FLOAT CFWL_GridImp::SetWidgetActualWidth(CFWL_GridWidgetInfo* pInfo, |
| FX_FLOAT fWidth) { |
| if (pInfo->m_Size[FWL_GRIDSIZE_MinWidth].eUnit == FWL_GRIDUNIT_Fixed && |
| fWidth < pInfo->m_Size[FWL_GRIDSIZE_MinWidth].fLength) { |
| fWidth = pInfo->m_Size[FWL_GRIDSIZE_MinWidth].fLength; |
| } |
| if (pInfo->m_Size[FWL_GRIDSIZE_MaxWidth].eUnit == FWL_GRIDUNIT_Fixed && |
| fWidth > pInfo->m_Size[FWL_GRIDSIZE_MaxWidth].fLength) { |
| fWidth = pInfo->m_Size[FWL_GRIDSIZE_MaxWidth].fLength; |
| } |
| pInfo->m_fActualWidth = fWidth; |
| return fWidth; |
| } |
| FX_FLOAT CFWL_GridImp::SetWidgetActualHeight(CFWL_GridWidgetInfo* pInfo, |
| FX_FLOAT fHeight) { |
| if (pInfo->m_Size[FWL_GRIDSIZE_MinHeight].eUnit == FWL_GRIDUNIT_Fixed && |
| fHeight < pInfo->m_Size[FWL_GRIDSIZE_MinHeight].fLength) { |
| fHeight = pInfo->m_Size[FWL_GRIDSIZE_MinHeight].fLength; |
| } |
| if (pInfo->m_Size[FWL_GRIDSIZE_MaxHeight].eUnit == FWL_GRIDUNIT_Fixed && |
| fHeight > pInfo->m_Size[FWL_GRIDSIZE_MaxHeight].fLength) { |
| fHeight = pInfo->m_Size[FWL_GRIDSIZE_MaxHeight].fLength; |
| } |
| pInfo->m_fActualHeight = fHeight; |
| 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(); |
| } |
| } |
| FX_BOOL CFWL_GridImp::IsGrid(IFWL_Widget* pWidget) { |
| if (!pWidget) |
| return FALSE; |
| return pWidget->GetClassID() == FWL_CLASSHASH_Grid; |
| } |
| void CFWL_GridImp::SetSpanAutoColRowSize(const CFX_PtrArray& spanAutos, |
| FX_FLOAT fTotalSize) { |
| int32_t iAutoColRows = spanAutos.GetSize(); |
| if (iAutoColRows < 1) { |
| return; |
| } |
| CFX_PtrArray autoNoMinMaxs; |
| FX_FLOAT fAutoPer = fTotalSize / iAutoColRows; |
| for (int32_t j = 0; j < iAutoColRows; j++) { |
| CFWL_GridColRow* pColumn = static_cast<CFWL_GridColRow*>(spanAutos[j]); |
| FX_FLOAT fOrgSize = pColumn->m_fActualSize; |
| if (SetColRowActualSize(pColumn, pColumn->m_fActualSize + fAutoPer, TRUE)) { |
| autoNoMinMaxs.Add(pColumn); |
| } else { |
| fTotalSize -= pColumn->m_fActualSize - fOrgSize; |
| int32_t iNoMinMax = iAutoColRows - (j + 1 - autoNoMinMaxs.GetSize()); |
| if (iNoMinMax > 0 && fTotalSize > 0) { |
| fAutoPer = fTotalSize / iNoMinMax; |
| } else { |
| break; |
| } |
| } |
| } |
| int32_t iNormals = autoNoMinMaxs.GetSize(); |
| if (fTotalSize > 0) { |
| if (iNormals == iAutoColRows) { |
| fAutoPer = fTotalSize / iNormals; |
| for (int32_t k = 0; k < iNormals; k++) { |
| CFWL_GridColRow* pColumn = |
| static_cast<CFWL_GridColRow*>(autoNoMinMaxs[k]); |
| pColumn->m_fActualSize += fAutoPer; |
| } |
| } else { |
| SetSpanAutoColRowSize(autoNoMinMaxs, fTotalSize); |
| } |
| } else { |
| } |
| } |
| void CFWL_GridImp::SetSpanScaledColRowSize(const CFX_PtrArray& spanScaleds, |
| FX_FLOAT fTotalSize, |
| FX_FLOAT fTotalScaledNum) { |
| int32_t iScaledColRows = spanScaleds.GetSize(); |
| if (iScaledColRows < 1) { |
| return; |
| } |
| CFX_PtrArray autoNoMinMaxs; |
| FX_FLOAT fPerSize = fTotalSize / fTotalScaledNum; |
| for (int32_t i = 0; i < iScaledColRows; i++) { |
| CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(spanScaleds[i]); |
| if (SetColRowActualSize(pColRow, pColRow->m_fActualSize + |
| fPerSize * pColRow->m_Size.fLength, |
| TRUE)) { |
| autoNoMinMaxs.Add(pColRow); |
| } else { |
| fTotalSize -= pColRow->m_fActualSize; |
| fTotalScaledNum -= pColRow->m_Size.fLength; |
| int32_t iNoMinMax = iScaledColRows - (i + 1 - autoNoMinMaxs.GetSize()); |
| if (iNoMinMax > 0 && fTotalSize > 0) { |
| fPerSize = fTotalSize / fTotalScaledNum; |
| } else { |
| break; |
| } |
| } |
| } |
| int32_t iNormals = autoNoMinMaxs.GetSize(); |
| if (fTotalSize > 0) { |
| if (iNormals == iScaledColRows) { |
| fPerSize = fTotalSize / fTotalScaledNum; |
| for (int32_t j = 0; j < iNormals; j++) { |
| CFWL_GridColRow* pColumn = |
| static_cast<CFWL_GridColRow*>(autoNoMinMaxs[j]); |
| pColumn->m_fActualSize += fPerSize * pColumn->m_Size.fLength; |
| } |
| } else { |
| SetSpanScaledColRowSize(autoNoMinMaxs, fTotalSize, fTotalScaledNum); |
| } |
| } else { |
| } |
| } |
| void CFWL_GridImp::SetScaledColRowsSize(const CFX_PtrArray& spanScaleds, |
| FX_FLOAT fTotalSize, |
| FX_FLOAT fTotalScaledNum) { |
| int32_t iScaledColRows = spanScaleds.GetSize(); |
| if (iScaledColRows < 1) { |
| return; |
| } |
| CFX_PtrArray autoNoMinMaxs; |
| FX_FLOAT fPerSize = fTotalSize / fTotalScaledNum; |
| for (int32_t i = 0; i < iScaledColRows; i++) { |
| CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(spanScaleds[i]); |
| if (!pColRow) { |
| continue; |
| } |
| FX_FLOAT fSize = fPerSize * pColRow->m_Size.fLength; |
| FX_FLOAT fOrgSize = pColRow->m_fActualSize; |
| if (SetColRowActualSize(pColRow, fSize, TRUE)) { |
| autoNoMinMaxs.Add(pColRow); |
| } else { |
| fTotalSize -= pColRow->m_fActualSize - fOrgSize; |
| fTotalScaledNum -= pColRow->m_Size.fLength; |
| int32_t iNoMinMax = iScaledColRows - (i + 1 - autoNoMinMaxs.GetSize()); |
| if (iNoMinMax > 0 && fTotalSize > 0) { |
| fPerSize = fTotalSize / fTotalScaledNum; |
| } else { |
| break; |
| } |
| } |
| } |
| int32_t iNormals = autoNoMinMaxs.GetSize(); |
| if (fTotalSize > 0) { |
| if (iNormals == iScaledColRows) { |
| fPerSize = fTotalSize / fTotalScaledNum; |
| for (int32_t i = 0; i < iNormals; i++) { |
| CFWL_GridColRow* pColRow = |
| static_cast<CFWL_GridColRow*>(autoNoMinMaxs[i]); |
| if (!pColRow) { |
| continue; |
| } |
| FX_FLOAT fSize = fPerSize * pColRow->m_Size.fLength; |
| pColRow->m_fActualSize = fSize; |
| } |
| } else { |
| SetScaledColRowsSize(autoNoMinMaxs, fTotalSize, fTotalScaledNum); |
| } |
| } else { |
| } |
| } |
| CFWL_GridImpDelegate::CFWL_GridImpDelegate(CFWL_GridImp* pOwner) |
| : m_pOwner(pOwner) {} |
| int32_t CFWL_GridImpDelegate::OnProcessMessage(CFWL_Message* pMessage) { |
| if (pMessage->GetClassID() != FWL_MSGHASH_Mouse) { |
| return 0; |
| } |
| CFWL_MsgMouse* pMsg = static_cast<CFWL_MsgMouse*>(pMessage); |
| if (pMsg->m_dwCmd != FWL_MSGMOUSECMD_LButtonDown) { |
| return 0; |
| } |
| return 1; |
| } |
| FWL_ERR CFWL_GridImpDelegate::OnDrawWidget(CFX_Graphics* pGraphics, |
| const CFX_Matrix* pMatrix) { |
| return m_pOwner->DrawWidget(pGraphics, pMatrix); |
| } |
