interface/layouter/ComplexLayouter.cpp

105 	Constraint(int32 start, int32 end, int32 min, int32 max)
109 		  max(max),
112 		if (min > max)
113 			max = min;
114 		effectiveMax = max;
121 		if (newMax < max)
122 			max = newMax;
123 		if (min > max)
124 			max = min;
125 		effectiveMax = max;
131 		return (value >= min && value <= max);
137 	int32		max;
146 	int32	max;
155 	int32	max;
229 	int32 max = (int32)_max + 1 - spacing;
233 	if (max > fUnlimited)
234 		max = fUnlimited;
243 		(*slot)->Restrict(min, max);
247 			max);
324 	int32 max = fSums[fElementCount].max;
329 	if (size > max)
330 		size = max;
336 	sums[fElementCount].max = size;
338 	sums[fElementCount].maxDirty = (size != max);
348 		TRACE("[%ld] minc = %4ld,  maxc = %4ld\n", i + 1, sum.min, sum.max);
378 				constraint->min, constraint->max);
478 			int32 baseMax = sum.max - constraint->min;
479 			bool minRedundant = (sumMin < sum.min && baseMax > base.max);
481 			int32 sumMax = base.max + constraint->effectiveMax;
483 			bool maxRedundant = (sumMax > sum.max && baseMin < base.min);
488 					// min and max equal -- add an equality constraint
492 					// min and max not equal -- add them individually,
554 	// The general idea for computing the min and max for the given constraints
558 	//   x_i + ... + x_{i+j} >= max[i,j], with i >= 1, j >= 0, i + j <= n
559 	//   and min[i,j], max[i,j] >= 0
565 	//   c[i+j] - c[i-1] <= max[i,j]
572 	//   minc[i-1] >= minc[i+j] - max[i,j]
577 	// can't contradict each other and are usually to be enforced over max
578 	// constraints. Afterwards we add the max constraints one by one. For each
580 	// a conflict, we relax the max constraint as much as necessary to yield
582 	// incorporated, the resulting minc[n] and maxc[n] are the min and max
589 	fSums[0].max = 0;
595 		sum.max = maxSum += fUnlimited;
633 			int32 baseMax = sum.max - constraint->min;
634 			if (baseMax < base.max)
635 				base.max = baseMax;
641 	// apply max constraints
654 		TRACE("[%ld] minc = %4ld,  maxc = %4ld\n", i + 1, sum.min, sum.max);
664 		fMax = fSums[fElementCount].max + spacing - 1;
682 	//   c[i+j] <= c[i-1] + max[i,j]
685 	// (1) maxc[k] <= maxc[i-1] + max[i,j]
686 	// (2) minc[i-1] >= minc[k] - max[i,j]
691 	// apply (1) maxc[k] <= maxc[i-1] + max[i,j]
692 	int32 max = currentConstraint->effectiveMax;
693 	int32 sumMax = base.max + max;
698 		max = sumMax - base.max;
701 	// apply (2) minc[i-1] >= minc[k] - max[i,j]
703 	int32 baseMin = sum.min - max;
704 	if (baseMin > base.max) {
705 		baseMin = base.max;
706 		max = sum.min - baseMin;
707 		sumMax = base.max + max;
710 	if (currentConstraint->effectiveMax != max) {
711 		TRACE("relaxing conflicting max constraint (1): "
713 			currentConstraint->end, currentConstraint->effectiveMax, max);
715 	currentConstraint->effectiveMax = max;
717 	if (baseMin <= base.min && sumMax >= sum.max) {
718 		TRACE("max constraint is redundant: x%ld + ... + x%ld <= %ld\n",
737 		if (sumMax < sum.max) {
739 			sum.max = sumMax;
751 		// check (1) maxc[k] <= maxc[i-1] + max[i,j]
752 		max = currentConstraint->effectiveMax;
753 		sumMax = base.max + max;
754 		if (sumMax < sum.max)
755 			diff = sum.max - sumMax;
757 		// check (2) minc[i-1] >= minc[k] - max[i,j]
758 		baseMin = sum.min - max;
771 			max += diff;
772 			TRACE("relaxing conflicting max constraint (2): "
774 				currentConstraint->end, currentConstraint->effectiveMax, max);
775 			currentConstraint->effectiveMax = max;
779 			sumMax = base.max + max;
780 			baseMin = sum.min - max;
782 			if (baseMin <= base.min && sumMax >= sum.max)
790 /*!	Propagate changes forward using min and max constraints. Max constraints
820 			// maxc[k] <= maxc[i-1] + max[i,j]
822 				int32 sumMax = base.max + constraint->effectiveMax;
823 				if (sumMax < sum.max) {
824 					sum.max = sumMax;
833 			if (sum.min > sum.max) {
835 				TRACE("adjusted max in propagation phase: index: "
836 					"%ld: %ld -> %ld\n", i, sum.max, sum.min);
837 				sum.max = sum.min;
862 			// minc[i-1] >= minc[k] - max[i,j]
866 					if (baseMin > base.max) {
867 						TRACE("min above max in back propagation phase: index: "
868 							"(%ld -> %ld), min: %ld, max: %ld\n", i,
869 							constraint->start, baseMin, base.max);
878 				int32 baseMax = sum.max - constraint->min;
879 				if (baseMax < base.max) {
881 						TRACE("max below min in back propagation phase: index: "
882 							"(%ld -> %ld), max: %ld, min: %ld\n", i,
885 					base.max = baseMax;
903 		fSumBackups[i + 1].max = sum.max;
915 		sum.max = fSumBackups[i + 1].max;