atlautosizedlg.h

j2me is based on j2mepolish, client & server for mobile application.

					if (iTypeDef == WMSRC_AUTO) {
						piWidthCol[i] = iValDef;
					} else if (iTypeDef == WMSRC_EXPANDABLE) {
						piWidthCol[i] = ::MulDiv(iTotalColExpand, iValDef, iColExpand);
						_NormalizeColRow(piWidthCol[i], iMinPixDef, iMaxPixDef);
						iColExpand -= iValDef;
						iTotalColExpand = (iTotalColExpand > piWidthCol[i] ? iTotalColExpand - piWidthCol[i] : 0);
					} else if (iTypeDef == WMSRC_CONTRACTABLE) {
						piWidthCol[i] = ::MulDiv(iTotalColContract, iValDef, iColContract);
						_NormalizeColRow(piWidthCol[i], iMinPixDef, iMaxPixDef);
						iColContract -= iValDef;
						iTotalColContract = (iTotalColContract > piWidthCol[i] ? iTotalColContract - piWidthCol[i] : 0);
					} else if (iTypeDef == WMSRC_GAP) {
						piWidthCol[i] = iMinPixDef;
					} else if (iTypeDef == WMSRC_GAPM) {
						piWidthCol[i] = iMinPixDef;
					} else {
						piWidthCol[i] = iMinPixDef;
					}		
				} else if (iType == WMSRC_GAP) {
					piWidthCol[i] = iMinPix;
				} else if (iType == WMSRC_GAPM) {
					piWidthCol[i] = iMinPix;
				} else {
					piWidthCol[i] = iMinPix;
				}

				iWidthTotal += piWidthCol[i];
				if (iWidthTotal > pRectWindow->right) {
					piWidthCol[i] -= iWidthTotal - pRectWindow->right;
					iWidthTotal = pRectWindow->right;
				}

#ifdef TRACEAUTOSIZE2
				ATLTRACE("%d ", piWidthCol[i]);
#endif
			}

			int *piHeightRow = (int*)_alloca(pheader->m_iNumRows * sizeof(int));
			int **ppiRowBegin = (int**)_alloca(pheader->m_iNumRows * sizeof(int*));

			HWND *phWnd = (HWND*)_alloca(pheader->m_iNumCols * sizeof(HWND));
			int **ppiCtrl = (int**)_alloca(pheader->m_iNumCols * sizeof(int**));
			RECT *prect = (RECT*)_alloca(pheader->m_iNumCols * sizeof(RECT));
			::memset(phWnd, 0, pheader->m_iNumCols * sizeof(HWND));
			::memset(ppiCtrl, 0, pheader->m_iNumCols * sizeof(int**));

			int iHeightTotal = pRectWindow->top;
			if (bMain) {
				iHeightTotal += pmargins->m_iTopBottom;
			}

			int iRow = 0;

#ifdef TRACEAUTOSIZE2
			ATLTRACE("\nRows: ");
#endif

			while (*piCell != WM_END) {
				ppiRowBegin[iRow] = piCell;

				if (*piCell == WMR_BEGIN) {
					int iType, iStyle, iVal;
					_TypeVal(piCell[1], iType, iStyle, iVal);

					if (iRow && !(iStyle & WMSRC_NOGAP)) {
						iHeightTotal += pmargins->m_iYGap;
					}

					if (iHeightTotal > pRectWindow->bottom) {
						iHeightTotal = pRectWindow->bottom;
					}

					int iTypeMin, iTypeMax;
					int iMinPix, iMaxPix;
					_LoadMinMax(ppiRowBegin[iRow] + 1, lYUnits, 8, iTypeMin, iMinPix, iTypeMax, iMaxPix);

					if (iType == WMSRC_AUTO) {
						piHeightRow[iRow] = iVal;
					} else if (iType == WMSRC_EXPANDABLE) {
						piHeightRow[iRow] = ::MulDiv(iTotalRowExpand, iVal, iRowExpand);
						_NormalizeColRow(piHeightRow[iRow], iMinPix, iMaxPix);
						iRowExpand -= iVal;
						iTotalRowExpand = (iTotalColExpand > piHeightRow[iRow] ? iTotalColExpand - piHeightRow[iRow] : 0);
					} else if (iType == WMSRC_CONTRACTABLE) {
						piHeightRow[iRow] = ::MulDiv(iTotalRowContract, iVal, iRowContract);
						_NormalizeColRow(piHeightRow[iRow], iMinPix, iMaxPix);
						iRowContract -= iVal;
						iTotalRowContract = (iTotalColContract > piHeightRow[iRow] ? iTotalColContract - piHeightRow[iRow] : 0);
					} else if (iType == WMSRC_EQUAL) {
						int iRowDef = iVal;
						int iTypeDef, iStyleDef, iValDef;
						do {
							_TypeVal(ppiRowBegin[iRowDef][1], iTypeDef, iStyleDef, iValDef);
						} while (iTypeDef == WMSRC_EQUAL && (iRowDef = iValDef) == iRowDef);

						int iTypeMinDef, iTypeMaxDef;
						int iMinPixDef, iMaxPixDef;
						_LoadMinMax(ppiRowBegin[iRowDef] + 1, lYUnits, 8, iTypeMinDef, iMinPixDef, iTypeMaxDef, iMaxPixDef);

						if (iTypeDef == WMSRC_AUTO) {
							piHeightRow[iRow] = iValDef;
						} else if (iTypeDef == WMSRC_EXPANDABLE) {
							piHeightRow[iRow] = ::MulDiv(iTotalRowExpand, iValDef, iRowExpand);
							_NormalizeColRow(piHeightRow[iRow], iMinPix, iMaxPix);
							iRowExpand -= iValDef;
							iTotalRowExpand = (iTotalColExpand > piHeightRow[iRow] ? iTotalColExpand - piHeightRow[iRow] : 0);
						} else if (iTypeDef == WMSRC_CONTRACTABLE) {
							piHeightRow[iRow] = ::MulDiv(iTotalRowContract, iValDef, iRowContract);
							_NormalizeColRow(piHeightRow[iRow], iMinPix, iMaxPix);
							iRowContract -= iValDef;
							iTotalRowContract = (iTotalColContract > piHeightRow[iRow] ? iTotalColContract - piHeightRow[iRow] : 0);
						} else if (iTypeDef == WMSRC_GAP) {
							piHeightRow[iRow] = iMinPixDef;
						} else if (iTypeDef == WMSRC_GAPM) {
							piHeightRow[iRow] = iMinPixDef;
						} else {
							piHeightRow[iRow] = iMinPixDef;
						}		
					} else if (iType == WMSRC_GAP) {
						piHeightRow[iRow] = iMinPix;
					} else if (iType == WMSRC_GAPM) {
						piHeightRow[iRow] = iMinPix;
					} else {
						piHeightRow[iRow] = iMinPix;
					}

					if (iHeightTotal + piHeightRow[iRow] > pRectWindow->bottom) {
						piHeightRow[iRow] = pRectWindow->bottom - iHeightTotal;
					}

#ifdef TRACEAUTOSIZE2
					ATLTRACE("%d ", piHeightRow[iRow]);
#endif

					piCell += 4;

					int iCol = 0;
					RECT *pLastRect = NULL;

					int iWidthTotal = pRectWindow->left;
					if (bMain) {
						iWidthTotal += pmargins->m_iLeftRight;
					}

					while (*piCell != WM_END && *piCell != WMR_END) {
						if (iCol < pheader->m_iNumCols) {
							if (iCol && !(piHeadCols[iCol * 3] & WMSRC_NOGAP)) {
								iWidthTotal += pmargins->m_iXGap;
							}

							if (iWidthTotal > pRectWindow->right) {
								iWidthTotal = pRectWindow->right;
							}

							if (*piCell != WMSCTRL_EXPDOWN) {
								if (!_MoveCtrl(iCol, hdwp, phWnd, ppiCtrl, prect, pmargins, lXUnits, lYUnits)) {
									return FALSE;
								}

								if (*piCell != WMSCTRL_EMPTY && *piCell != WMSCTRL_EXPRIGHT) {
									prect[iCol].left = iWidthTotal;
									prect[iCol].top = iHeightTotal;
									prect[iCol].right = piWidthCol[iCol];
									prect[iCol].bottom = piHeightRow[iRow];
									pLastRect = &prect[iCol];

									if (*piCell != WMH_BEGIN) {
										phWnd[iCol] = pT->GetDlgItem(*piCell);
										ppiCtrl[iCol] = NULL;
										if (!phWnd[iCol]) {
											phWnd[iCol] = (HWND)-1;
											ATLTRACE(_T("Inexistant ctrl in row: %d, col: %d. Ignored.\n"), iRow, iCol);
										}
									} else {
										phWnd[iCol] = NULL;
										ppiCtrl[iCol] = piCell;
										piCell += piCell[1];
									}
								} else {
									phWnd[iCol] = NULL;
									ppiCtrl[iCol] = NULL;
									if (*piCell != WMSCTRL_EXPRIGHT) {
										pLastRect = NULL;
									}
								}
							} 

							if (*piCell == WMSCTRL_EXPRIGHT) {
								if (pLastRect) {
									pLastRect->right += piWidthCol[iCol];
									if ((piHeadCols[iCol * 3] & WMSRC_NOGAP) != WMSRC_NOGAP && iCol) {
										pLastRect->right += pmargins->m_iXGap;
										if (pLastRect->left + pLastRect->right > pRectWindow->right) {
											pLastRect->right = pRectWindow->right - pLastRect->left;
										}
									}
								} else {
									ATLTRACE(_T("Wrong continue right flag in row: %d, column: %d. Ignored.\n"), iRow, iCol);
								}
							} else if (*piCell == WMSCTRL_EXPDOWN) {
								if (phWnd[iCol] || ppiCtrl[iCol]) {
									prect[iCol].bottom += piHeightRow[iRow];
									if (iRow && !(iStyle & WMSRC_NOGAP)) {
										prect[iCol].bottom += pmargins->m_iYGap;
										if (prect[iCol].top + prect[iCol].bottom > pRectWindow->bottom) {
											prect[iCol].bottom = pRectWindow->bottom - prect[iCol].top;
										}
									}
								} else {
									ATLTRACE(_T("Wrong continue down flag in row: %d, column: %d. Ignored.\n"), iRow, iCol);
								}
								pLastRect = NULL;
							}

							iWidthTotal += piWidthCol[iCol];
						}

						iCol++;
						piCell++;
					}

					for (int i = iCol; i < pheader->m_iNumCols; i++) {
						if (!_MoveCtrl(i, hdwp, phWnd, ppiCtrl, prect, pmargins, lXUnits, lYUnits)) {
							return FALSE;
						}
					}
				} else {
					ATLTRACE(_T("Malformed row: %d. Skipped. \n"), iRow);
					while (*piCell != WMR_END && *piCell != WM_END) {
						piCell++;
					}

					for (int i = 0; i < pheader->m_iNumCols; i++) {
						if (!_MoveCtrl(i, hdwp, phWnd, ppiCtrl, prect, pmargins, lXUnits, lYUnits)) {
							return FALSE;
						}
					}

					piHeightRow[iRow] = 0;
				}

				iHeightTotal += piHeightRow[iRow];

				if (*piCell != WM_END) {
					piCell++;
				} else {
					ATLTRACE(_T("Malformed endrow in row: %d. Ignored.\n"), iRow);
				}

				iRow++;
			} 			

			for (int i = 0; i < pheader->m_iNumCols; i++) {
				if (!_MoveCtrl(i, hdwp, phWnd, ppiCtrl, prect, pmargins, lXUnits, lYUnits)) {
					return FALSE;
				}
			}
		}

		ATLASSERT(*piCell == WM_END);

		return TRUE;
	}

	BOOL _MoveCtrl(int iCol, HDWP &hdwp, HWND *phWnd, int **ppiCtrl, RECT *prect, CMargins *pmargins, LONG lXUnits, LONG lYUnits)
	{
		if (phWnd[iCol] && phWnd[iCol] != (HWND)-1) {
			POINT pt = {0};
			__if_exists(T::GetScrollOffset) {
				T* pT = static_cast<T*>(this);
				pT->GetScrollOffset(pt);
			}

			UINT uiFlags = ::GetWindowLong(phWnd[iCol], GWL_EXSTYLE) & WS_EX_TRANSPARENT ? SWP_NOCOPYBITS : 0;
			ATLVERIFY((hdwp = ::DeferWindowPos(hdwp, phWnd[iCol], NULL, prect[iCol].left - pt.x, prect[iCol].top - pt.y, prect[iCol].right, prect[iCol].bottom, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOZORDER|uiFlags)) != NULL);
			if (!hdwp) {
				return FALSE;
			}
			phWnd[iCol] = NULL;
		} else if (ppiCtrl[iCol]) {
			RECT rect = {prect[iCol].left, prect[iCol].top, prect[iCol].left + prect[iCol].right, prect[iCol].top + prect[iCol].bottom};
			if (!_CtrlsArrange(hdwp, (CCtrlGroup*)ppiCtrl[iCol], pmargins, lXUnits, lYUnits, &rect, FALSE)) {
				return FALSE;
			}

			ppiCtrl[iCol] = NULL;
		}

		return TRUE;
	}

	/// Converts margins and gaps from DLGU or Pixels to Pixels
	static void _CheckMargins(long lXUnits, int iXUnitsBase, long lYUnits, int iYUnitsBase, const CMargins *pmargins, CMargins *pmarginsPix)
	{
		pmarginsPix->m_iLeftRight = (pmargins->m_iLeftRight > 0 ? ::MulDiv(pmargins->m_iLeftRight, lXUnits, iXUnitsBase) : -pmargins->m_iLeftRight);
		pmarginsPix->m_iTopBottom = (pmargins->m_iTopBottom > 0 ? ::MulDiv(pmargins->m_iTopBottom, lYUnits, iYUnitsBase) : -pmargins->m_iTopBottom);
		pmarginsPix->m_iXGap = (pmargins->m_iXGap > 0 ? ::MulDiv(pmargins->m_iXGap, lXUnits, iXUnitsBase) : -pmargins->m_iXGap);
		pmarginsPix->m_iYGap = (pmargins->m_iYGap > 0 ? ::MulDiv(pmargins->m_iYGap, lYUnits, iYUnitsBase) : -pmargins->m_iYGap);
	}

	/// Splits the type of a Row/Col in Type, ExStyle and Val
	static void _TypeVal(int iBase, int &iType, int &iStyle, int &iVal)
	{
		if (iBase >= 0) {
			iType = iBase & WMSRC_TYPEMASK;
			iStyle = iBase & WMSRC_EXSTYLEMASK;
			iVal = iBase & WMSRC_VALMASK;
		} else {
			iBase = 0 - iBase;
			iType = iBase & WMSRC_TYPEMASK;
			iStyle = iBase & WMSRC_EXSTYLEMASK;
			iVal = -(int)(iBase & WMSRC_VALMASK);
		}
	}

	static void _SetVariableMinMax(int iCR, int *piColRow)
	{
		_SetVariableMinMax(iCR, piColRow[1]);
		_SetVariableMinMax(iCR, piColRow[2], WMSRCMM_MAXVAL);
	}

	static void _SetVariableMinMax(int iCR, int &iBase, int iVal = 0)
	{
		iCR;

		BOOL bNeg = iBase < 0;

		if (bNeg) {
			iBase = -iBase;
		}

		if (iBase & WMSRCMM_SIZECALC) {
			iBase = WMSRCMM_SIZECALC|WMSRCMM_NEEDCALC|iVal;
			bNeg = FALSE;
		} else if (iBase & WMSRCMM_NEEDCALC) {
			ATLTRACE(_T("Wrong min-max flag in column (or row): %d. Fixed.\n"), iCR);
			iBase &= ~WMSRCMM_NEEDCALC;
		}

		if (bNeg) {
			iBase = -iBase;
		}
	}

	static void _CheckEqualMinMax(int iCR, int *piColRow)
	{
		_CheckEqualMinMax(iCR, piColRow[1]);
		_CheckEqualMinMax(iCR, piColRow[2]);
	}

	static void _CheckEqualMinMax(int iCR, int &iBase)
	{
		iCR;

		BOOL bNeg = iBase < 0;

		if (bNeg) {
			iBase = -iBase;
		}

		if (!(iBase & WMSRCMM_SIZECALC)) {
			ATLTRACE(_T("Equal columns/rows can't have min/max value. Ignored value in column (or row) %d.\n"), iCR);
		} else if (iBase & WMSRCMM_NEEDCALC) {
			ATLTRACE(_T("Wrong min-max flag in column (or row): %d. Fixed.\n"), iCR);
		}

		iBase = WMSRCMM_SIZECALC;
	}

	static void _CheckFixedMinMax(int iCR, int *piColRow, long lXYUnits, int iXYUnitsBase, int iVal)
	{
		_CheckFixedMinMax(iCR, piColRow[1], lXYUnits, iXYUnitsBase, iVal);
		_CheckFixedMinMax(iCR, piColRow[2], lXYUnits, iXYUnitsBase, iVal);
	}

	static void _CheckFixedMinMax(int iCR, int &iBase, long lXYUnits, int iXYUnitsBase, int iVal)
	{
		iCR;

		BOOL bNeg = iBase < 0;

		if (bNeg) {
			iBase = -iBase;
		}

		if (iBase & WMSRCMM_SIZECALC) {
			iBase = WMSRCMM