org.jpedal.objects.acroforms.utils.FormUtils Maven / Gradle / Ivy

/*
 * ===========================================
 * Java Pdf Extraction Decoding Access Library
 * ===========================================
 *
 * Project Info:  http://www.idrsolutions.com
 * Help section for developers at http://www.idrsolutions.com/support/
 *
 * (C) Copyright 1997-2017 IDRsolutions and Contributors.
 *
 * This file is part of JPedal/JPDF2HTML5
 *
 @LICENSE@
 *
 * ---------------
 * FormUtils.java
 * ---------------
 */
package org.jpedal.objects.acroforms.utils;

import java.awt.Rectangle;

import org.jpedal.objects.raw.FormObject;

/**
 * general purpose functions used in forms
 */
public class FormUtils {

    /**
     * sorts the integer array into the right order to read the
     * component array in size order largest first
     */
    public static FormObject[] sortGroupLargestFirst(final FormObject[] comps) {

        return sortCompsDesending(comps);
    }

    /**
     * sorts as a tree like structure in array representation,
     * the integer array in descending size order comparing the component size,
     */
    private static FormObject[] sortCompsDesending(final FormObject[] array) {
        //reference
        //Sorts.quicksort(new int[1],new int[1]);

	/* copy so we don't sort original */
        final int items = array.length;

        //pointer to left side of unsorted array
        int left = items / 2;
        //pointer to right side of unsorted array
        int right = items - 1;

        //sift through array into a heap
        while (left > 0) {

            left -= 1;

            //go through tree starting with leaves and going up
            siftCompsDesending(array, left, right);
        }

        //rearrange heap into a sorted array
        while (right > 0) {

            //assert: largest unsorted value is at a[0]
            //move largest item to right end
            final FormObject tempA = array[0];
            array[0] = array[right];
            array[right] = tempA;
            //assert: a[right..] is sorted

            //right is largest and sorted decrement it
            right -= 1;

            //get largest value in the tree to the leftMost position
            siftCompsDesending(array, left, right);
        }
        //assert: right==0, therefore a[0..] is all sorted

        return array;
    }

    /**
     * see sortCompsDesending(Component[])
     * This Is Called from That Method ONLY
     */
    private static void siftCompsDesending(final FormObject[] array, final int left, final int right) {
        int currentLeft;
        final FormObject primaryTMP;
        int childL;

        //assign left to local
        currentLeft = left;
        //temp store of left item
        primaryTMP = array[currentLeft];

        //Left child node of currentLeft
        childL = 2 * left + 1;

        //Find a[left]'s larger child
        if ((childL < right) && shouldSwapControlDesending(array[childL], array[childL + 1])) {
            childL += 1;
        }
        //assert: a[childL] is larger child

        //sift temp to be in correct place in highest on leftMost and arranged as tree
        while ((childL <= right) && shouldSwapControlDesending(primaryTMP, array[childL])) {
            //assign highest item to leftmost position
            array[currentLeft] = array[childL];
            currentLeft = childL;
            childL = 2 * childL + 1;

            //pick highest child
            if ((childL < right) && shouldSwapControlDesending(array[childL], array[childL + 1])) {
                childL += 1;
            }
        }
        //put temp in the correct place in the sub-heap
        array[currentLeft] = primaryTMP;
        //assert: a[left] is the root a sub-heap.
    }

    /**
     * the control of the order in the sortCompsDesending(Component[]) method
     */
    private static boolean shouldSwapControlDesending(final FormObject arg1, final FormObject arg2) {
        if (arg1 == null) {
            return arg2 != null;
        } else {
            if (arg2 == null) {
                return false;
            } else {
                final Rectangle first = arg1.getBoundingRectangle();
                final Rectangle second = arg2.getBoundingRectangle();
		
		/*
		 * sorts by area, same as acrobat
		 * return (first.width*first.height)>(second.width*second.height);
		 */
                return (first.width * first.height) < (second.width * second.height);
            }
        }
    }
}