source: java/FramclipsePlugin/src/main/java/com/framsticks/framclipse/editors/codeCompletion/OrderableCompletionProposal.java @ 193

package com.framsticks.framclipse.editors.codeCompletion;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;

public class OrderableCompletionProposal implements ICompletionProposal,
                Comparable<OrderableCompletionProposal> {

        /** The string to be displayed in the completion proposal popup. */
        private String fDisplayString;
        /** The replacement string. */
        private String fReplacementString;
        /** The replacement offset. */
        private int fReplacementOffset;
        /** The replacement length. */
        private int fReplacementLength;
        /** The cursor position after this proposal has been applied. */
        private int fCursorPosition;
        /** The image to be displayed in the completion proposal popup. */
        private Image fImage;
        /** The context information of this proposal. */
        private IContextInformation fContextInformation;
        /** The additional info of this proposal. */
        private String fAdditionalProposalInfo;

        private boolean function;
        private String name;
        private String type;

        /**
         * Creates a new completion proposal based on the provided information. The
         * replacement string is considered being the display string too. All
         * remaining fields are set to <code>null</code>.
         * 
         * @param replacementString
         *            the actual string to be inserted into the document
         * @param replacementOffset
         *            the offset of the text to be replaced
         * @param replacementLength
         *            the length of the text to be replaced
         * @param cursorPosition
         *            the position of the cursor following the insert relative to
         *            replacementOffset
         */
        public OrderableCompletionProposal(String replacementString, int replacementOffset,
                        int replacementLength, int cursorPosition) {
                this(replacementString, replacementOffset, replacementLength, cursorPosition, null, null,
                                null, null);
        }

        /**
         * Creates a new completion proposal. All fields are initialized based on
         * the provided information.
         * 
         * @param replacementString
         *            the actual string to be inserted into the document
         * @param replacementOffset
         *            the offset of the text to be replaced
         * @param replacementLength
         *            the length of the text to be replaced
         * @param cursorPosition
         *            the position of the cursor following the insert relative to
         *            replacementOffset
         * @param image
         *            the image to display for this proposal
         * @param displayString
         *            the string to be displayed for the proposal
         * @param contextInformation
         *            the context information associated with this proposal
         * @param additionalProposalInfo
         *            the additional information associated with this proposal
         */
        public OrderableCompletionProposal(String replacementString, int replacementOffset,
                        int replacementLength, int cursorPosition, Image image, String displayString,
                        IContextInformation contextInformation, String additionalProposalInfo) {
                Assert.isNotNull(replacementString);
                Assert.isTrue(replacementOffset >= 0);
                Assert.isTrue(replacementLength >= 0);
                Assert.isTrue(cursorPosition >= 0);

                fReplacementString = replacementString;
                fReplacementOffset = replacementOffset;
                fReplacementLength = replacementLength;
                fCursorPosition = cursorPosition;
                fImage = image;
                fDisplayString = displayString;
                fContextInformation = contextInformation;
                fAdditionalProposalInfo = additionalProposalInfo;
        }

        /*
         * @see ICompletionProposal#apply(IDocument)
         */
        public void apply(IDocument document) {
                try {
                        document.replace(fReplacementOffset, fReplacementLength, fReplacementString);
                } catch (BadLocationException x) {
                        // ignore
                }
        }

        /*
         * @see ICompletionProposal#getSelection(IDocument)
         */
        public Point getSelection(IDocument document) {
                return new Point(fReplacementOffset + fCursorPosition, 0);
        }

        /*
         * @see ICompletionProposal#getContextInformation()
         */
        public IContextInformation getContextInformation() {
                return fContextInformation;
        }

        /*
         * @see ICompletionProposal#getImage()
         */
        public Image getImage() {
                return fImage;
        }

        /*
         * @see ICompletionProposal#getDisplayString()
         */
        public String getDisplayString() {
                if (fDisplayString != null) {
                        return fDisplayString;
                }
                return fReplacementString;
        }

        /*
         * @see ICompletionProposal#getAdditionalProposalInfo()
         */
        public String getAdditionalProposalInfo() {
                return fAdditionalProposalInfo;
        }

        public boolean isFunction() {
                return function;
        }

        public void setFunction(boolean function) {
                this.function = function;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public String getType() {
                return type;
        }

        public void setType(String type) {
                this.type = type;
        }

        public int compareTo(OrderableCompletionProposal o) {
                if (o.function && !function) {
                        return -1;
                }
                if (!o.function && function) {
                        return 1;
                }

                if ((type == null) && (o.type != null)) {
                        int typeNameComparison = -1 * o.type.compareTo(name);
                        if (typeNameComparison == 0) {
                                return -1;
                        }
                        return typeNameComparison;
                }
                if (type != null) {
                        if (o.type == null) {
                                int typeNameComparison = type.compareTo(o.name);
                                if (typeNameComparison == 0) {
                                        return 1;
                                }
                                return typeNameComparison;
                        }

                        int typeComparison = type.compareTo(o.type);
                        if (typeComparison != 0) {
                                return typeComparison;
                        }
                }

                return name.compareTo(o.name);
        }
}