interface/layouter/ComplexLayouter.cpp

105 	Constraint(int32 start, int32 end, int32 min, int32 max)
108 		  min(min),
112 		if (min > max)
113 			max = min;
119 		if (newMin > min)
120 			min = newMin;
123 		if (min > max)
124 			max = min;
131 		return (value >= min && value <= max);
136 	int32		min;
145 	int32	min;
154 	int32	min;
228 	int32 min = (int32)_min + 1 - spacing;
231 	if (min < 0)
232 		min = 0;
243 		(*slot)->Restrict(min, max);
246 		Constraint* constraint = new(nothrow) Constraint(element, end, min,
323 	int32 min = fSums[fElementCount].min;
327 	if (size < min)
328 		size = min;
335 	sums[fElementCount].min = size;
337 	sums[fElementCount].minDirty = (size != min);
348 		TRACE("[%ld] minc = %4ld,  maxc = %4ld\n", i + 1, sum.min, sum.max);
378 				constraint->min, constraint->max);
422 		values[i] = sums[i + 1].min - sums[i].min;
477 			int32 sumMin = base.min + constraint->min;
478 			int32 baseMax = sum.max - constraint->min;
479 			bool minRedundant = (sumMin < sum.min && baseMax > base.max);
482 			int32 baseMin = sum.min - constraint->effectiveMax;
483 			bool maxRedundant = (sumMax > sum.max && baseMin < base.min);
487 				if (constraint->min == constraint->effectiveMax) {
488 					// min and max equal -- add an equality constraint
490 						constraint->end, constraint->min, true);
492 					// min and max not equal -- add them individually,
497 							constraint->min, false);
554 	// The general idea for computing the min and max for the given constraints
557 	//   x_i + ... + x_{i+j} >= min[i,j] and
559 	//   and min[i,j], max[i,j] >= 0
564 	//   c[i+j] - c[i-1] >= min[i,j]
570 	//   minc[i+j] >= c[i-1] + min[i,j]
571 	//   maxc[i+j] <= c[i-1] + min[i,j]
573 	//   maxc[i-1] >= maxc[i+j] - min[i,j]
576 	// backwards. First we start considering all min constraints only. They
582 	// incorporated, the resulting minc[n] and maxc[n] are the min and max
588 	fSums[0].min = 0;
594 		sum.min = 0;
600 	// apply min constraints forward:
601 	//   minc[i+j] >= minc[i-1] + min[i,j]
607 			int32 minSum = fSums[constraint->start].min + constraint->min;
608 			//Do not allow the cumulative minimum at fSums[i+1].min to be less than the
609 			//cumulative minimum already established at fSums[i].min (fSums[i] may have been
611 			if (minSum < fSums[i].min) {
612 				minSum = fSums[i].min;
614 			if (minSum > sum.min) {
615 				sum.min = minSum;
617 				TRACE("min constraint is redundant: x%ld + ... + x%ld >= %ld\n",
618 					constraint->start, constraint->end, constraint->min);
625 	// apply min constraints backwards:
626 	//   maxc[i-1] <= maxc[i+j] - min[i,j]
633 			int32 baseMax = sum.max - constraint->min;
654 		TRACE("[%ld] minc = %4ld,  maxc = %4ld\n", i + 1, sum.min, sum.max);
663 		fMin = fSums[fElementCount].min + spacing - 1;
696 	if (sumMax < sum.min) {
697 		sumMax = sum.min;
703 	int32 baseMin = sum.min - max;
706 		max = sum.min - baseMin;
717 	if (baseMin <= base.min && sumMax >= sum.max) {
732 		if (baseMin > base.min) {
733 			base.min = baseMin;
758 		baseMin = sum.min - max;
759 		if (baseMin > base.min)
760 			diff = max_c(diff, baseMin - base.min);
780 			baseMin = sum.min - max;
782 			if (baseMin <= base.min && sumMax >= sum.max)
790 /*!	Propagate changes forward using min and max constraints. Max constraints
811 			// minc[k] >= minc[i-1] + min[i,j]
813 				int32 sumMin = base.min + constraint->min;
814 				if (sumMin > sum.min) {
815 					sum.min = sumMin;
833 			if (sum.min > sum.max) {
836 					"%ld: %ld -> %ld\n", i, sum.max, sum.min);
837 				sum.max = sum.min;
864 				int32 baseMin = sum.min - constraint->effectiveMax;
865 				if (baseMin > base.min) {
867 						TRACE("min above max in back propagation phase: index: "
868 							"(%ld -> %ld), min: %ld, max: %ld\n", i,
871 					base.min = baseMin;
876 			// maxc[i-1] <= maxc[k] - min[i,j]
878 				int32 baseMax = sum.max - constraint->min;
880 					if (baseMax < base.min) {
881 						TRACE("max below min in back propagation phase: index: "
882 							"(%ld -> %ld), max: %ld, min: %ld\n", i,
883 							constraint->start, baseMax, base.min);
902 		fSumBackups[i + 1].min = sum.min;
914 		sum.min = fSumBackups[i + 1].min;