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 |