| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 PDFium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | |
| 6 | |
| 7 #include "xfa/fwl/core/fwl_gridimp.h" | |
| 8 | |
| 9 #include "xfa/fwl/core/cfwl_message.h" | |
| 10 #include "xfa/fwl/core/cfwl_widgetimpproperties.h" | |
| 11 #include "xfa/fwl/core/fwl_contentimp.h" | |
| 12 #include "xfa/fwl/core/fwl_noteimp.h" | |
| 13 #include "xfa/fwl/core/fwl_targetimp.h" | |
| 14 #include "xfa/fwl/core/fwl_threadimp.h" | |
| 15 #include "xfa/fwl/core/fwl_widgetimp.h" | |
| 16 #include "xfa/fxgraphics/cfx_color.h" | |
| 17 #include "xfa/fxgraphics/cfx_path.h" | |
| 18 | |
| 19 // static | |
| 20 IFWL_Grid* IFWL_Grid::Create(const CFWL_WidgetImpProperties& properties) { | |
| 21 IFWL_Grid* pGrid = new IFWL_Grid; | |
| 22 CFWL_GridImp* pGridImpl = new CFWL_GridImp(properties, nullptr); | |
| 23 pGrid->SetImpl(pGridImpl); | |
| 24 pGridImpl->SetInterface(pGrid); | |
| 25 return pGrid; | |
| 26 } | |
| 27 IFWL_Grid::IFWL_Grid() {} | |
| 28 FWL_HGRIDCOLROW IFWL_Grid::InsertColRow(FX_BOOL bColumn, int32_t nIndex) { | |
| 29 return static_cast<CFWL_GridImp*>(GetImpl())->InsertColRow(bColumn, nIndex); | |
| 30 } | |
| 31 int32_t IFWL_Grid::CountColRows(FX_BOOL bColumn) { | |
| 32 return static_cast<CFWL_GridImp*>(GetImpl())->CountColRows(bColumn); | |
| 33 } | |
| 34 FWL_HGRIDCOLROW IFWL_Grid::GetColRow(FX_BOOL bColumn, int32_t nIndex) { | |
| 35 return static_cast<CFWL_GridImp*>(GetImpl())->GetColRow(bColumn, nIndex); | |
| 36 } | |
| 37 int32_t IFWL_Grid::GetIndex(FWL_HGRIDCOLROW hColRow) { | |
| 38 return static_cast<CFWL_GridImp*>(GetImpl())->GetIndex(hColRow); | |
| 39 } | |
| 40 FX_FLOAT IFWL_Grid::GetSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { | |
| 41 return static_cast<CFWL_GridImp*>(GetImpl())->GetSize(hColRow, eUnit); | |
| 42 } | |
| 43 FWL_ERR IFWL_Grid::SetSize(FWL_HGRIDCOLROW hColRow, | |
| 44 FX_FLOAT fSize, | |
| 45 FWL_GRIDUNIT eUnit) { | |
| 46 return static_cast<CFWL_GridImp*>(GetImpl())->SetSize(hColRow, fSize, eUnit); | |
| 47 } | |
| 48 FX_FLOAT IFWL_Grid::GetMinSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { | |
| 49 return static_cast<CFWL_GridImp*>(GetImpl())->GetMinSize(hColRow, eUnit); | |
| 50 } | |
| 51 FWL_ERR IFWL_Grid::SetMinSize(FWL_HGRIDCOLROW hColRow, | |
| 52 FX_FLOAT fSize, | |
| 53 FWL_GRIDUNIT eUnit) { | |
| 54 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 55 ->SetMinSize(hColRow, fSize, eUnit); | |
| 56 } | |
| 57 FX_FLOAT IFWL_Grid::GetMaxSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { | |
| 58 return static_cast<CFWL_GridImp*>(GetImpl())->GetMaxSize(hColRow, eUnit); | |
| 59 } | |
| 60 FWL_ERR IFWL_Grid::SetMaxSize(FWL_HGRIDCOLROW hColRow, | |
| 61 FX_FLOAT fSize, | |
| 62 FWL_GRIDUNIT eUnit) { | |
| 63 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 64 ->SetMaxSize(hColRow, fSize, eUnit); | |
| 65 } | |
| 66 FX_BOOL IFWL_Grid::DeleteColRow(FWL_HGRIDCOLROW hColRow) { | |
| 67 return static_cast<CFWL_GridImp*>(GetImpl())->DeleteColRow(hColRow); | |
| 68 } | |
| 69 FX_BOOL IFWL_Grid::IsColumn(FWL_HGRIDCOLROW hColRow) { | |
| 70 return static_cast<CFWL_GridImp*>(GetImpl())->IsColumn(hColRow); | |
| 71 } | |
| 72 int32_t IFWL_Grid::GetWidgetPos(IFWL_Widget* pWidget, FX_BOOL bColumn) { | |
| 73 return static_cast<CFWL_GridImp*>(GetImpl())->GetWidgetPos(pWidget, bColumn); | |
| 74 } | |
| 75 FWL_ERR IFWL_Grid::SetWidgetPos(IFWL_Widget* pWidget, | |
| 76 int32_t iPos, | |
| 77 FX_BOOL bColumn) { | |
| 78 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 79 ->SetWidgetPos(pWidget, iPos, bColumn); | |
| 80 } | |
| 81 int32_t IFWL_Grid::GetWidgetSpan(IFWL_Widget* pWidget, FX_BOOL bColumn) { | |
| 82 return static_cast<CFWL_GridImp*>(GetImpl())->GetWidgetSpan(pWidget, bColumn); | |
| 83 } | |
| 84 FWL_ERR IFWL_Grid::SetWidgetSpan(IFWL_Widget* pWidget, | |
| 85 int32_t iSpan, | |
| 86 FX_BOOL bColumn) { | |
| 87 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 88 ->SetWidgetSpan(pWidget, iSpan, bColumn); | |
| 89 } | |
| 90 FX_FLOAT IFWL_Grid::GetWidgetSize(IFWL_Widget* pWidget, | |
| 91 FWL_GRIDSIZE eSize, | |
| 92 FWL_GRIDUNIT& eUnit) { | |
| 93 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 94 ->GetWidgetSize(pWidget, eSize, eUnit); | |
| 95 } | |
| 96 FWL_ERR IFWL_Grid::SetWidgetSize(IFWL_Widget* pWidget, | |
| 97 FWL_GRIDSIZE eSize, | |
| 98 FX_FLOAT fSize, | |
| 99 FWL_GRIDUNIT eUit) { | |
| 100 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 101 ->SetWidgetSize(pWidget, eSize, fSize, eUit); | |
| 102 } | |
| 103 FX_BOOL IFWL_Grid::GetWidgetMargin(IFWL_Widget* pWidget, | |
| 104 FWL_GRIDMARGIN eMargin, | |
| 105 FX_FLOAT& fMargin) { | |
| 106 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 107 ->GetWidgetMargin(pWidget, eMargin, fMargin); | |
| 108 } | |
| 109 FWL_ERR IFWL_Grid::SetWidgetMargin(IFWL_Widget* pWidget, | |
| 110 FWL_GRIDMARGIN eMargin, | |
| 111 FX_FLOAT fMargin) { | |
| 112 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 113 ->SetWidgetMargin(pWidget, eMargin, fMargin); | |
| 114 } | |
| 115 FWL_ERR IFWL_Grid::RemoveWidgetMargin(IFWL_Widget* pWidget, | |
| 116 FWL_GRIDMARGIN eMargin) { | |
| 117 return static_cast<CFWL_GridImp*>(GetImpl()) | |
| 118 ->RemoveWidgetMargin(pWidget, eMargin); | |
| 119 } | |
| 120 FX_FLOAT IFWL_Grid::GetGridSize(FWL_GRIDSIZE eSize, FWL_GRIDUNIT& eUnit) { | |
| 121 return static_cast<CFWL_GridImp*>(GetImpl())->GetGridSize(eSize, eUnit); | |
| 122 } | |
| 123 FWL_ERR IFWL_Grid::SetGridSize(FWL_GRIDSIZE eSize, | |
| 124 FX_FLOAT fSize, | |
| 125 FWL_GRIDUNIT eUit) { | |
| 126 return static_cast<CFWL_GridImp*>(GetImpl())->SetGridSize(eSize, fSize, eUit); | |
| 127 } | |
| 128 | |
| 129 CFWL_GridImp::CFWL_GridImp(const CFWL_WidgetImpProperties& properties, | |
| 130 IFWL_Widget* pOuter) | |
| 131 : CFWL_ContentImp(properties, pOuter) { | |
| 132 m_Size[FWL_GRIDSIZE_Width].eUnit = FWL_GRIDUNIT_Auto; | |
| 133 m_Size[FWL_GRIDSIZE_Width].fLength = 0; | |
| 134 m_Size[FWL_GRIDSIZE_Height].eUnit = FWL_GRIDUNIT_Auto; | |
| 135 m_Size[FWL_GRIDSIZE_Height].fLength = 0; | |
| 136 m_Size[FWL_GRIDSIZE_MinWidth].eUnit = FWL_GRIDUNIT_Fixed; | |
| 137 m_Size[FWL_GRIDSIZE_MinWidth].fLength = 0; | |
| 138 m_Size[FWL_GRIDSIZE_MaxWidth].eUnit = FWL_GRIDUNIT_Infinity; | |
| 139 m_Size[FWL_GRIDSIZE_MaxWidth].fLength = 0; | |
| 140 m_Size[FWL_GRIDSIZE_MinHeight].eUnit = FWL_GRIDUNIT_Fixed; | |
| 141 m_Size[FWL_GRIDSIZE_MinHeight].fLength = 0; | |
| 142 m_Size[FWL_GRIDSIZE_MaxHeight].eUnit = FWL_GRIDUNIT_Infinity; | |
| 143 m_Size[FWL_GRIDSIZE_MaxHeight].fLength = 0; | |
| 144 } | |
| 145 CFWL_GridImp::~CFWL_GridImp() { | |
| 146 int32_t iCount = m_Columns.GetSize(); | |
| 147 for (int32_t i = 0; i < iCount; i++) { | |
| 148 delete static_cast<CFWL_GridColRow*>(m_Columns[i]); | |
| 149 } | |
| 150 m_Columns.RemoveAll(); | |
| 151 iCount = m_Rows.GetSize(); | |
| 152 for (int32_t j = 0; j < iCount; j++) { | |
| 153 delete static_cast<CFWL_GridColRow*>(m_Rows[j]); | |
| 154 } | |
| 155 m_Rows.RemoveAll(); | |
| 156 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 157 while (ps) { | |
| 158 IFWL_Widget* pWidget; | |
| 159 CFWL_GridWidgetInfo* pInfo; | |
| 160 m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo); | |
| 161 delete pInfo; | |
| 162 } | |
| 163 m_mapWidgetInfo.RemoveAll(); | |
| 164 delete m_pDelegate; | |
| 165 m_pDelegate = nullptr; | |
| 166 } | |
| 167 FWL_ERR CFWL_GridImp::GetClassName(CFX_WideString& wsClass) const { | |
| 168 wsClass = FWL_CLASS_Grid; | |
| 169 return FWL_ERR_Succeeded; | |
| 170 } | |
| 171 uint32_t CFWL_GridImp::GetClassID() const { | |
| 172 return FWL_CLASSHASH_Grid; | |
| 173 } | |
| 174 FWL_ERR CFWL_GridImp::Initialize() { | |
| 175 if (CFWL_ContentImp::Initialize() != FWL_ERR_Succeeded) | |
| 176 return FWL_ERR_Indefinite; | |
| 177 m_pDelegate = new CFWL_GridImpDelegate(this); | |
| 178 return FWL_ERR_Succeeded; | |
| 179 } | |
| 180 FWL_ERR CFWL_GridImp::Finalize() { | |
| 181 if (CFWL_ContentImp::Finalize() != FWL_ERR_Succeeded) | |
| 182 return FWL_ERR_Indefinite; | |
| 183 delete m_pDelegate; | |
| 184 m_pDelegate = nullptr; | |
| 185 return FWL_ERR_Succeeded; | |
| 186 } | |
| 187 FWL_ERR CFWL_GridImp::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) { | |
| 188 if (bAutoSize) { | |
| 189 rect.left = 0; | |
| 190 rect.top = 0; | |
| 191 rect.width = ProcessUnCertainColumns(); | |
| 192 rect.height = ProcessUnCertainRows(); | |
| 193 } else { | |
| 194 rect = m_pProperties->m_rtWidget; | |
| 195 } | |
| 196 return FWL_ERR_Succeeded; | |
| 197 } | |
| 198 FWL_ERR CFWL_GridImp::SetWidgetRect(const CFX_RectF& rect) { | |
| 199 CFWL_WidgetImp::SetWidgetRect(rect); | |
| 200 return FWL_ERR_Succeeded; | |
| 201 } | |
| 202 FWL_ERR CFWL_GridImp::Update() { | |
| 203 if (IsLocked()) { | |
| 204 return FWL_ERR_Indefinite; | |
| 205 } | |
| 206 ProcessColumns(m_pProperties->m_rtWidget.width); | |
| 207 ProcessRows(m_pProperties->m_rtWidget.height); | |
| 208 SetAllWidgetsRect(); | |
| 209 return FWL_ERR_Succeeded; | |
| 210 } | |
| 211 FWL_ERR CFWL_GridImp::DrawWidget(CFX_Graphics* pGraphics, | |
| 212 const CFX_Matrix* pMatrix) { | |
| 213 if (!pGraphics) | |
| 214 return FWL_ERR_Indefinite; | |
| 215 if ((m_pProperties->m_dwStyleExes & FWL_GRIDSTYLEEXT_ShowGridLines) == 0) { | |
| 216 return FWL_ERR_Succeeded; | |
| 217 } | |
| 218 pGraphics->SaveGraphState(); | |
| 219 if (pMatrix) { | |
| 220 pGraphics->ConcatMatrix(pMatrix); | |
| 221 } | |
| 222 { | |
| 223 FX_BOOL bDrawLine = FALSE; | |
| 224 CFX_Path path; | |
| 225 path.Create(); | |
| 226 int32_t iColumns = m_Columns.GetSize(); | |
| 227 for (int32_t i = 1; i < iColumns; i++) { | |
| 228 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Columns[i]); | |
| 229 if (!pColRow) { | |
| 230 continue; | |
| 231 } | |
| 232 bDrawLine = TRUE; | |
| 233 path.AddLine(pColRow->m_fActualPos, 0, pColRow->m_fActualPos, | |
| 234 m_pProperties->m_rtWidget.height); | |
| 235 } | |
| 236 int32_t iRows = m_Rows.GetSize(); | |
| 237 for (int32_t j = 1; j < iRows; j++) { | |
| 238 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[j]); | |
| 239 if (!pColRow) { | |
| 240 continue; | |
| 241 } | |
| 242 bDrawLine = TRUE; | |
| 243 path.AddLine(0, pColRow->m_fActualPos, m_pProperties->m_rtWidget.width, | |
| 244 pColRow->m_fActualPos); | |
| 245 } | |
| 246 if (bDrawLine) { | |
| 247 CFX_Color cr(0xFFFF0000); | |
| 248 pGraphics->SetStrokeColor(&cr); | |
| 249 pGraphics->StrokePath(&path); | |
| 250 } | |
| 251 } | |
| 252 pGraphics->RestoreGraphState(); | |
| 253 return FWL_ERR_Succeeded; | |
| 254 } | |
| 255 FWL_ERR CFWL_GridImp::InsertWidget(IFWL_Widget* pChild, int32_t nIndex) { | |
| 256 if (!pChild) | |
| 257 return FWL_ERR_Indefinite; | |
| 258 CFWL_ContentImp::InsertWidget(pChild, nIndex); | |
| 259 if (!m_mapWidgetInfo.GetValueAt(pChild)) { | |
| 260 CFWL_GridWidgetInfo* pInfo = new CFWL_GridWidgetInfo; | |
| 261 m_mapWidgetInfo.SetAt(pChild, pInfo); | |
| 262 m_Widgets.Add(pChild); | |
| 263 } | |
| 264 return FWL_ERR_Succeeded; | |
| 265 } | |
| 266 FWL_ERR CFWL_GridImp::RemoveWidget(IFWL_Widget* pWidget) { | |
| 267 if (!pWidget) | |
| 268 return FWL_ERR_Indefinite; | |
| 269 CFWL_ContentImp::RemoveWidget(pWidget); | |
| 270 if (CFWL_GridWidgetInfo* pInfo = static_cast<CFWL_GridWidgetInfo*>( | |
| 271 m_mapWidgetInfo.GetValueAt(pWidget))) { | |
| 272 m_mapWidgetInfo.RemoveKey(pWidget); | |
| 273 delete pInfo; | |
| 274 int32_t nIndex = m_Widgets.Find(pWidget); | |
| 275 m_Widgets.RemoveAt(nIndex, 1); | |
| 276 } | |
| 277 return FWL_ERR_Succeeded; | |
| 278 } | |
| 279 FWL_HGRIDCOLROW CFWL_GridImp::InsertColRow(FX_BOOL bColumn, int32_t nIndex) { | |
| 280 if (bColumn) { | |
| 281 if (nIndex < 0 || nIndex > m_Columns.GetSize()) { | |
| 282 nIndex = m_Columns.GetSize(); | |
| 283 } | |
| 284 CFWL_GridColRow* pColumn = new CFWL_GridColRow; | |
| 285 m_Columns.InsertAt(nIndex, pColumn, 1); | |
| 286 return (FWL_HGRIDCOLROW)pColumn; | |
| 287 } | |
| 288 if (nIndex < 0 || nIndex > m_Rows.GetSize()) { | |
| 289 nIndex = m_Rows.GetSize(); | |
| 290 } | |
| 291 CFWL_GridColRow* pRow = new CFWL_GridColRow; | |
| 292 m_Rows.InsertAt(nIndex, pRow, 1); | |
| 293 return (FWL_HGRIDCOLROW)pRow; | |
| 294 } | |
| 295 int32_t CFWL_GridImp::CountColRows(FX_BOOL bColumn) { | |
| 296 if (bColumn) { | |
| 297 return m_Columns.GetSize(); | |
| 298 } | |
| 299 return m_Rows.GetSize(); | |
| 300 } | |
| 301 FWL_HGRIDCOLROW CFWL_GridImp::GetColRow(FX_BOOL bColumn, int32_t nIndex) { | |
| 302 if (bColumn) { | |
| 303 if (nIndex < 0 || nIndex >= m_Columns.GetSize()) { | |
| 304 return NULL; | |
| 305 } | |
| 306 return (FWL_HGRIDCOLROW)m_Columns[nIndex]; | |
| 307 } | |
| 308 if (nIndex < 0 || nIndex >= m_Rows.GetSize()) { | |
| 309 return NULL; | |
| 310 } | |
| 311 return (FWL_HGRIDCOLROW)m_Rows[nIndex]; | |
| 312 } | |
| 313 int32_t CFWL_GridImp::GetIndex(FWL_HGRIDCOLROW hColRow) { | |
| 314 if (IsColumn(hColRow)) { | |
| 315 return m_Columns.Find(hColRow); | |
| 316 } | |
| 317 return m_Rows.Find(hColRow); | |
| 318 } | |
| 319 FX_FLOAT CFWL_GridImp::GetSize(FWL_HGRIDCOLROW hColRow, FWL_GRIDUNIT& eUnit) { | |
| 320 if (!hColRow) | |
| 321 return -1; | |
| 322 CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 323 eUnit = pColRow->m_Size.eUnit; | |
| 324 return pColRow->m_Size.fLength; | |
| 325 } | |
| 326 FWL_ERR CFWL_GridImp::SetSize(FWL_HGRIDCOLROW hColRow, | |
| 327 FX_FLOAT fSize, | |
| 328 FWL_GRIDUNIT eUnit) { | |
| 329 if (!hColRow) | |
| 330 return FWL_ERR_Indefinite; | |
| 331 CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 332 pColRow->m_Size.eUnit = eUnit; | |
| 333 pColRow->m_Size.fLength = fSize; | |
| 334 return FWL_ERR_Succeeded; | |
| 335 } | |
| 336 FX_FLOAT CFWL_GridImp::GetMinSize(FWL_HGRIDCOLROW hColRow, | |
| 337 FWL_GRIDUNIT& eUnit) { | |
| 338 if (!hColRow) | |
| 339 return -1; | |
| 340 CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 341 eUnit = pColRow->m_MinSize.eUnit; | |
| 342 return pColRow->m_MinSize.fLength; | |
| 343 } | |
| 344 FWL_ERR CFWL_GridImp::SetMinSize(FWL_HGRIDCOLROW hColRow, | |
| 345 FX_FLOAT fSize, | |
| 346 FWL_GRIDUNIT eUnit) { | |
| 347 if (!hColRow) | |
| 348 return FWL_ERR_Indefinite; | |
| 349 CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 350 pColRow->m_MinSize.eUnit = eUnit; | |
| 351 pColRow->m_MinSize.fLength = fSize; | |
| 352 return FWL_ERR_Succeeded; | |
| 353 } | |
| 354 FX_FLOAT CFWL_GridImp::GetMaxSize(FWL_HGRIDCOLROW hColRow, | |
| 355 FWL_GRIDUNIT& eUnit) { | |
| 356 if (!hColRow) | |
| 357 return -1; | |
| 358 CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 359 eUnit = pColRow->m_MaxSize.eUnit; | |
| 360 return pColRow->m_MaxSize.fLength; | |
| 361 } | |
| 362 FWL_ERR CFWL_GridImp::SetMaxSize(FWL_HGRIDCOLROW hColRow, | |
| 363 FX_FLOAT fSize, | |
| 364 FWL_GRIDUNIT eUnit) { | |
| 365 if (!hColRow) | |
| 366 return FWL_ERR_Indefinite; | |
| 367 CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 368 pColRow->m_MaxSize.eUnit = eUnit; | |
| 369 pColRow->m_MaxSize.fLength = fSize; | |
| 370 return FWL_ERR_Succeeded; | |
| 371 } | |
| 372 FX_BOOL CFWL_GridImp::DeleteColRow(FWL_HGRIDCOLROW hColRow) { | |
| 373 int32_t nIndex = m_Columns.Find(hColRow); | |
| 374 if (nIndex >= 0) { | |
| 375 m_Columns.RemoveAt(nIndex); | |
| 376 delete reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 377 return TRUE; | |
| 378 } | |
| 379 nIndex = m_Rows.Find(hColRow); | |
| 380 if (nIndex >= 0) { | |
| 381 delete reinterpret_cast<CFWL_GridColRow*>(hColRow); | |
| 382 m_Rows.RemoveAt(nIndex); | |
| 383 return TRUE; | |
| 384 } | |
| 385 return FALSE; | |
| 386 } | |
| 387 FX_BOOL CFWL_GridImp::IsColumn(FWL_HGRIDCOLROW hColRow) { | |
| 388 return m_Columns.Find(hColRow) != -1; | |
| 389 } | |
| 390 int32_t CFWL_GridImp::GetWidgetPos(IFWL_Widget* pWidget, FX_BOOL bColumn) { | |
| 391 CFWL_GridWidgetInfo* pInfo = | |
| 392 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 393 if (pInfo) { | |
| 394 return bColumn ? pInfo->m_iColumn : pInfo->m_iRow; | |
| 395 } | |
| 396 return -1; | |
| 397 } | |
| 398 FWL_ERR CFWL_GridImp::SetWidgetPos(IFWL_Widget* pWidget, | |
| 399 int32_t iPos, | |
| 400 FX_BOOL bColumn) { | |
| 401 CFWL_GridWidgetInfo* pInfo = | |
| 402 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 403 if (pInfo) { | |
| 404 bColumn ? pInfo->m_iColumn = iPos : pInfo->m_iRow = iPos; | |
| 405 } | |
| 406 return FWL_ERR_Succeeded; | |
| 407 } | |
| 408 int32_t CFWL_GridImp::GetWidgetSpan(IFWL_Widget* pWidget, FX_BOOL bColumn) { | |
| 409 CFWL_GridWidgetInfo* pInfo = | |
| 410 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 411 if (pInfo) { | |
| 412 return bColumn ? pInfo->m_iColumnSpan : pInfo->m_iRowSpan; | |
| 413 } | |
| 414 return 0; | |
| 415 } | |
| 416 FWL_ERR CFWL_GridImp::SetWidgetSpan(IFWL_Widget* pWidget, | |
| 417 int32_t iSpan, | |
| 418 FX_BOOL bColumn) { | |
| 419 CFWL_GridWidgetInfo* pInfo = | |
| 420 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 421 if (pInfo) { | |
| 422 bColumn ? pInfo->m_iColumnSpan = iSpan : pInfo->m_iRowSpan = iSpan; | |
| 423 } | |
| 424 return FWL_ERR_Succeeded; | |
| 425 } | |
| 426 FX_FLOAT CFWL_GridImp::GetWidgetSize(IFWL_Widget* pWidget, | |
| 427 FWL_GRIDSIZE eSize, | |
| 428 FWL_GRIDUNIT& eUnit) { | |
| 429 CFWL_GridWidgetInfo* pInfo = | |
| 430 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 431 if (pInfo) { | |
| 432 eUnit = pInfo->m_Size[eSize].eUnit; | |
| 433 return pInfo->m_Size[eSize].fLength; | |
| 434 } | |
| 435 return 0; | |
| 436 } | |
| 437 FWL_ERR CFWL_GridImp::SetWidgetSize(IFWL_Widget* pWidget, | |
| 438 FWL_GRIDSIZE eSize, | |
| 439 FX_FLOAT fSize, | |
| 440 FWL_GRIDUNIT eUit) { | |
| 441 CFWL_GridWidgetInfo* pInfo = | |
| 442 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 443 if (pInfo) { | |
| 444 pInfo->m_Size[eSize].fLength = fSize; | |
| 445 pInfo->m_Size[eSize].eUnit = eUit; | |
| 446 } | |
| 447 return FWL_ERR_Succeeded; | |
| 448 } | |
| 449 FX_BOOL CFWL_GridImp::GetWidgetMargin(IFWL_Widget* pWidget, | |
| 450 FWL_GRIDMARGIN eMargin, | |
| 451 FX_FLOAT& fMargin) { | |
| 452 CFWL_GridWidgetInfo* pInfo = | |
| 453 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 454 if (pInfo) { | |
| 455 fMargin = pInfo->m_Margin[eMargin]; | |
| 456 return (pInfo->m_dwMarginFlag & (1 << eMargin)) != 0; | |
| 457 } | |
| 458 return FALSE; | |
| 459 } | |
| 460 FWL_ERR CFWL_GridImp::SetWidgetMargin(IFWL_Widget* pWidget, | |
| 461 FWL_GRIDMARGIN eMargin, | |
| 462 FX_FLOAT fMargin) { | |
| 463 CFWL_GridWidgetInfo* pInfo = | |
| 464 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 465 if (pInfo) { | |
| 466 pInfo->m_Margin[eMargin] = fMargin; | |
| 467 pInfo->m_dwMarginFlag |= (1 << eMargin); | |
| 468 } | |
| 469 return FWL_ERR_Succeeded; | |
| 470 } | |
| 471 FWL_ERR CFWL_GridImp::RemoveWidgetMargin(IFWL_Widget* pWidget, | |
| 472 FWL_GRIDMARGIN eMargin) { | |
| 473 CFWL_GridWidgetInfo* pInfo = | |
| 474 static_cast<CFWL_GridWidgetInfo*>(GetWidgetInfo(pWidget)); | |
| 475 if (pInfo) { | |
| 476 pInfo->m_dwMarginFlag &= ~(1 << eMargin); | |
| 477 } | |
| 478 return FWL_ERR_Succeeded; | |
| 479 } | |
| 480 FX_FLOAT CFWL_GridImp::GetGridSize(FWL_GRIDSIZE eSize, FWL_GRIDUNIT& eUnit) { | |
| 481 eUnit = m_Size[eSize].eUnit; | |
| 482 return m_Size[eSize].fLength; | |
| 483 } | |
| 484 FWL_ERR CFWL_GridImp::SetGridSize(FWL_GRIDSIZE eSize, | |
| 485 FX_FLOAT fSize, | |
| 486 FWL_GRIDUNIT eUit) { | |
| 487 m_Size[eSize].fLength = fSize; | |
| 488 m_Size[eSize].eUnit = eUit; | |
| 489 return FWL_ERR_Succeeded; | |
| 490 } | |
| 491 CFWL_GridWidgetInfo* CFWL_GridImp::GetWidgetInfo(IFWL_Widget* pWidget) { | |
| 492 return static_cast<CFWL_GridWidgetInfo*>(m_mapWidgetInfo.GetValueAt(pWidget)); | |
| 493 } | |
| 494 void CFWL_GridImp::ProcFixedColRow(CFWL_GridColRow* pColRow, | |
| 495 int32_t nIndex, | |
| 496 FX_FLOAT fColRowSize, | |
| 497 FX_BOOL bColumn) { | |
| 498 pColRow->m_fActualSize = fColRowSize; | |
| 499 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 500 while (ps) { | |
| 501 void* key = nullptr; | |
| 502 void* value = nullptr; | |
| 503 m_mapWidgetInfo.GetNextAssoc(ps, key, value); | |
| 504 IFWL_Widget* pWidget = static_cast<IFWL_Widget*>(key); | |
| 505 CFWL_GridWidgetInfo* pInfo = static_cast<CFWL_GridWidgetInfo*>(value); | |
| 506 if (bColumn) { | |
| 507 if (pInfo->m_iColumn == nIndex && pInfo->m_iColumnSpan == 1) { | |
| 508 CalcWidgetWidth(pWidget, pInfo, pColRow->m_fActualSize); | |
| 509 } | |
| 510 } else { | |
| 511 if (pInfo->m_iRow == nIndex && pInfo->m_iRowSpan == 1) { | |
| 512 CalcWidgetHeigt(pWidget, pInfo, pColRow->m_fActualSize); | |
| 513 } | |
| 514 } | |
| 515 } | |
| 516 } | |
| 517 void CFWL_GridImp::ProcAutoColRow(CFWL_GridColRow* pColRow, | |
| 518 int32_t nIndex, | |
| 519 FX_BOOL bColumn) { | |
| 520 if (!pColRow) | |
| 521 return; | |
| 522 FX_FLOAT fMaxSize = 0, fWidgetSize = 0; | |
| 523 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 524 while (ps) { | |
| 525 IFWL_Widget* pWidget = NULL; | |
| 526 CFWL_GridWidgetInfo* pInfo = NULL; | |
| 527 m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo); | |
| 528 if (!pWidget || !pInfo) { | |
| 529 continue; | |
| 530 } | |
| 531 if (bColumn) { | |
| 532 if (pInfo->m_iColumn != nIndex || pInfo->m_iColumnSpan != 1) { | |
| 533 continue; | |
| 534 } | |
| 535 fWidgetSize = CalcAutoColumnWidgetWidth(pWidget, pInfo); | |
| 536 if (fMaxSize < fWidgetSize) { | |
| 537 fMaxSize = fWidgetSize; | |
| 538 } | |
| 539 } else { | |
| 540 if (pInfo->m_iRow != nIndex || pInfo->m_iRowSpan != 1) { | |
| 541 continue; | |
| 542 } | |
| 543 fWidgetSize = CalcAutoColumnWidgetHeight(pWidget, pInfo); | |
| 544 if (fMaxSize < fWidgetSize) { | |
| 545 fMaxSize = fWidgetSize; | |
| 546 } | |
| 547 } | |
| 548 } | |
| 549 SetColRowActualSize(pColRow, fMaxSize); | |
| 550 } | |
| 551 void CFWL_GridImp::ProcScaledColRow(CFWL_GridColRow* pColRow, | |
| 552 int32_t nIndex, | |
| 553 FX_FLOAT fColRowSize, | |
| 554 FX_BOOL bColumn) { | |
| 555 if (fColRowSize > 0) { | |
| 556 ProcFixedColRow(pColRow, nIndex, fColRowSize, bColumn); | |
| 557 } | |
| 558 } | |
| 559 void CFWL_GridImp::CalcWidgetWidth(IFWL_Widget* pWidget, | |
| 560 CFWL_GridWidgetInfo* pInfo, | |
| 561 FX_FLOAT fColunmWidth) { | |
| 562 if (pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 563 SetWidgetActualWidth(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Width].fLength); | |
| 564 } else { | |
| 565 FX_FLOAT fWidth = 0; | |
| 566 FX_FLOAT fLeftMargin = 0, fRightMargin = 0; | |
| 567 FX_BOOL bLeftMargin = | |
| 568 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Left, fLeftMargin); | |
| 569 FX_BOOL bRightMargin = | |
| 570 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Right, fRightMargin); | |
| 571 if (bLeftMargin && bRightMargin) { | |
| 572 fWidth = fColunmWidth - fLeftMargin - fRightMargin; | |
| 573 } else { | |
| 574 CFX_RectF rtAuto; | |
| 575 pWidget->GetWidgetRect(rtAuto, TRUE); | |
| 576 fWidth = rtAuto.Width(); | |
| 577 } | |
| 578 SetWidgetActualWidth(pInfo, fWidth); | |
| 579 } | |
| 580 } | |
| 581 void CFWL_GridImp::CalcWidgetHeigt(IFWL_Widget* pWidget, | |
| 582 CFWL_GridWidgetInfo* pInfo, | |
| 583 FX_FLOAT fRowHeigt) { | |
| 584 if (pInfo->m_Size[FWL_GRIDSIZE_Height].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 585 SetWidgetActualHeight(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Height].fLength); | |
| 586 } else { | |
| 587 FX_FLOAT fHeight = 0; | |
| 588 FX_FLOAT fTopMargin = 0, fBottomMargin = 0; | |
| 589 FX_BOOL bTopMargin = | |
| 590 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Top, fTopMargin); | |
| 591 FX_BOOL bBottomMargin = | |
| 592 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Bottom, fBottomMargin); | |
| 593 if (bTopMargin && bBottomMargin) { | |
| 594 fHeight = fRowHeigt - fTopMargin - fBottomMargin; | |
| 595 } else { | |
| 596 CFX_RectF rtAuto; | |
| 597 pWidget->GetWidgetRect(rtAuto, TRUE); | |
| 598 fHeight = rtAuto.Height(); | |
| 599 } | |
| 600 SetWidgetActualHeight(pInfo, fHeight); | |
| 601 } | |
| 602 } | |
| 603 FX_FLOAT CFWL_GridImp::CalcAutoColumnWidgetWidth(IFWL_Widget* pWidget, | |
| 604 CFWL_GridWidgetInfo* pInfo) { | |
| 605 FX_FLOAT fLeftMargin = 0, fRightMargin = 0; | |
| 606 FX_BOOL bLeftMargin = | |
| 607 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Left, fLeftMargin); | |
| 608 FX_BOOL bRightMargin = | |
| 609 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Right, fRightMargin); | |
| 610 if (pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 611 SetWidgetActualWidth(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Width].fLength); | |
| 612 } else { | |
| 613 CFX_RectF rtAuto; | |
| 614 pWidget->GetWidgetRect(rtAuto, TRUE); | |
| 615 FX_FLOAT fWidth = rtAuto.width; | |
| 616 SetWidgetActualWidth(pInfo, fWidth); | |
| 617 } | |
| 618 FX_FLOAT fTotal = pInfo->m_fActualWidth; | |
| 619 if (bLeftMargin) { | |
| 620 fTotal += fLeftMargin; | |
| 621 } | |
| 622 if (bRightMargin) { | |
| 623 fTotal += fRightMargin; | |
| 624 } | |
| 625 return fTotal; | |
| 626 } | |
| 627 FX_FLOAT CFWL_GridImp::CalcAutoColumnWidgetHeight(IFWL_Widget* pWidget, | |
| 628 CFWL_GridWidgetInfo* pInfo) { | |
| 629 FX_FLOAT fTopMargin = 0, fBottomMargin = 0; | |
| 630 FX_BOOL bTopMargin = GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Top, fTopMargin); | |
| 631 FX_BOOL bBottomMargin = | |
| 632 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Bottom, fBottomMargin); | |
| 633 if (pInfo->m_Size[FWL_GRIDSIZE_Height].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 634 SetWidgetActualHeight(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Height].fLength); | |
| 635 } else { | |
| 636 CFX_RectF rtAuto; | |
| 637 pWidget->GetWidgetRect(rtAuto, TRUE); | |
| 638 FX_FLOAT fHeight = rtAuto.height; | |
| 639 SetWidgetActualHeight(pInfo, fHeight); | |
| 640 } | |
| 641 FX_FLOAT fTotal = pInfo->m_fActualHeight; | |
| 642 if (bTopMargin) { | |
| 643 fTotal += fTopMargin; | |
| 644 } | |
| 645 if (bBottomMargin) { | |
| 646 fTotal += fBottomMargin; | |
| 647 } | |
| 648 return fTotal; | |
| 649 } | |
| 650 FX_FLOAT CFWL_GridImp::ProcessColumns(FX_FLOAT fWidth) { | |
| 651 if (fWidth <= 0) { | |
| 652 return ProcessUnCertainColumns(); | |
| 653 } | |
| 654 int32_t iColumns = m_Columns.GetSize(); | |
| 655 if (iColumns < 1) { | |
| 656 return fWidth; | |
| 657 } | |
| 658 FX_FLOAT fFixedWidth = 0; | |
| 659 FX_FLOAT fAutoWidth = 0; | |
| 660 CFX_PtrArray autoColumns; | |
| 661 CFX_PtrArray scaledColumns; | |
| 662 FX_FLOAT fScaledColumnNum = 0; | |
| 663 for (int32_t i = 0; i < iColumns; i++) { | |
| 664 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Columns[i]); | |
| 665 if (!pColRow) { | |
| 666 continue; | |
| 667 } | |
| 668 switch (pColRow->m_Size.eUnit) { | |
| 669 case FWL_GRIDUNIT_Fixed: { | |
| 670 SetColRowActualSize(pColRow, pColRow->m_Size.fLength); | |
| 671 fFixedWidth += pColRow->m_fActualSize; | |
| 672 break; | |
| 673 } | |
| 674 case FWL_GRIDUNIT_Auto: { | |
| 675 ProcAutoColRow(pColRow, i, TRUE); | |
| 676 autoColumns.Add(pColRow); | |
| 677 break; | |
| 678 } | |
| 679 case FWL_GRIDUNIT_Scaled: | |
| 680 default: { | |
| 681 fScaledColumnNum += pColRow->m_Size.fLength; | |
| 682 scaledColumns.Add(pColRow); | |
| 683 SetColRowActualSize(pColRow, 0); | |
| 684 } | |
| 685 } | |
| 686 } | |
| 687 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 688 while (ps) { | |
| 689 IFWL_Widget* pWidget = NULL; | |
| 690 CFWL_GridWidgetInfo* pInfo = NULL; | |
| 691 m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo); | |
| 692 if (!pInfo || pInfo->m_iColumnSpan < 2) { | |
| 693 continue; | |
| 694 } | |
| 695 CFX_PtrArray spanAutoColumns; | |
| 696 FX_FLOAT fSpanSize = 0; | |
| 697 int32_t iAutoColRows = 0; | |
| 698 int32_t iScaledColRows = 0; | |
| 699 for (int32_t i = 0; i < pInfo->m_iColumnSpan; i++) { | |
| 700 CFWL_GridColRow* pColumn = reinterpret_cast<CFWL_GridColRow*>( | |
| 701 GetColRow(TRUE, pInfo->m_iColumn + i)); | |
| 702 if (!pColumn) { | |
| 703 break; | |
| 704 } | |
| 705 fSpanSize += pColumn->m_fActualSize; | |
| 706 if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Auto) { | |
| 707 iAutoColRows++; | |
| 708 spanAutoColumns.Add(pColumn); | |
| 709 } else if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Scaled) { | |
| 710 iScaledColRows++; | |
| 711 } | |
| 712 } | |
| 713 if (iAutoColRows < 1) { | |
| 714 continue; | |
| 715 } | |
| 716 FX_FLOAT fWidgetWidth = CalcAutoColumnWidgetWidth(pWidget, pInfo); | |
| 717 if (fWidgetWidth > fSpanSize) { | |
| 718 if (iScaledColRows > 0) { | |
| 719 } else { | |
| 720 SetSpanAutoColRowSize(spanAutoColumns, fWidgetWidth - fSpanSize); | |
| 721 } | |
| 722 } | |
| 723 } | |
| 724 int32_t iAutoCols = autoColumns.GetSize(); | |
| 725 for (int32_t k = 0; k < iAutoCols; k++) { | |
| 726 fAutoWidth += static_cast<CFWL_GridColRow*>(autoColumns[k])->m_fActualSize; | |
| 727 } | |
| 728 FX_FLOAT fScaledWidth = fWidth - fFixedWidth - fAutoWidth; | |
| 729 if (fScaledWidth > 0 && fScaledColumnNum > 0) { | |
| 730 SetScaledColRowsSize(scaledColumns, fScaledWidth, fScaledColumnNum); | |
| 731 } | |
| 732 return fWidth; | |
| 733 } | |
| 734 FX_FLOAT CFWL_GridImp::ProcessRows(FX_FLOAT fHeight) { | |
| 735 if (fHeight <= 0) { | |
| 736 return ProcessUnCertainRows(); | |
| 737 } | |
| 738 int32_t iRows = m_Rows.GetSize(); | |
| 739 if (iRows < 1) { | |
| 740 return fHeight; | |
| 741 } | |
| 742 FX_FLOAT fFixedHeight = 0; | |
| 743 FX_FLOAT fAutoHeigt = 0; | |
| 744 CFX_PtrArray autoRows; | |
| 745 CFX_PtrArray scaledRows; | |
| 746 FX_FLOAT fScaledRowNum = 0; | |
| 747 for (int32_t i = 0; i < iRows; i++) { | |
| 748 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[i]); | |
| 749 if (!pColRow) { | |
| 750 continue; | |
| 751 } | |
| 752 switch (pColRow->m_Size.eUnit) { | |
| 753 case FWL_GRIDUNIT_Fixed: { | |
| 754 SetColRowActualSize(pColRow, pColRow->m_Size.fLength); | |
| 755 fFixedHeight += pColRow->m_fActualSize; | |
| 756 break; | |
| 757 } | |
| 758 case FWL_GRIDUNIT_Auto: { | |
| 759 ProcAutoColRow(pColRow, i, FALSE); | |
| 760 autoRows.Add(pColRow); | |
| 761 break; | |
| 762 } | |
| 763 case FWL_GRIDUNIT_Scaled: | |
| 764 default: { | |
| 765 fScaledRowNum += pColRow->m_Size.fLength; | |
| 766 scaledRows.Add(pColRow); | |
| 767 SetColRowActualSize(pColRow, 0); | |
| 768 break; | |
| 769 } | |
| 770 } | |
| 771 } | |
| 772 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 773 while (ps) { | |
| 774 IFWL_Widget* pWidget = NULL; | |
| 775 CFWL_GridWidgetInfo* pInfo = NULL; | |
| 776 m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo); | |
| 777 if (!pInfo || pInfo->m_iRowSpan < 2) { | |
| 778 continue; | |
| 779 } | |
| 780 CFX_PtrArray spanAutoRows; | |
| 781 FX_FLOAT fSpanSize = 0; | |
| 782 int32_t iAutoColRows = 0; | |
| 783 int32_t iScaledColRows = 0; | |
| 784 for (int32_t i = 0; i < pInfo->m_iRowSpan; i++) { | |
| 785 CFWL_GridColRow* pRow = reinterpret_cast<CFWL_GridColRow*>( | |
| 786 GetColRow(FALSE, pInfo->m_iRow + i)); | |
| 787 if (!pRow) { | |
| 788 break; | |
| 789 } | |
| 790 fSpanSize += pRow->m_fActualSize; | |
| 791 if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Auto) { | |
| 792 iAutoColRows++; | |
| 793 spanAutoRows.Add(pRow); | |
| 794 } else if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Scaled) { | |
| 795 iScaledColRows++; | |
| 796 } | |
| 797 } | |
| 798 if (iAutoColRows < 1) { | |
| 799 continue; | |
| 800 } | |
| 801 FX_FLOAT fWidgetHeight = CalcAutoColumnWidgetHeight(pWidget, pInfo); | |
| 802 if (fWidgetHeight > fSpanSize) { | |
| 803 if (iScaledColRows > 0) { | |
| 804 } else { | |
| 805 SetSpanAutoColRowSize(spanAutoRows, fWidgetHeight - fSpanSize); | |
| 806 } | |
| 807 } | |
| 808 } | |
| 809 int32_t iAutoRows = autoRows.GetSize(); | |
| 810 for (int32_t k = 0; k < iAutoRows; k++) { | |
| 811 fAutoHeigt += | |
| 812 reinterpret_cast<CFWL_GridColRow*>(autoRows[k])->m_fActualSize; | |
| 813 } | |
| 814 FX_FLOAT fScaledHeight = fHeight - fFixedHeight - fAutoHeigt; | |
| 815 if (fScaledHeight > 0 && fScaledRowNum > 0) { | |
| 816 SetScaledColRowsSize(scaledRows, fScaledHeight, fScaledRowNum); | |
| 817 } | |
| 818 return fHeight; | |
| 819 } | |
| 820 FX_FLOAT CFWL_GridImp::ProcessUnCertainColumns() { | |
| 821 int32_t iColumns = m_Columns.GetSize(); | |
| 822 if (iColumns < 1) { | |
| 823 CFWL_GridColRow* pColRow = new CFWL_GridColRow; | |
| 824 pColRow->m_Size.eUnit = FWL_GRIDUNIT_Auto; | |
| 825 ProcAutoColRow(pColRow, 0, TRUE); | |
| 826 FX_FLOAT fWidth = pColRow->m_fActualSize; | |
| 827 delete pColRow; | |
| 828 return fWidth; | |
| 829 } | |
| 830 FX_FLOAT fFixedWidth = 0; | |
| 831 CFX_PtrArray autoColumns; | |
| 832 CFX_PtrArray scaledColumns; | |
| 833 FX_FLOAT fScaledColumnNum = 0; | |
| 834 FX_FLOAT fScaledMaxPerWidth = 0; | |
| 835 for (int32_t i = 0; i < iColumns; i++) { | |
| 836 CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(m_Columns[i]); | |
| 837 if (!pColRow) { | |
| 838 continue; | |
| 839 } | |
| 840 switch (pColRow->m_Size.eUnit) { | |
| 841 case FWL_GRIDUNIT_Fixed: { | |
| 842 SetColRowActualSize(pColRow, pColRow->m_Size.fLength); | |
| 843 fFixedWidth += pColRow->m_fActualSize; | |
| 844 break; | |
| 845 } | |
| 846 case FWL_GRIDUNIT_Auto: { | |
| 847 ProcAutoColRow(pColRow, i, TRUE); | |
| 848 autoColumns.Add(pColRow); | |
| 849 break; | |
| 850 } | |
| 851 case FWL_GRIDUNIT_Scaled: | |
| 852 default: { | |
| 853 ProcAutoColRow(pColRow, i, TRUE); | |
| 854 fScaledColumnNum += pColRow->m_Size.fLength; | |
| 855 scaledColumns.Add(pColRow); | |
| 856 if (pColRow->m_Size.fLength <= 0) { | |
| 857 break; | |
| 858 } | |
| 859 FX_FLOAT fPerWidth = pColRow->m_fActualSize / pColRow->m_Size.fLength; | |
| 860 if (fPerWidth > fScaledMaxPerWidth) { | |
| 861 fScaledMaxPerWidth = fPerWidth; | |
| 862 } | |
| 863 } | |
| 864 } | |
| 865 } | |
| 866 iColumns = scaledColumns.GetSize(); | |
| 867 for (int32_t j = 0; j < iColumns; j++) { | |
| 868 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(scaledColumns[j]); | |
| 869 if (!pColRow) { | |
| 870 continue; | |
| 871 } | |
| 872 SetColRowActualSize(pColRow, fScaledMaxPerWidth * pColRow->m_Size.fLength); | |
| 873 } | |
| 874 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 875 while (ps) { | |
| 876 IFWL_Widget* pWidget = NULL; | |
| 877 CFWL_GridWidgetInfo* pInfo = NULL; | |
| 878 m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo); | |
| 879 if (!pInfo || pInfo->m_iColumnSpan < 2) { | |
| 880 continue; | |
| 881 } | |
| 882 CFX_PtrArray spanAutoColumns; | |
| 883 CFX_PtrArray spanScaledColumns; | |
| 884 FX_FLOAT fSpanSize = 0; | |
| 885 FX_FLOAT fScaledSum = 0; | |
| 886 int32_t iAutoColRows = 0; | |
| 887 int32_t iScaledColRows = 0; | |
| 888 for (int32_t i = 0; i < pInfo->m_iColumnSpan; i++) { | |
| 889 CFWL_GridColRow* pColumn = reinterpret_cast<CFWL_GridColRow*>( | |
| 890 GetColRow(TRUE, pInfo->m_iColumn + i)); | |
| 891 if (!pColumn) { | |
| 892 break; | |
| 893 } | |
| 894 fSpanSize += pColumn->m_fActualSize; | |
| 895 if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Auto) { | |
| 896 iAutoColRows++; | |
| 897 spanAutoColumns.Add(pColumn); | |
| 898 } else if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Scaled) { | |
| 899 iScaledColRows++; | |
| 900 fScaledSum += pColumn->m_Size.fLength; | |
| 901 spanScaledColumns.Add(pColumn); | |
| 902 } | |
| 903 } | |
| 904 if (iAutoColRows < 1 && iScaledColRows < 1) { | |
| 905 continue; | |
| 906 } | |
| 907 FX_FLOAT fWidgetWidth = CalcAutoColumnWidgetWidth(pWidget, pInfo); | |
| 908 if (fWidgetWidth > fSpanSize) { | |
| 909 if (iScaledColRows > 0) { | |
| 910 if (fScaledSum <= 0) { | |
| 911 continue; | |
| 912 } | |
| 913 SetSpanScaledColRowSize(spanScaledColumns, fWidgetWidth - fSpanSize, | |
| 914 fScaledSum); | |
| 915 } else { | |
| 916 SetSpanAutoColRowSize(spanAutoColumns, fWidgetWidth - fSpanSize); | |
| 917 } | |
| 918 } | |
| 919 } | |
| 920 FX_FLOAT fAutoWidth = 0; | |
| 921 int32_t iAutoCols = autoColumns.GetSize(); | |
| 922 for (int32_t m = 0; m < iAutoCols; m++) { | |
| 923 fAutoWidth += static_cast<CFWL_GridColRow*>(autoColumns[m])->m_fActualSize; | |
| 924 } | |
| 925 FX_FLOAT fScaledWidth = 0; | |
| 926 iColumns = scaledColumns.GetSize(); | |
| 927 for (int32_t n = 0; n < iColumns; n++) { | |
| 928 fScaledWidth += | |
| 929 static_cast<CFWL_GridColRow*>(scaledColumns[n])->m_fActualSize; | |
| 930 } | |
| 931 return fFixedWidth + fAutoWidth + fScaledWidth; | |
| 932 } | |
| 933 FX_FLOAT CFWL_GridImp::ProcessUnCertainRows() { | |
| 934 int32_t iRows = m_Rows.GetSize(); | |
| 935 if (iRows < 1) { | |
| 936 CFWL_GridColRow* pColRow = new CFWL_GridColRow; | |
| 937 pColRow->m_Size.eUnit = FWL_GRIDUNIT_Auto; | |
| 938 ProcAutoColRow(pColRow, 0, FALSE); | |
| 939 FX_FLOAT fWidth = pColRow->m_fActualSize; | |
| 940 delete pColRow; | |
| 941 return fWidth; | |
| 942 } | |
| 943 FX_FLOAT fFixedHeight = 0; | |
| 944 CFX_PtrArray autoRows; | |
| 945 CFX_PtrArray scaledRows; | |
| 946 FX_FLOAT fScaledRowNum = 0; | |
| 947 FX_FLOAT fScaledMaxPerHeight = 0; | |
| 948 for (int32_t i = 0; i < iRows; i++) { | |
| 949 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[i]); | |
| 950 if (!pColRow) { | |
| 951 continue; | |
| 952 } | |
| 953 switch (pColRow->m_Size.eUnit) { | |
| 954 case FWL_GRIDUNIT_Fixed: { | |
| 955 SetColRowActualSize(pColRow, pColRow->m_Size.fLength); | |
| 956 fFixedHeight += pColRow->m_fActualSize; | |
| 957 break; | |
| 958 } | |
| 959 case FWL_GRIDUNIT_Auto: { | |
| 960 ProcAutoColRow(pColRow, i, FALSE); | |
| 961 autoRows.Add(pColRow); | |
| 962 break; | |
| 963 } | |
| 964 case FWL_GRIDUNIT_Scaled: | |
| 965 default: { | |
| 966 ProcAutoColRow(pColRow, i, FALSE); | |
| 967 fScaledRowNum += pColRow->m_Size.fLength; | |
| 968 scaledRows.Add(pColRow); | |
| 969 if (pColRow->m_Size.fLength > 0) { | |
| 970 FX_FLOAT fPerHeight = | |
| 971 pColRow->m_fActualSize / pColRow->m_Size.fLength; | |
| 972 if (fPerHeight > fScaledMaxPerHeight) { | |
| 973 fScaledMaxPerHeight = fPerHeight; | |
| 974 } | |
| 975 } | |
| 976 break; | |
| 977 } | |
| 978 } | |
| 979 } | |
| 980 iRows = scaledRows.GetSize(); | |
| 981 for (int32_t j = 0; j < iRows; j++) { | |
| 982 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(scaledRows[j]); | |
| 983 if (!pColRow) { | |
| 984 continue; | |
| 985 } | |
| 986 SetColRowActualSize(pColRow, fScaledMaxPerHeight * pColRow->m_Size.fLength); | |
| 987 } | |
| 988 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 989 while (ps) { | |
| 990 void* key = nullptr; | |
| 991 void* value = nullptr; | |
| 992 m_mapWidgetInfo.GetNextAssoc(ps, key, value); | |
| 993 IFWL_Widget* pWidget = static_cast<IFWL_Widget*>(key); | |
| 994 CFWL_GridWidgetInfo* pInfo = static_cast<CFWL_GridWidgetInfo*>(value); | |
| 995 if (pInfo->m_iRowSpan < 2) { | |
| 996 continue; | |
| 997 } | |
| 998 CFX_PtrArray spanAutoRows; | |
| 999 CFX_PtrArray spanScaledRows; | |
| 1000 FX_FLOAT fSpanSize = 0; | |
| 1001 FX_FLOAT fScaledSum = 0; | |
| 1002 int32_t iAutoColRows = 0; | |
| 1003 int32_t iScaledColRows = 0; | |
| 1004 for (int32_t i = 0; i < pInfo->m_iRowSpan; i++) { | |
| 1005 CFWL_GridColRow* pRow = reinterpret_cast<CFWL_GridColRow*>( | |
| 1006 GetColRow(FALSE, pInfo->m_iRow + i)); | |
| 1007 if (!pRow) { | |
| 1008 break; | |
| 1009 } | |
| 1010 fSpanSize += pRow->m_fActualSize; | |
| 1011 if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Auto) { | |
| 1012 iAutoColRows++; | |
| 1013 spanAutoRows.Add(pRow); | |
| 1014 } else if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Scaled) { | |
| 1015 iScaledColRows++; | |
| 1016 fScaledSum += pRow->m_Size.fLength; | |
| 1017 spanScaledRows.Add(pRow); | |
| 1018 } | |
| 1019 } | |
| 1020 if (iAutoColRows < 1 && iScaledColRows < 1) { | |
| 1021 continue; | |
| 1022 } | |
| 1023 FX_FLOAT fWidgetHeight = CalcAutoColumnWidgetHeight(pWidget, pInfo); | |
| 1024 if (fWidgetHeight > fSpanSize) { | |
| 1025 if (iScaledColRows > 0) { | |
| 1026 if (fScaledSum <= 0) { | |
| 1027 continue; | |
| 1028 } | |
| 1029 SetSpanScaledColRowSize(spanScaledRows, fWidgetHeight - fSpanSize, | |
| 1030 fScaledSum); | |
| 1031 } else { | |
| 1032 SetSpanAutoColRowSize(spanAutoRows, fWidgetHeight - fSpanSize); | |
| 1033 } | |
| 1034 } | |
| 1035 } | |
| 1036 FX_FLOAT fAutoHeigt = 0; | |
| 1037 int32_t iAutoRows = autoRows.GetSize(); | |
| 1038 for (int32_t m = 0; m < iAutoRows; m++) { | |
| 1039 fAutoHeigt += static_cast<CFWL_GridColRow*>(autoRows[m])->m_fActualSize; | |
| 1040 } | |
| 1041 FX_FLOAT fScaledHeight = 0; | |
| 1042 iRows = scaledRows.GetSize(); | |
| 1043 for (int32_t n = 0; n < iRows; n++) { | |
| 1044 fScaledHeight += | |
| 1045 static_cast<CFWL_GridColRow*>(scaledRows[n])->m_fActualSize; | |
| 1046 } | |
| 1047 return fFixedHeight + fAutoHeigt + fScaledHeight; | |
| 1048 } | |
| 1049 FX_BOOL CFWL_GridImp::SetColRowActualSize(CFWL_GridColRow* pColRow, | |
| 1050 FX_FLOAT fSize, | |
| 1051 FX_BOOL bSetBeyond) { | |
| 1052 if (pColRow->m_MinSize.eUnit == FWL_GRIDUNIT_Fixed && | |
| 1053 fSize < pColRow->m_MinSize.fLength) { | |
| 1054 pColRow->m_fActualSize = pColRow->m_MinSize.fLength; | |
| 1055 return FALSE; | |
| 1056 } | |
| 1057 if (pColRow->m_MaxSize.eUnit == FWL_GRIDUNIT_Fixed && | |
| 1058 fSize > pColRow->m_MaxSize.fLength) { | |
| 1059 pColRow->m_fActualSize = pColRow->m_MaxSize.fLength; | |
| 1060 return FALSE; | |
| 1061 } | |
| 1062 if (bSetBeyond) { | |
| 1063 return TRUE; | |
| 1064 } | |
| 1065 pColRow->m_fActualSize = fSize; | |
| 1066 return TRUE; | |
| 1067 } | |
| 1068 FX_FLOAT CFWL_GridImp::SetWidgetActualWidth(CFWL_GridWidgetInfo* pInfo, | |
| 1069 FX_FLOAT fWidth) { | |
| 1070 if (pInfo->m_Size[FWL_GRIDSIZE_MinWidth].eUnit == FWL_GRIDUNIT_Fixed && | |
| 1071 fWidth < pInfo->m_Size[FWL_GRIDSIZE_MinWidth].fLength) { | |
| 1072 fWidth = pInfo->m_Size[FWL_GRIDSIZE_MinWidth].fLength; | |
| 1073 } | |
| 1074 if (pInfo->m_Size[FWL_GRIDSIZE_MaxWidth].eUnit == FWL_GRIDUNIT_Fixed && | |
| 1075 fWidth > pInfo->m_Size[FWL_GRIDSIZE_MaxWidth].fLength) { | |
| 1076 fWidth = pInfo->m_Size[FWL_GRIDSIZE_MaxWidth].fLength; | |
| 1077 } | |
| 1078 pInfo->m_fActualWidth = fWidth; | |
| 1079 return fWidth; | |
| 1080 } | |
| 1081 FX_FLOAT CFWL_GridImp::SetWidgetActualHeight(CFWL_GridWidgetInfo* pInfo, | |
| 1082 FX_FLOAT fHeight) { | |
| 1083 if (pInfo->m_Size[FWL_GRIDSIZE_MinHeight].eUnit == FWL_GRIDUNIT_Fixed && | |
| 1084 fHeight < pInfo->m_Size[FWL_GRIDSIZE_MinHeight].fLength) { | |
| 1085 fHeight = pInfo->m_Size[FWL_GRIDSIZE_MinHeight].fLength; | |
| 1086 } | |
| 1087 if (pInfo->m_Size[FWL_GRIDSIZE_MaxHeight].eUnit == FWL_GRIDUNIT_Fixed && | |
| 1088 fHeight > pInfo->m_Size[FWL_GRIDSIZE_MaxHeight].fLength) { | |
| 1089 fHeight = pInfo->m_Size[FWL_GRIDSIZE_MaxHeight].fLength; | |
| 1090 } | |
| 1091 pInfo->m_fActualHeight = fHeight; | |
| 1092 return fHeight; | |
| 1093 } | |
| 1094 void CFWL_GridImp::SetAllWidgetsRect() { | |
| 1095 FX_FLOAT fStartLeft = 0; | |
| 1096 int32_t iColumns = m_Columns.GetSize(); | |
| 1097 for (int32_t i = 0; i < iColumns; i++) { | |
| 1098 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Columns[i]); | |
| 1099 if (!pColRow) { | |
| 1100 continue; | |
| 1101 } | |
| 1102 pColRow->m_fActualPos = fStartLeft; | |
| 1103 fStartLeft += pColRow->m_fActualSize; | |
| 1104 } | |
| 1105 FX_FLOAT fStartTop = 0; | |
| 1106 int32_t iRows = m_Rows.GetSize(); | |
| 1107 for (int32_t j = 0; j < iRows; j++) { | |
| 1108 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[j]); | |
| 1109 if (!pColRow) { | |
| 1110 continue; | |
| 1111 } | |
| 1112 pColRow->m_fActualPos = fStartTop; | |
| 1113 fStartTop += pColRow->m_fActualSize; | |
| 1114 } | |
| 1115 FX_POSITION ps = m_mapWidgetInfo.GetStartPosition(); | |
| 1116 while (ps) { | |
| 1117 IFWL_Widget* pWidget = NULL; | |
| 1118 CFWL_GridWidgetInfo* pInfo = NULL; | |
| 1119 m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo); | |
| 1120 if (!pWidget || !pInfo) { | |
| 1121 continue; | |
| 1122 } | |
| 1123 FX_FLOAT fColumnStart = 0; | |
| 1124 CFWL_GridColRow* pColumn = | |
| 1125 reinterpret_cast<CFWL_GridColRow*>(GetColRow(TRUE, pInfo->m_iColumn)); | |
| 1126 if (pColumn) { | |
| 1127 fColumnStart = pColumn->m_fActualPos; | |
| 1128 } | |
| 1129 FX_FLOAT fRowStart = 0; | |
| 1130 CFWL_GridColRow* pRow = | |
| 1131 reinterpret_cast<CFWL_GridColRow*>(GetColRow(FALSE, pInfo->m_iRow)); | |
| 1132 if (pRow) { | |
| 1133 fRowStart = pRow->m_fActualPos; | |
| 1134 } | |
| 1135 FX_FLOAT fColumnWidth = 0; | |
| 1136 if (iColumns > 0) { | |
| 1137 for (int32_t j = 0; j < pInfo->m_iColumnSpan; j++) { | |
| 1138 CFWL_GridColRow* pCol = reinterpret_cast<CFWL_GridColRow*>( | |
| 1139 GetColRow(TRUE, pInfo->m_iColumn + j)); | |
| 1140 if (!pCol) { | |
| 1141 break; | |
| 1142 } | |
| 1143 fColumnWidth += pCol->m_fActualSize; | |
| 1144 } | |
| 1145 } else { | |
| 1146 fColumnWidth = m_pProperties->m_rtWidget.width; | |
| 1147 } | |
| 1148 FX_FLOAT fRowHeight = 0; | |
| 1149 if (iRows > 0) { | |
| 1150 for (int32_t k = 0; k < pInfo->m_iRowSpan; k++) { | |
| 1151 CFWL_GridColRow* pR = reinterpret_cast<CFWL_GridColRow*>( | |
| 1152 GetColRow(FALSE, pInfo->m_iRow + k)); | |
| 1153 if (!pR) { | |
| 1154 break; | |
| 1155 } | |
| 1156 fRowHeight += pR->m_fActualSize; | |
| 1157 } | |
| 1158 } else { | |
| 1159 fRowHeight = m_pProperties->m_rtWidget.height; | |
| 1160 } | |
| 1161 FX_FLOAT fLeftMargin = 0, fRightMargin = 0; | |
| 1162 FX_BOOL bLeftMargin = | |
| 1163 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Left, fLeftMargin); | |
| 1164 FX_BOOL bRightMargin = | |
| 1165 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Right, fRightMargin); | |
| 1166 FX_FLOAT fTopMargin = 0, fBottomMargin = 0; | |
| 1167 FX_BOOL bTopMargin = | |
| 1168 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Top, fTopMargin); | |
| 1169 FX_BOOL bBottomMargin = | |
| 1170 GetWidgetMargin(pWidget, FWL_GRIDMARGIN_Bottom, fBottomMargin); | |
| 1171 if (pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 1172 SetWidgetActualWidth(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Width].fLength); | |
| 1173 } else { | |
| 1174 if (bLeftMargin && bRightMargin) { | |
| 1175 SetWidgetActualWidth(pInfo, fColumnWidth - fLeftMargin - fRightMargin); | |
| 1176 } else { | |
| 1177 CFX_RectF rtAuto; | |
| 1178 pWidget->GetWidgetRect(rtAuto, TRUE); | |
| 1179 SetWidgetActualWidth(pInfo, rtAuto.width); | |
| 1180 } | |
| 1181 } | |
| 1182 if (pInfo->m_Size[FWL_GRIDSIZE_Height].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 1183 SetWidgetActualHeight(pInfo, pInfo->m_Size[FWL_GRIDSIZE_Height].fLength); | |
| 1184 } else { | |
| 1185 if (bTopMargin && bBottomMargin) { | |
| 1186 SetWidgetActualHeight(pInfo, fRowHeight - fTopMargin - fBottomMargin); | |
| 1187 } else { | |
| 1188 CFX_RectF rtAuto; | |
| 1189 pWidget->GetWidgetRect(rtAuto, TRUE); | |
| 1190 SetWidgetActualHeight(pInfo, rtAuto.height); | |
| 1191 } | |
| 1192 } | |
| 1193 if (bLeftMargin && bRightMargin && | |
| 1194 pInfo->m_Size[FWL_GRIDSIZE_Width].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 1195 fLeftMargin = | |
| 1196 fColumnStart + fLeftMargin + | |
| 1197 (fColumnWidth - fLeftMargin - fRightMargin - pInfo->m_fActualWidth) / | |
| 1198 2; | |
| 1199 } else if (bLeftMargin) { | |
| 1200 fLeftMargin = fColumnStart + fLeftMargin; | |
| 1201 } else if (bRightMargin) { | |
| 1202 fLeftMargin = | |
| 1203 fColumnStart + fColumnWidth - fRightMargin - pInfo->m_fActualWidth; | |
| 1204 } else { | |
| 1205 fLeftMargin = fColumnStart; | |
| 1206 } | |
| 1207 if (bTopMargin && bBottomMargin && | |
| 1208 pInfo->m_Size[FWL_GRIDSIZE_Height].eUnit == FWL_GRIDUNIT_Fixed) { | |
| 1209 fTopMargin = | |
| 1210 fRowStart + fTopMargin + | |
| 1211 (fRowHeight - fTopMargin - fBottomMargin - pInfo->m_fActualHeight) / | |
| 1212 2; | |
| 1213 } else if (bTopMargin) { | |
| 1214 fTopMargin = fRowStart + fTopMargin; | |
| 1215 } else if (bBottomMargin) { | |
| 1216 fTopMargin = | |
| 1217 fRowStart + fRowHeight - fBottomMargin - pInfo->m_fActualHeight; | |
| 1218 } else { | |
| 1219 fTopMargin = fRowStart; | |
| 1220 } | |
| 1221 CFX_RectF rtWidget, rtOld; | |
| 1222 rtWidget.Set(fLeftMargin, fTopMargin, pInfo->m_fActualWidth, | |
| 1223 pInfo->m_fActualHeight); | |
| 1224 pWidget->GetWidgetRect(rtOld); | |
| 1225 if (rtWidget == rtOld) { | |
| 1226 continue; | |
| 1227 } | |
| 1228 pWidget->SetWidgetRect(rtWidget); | |
| 1229 if (rtWidget.width == rtOld.width && rtWidget.height == rtOld.height) { | |
| 1230 continue; | |
| 1231 } | |
| 1232 pWidget->Update(); | |
| 1233 } | |
| 1234 } | |
| 1235 FX_BOOL CFWL_GridImp::IsGrid(IFWL_Widget* pWidget) { | |
| 1236 if (!pWidget) | |
| 1237 return FALSE; | |
| 1238 return pWidget->GetClassID() == FWL_CLASSHASH_Grid; | |
| 1239 } | |
| 1240 void CFWL_GridImp::SetSpanAutoColRowSize(const CFX_PtrArray& spanAutos, | |
| 1241 FX_FLOAT fTotalSize) { | |
| 1242 int32_t iAutoColRows = spanAutos.GetSize(); | |
| 1243 if (iAutoColRows < 1) { | |
| 1244 return; | |
| 1245 } | |
| 1246 CFX_PtrArray autoNoMinMaxs; | |
| 1247 FX_FLOAT fAutoPer = fTotalSize / iAutoColRows; | |
| 1248 for (int32_t j = 0; j < iAutoColRows; j++) { | |
| 1249 CFWL_GridColRow* pColumn = static_cast<CFWL_GridColRow*>(spanAutos[j]); | |
| 1250 FX_FLOAT fOrgSize = pColumn->m_fActualSize; | |
| 1251 if (SetColRowActualSize(pColumn, pColumn->m_fActualSize + fAutoPer, TRUE)) { | |
| 1252 autoNoMinMaxs.Add(pColumn); | |
| 1253 } else { | |
| 1254 fTotalSize -= pColumn->m_fActualSize - fOrgSize; | |
| 1255 int32_t iNoMinMax = iAutoColRows - (j + 1 - autoNoMinMaxs.GetSize()); | |
| 1256 if (iNoMinMax > 0 && fTotalSize > 0) { | |
| 1257 fAutoPer = fTotalSize / iNoMinMax; | |
| 1258 } else { | |
| 1259 break; | |
| 1260 } | |
| 1261 } | |
| 1262 } | |
| 1263 int32_t iNormals = autoNoMinMaxs.GetSize(); | |
| 1264 if (fTotalSize > 0) { | |
| 1265 if (iNormals == iAutoColRows) { | |
| 1266 fAutoPer = fTotalSize / iNormals; | |
| 1267 for (int32_t k = 0; k < iNormals; k++) { | |
| 1268 CFWL_GridColRow* pColumn = | |
| 1269 static_cast<CFWL_GridColRow*>(autoNoMinMaxs[k]); | |
| 1270 pColumn->m_fActualSize += fAutoPer; | |
| 1271 } | |
| 1272 } else { | |
| 1273 SetSpanAutoColRowSize(autoNoMinMaxs, fTotalSize); | |
| 1274 } | |
| 1275 } else { | |
| 1276 } | |
| 1277 } | |
| 1278 void CFWL_GridImp::SetSpanScaledColRowSize(const CFX_PtrArray& spanScaleds, | |
| 1279 FX_FLOAT fTotalSize, | |
| 1280 FX_FLOAT fTotalScaledNum) { | |
| 1281 int32_t iScaledColRows = spanScaleds.GetSize(); | |
| 1282 if (iScaledColRows < 1) { | |
| 1283 return; | |
| 1284 } | |
| 1285 CFX_PtrArray autoNoMinMaxs; | |
| 1286 FX_FLOAT fPerSize = fTotalSize / fTotalScaledNum; | |
| 1287 for (int32_t i = 0; i < iScaledColRows; i++) { | |
| 1288 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(spanScaleds[i]); | |
| 1289 if (SetColRowActualSize(pColRow, pColRow->m_fActualSize + | |
| 1290 fPerSize * pColRow->m_Size.fLength, | |
| 1291 TRUE)) { | |
| 1292 autoNoMinMaxs.Add(pColRow); | |
| 1293 } else { | |
| 1294 fTotalSize -= pColRow->m_fActualSize; | |
| 1295 fTotalScaledNum -= pColRow->m_Size.fLength; | |
| 1296 int32_t iNoMinMax = iScaledColRows - (i + 1 - autoNoMinMaxs.GetSize()); | |
| 1297 if (iNoMinMax > 0 && fTotalSize > 0) { | |
| 1298 fPerSize = fTotalSize / fTotalScaledNum; | |
| 1299 } else { | |
| 1300 break; | |
| 1301 } | |
| 1302 } | |
| 1303 } | |
| 1304 int32_t iNormals = autoNoMinMaxs.GetSize(); | |
| 1305 if (fTotalSize > 0) { | |
| 1306 if (iNormals == iScaledColRows) { | |
| 1307 fPerSize = fTotalSize / fTotalScaledNum; | |
| 1308 for (int32_t j = 0; j < iNormals; j++) { | |
| 1309 CFWL_GridColRow* pColumn = | |
| 1310 static_cast<CFWL_GridColRow*>(autoNoMinMaxs[j]); | |
| 1311 pColumn->m_fActualSize += fPerSize * pColumn->m_Size.fLength; | |
| 1312 } | |
| 1313 } else { | |
| 1314 SetSpanScaledColRowSize(autoNoMinMaxs, fTotalSize, fTotalScaledNum); | |
| 1315 } | |
| 1316 } else { | |
| 1317 } | |
| 1318 } | |
| 1319 void CFWL_GridImp::SetScaledColRowsSize(const CFX_PtrArray& spanScaleds, | |
| 1320 FX_FLOAT fTotalSize, | |
| 1321 FX_FLOAT fTotalScaledNum) { | |
| 1322 int32_t iScaledColRows = spanScaleds.GetSize(); | |
| 1323 if (iScaledColRows < 1) { | |
| 1324 return; | |
| 1325 } | |
| 1326 CFX_PtrArray autoNoMinMaxs; | |
| 1327 FX_FLOAT fPerSize = fTotalSize / fTotalScaledNum; | |
| 1328 for (int32_t i = 0; i < iScaledColRows; i++) { | |
| 1329 CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(spanScaleds[i]); | |
| 1330 if (!pColRow) { | |
| 1331 continue; | |
| 1332 } | |
| 1333 FX_FLOAT fSize = fPerSize * pColRow->m_Size.fLength; | |
| 1334 FX_FLOAT fOrgSize = pColRow->m_fActualSize; | |
| 1335 if (SetColRowActualSize(pColRow, fSize, TRUE)) { | |
| 1336 autoNoMinMaxs.Add(pColRow); | |
| 1337 } else { | |
| 1338 fTotalSize -= pColRow->m_fActualSize - fOrgSize; | |
| 1339 fTotalScaledNum -= pColRow->m_Size.fLength; | |
| 1340 int32_t iNoMinMax = iScaledColRows - (i + 1 - autoNoMinMaxs.GetSize()); | |
| 1341 if (iNoMinMax > 0 && fTotalSize > 0) { | |
| 1342 fPerSize = fTotalSize / fTotalScaledNum; | |
| 1343 } else { | |
| 1344 break; | |
| 1345 } | |
| 1346 } | |
| 1347 } | |
| 1348 int32_t iNormals = autoNoMinMaxs.GetSize(); | |
| 1349 if (fTotalSize > 0) { | |
| 1350 if (iNormals == iScaledColRows) { | |
| 1351 fPerSize = fTotalSize / fTotalScaledNum; | |
| 1352 for (int32_t i = 0; i < iNormals; i++) { | |
| 1353 CFWL_GridColRow* pColRow = | |
| 1354 static_cast<CFWL_GridColRow*>(autoNoMinMaxs[i]); | |
| 1355 if (!pColRow) { | |
| 1356 continue; | |
| 1357 } | |
| 1358 FX_FLOAT fSize = fPerSize * pColRow->m_Size.fLength; | |
| 1359 pColRow->m_fActualSize = fSize; | |
| 1360 } | |
| 1361 } else { | |
| 1362 SetScaledColRowsSize(autoNoMinMaxs, fTotalSize, fTotalScaledNum); | |
| 1363 } | |
| 1364 } else { | |
| 1365 } | |
| 1366 } | |
| 1367 CFWL_GridImpDelegate::CFWL_GridImpDelegate(CFWL_GridImp* pOwner) | |
| 1368 : m_pOwner(pOwner) {} | |
| 1369 int32_t CFWL_GridImpDelegate::OnProcessMessage(CFWL_Message* pMessage) { | |
| 1370 if (pMessage->GetClassID() != FWL_MSGHASH_Mouse) { | |
| 1371 return 0; | |
| 1372 } | |
| 1373 CFWL_MsgMouse* pMsg = static_cast<CFWL_MsgMouse*>(pMessage); | |
| 1374 if (pMsg->m_dwCmd != FWL_MSGMOUSECMD_LButtonDown) { | |
| 1375 return 0; | |
| 1376 } | |
| 1377 return 1; | |
| 1378 } | |
| 1379 FWL_ERR CFWL_GridImpDelegate::OnDrawWidget(CFX_Graphics* pGraphics, | |
| 1380 const CFX_Matrix* pMatrix) { | |
| 1381 return m_pOwner->DrawWidget(pGraphics, pMatrix); | |
| 1382 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1862243002:
Remove IFWL_Grid and other grid classes. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@master