Module com.miglayout.core
Package net.miginfocom.layout

Class ConstraintParser

java.lang.Object
net.miginfocom.layout.ConstraintParser
public final class ConstraintParser extends Object
Parses string constraints.

  • Constructor Details

    • ConstraintParser

      private ConstraintParser()

  • Method Details

    • parseLayoutConstraint

      public static LC parseLayoutConstraint(String s)
      Parses the layout constraints and stores the parsed values in the transient (cache) member variables.
      Parameters:
      s - The String to parse. Should not be null and must be lower case and trimmed.
      Returns:
      The parsed constraint. Never null.
      Throws:
      RuntimeException - if the constraint was not valid.

    • parseRowConstraints

      public static AC parseRowConstraints(String s)
      Parses the column or rows constraints. They normally looks something like "[min:pref]rel[10px][]".
      Parameters:
      s - The string to parse. Not null.
      Returns:
      An array of DimConstraints that is as many are there exist "[...]" sections in the string that is parsed.
      Throws:
      RuntimeException - if the constraint was not valid.

    • parseColumnConstraints

      public static AC parseColumnConstraints(String s)
      Parses the column or rows constraints. They normally looks something like "[min:pref]rel[10px][]".
      Parameters:
      s - The string to parse. Not null.
      Returns:
      An array of DimConstraints that is as many are there exist "[...]" sections in the string that is parsed.
      Throws:
      RuntimeException - if the constraint was not valid.

    • parseAxisConstraint

      private static AC parseAxisConstraint(String s, boolean isCols)
      Parses the column or rows constraints. They normally looks something like "[min:pref]rel[10px][]".
      Parameters:
      s - The string to parse. Not null.
      isCols - If this for columns rather than rows.
      Returns:
      An array of DimConstraints that is as many are there exist "[...]" sections in the string that is parsed.
      Throws:
      RuntimeException - if the constraint was not valid.

    • parseDimConstraint

      private static DimConstraint parseDimConstraint(String s, BoundSize gapBefore, BoundSize gapAfter, boolean isCols)
      Parses a single column or row constraint.
      Parameters:
      s - The single constraint to parse. May look something like "min:pref,fill,grow". Should not be null and must be lower case and trimmed.
      gapBefore - The default gap "before" the column/row constraint. Can be overridden with a "gap" section within s.
      gapAfter - The default gap "after" the column/row constraint. Can be overridden with a "gap" section within s.
      isCols - If the constraints are column constraints rather than row constraints.
      Returns:
      A single constraint. Never null.
      Throws:
      RuntimeException - if the constraint was not valid.

    • parseComponentConstraints

      public static Map<ComponentWrapper,CC> parseComponentConstraints(Map<ComponentWrapper,String> constrMap)
      Parses all component constraints and stores the parsed values in the transient (cache) member variables.
      Parameters:
      constrMap - The constraints as Strings. Strings must be lower case and trimmed
      Returns:
      The parsed constraints. Never null.

    • parseComponentConstraint

      public static CC parseComponentConstraint(String s)
      Parses one component constraint and returns the parsed value.
      Parameters:
      s - The string to parse. Must be lower case and trimmed.
      Returns:
      The parsed constraint. Never null.
      Throws:
      RuntimeException - if the constraint was not valid.

    • parseInsets

      public static UnitValue[] parseInsets(String s, boolean acceptPanel)
      Parses insets which consists of 1-4 UnitValues.
      Parameters:
      s - The string to parse. E.g. "10 10 10 10" or "20". If less than 4 groups the last will be used for the missing.
      acceptPanel - If "panel" and "dialog" should be accepted. They are used to access platform defaults.
      Returns:
      An array of length 4 with the parsed insets.
      Throws:
      IllegalArgumentException - if the parsing could not be done.

    • parseGaps

      private static BoundSize[] parseGaps(String s)
      Parses gaps.
      Parameters:
      s - The string that contains gap information. Should start with "gap".
      Returns:
      The gaps as specified in s. Indexed: [top,left,bottom,right][min,pref,max] or [before,after][min,pref,max] if oneDim is true.

    • parseSpan

      private static int parseSpan(String s)

    • parseFloat

      private static Float parseFloat(String s, Float nullVal)

    • parseBoundSize

      public static BoundSize parseBoundSize(String s, boolean isGap, boolean isHor)
      Parses a single "min:pref:max" value. May look something like "10px:20lp:30%" or "pref!".
      Parameters:
      s - The string to parse. Not null.
      isGap - If this bound size is a gap (different empty string handling).
      isHor - If the size is for the horizontal dimension.
      Returns:
      A bound size that may be null if the string was "null", "n" or null.

    • parseUnitValueOrAlign

      public static UnitValue parseUnitValueOrAlign(String s, boolean isHor, UnitValue emptyReplacement)
      Parses a single unit value that may also be an alignment as parsed by parseAlignKeywords(String, boolean).
      Parameters:
      s - The string to parse. Not null. May look something like "10px" or "5dlu".
      isHor - If the value is for the horizontal dimension.
      emptyReplacement - A replacement if s is empty. May be null.
      Returns:
      The parsed unit value. May be null.

    • parseUnitValue

      public static UnitValue parseUnitValue(String s, boolean isHor)
      Parses a single unit value. E.g. "10px" or "5in"
      Parameters:
      s - The string to parse. Not null. May look something like "10px" or "5dlu".
      isHor - If the value is for the horizontal dimension.
      Returns:
      The parsed unit value. null is empty string,

    • parseUnitValue

      private static UnitValue parseUnitValue(String s, UnitValue emptyReplacement, boolean isHor)
      Parses a single unit value.
      Parameters:
      s - The string to parse. May be null. May look something like "10px" or "5dlu".
      emptyReplacement - A replacement s is empty or null. May be null.
      isHor - If the value is for the horizontal dimension.
      Returns:
      The parsed unit value. May be null.

    • parseAlignKeywords

      static UnitValue parseAlignKeywords(String s, boolean isHor)
      Parses alignment keywords and returns the appropriate UnitValue.
      Parameters:
      s - The string to parse. Not null.
      isHor - If alignments for horizontal is checked. false means vertical.
      Returns:
      The unit value or null if not recognized (no exception).

    • getNumTextParts

      private static String[] getNumTextParts(String s)
      Splits a text-number combination such as "hello 10.0" into {"hello", "10.0"}.
      Parameters:
      s - The string to split. Not null. Needs be be reasonably formatted since the method only finds the first 0-9 or . and cuts the string in half there.
      Returns:
      Always length 2 and no null elements. Elements are "" if no part found.

    • getOper

      private static int getOper(String s)
      Returns the operation depending on the start character.
      Parameters:
      s - The string to check. Not null.
      Returns:
      E.g. UnitValue.ADD, UnitValue.SUB or UnitValue.STATIC. Returns negative value for in-line operations.

    • startsWithLenient

      private static int startsWithLenient(String s, String[] matches, int[] minChars, boolean acceptTrailing)
      Returns if a string shares at least a specified numbers starting characters with a number of matches.

      This method just exercise startsWithLenient(String, String, int, boolean) with every one of matches and minChars.

      Parameters:
      s - The string to check. Not null.
      matches - A number of possible starts for s.
      minChars - The minimum number of characters to match for every element in matches. Needs to be of same length as matches. Can be null.
      acceptTrailing - If after the required number of characters are matched on recognized characters that are not in one of the the matches string should be accepted. For instance if "abczz" should be matched with "abcdef" and min chars 3.
      Returns:
      The index of the first unmatched character if minChars was reached or -1 if a match was not found.

    • startsWithLenient

      private static int startsWithLenient(String s, String match, int minChars, boolean acceptTrailing)
      Returns if a string shares at least a specified numbers starting characters with a match.
      Parameters:
      s - The string to check. Not null and must be trimmed.
      match - The possible start for s. Not null and must be trimmed.
      minChars - The mimimum number of characters to match to s for it this to be considered a match. -1 means the full length of match.
      acceptTrailing - If after the required number of charecters are matched unrecognized characters that are not in one of the the matches string should be accepted. For instance if "abczz" should be matched with "abcdef" and min chars 3.
      Returns:
      The index of the first unmatched character if minChars was reached or -1 if a match was not found.

    • toTrimmedTokens

      private static String[] toTrimmedTokens(String s, char sep)
      Parses a string and returns it in those parts of the string that are separated with a sep character.

      separator characters within parentheses will not be counted or handled in any way, whatever the depth.

      A space separator will be a hit to one or more spaces and thus not return empty strings.

      Parameters:
      s - The string to parse. If it starts and/or ends with a sep the first and/or last element returned will be "". If two sep are next to each other and empty element will be "between" the periods. The sep themselves will never be returned.
      sep - The separator char.
      Returns:
      Those parts of the string that are separated with sep. Never null and at least of size 1
      Since:
      6.7.2 Changed so more than one space in a row works as one space.

    • getRowColAndGapsTrimmed

      private static ArrayList<String> getRowColAndGapsTrimmed(String s)
      Parses "AAA[BBB]CCC[DDD]EEE" into {"AAA", "BBB", "CCC", "DDD", "EEE", "FFF"}. Handles empty parts. Will always start and end outside a [] block so that the number of returned elemets will always be uneven and at least of length 3.

      "|" is interpreted as "][".

      Parameters:
      s - The string. Might be "" but not null. Should be trimmed.
      Returns:
      The string divided into elements. Never null and at least of length 3.
      Throws:
      IllegalArgumentException - If a [] mismatch of some kind. (If not same [ as ] count or if the interleave.)

    • prepare

      public static String prepare(String s)
      Makes null "", trims and converts to lower case.
      Parameters:
      s - The string
      Returns:
      Not null.