Datasets:

CM

/

codexglue_code2text_java

like 2

[ "private", "static", "void", "exportSymbols", "(", "SymbolTable", "syms", ",", "String", "filename", ")", "{", "if", "(", "syms", "==", "null", ")", "{", "return", ";", "}", "try", "(", "PrintWriter", "out", "=", "new", "PrintWriter", "(", "new", "FileWriter", "(", "filename", ")", ")", ")", "{", "for", "(", "ObjectIntCursor", "<", "String", ">", "sym", ":", "syms", ")", "{", "out", ".", "println", "(", "sym", ".", "key", "+", "\"\\t\"", "+", "sym", ".", "value", ")", ";", "}", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Exports", "a", "symbols", "map", "to", "the", "openfst", "text", "format" ]

[ "private", "static", "Optional", "<", "MutableSymbolTable", ">", "importSymbols", "(", "String", "filename", ")", "{", "URL", "resource", ";", "try", "{", "resource", "=", "Resources", ".", "getResource", "(", "filename", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "return", "Optional", ".", "absent", "(", ")", ";", "}", "return", "importSymbolsFrom", "(", "asCharSource", "(", "resource", ",", "Charsets", ".", "UTF_8", ")", ")", ";", "}" ]

[ "Imports", "an", "openfst", "s", "symbols", "file" ]

[ "public", "static", "<", "W", ",", "S", "extends", "GenericSemiring", "<", "W", ">", ">", "UnionSemiring", "<", "W", ",", "S", ">", "makeForOrdering", "(", "S", "weightSemiring", ",", "Ordering", "<", "W", ">", "ordering", ",", "MergeStrategy", "<", "W", ">", "merge", ")", "{", "return", "makeForOrdering", "(", "weightSemiring", ",", "ordering", ",", "merge", ",", "UnionMode", ".", "NORMAL", ")", ";", "}" ]

[ "Creates", "a", "new", "union", "semirng", "for", "the", "given", "underlying", "weight", "semiring", "and", "ordering" ]

[ "@", "Override", "public", "GallicWeight", "commonDivisor", "(", "GallicWeight", "a", ",", "GallicWeight", "b", ")", "{", "double", "newWeight", "=", "this", ".", "weightSemiring", ".", "plus", "(", "a", ".", "getWeight", "(", ")", ",", "b", ".", "getWeight", "(", ")", ")", ";", "if", "(", "isZero", "(", "a", ")", ")", "{", "if", "(", "isZero", "(", "b", ")", ")", "{", "return", "zero", ";", "}", "if", "(", "b", ".", "getLabels", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "return", "GallicWeight", ".", "create", "(", "GallicWeight", ".", "EMPTY", ",", "newWeight", ")", ";", "}", "// just the first char of b", "return", "GallicWeight", ".", "createSingleLabel", "(", "b", ".", "getLabels", "(", ")", ".", "get", "(", "0", ")", ",", "newWeight", ")", ";", "}", "else", "if", "(", "isZero", "(", "b", ")", ")", "{", "if", "(", "a", ".", "getLabels", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "return", "GallicWeight", ".", "create", "(", "GallicWeight", ".", "EMPTY", ",", "newWeight", ")", ";", "}", "// just the first char of a", "return", "GallicWeight", ".", "createSingleLabel", "(", "a", ".", "getLabels", "(", ")", ".", "get", "(", "0", ")", ",", "newWeight", ")", ";", "}", "else", "{", "// neither are zero, emit one char if they share it, otherwise empty", "if", "(", "a", ".", "getLabels", "(", ")", ".", "isEmpty", "(", ")", "||", "b", ".", "getLabels", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "return", "GallicWeight", ".", "create", "(", "GallicWeight", ".", "EMPTY", ",", "newWeight", ")", ";", "}", "if", "(", "a", ".", "getLabels", "(", ")", ".", "get", "(", "0", ")", "==", "b", ".", "getLabels", "(", ")", ".", "get", "(", "0", ")", ")", "{", "return", "GallicWeight", ".", "createSingleLabel", "(", "a", ".", "getLabels", "(", ")", ".", "get", "(", "0", ")", ",", "newWeight", ")", ";", "}", "return", "GallicWeight", ".", "create", "(", "GallicWeight", ".", "EMPTY", ",", "newWeight", ")", ";", "}", "}" ]

[ "In", "this", "gallic", "semiring", "we", "restrict", "the", "common", "divisor", "to", "only", "be", "the", "first", "character", "in", "the", "stringweight", "In", "more", "general", "real", "-", "time", "FSTs", "that", "support", "substrings", "this", "could", "be", "longer", "but", "openfst", "doesn", "t", "support", "this", "and", "we", "don", "t", "support", "this" ]

[ "public", "static", "MutableFst", "reverse", "(", "Fst", "infst", ")", "{", "infst", ".", "throwIfInvalid", "(", ")", ";", "MutableFst", "fst", "=", "ExtendFinal", ".", "apply", "(", "infst", ")", ";", "Semiring", "semiring", "=", "fst", ".", "getSemiring", "(", ")", ";", "MutableFst", "result", "=", "new", "MutableFst", "(", "fst", ".", "getStateCount", "(", ")", ",", "semiring", ")", ";", "result", ".", "setInputSymbolsAsCopy", "(", "fst", ".", "getInputSymbols", "(", ")", ")", ";", "result", ".", "setOutputSymbolsAsCopy", "(", "fst", ".", "getOutputSymbols", "(", ")", ")", ";", "MutableState", "[", "]", "stateMap", "=", "initStateMap", "(", "fst", ",", "semiring", ",", "result", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "fst", ".", "getStateCount", "(", ")", ";", "i", "++", ")", "{", "State", "oldState", "=", "fst", ".", "getState", "(", "i", ")", ";", "MutableState", "newState", "=", "stateMap", "[", "oldState", ".", "getId", "(", ")", "]", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "oldState", ".", "getArcCount", "(", ")", ";", "j", "++", ")", "{", "Arc", "oldArc", "=", "oldState", ".", "getArc", "(", "j", ")", ";", "MutableState", "newNextState", "=", "stateMap", "[", "oldArc", ".", "getNextState", "(", ")", ".", "getId", "(", ")", "]", ";", "double", "newWeight", "=", "semiring", ".", "reverse", "(", "oldArc", ".", "getWeight", "(", ")", ")", ";", "result", ".", "addArc", "(", "newNextState", ",", "oldArc", ".", "getIlabel", "(", ")", ",", "oldArc", ".", "getOlabel", "(", ")", ",", "newState", ",", "newWeight", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Reverses", "an", "fst" ]

[ "public", "static", "MutableFst", "apply", "(", "Fst", "fst", ")", "{", "fst", ".", "throwIfInvalid", "(", ")", ";", "MutableFst", "copy", "=", "MutableFst", ".", "copyFrom", "(", "fst", ")", ";", "Semiring", "semiring", "=", "copy", ".", "getSemiring", "(", ")", ";", "ArrayList", "<", "MutableState", ">", "resultStates", "=", "initResultStates", "(", "copy", ",", "semiring", ")", ";", "// Add a new single final", "MutableState", "newFinal", "=", "new", "MutableState", "(", "semiring", ".", "one", "(", ")", ")", ";", "copy", ".", "addState", "(", "newFinal", ")", ";", "int", "epsILabel", "=", "copy", ".", "getInputSymbols", "(", ")", ".", "get", "(", "Fst", ".", "EPS", ")", ";", "int", "epsOLabel", "=", "copy", ".", "getOutputSymbols", "(", ")", ".", "get", "(", "Fst", ".", "EPS", ")", ";", "for", "(", "MutableState", "s", ":", "resultStates", ")", "{", "// add epsilon transition from the old final to the new one", "copy", ".", "addArc", "(", "s", ",", "epsILabel", ",", "epsOLabel", ",", "newFinal", ",", "s", ".", "getFinalWeight", "(", ")", ")", ";", "// set old state's weight to zero", "s", ".", "setFinalWeight", "(", "semiring", ".", "zero", "(", ")", ")", ";", "}", "return", "copy", ";", "}" ]

[ "Creates", "a", "new", "FST", "that", "is", "a", "copy", "of", "the", "existing", "with", "a", "new", "signle", "final", "state" ]

[ "public", "static", "WriteableSymbolTable", "symbolTableEffectiveCopy", "(", "SymbolTable", "syms", ")", "{", "if", "(", "syms", "instanceof", "ImmutableSymbolTable", ")", "{", "return", "new", "UnionSymbolTable", "(", "syms", ")", ";", "}", "if", "(", "syms", "instanceof", "UnionSymbolTable", ")", "{", "return", "UnionSymbolTable", ".", "copyFrom", "(", "(", "UnionSymbolTable", ")", "syms", ")", ";", "}", "if", "(", "syms", "instanceof", "FrozenSymbolTable", ")", "{", "return", "(", "FrozenSymbolTable", ")", "syms", ";", "}", "// maybe consider the size and if its \"big\" return a union of the mutable version?", "return", "new", "MutableSymbolTable", "(", "syms", ")", ";", "}" ]

[ "Returns", "an", "effective", "copy", "of", "the", "given", "symbol", "table", "which", "might", "be", "a", "unioned", "symbol", "table", "that", "is", "just", "a", "mutable", "filter", "on", "top", "of", "a", "backing", "table", "which", "is", "treated", "as", "immutable", "NOTE", "a", "frozen", "symbol", "table", "indicates", "that", "you", "do", "NOT", "want", "writes", "to", "be", "allowed" ]

[ "public", "static", "MutableFst", "remove", "(", "Fst", "fst", ")", "{", "Preconditions", ".", "checkNotNull", "(", "fst", ")", ";", "Preconditions", ".", "checkNotNull", "(", "fst", ".", "getSemiring", "(", ")", ")", ";", "Semiring", "semiring", "=", "fst", ".", "getSemiring", "(", ")", ";", "MutableFst", "result", "=", "MutableFst", ".", "emptyWithCopyOfSymbols", "(", "fst", ")", ";", "int", "iEps", "=", "fst", ".", "getInputSymbols", "(", ")", ".", "get", "(", "Fst", ".", "EPS", ")", ";", "int", "oEps", "=", "fst", ".", "getOutputSymbols", "(", ")", ".", "get", "(", "Fst", ".", "EPS", ")", ";", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "HashMap", "<", "Integer", ",", "Double", ">", "[", "]", "closure", "=", "new", "HashMap", "[", "fst", ".", "getStateCount", "(", ")", "]", ";", "MutableState", "[", "]", "oldToNewStateMap", "=", "new", "MutableState", "[", "fst", ".", "getStateCount", "(", ")", "]", ";", "State", "[", "]", "newToOldStateMap", "=", "new", "State", "[", "fst", ".", "getStateCount", "(", ")", "]", ";", "initResultStates", "(", "fst", ",", "result", ",", "oldToNewStateMap", ",", "newToOldStateMap", ")", ";", "addNonEpsilonArcs", "(", "fst", ",", "result", ",", "iEps", ",", "oEps", ",", "closure", ",", "oldToNewStateMap", ")", ";", "// augment fst with arcs generated from epsilon moves.", "for", "(", "int", "i", "=", "0", ";", "i", "<", "result", ".", "getStateCount", "(", ")", ";", "i", "++", ")", "{", "MutableState", "state", "=", "result", ".", "getState", "(", "i", ")", ";", "State", "oldState", "=", "newToOldStateMap", "[", "state", ".", "getId", "(", ")", "]", ";", "if", "(", "closure", "[", "oldState", ".", "getId", "(", ")", "]", "==", "null", ")", "{", "continue", ";", "}", "for", "(", "Integer", "pathFinalStateIndex", ":", "closure", "[", "oldState", ".", "getId", "(", ")", "]", ".", "keySet", "(", ")", ")", "{", "State", "closureState", "=", "fst", ".", "getState", "(", "pathFinalStateIndex", ")", ";", "if", "(", "semiring", ".", "isNotZero", "(", "closureState", ".", "getFinalWeight", "(", ")", ")", ")", "{", "Double", "prevWeight", "=", "getPathWeight", "(", "oldState", ",", "closureState", ",", "closure", ")", ";", "Preconditions", ".", "checkNotNull", "(", "prevWeight", ",", "\"problem with prev weight on closure from %s\"", ",", "oldState", ")", ";", "state", ".", "setFinalWeight", "(", "semiring", ".", "plus", "(", "state", ".", "getFinalWeight", "(", ")", ",", "semiring", ".", "times", "(", "prevWeight", ",", "closureState", ".", "getFinalWeight", "(", ")", ")", ")", ")", ";", "}", "for", "(", "int", "j", "=", "0", ";", "j", "<", "closureState", ".", "getArcCount", "(", ")", ";", "j", "++", ")", "{", "Arc", "arc", "=", "closureState", ".", "getArc", "(", "j", ")", ";", "if", "(", "(", "arc", ".", "getIlabel", "(", ")", "!=", "iEps", ")", "||", "(", "arc", ".", "getOlabel", "(", ")", "!=", "oEps", ")", ")", "{", "Double", "pathWeight", "=", "getPathWeight", "(", "oldState", ",", "closureState", ",", "closure", ")", ";", "Preconditions", ".", "checkNotNull", "(", "pathWeight", ",", "\"problem with prev weight on closure from %s\"", ",", "oldState", ")", ";", "double", "newWeight", "=", "semiring", ".", "times", "(", "arc", ".", "getWeight", "(", ")", ",", "pathWeight", ")", ";", "MutableState", "nextState", "=", "oldToNewStateMap", "[", "arc", ".", "getNextState", "(", ")", ".", "getId", "(", ")", "]", ";", "result", ".", "addArc", "(", "state", ",", "arc", ".", "getIlabel", "(", ")", ",", "arc", ".", "getOlabel", "(", ")", ",", "nextState", ",", "newWeight", ")", ";", "}", "}", "}", "}", "Connect", ".", "apply", "(", "result", ")", ";", "ArcSort", ".", "sortByInput", "(", "result", ")", ";", "return", "result", ";", "}" ]

[ "Removes", "epsilon", "transitions", "from", "an", "fst", ".", "Returns", "a", "new", "epsilon", "-", "free", "fst", "and", "does", "not", "modify", "the", "original", "fst" ]

[ "private", "static", "void", "put", "(", "State", "fromState", ",", "State", "toState", ",", "double", "weight", ",", "HashMap", "<", "Integer", ",", "Double", ">", "[", "]", "closure", ")", "{", "HashMap", "<", "Integer", ",", "Double", ">", "maybe", "=", "closure", "[", "fromState", ".", "getId", "(", ")", "]", ";", "if", "(", "maybe", "==", "null", ")", "{", "maybe", "=", "new", "HashMap", "<", "Integer", ",", "Double", ">", "(", ")", ";", "closure", "[", "fromState", ".", "getId", "(", ")", "]", "=", "maybe", ";", "}", "maybe", ".", "put", "(", "toState", ".", "getId", "(", ")", ",", "weight", ")", ";", "}" ]

[ "Put", "a", "new", "state", "in", "the", "epsilon", "closure" ]

[ "private", "static", "void", "add", "(", "State", "fromState", ",", "State", "toState", ",", "double", "weight", ",", "HashMap", "<", "Integer", ",", "Double", ">", "[", "]", "closure", ",", "Semiring", "semiring", ")", "{", "Double", "old", "=", "getPathWeight", "(", "fromState", ",", "toState", ",", "closure", ")", ";", "if", "(", "old", "==", "null", ")", "{", "put", "(", "fromState", ",", "toState", ",", "weight", ",", "closure", ")", ";", "}", "else", "{", "put", "(", "fromState", ",", "toState", ",", "semiring", ".", "plus", "(", "weight", ",", "old", ")", ",", "closure", ")", ";", "}", "}" ]

[ "Add", "a", "state", "in", "the", "epsilon", "closure" ]

[ "private", "static", "void", "calculateClosure", "(", "Fst", "fst", ",", "State", "state", ",", "HashMap", "<", "Integer", ",", "Double", ">", "[", "]", "closure", ",", "Semiring", "semiring", ",", "int", "iEps", ",", "int", "oEps", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "state", ".", "getArcCount", "(", ")", ";", "j", "++", ")", "{", "Arc", "arc", "=", "state", ".", "getArc", "(", "j", ")", ";", "if", "(", "(", "arc", ".", "getIlabel", "(", ")", "!=", "iEps", ")", "||", "(", "arc", ".", "getOlabel", "(", ")", "!=", "oEps", ")", ")", "{", "continue", ";", "}", "int", "nextStateId", "=", "arc", ".", "getNextState", "(", ")", ".", "getId", "(", ")", ";", "if", "(", "closure", "[", "nextStateId", "]", "==", "null", ")", "{", "calculateClosure", "(", "fst", ",", "arc", ".", "getNextState", "(", ")", ",", "closure", ",", "semiring", ",", "iEps", ",", "oEps", ")", ";", "}", "HashMap", "<", "Integer", ",", "Double", ">", "closureEntry", "=", "closure", "[", "nextStateId", "]", ";", "if", "(", "closureEntry", "!=", "null", ")", "{", "for", "(", "Integer", "pathFinalStateIndex", ":", "closureEntry", ".", "keySet", "(", ")", ")", "{", "State", "pathFinalState", "=", "fst", ".", "getState", "(", "pathFinalStateIndex", ")", ";", "Double", "prevPathWeight", "=", "getPathWeight", "(", "arc", ".", "getNextState", "(", ")", ",", "pathFinalState", ",", "closure", ")", ";", "Preconditions", ".", "checkNotNull", "(", "prevPathWeight", ",", "\"prev arc %s never set in closure\"", ",", "arc", ")", ";", "double", "newPathWeight", "=", "semiring", ".", "times", "(", "prevPathWeight", ",", "arc", ".", "getWeight", "(", ")", ")", ";", "add", "(", "state", ",", "pathFinalState", ",", "newPathWeight", ",", "closure", ",", "semiring", ")", ";", "}", "}", "add", "(", "state", ",", "arc", ".", "getNextState", "(", ")", ",", "arc", ".", "getWeight", "(", ")", ",", "closure", ",", "semiring", ")", ";", "}", "}" ]

[ "Calculate", "the", "epsilon", "closure" ]

[ "@", "Nullable", "private", "static", "Double", "getPathWeight", "(", "State", "inState", ",", "State", "outState", ",", "HashMap", "<", "Integer", ",", "Double", ">", "[", "]", "closure", ")", "{", "if", "(", "closure", "[", "inState", ".", "getId", "(", ")", "]", "!=", "null", ")", "{", "return", "closure", "[", "inState", ".", "getId", "(", ")", "]", ".", "get", "(", "outState", ".", "getId", "(", ")", ")", ";", "}", "return", "null", ";", "}" ]

[ "Get", "an", "epsilon", "path", "s", "cost", "in", "epsilon", "closure" ]

[ "public", "static", "int", "maxIdIn", "(", "SymbolTable", "table", ")", "{", "int", "max", "=", "0", ";", "for", "(", "ObjectIntCursor", "<", "String", ">", "cursor", ":", "table", ")", "{", "max", "=", "Math", ".", "max", "(", "max", ",", "cursor", ".", "value", ")", ";", "}", "return", "max", ";", "}" ]

[ "Returns", "the", "current", "max", "id", "mapped", "in", "this", "symbol", "table", "or", "0", "if", "this", "has", "no", "mappings" ]

[ "@", "Override", "public", "int", "get", "(", "String", "symbol", ")", "{", "int", "id", "=", "symbolToId", ".", "getOrDefault", "(", "symbol", ",", "-", "1", ")", ";", "if", "(", "id", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"No symbol exists for key \"", "+", "symbol", ")", ";", "}", "return", "id", ";", "}" ]

[ "Returns", "the", "id", "of", "the", "symbol", "or", "throws", "an", "exception", "if", "this", "symbol", "isnt", "in", "the", "table" ]

[ "public", "static", "InetAddress", "getAddress", "(", ")", "{", "try", "{", "return", "InetAddress", ".", "getByAddress", "(", "new", "byte", "[", "]", "{", "0", ",", "0", ",", "0", ",", "0", "}", ")", ";", "/*for (Enumeration e = NetworkInterface.getNetworkInterfaces();\n e.hasMoreElements();) {\n\n NetworkInterface ni = (NetworkInterface) e.nextElement();\n System.out.println(\"NetworkInterface = \" + ni.getName());\n if (!ni.getName().contains(\"lo\")) {\n for (Enumeration ee = ni.getInetAddresses(); ee.hasMoreElements();) {\n InetAddress ip = (InetAddress) ee.nextElement();\n if (ip instanceof Inet4Address && ip.getAddress() != null) {\n return ip;\n }\n //System.out.println(\"Ip's: \" + ip.getHostAddress());\n }\n }\n }\n NetworkInterface lo = NetworkInterface.getByName(\"lo\");\n if (lo != null) {\n for (Enumeration ee = lo.getInetAddresses(); ee.hasMoreElements();) {\n InetAddress ip = (InetAddress) ee.nextElement();\n if (ip instanceof Inet4Address && ip.getAddress() != null) {\n return ip;\n }\n }\n }\n \n NetworkInterface lo0 = NetworkInterface.getByName(\"lo0\");\n if (lo0 != null) {\n for (Enumeration ee = lo0.getInetAddresses(); ee.hasMoreElements();) {\n InetAddress ip = (InetAddress) ee.nextElement();\n if (ip instanceof Inet4Address && ip.getAddress() != null) {\n return ip;\n }\n }\n }*/", "}", "catch", "(", "Exception", "e", ")", "{", "System", ".", "err", ".", "println", "(", "\"Error\"", ")", ";", "}", "return", "null", ";", "}" ]

[ "This", "method", "returns", "the", "address", "of", "the", "machine", ".", "It", "is", "needed", "to", "successfully", "communicate", "with", "emulators", "hosted", "into", "other", "machines", "." ]

[ "public", "void", "setCalendar", "(", "int", "year", ",", "int", "month", ",", "int", "dayOfMonth", ",", "int", "hour", ",", "int", "minute", ",", "int", "second", ")", "{", "this", ".", "year", "=", "year", ";", "this", ".", "month", "=", "month", ";", "this", ".", "dayOfMonth", "=", "dayOfMonth", ";", "this", ".", "hour", "=", "hour", ";", "this", ".", "minute", "=", "minute", ";", "this", ".", "second", "=", "second", ";", "this", ".", "createCalendar", "(", ")", ";", "}" ]

[ "It", "sets", "the", "simulation", "time", "." ]

[ "public", "void", "addValue", "(", "long", "newValue", ")", "{", "// keep a \"total\" timer for all values\r", "InApplicationMonitor", ".", "getInstance", "(", ")", ".", "addTimerMeasurement", "(", "timerName", ",", "newValue", ")", ";", "// keep track of the current maximum value\r", "if", "(", "newValue", ">", "currentMaxValue", ")", "{", "currentMaxValue", "=", "newValue", ";", "}", "// select the bin to put this value in\r", "long", "binIndex", ";", "if", "(", "newValue", ">", "maxLimit", ")", "{", "binIndex", "=", "maxLimit", "/", "factor", ";", "}", "else", "{", "binIndex", "=", "newValue", "/", "factor", ";", "}", "// add the new value to the appropriate bin\r", "String", "binName", "=", "getBinName", "(", "binIndex", ")", ";", "InApplicationMonitor", ".", "getInstance", "(", ")", ".", "incrementCounter", "(", "binName", ")", ";", "}" ]

[ "adds", "a", "new", "value", "to", "the", "InApplicationMonitor", "grouping", "it", "into", "the", "appropriate", "bin", "." ]

[ "public", "boolean", "evaluate", "(", "Agent", "agent", ")", "{", "long", "t", "=", "agent", ".", "getAgentsAppState", "(", ")", ".", "getPHAInterface", "(", ")", ".", "getSimTime", "(", ")", ".", "getTimeInMillis", "(", ")", ";", "if", "(", "t", "!=", "timestamp", ")", "{", "timestamp", "=", "t", ";", "evaluation", "=", "simpleEvaluation", "(", "agent", ")", ";", "}", "return", "evaluation", ";", "}" ]

[ "It", "tells", "if", "the", "condition", "is", "met" ]

[ "private", "void", "registerJMXStuff", "(", ")", "{", "LOG", ".", "info", "(", "\"registering InApplicationMonitorDynamicMBean on JMX server\"", ")", ";", "try", "{", "jmxBeanRegistrationHelper", ".", "registerMBeanOnJMX", "(", "this", ",", "\"InApplicationMonitor\"", ",", "null", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "error", "(", "\"could not register MBean server : \"", ",", "e", ")", ";", "}", "}" ]

[ "registers", "the", "InApplicationMonitor", "as", "JMX", "MBean", "on", "the", "running", "JMX", "server", "-", "if", "no", "JMX", "server", "is", "running", "one", "is", "started", "automagically", "." ]

[ "public", "static", "Geometry", "createCube", "(", "Vector3f", "dimensions", ",", "ColorRGBA", "color", ")", "{", "checkInit", "(", ")", ";", "Box", "b", "=", "new", "Box", "(", "dimensions", ".", "getX", "(", ")", ",", "dimensions", ".", "getY", "(", ")", ",", "dimensions", ".", "getZ", "(", ")", ")", ";", "// create cube shape at the origin", "Geometry", "geom", "=", "new", "Geometry", "(", "\"Box\"", ",", "b", ")", ";", "// create cube geometry from the shape", "Material", "mat", "=", "new", "Material", "(", "assetManager", ",", "\"Common/MatDefs/Misc/Unshaded.j3md\"", ")", ";", "// create a simple material", "mat", ".", "setColor", "(", "\"Color\"", ",", "color", ")", ";", "// set color of material to blue", "geom", ".", "setMaterial", "(", "mat", ")", ";", "// set the cube's material", "return", "geom", ";", "}" ]

[ "Creates", "a", "cube", "given", "its", "dimensions", "and", "its", "color" ]

[ "public", "static", "Geometry", "createShape", "(", "String", "name", ",", "Mesh", "shape", ",", "ColorRGBA", "color", ")", "{", "checkInit", "(", ")", ";", "Geometry", "g", "=", "new", "Geometry", "(", "name", ",", "shape", ")", ";", "Material", "mat", "=", "new", "Material", "(", "assetManager", ",", "\"Common/MatDefs/Misc/Unshaded.j3md\"", ")", ";", "mat", ".", "getAdditionalRenderState", "(", ")", ".", "setWireframe", "(", "true", ")", ";", "mat", ".", "setColor", "(", "\"Color\"", ",", "color", ")", ";", "g", ".", "setMaterial", "(", "mat", ")", ";", "return", "g", ";", "}" ]

[ "Creates", "a", "geometry", "given", "its", "name", "its", "mesh", "and", "its", "color" ]

[ "public", "static", "BitmapText", "attachAName", "(", "Node", "node", ",", "String", "name", ")", "{", "checkInit", "(", ")", ";", "BitmapFont", "guiFont", "=", "assetManager", ".", "loadFont", "(", "\"Interface/Fonts/Default.fnt\"", ")", ";", "BitmapText", "ch", "=", "new", "BitmapText", "(", "guiFont", ",", "false", ")", ";", "ch", ".", "setName", "(", "\"BitmapText\"", ")", ";", "ch", ".", "setSize", "(", "guiFont", ".", "getCharSet", "(", ")", ".", "getRenderedSize", "(", ")", "*", "0.02f", ")", ";", "ch", ".", "setText", "(", "name", ")", ";", "// crosshairs", "ch", ".", "setColor", "(", "new", "ColorRGBA", "(", "0f", ",", "0f", ",", "0f", ",", "1f", ")", ")", ";", "ch", ".", "getLocalScale", "(", ")", ".", "divideLocal", "(", "node", ".", "getLocalScale", "(", ")", ")", ";", "// controlador para que los objetos miren a la cámara.", "BillboardControl", "control", "=", "new", "BillboardControl", "(", ")", ";", "ch", ".", "addControl", "(", "control", ")", ";", "node", ".", "attachChild", "(", "ch", ")", ";", "return", "ch", ";", "}" ]

[ "Creates", "a", "geometry", "with", "the", "same", "name", "of", "the", "given", "node", ".", "It", "adds", "a", "controller", "called", "BillboardControl", "that", "turns", "the", "name", "of", "the", "node", "in", "order", "to", "look", "at", "the", "camera", "." ]

[ "public", "void", "setFilePath", "(", "String", "filePath", ")", "{", "this", ".", "filePath", "=", "filePath", ";", "if", "(", "!", "this", ".", "filePath", ".", "endsWith", "(", "File", ".", "separator", ")", ")", "{", "this", ".", "filePath", "+=", "File", ".", "separator", ";", "}", "}" ]

[ "Set", "the", "file", "path", "to", "store", "the", "screenshot", ".", "Include", "the", "seperator", "at", "the", "end", "of", "the", "path", ".", "Use", "an", "emptry", "string", "to", "use", "the", "application", "folder", ".", "Use", "NULL", "to", "use", "the", "system", "default", "storage", "folder", "." ]

[ "public", "void", "addReportableObserver", "(", "final", "ReportableObserver", "reportableObserver", ")", "{", "reportableObservers", ".", "add", "(", "reportableObserver", ")", ";", "LOGGER", ".", "info", "(", "\"registering new ReportableObserver (\"", "+", "reportableObserver", ".", "getClass", "(", ")", ".", "getName", "(", ")", "+", "\")\"", ")", ";", "// iterate over all reportables that are registered already and call the observer for each one of them", "reportInto", "(", "new", "ReportVisitor", "(", ")", "{", "public", "void", "notifyReportableObserver", "(", "Reportable", "reportable", ")", "{", "reportableObserver", ".", "addNewReportable", "(", "reportable", ")", ";", "}", "@", "Override", "public", "void", "reportCounter", "(", "Counter", "counter", ")", "{", "notifyReportableObserver", "(", "counter", ")", ";", "}", "@", "Override", "public", "void", "reportTimer", "(", "Timer", "timer", ")", "{", "notifyReportableObserver", "(", "timer", ")", ";", "}", "@", "Override", "public", "void", "reportStateValue", "(", "StateValueProvider", "stateValueProvider", ")", "{", "notifyReportableObserver", "(", "stateValueProvider", ")", ";", "}", "@", "Override", "public", "void", "reportMultiValue", "(", "MultiValueProvider", "multiValueProvider", ")", "{", "notifyReportableObserver", "(", "multiValueProvider", ")", ";", "}", "@", "Override", "public", "void", "reportHistorizableList", "(", "HistorizableList", "historizableList", ")", "{", "notifyReportableObserver", "(", "historizableList", ")", ";", "}", "@", "Override", "public", "void", "reportVersion", "(", "Version", "version", ")", "{", "notifyReportableObserver", "(", "version", ")", ";", "}", "}", ")", ";", "}" ]

[ "adds", "a", "new", "ReportableObserver", "that", "wants", "to", "be", "notified", "about", "new", "Reportables", "that", "are", "registered", "on", "the", "InApplicationMonitor" ]

[ "HistorizableList", "getHistorizableList", "(", "final", "String", "name", ")", "{", "return", "historizableLists", ".", "get", "(", "name", ",", "new", "Monitors", ".", "Factory", "<", "HistorizableList", ">", "(", ")", "{", "@", "Override", "public", "HistorizableList", "createMonitor", "(", ")", "{", "return", "new", "HistorizableList", "(", "name", ",", "maxHistoryEntriesToKeep", ")", ";", "}", "}", ")", ";", "}" ]

[ "internally", "used", "method", "to", "retrieve", "or", "create", "and", "register", "a", "named", "HistorizableList", "." ]

[ "public", "void", "initializeCounter", "(", "String", "name", ")", "{", "String", "escapedName", "=", "keyHandler", ".", "handle", "(", "name", ")", ";", "for", "(", "MonitorPlugin", "p", ":", "getPlugins", "(", ")", ")", "{", "p", ".", "initializeCounter", "(", "escapedName", ")", ";", "}", "}" ]

[ "If", "you", "want", "to", "ensure", "existance", "of", "a", "counter", "for", "example", "you", "want", "to", "prevent", "spelling", "errors", "in", "an", "operational", "monitoring", "configuration", "you", "may", "initialize", "a", "counter", "using", "this", "method", ".", "The", "plugins", "will", "decide", "how", "to", "handle", "this", "initialization", "." ]

[ "public", "void", "registerAllPossibleTransition", "(", "Automaton", "[", "]", "states", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "states", ".", "length", ";", "i", "++", ")", "{", "for", "(", "int", "j", "=", "i", ";", "j", "<", "states", ".", "length", ";", "j", "++", ")", "{", "registerTransition", "(", "states", "[", "i", "]", ",", "states", "[", "j", "]", ")", ";", "registerTransition", "(", "states", "[", "j", "]", ",", "states", "[", "i", "]", ")", ";", "}", "}", "}" ]

[ "Pasandole", "un", "array", "genera", "todas", "las", "transiciones", "posibles", "entre", "los", "estados", "." ]

[ "public", "ArrayList", "<", "Transition", ">", "possibleNextStates", "(", "Automaton", "source", ")", "{", "ArrayList", "<", "Transition", ">", "r", "=", "possibleTransitions", ".", "get", "(", "source", ")", ";", "if", "(", "r", "==", "null", ")", "{", "throw", "new", "UnsupportedOperationException", "(", "\"Not transitions registered from \"", "+", "source", ".", "getName", "(", ")", "+", "\", automaton \"", "+", "this", ".", "getName", "(", ")", ")", ";", "}", "ArrayList", "<", "Transition", ">", "activatedTransitions", "=", "new", "ArrayList", "<", "Transition", ">", "(", ")", ";", "for", "(", "Transition", "t", ":", "r", ")", "{", "if", "(", "t", ".", "evaluate", "(", ")", ")", "{", "activatedTransitions", ".", "add", "(", "t", ")", ";", "}", "}", ";", "return", "activatedTransitions", ";", "}" ]

[ "Dado", "un", "estado", "se", "devuelve", "una", "lista", "con", "los", "posibles", "estados", "que", "le", "siguen", "en", "el", "protocolo", "." ]

[ "public", "boolean", "createFile", "(", ")", "{", "try", "{", "try", "(", "FileWriter", "newDic", "=", "new", "FileWriter", "(", "path", "+", "\"/\"", "+", "name", "+", "\".\"", "+", "FILE_EXTENSION", ")", ";", "BufferedWriter", "bufWriter", "=", "new", "BufferedWriter", "(", "newDic", ")", ")", "{", "bufWriter", ".", "write", "(", "HEAD", ")", ";", "if", "(", "sentences", ".", "size", "(", ")", ">", "0", ")", "{", "bufWriter", ".", "write", "(", "\"public <sentence> = (\"", "+", "sentences", ".", "get", "(", "0", ")", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "sentences", ".", "size", "(", ")", ";", "i", "++", ")", "{", "bufWriter", ".", "write", "(", "\" | \"", "+", "sentences", ".", "get", "(", "i", ")", ")", ";", "}", "bufWriter", ".", "write", "(", "\" );\\n\"", ")", ";", "}", "bufWriter", ".", "flush", "(", ")", ";", "}", "return", "true", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "Logger", ".", "getLogger", "(", "GrammarFacilitator", ".", "class", ".", "getName", "(", ")", ")", ".", "log", "(", "Level", ".", "SEVERE", ",", "null", ",", "ex", ")", ";", "}", "return", "false", ";", "}" ]

[ "Create", "a", "file", "with", "the", "JSGF", "Grammar" ]

[ "@", "Override", "public", "void", "validate", "(", ")", "{", "// make sure the encoding is set..\r", "if", "(", "this", ".", "encoding", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"File encoding must not be null!\"", ")", ";", "}", "//make sure it's a valid charset\r", "Charset", ".", "forName", "(", "this", ".", "encoding", ")", ";", "// make sure the delimiter and the text qualifier are not the same..\r", "if", "(", "this", ".", "textQualifier", "==", "this", ".", "fieldDelimiter", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Field delimiter and text qualifier can not be equal!\"", ")", ";", "}", "// make sure file mask is set..\r", "if", "(", "StringUtil", ".", "isBlank", "(", "this", ".", "fileMask", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"File mask must not be blank!\"", ")", ";", "}", "// make sure source path is set..\r", "if", "(", "StringUtil", ".", "isBlank", "(", "this", ".", "sourcePath", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Source path must not be blank!\"", ")", ";", "}", "// make sure keyColumnName is set..\r", "if", "(", "this", ".", "keyColumnNames", "==", "null", "||", "this", ".", "keyColumnNames", ".", "length", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"key column name must not be blank!\"", ")", ";", "}", "// make sure fields is set..\r", "if", "(", "this", ".", "fields", "==", "null", "||", "this", ".", "fields", ".", "length", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Column names must not be blank!\"", ")", ";", "}", "// make sure key separator is set..\r", "if", "(", "StringUtil", ".", "isBlank", "(", "this", ".", "keyseparator", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"File mask must not be blank!\"", ")", ";", "}", "}" ]

[ "Determine", "if", "all", "the", "values", "are", "valid", "." ]

[ "public", "void", "run", "(", ")", "{", "try", "{", "StringBuffer", "sb", "=", "this", ".", "generateReport", "(", ")", ";", "ingenias", ".", "editor", ".", "Log", ".", "getInstance", "(", ")", ".", "log", "(", "\"Statistics of usage of meta-model entities and relationships\"", ")", ";", "ingenias", ".", "editor", ".", "Log", ".", "getInstance", "(", ")", ".", "log", "(", "\"Name Number of times it appears\"", ")", ";", "ingenias", ".", "editor", ".", "Log", ".", "getInstance", "(", ")", ".", "log", "(", "\"---- --------------------------\"", ")", ";", "ingenias", ".", "editor", ".", "Log", ".", "getInstance", "(", ")", ".", "log", "(", "sb", ".", "toString", "(", ")", ")", ";", "}", "catch", "(", "Exception", "ex", ")", "{", "ex", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "It", "creates", "stats", "of", "usage", "by", "traversing", "diagrams", "of", "your", "specification", ".", "Resulting", "report", "appears", "in", "standard", "output", "or", "in", "the", "IDE" ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "Advanced", "app", "=", "new", "Advanced", "(", ")", ";", "AppSettings", "settings", "=", "new", "AppSettings", "(", "true", ")", ";", "settings", ".", "setAudioRenderer", "(", "AurellemSystemDelegate", ".", "SEND", ")", ";", "JmeSystem", ".", "setSystemDelegate", "(", "new", "AurellemSystemDelegate", "(", ")", ")", ";", "app", ".", "setSettings", "(", "settings", ")", ";", "app", ".", "setShowSettings", "(", "false", ")", ";", "app", ".", "setPauseOnLostFocus", "(", "false", ")", ";", "/*try {\n //Capture.captureVideo(app, File.createTempFile(\"advanced\",\".avi\"));\n Capture.captureAudio(app, File.createTempFile(\"advanced\",\".wav\"));\n }\n catch (IOException e) {e.printStackTrace();}*/", "app", ".", "start", "(", ")", ";", "}" ]

[ "You", "will", "see", "three", "grey", "cubes", "a", "blue", "sphere", "and", "a", "path", "which", "circles", "each", "cube", ".", "The", "blue", "sphere", "is", "generating", "a", "constant", "monotone", "sound", "as", "it", "moves", "along", "the", "track", ".", "Each", "cube", "is", "listening", "for", "sound", ";", "when", "a", "cube", "hears", "sound", "whose", "intensity", "is", "greater", "than", "a", "certain", "threshold", "it", "changes", "its", "color", "from", "grey", "to", "green", "." ]

[ "public", "void", "add", "(", "SensorListener", "sensorListener", ")", "{", "if", "(", "!", "listeners", ".", "contains", "(", "sensorListener", ")", ")", "{", "listeners", ".", "add", "(", "sensorListener", ")", ";", "if", "(", "!", "isEnabled", "(", ")", ")", "{", "setEnabled", "(", "true", ")", ";", "}", "}", "}" ]

[ "Adds", "a", "sensor", "listener", "and", "the", "sensor", "is", "enabled", "if", "it", "was", "disabled", "in", "order", "to", "feed", "data", "to", "the", "listener" ]

[ "public", "void", "remove", "(", "SensorListener", "sensorListener", ")", "{", "listeners", ".", "remove", "(", "sensorListener", ")", ";", "if", "(", "listeners", ".", "isEmpty", "(", ")", "&&", "isEnabled", "(", ")", ")", "{", "setEnabled", "(", "false", ")", ";", "}", "}" ]

[ "Removes", "a", "listener", "and", "if", "there", "are", "not", "more", "listener", "the", "sensor", "is", "disabled", "in", "order", "to", "save", "resources" ]

[ "public", "Set", "<", "String", ">", "getDeadlockedThreads", "(", ")", "{", "final", "long", "[", "]", "threadIds", "=", "threads", ".", "findDeadlockedThreads", "(", ")", ";", "if", "(", "threadIds", "!=", "null", ")", "{", "final", "Set", "<", "String", ">", "threads", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "for", "(", "ThreadInfo", "info", ":", "this", ".", "threads", ".", "getThreadInfo", "(", "threadIds", ",", "MAX_STACK_TRACE_DEPTH", ")", ")", "{", "final", "StringBuilder", "stackTrace", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "StackTraceElement", "element", ":", "info", ".", "getStackTrace", "(", ")", ")", "{", "stackTrace", ".", "append", "(", "\"\\t at \"", ")", ".", "append", "(", "element", ".", "toString", "(", ")", ")", ".", "append", "(", "'", "'", ")", ";", "}", "threads", ".", "add", "(", "String", ".", "format", "(", "\"%s locked on %s (owned by %s):\\n%s\"", ",", "info", ".", "getThreadName", "(", ")", ",", "info", ".", "getLockName", "(", ")", ",", "info", ".", "getLockOwnerName", "(", ")", ",", "stackTrace", ".", "toString", "(", ")", ")", ")", ";", "}", "return", "Collections", ".", "unmodifiableSet", "(", "threads", ")", ";", "}", "return", "Collections", ".", "emptySet", "(", ")", ";", "}" ]

[ "Returns", "a", "set", "of", "strings", "describing", "deadlocked", "threads", "if", "any", "are", "deadlocked", "." ]

[ "private", "void", "filter", "(", "Vector3f", "acc", ")", "{", "float", "threshold", "=", "15f", ";", "if", "(", "acc", ".", "x", ">", "threshold", ")", "{", "acc", ".", "x", "=", "threshold", ";", "}", "else", "if", "(", "acc", ".", "x", "<", "-", "threshold", ")", "{", "acc", ".", "x", "=", "-", "threshold", ";", "}", "if", "(", "acc", ".", "y", ">", "threshold", ")", "{", "acc", ".", "y", "=", "threshold", ";", "}", "else", "if", "(", "acc", ".", "y", "<", "-", "threshold", ")", "{", "acc", ".", "y", "=", "-", "threshold", ";", "}", "if", "(", "acc", ".", "z", ">", "threshold", ")", "{", "acc", ".", "z", "=", "threshold", ";", "}", "else", "if", "(", "acc", ".", "z", "<", "-", "threshold", ")", "{", "acc", ".", "z", "=", "-", "threshold", ";", "}", "}" ]

[ "remove", "pointed", "values" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "static", "<", "E", ">", "E", "wrapObject", "(", "final", "Class", "<", "E", ">", "clazz", ",", "final", "Object", "target", ",", "final", "TimingReporter", "timingReporter", ")", "{", "return", "(", "E", ")", "Proxy", ".", "newProxyInstance", "(", "GenericMonitoringWrapper", ".", "class", ".", "getClassLoader", "(", ")", ",", "new", "Class", "[", "]", "{", "clazz", "}", ",", "new", "GenericMonitoringWrapper", "<", "E", ">", "(", "clazz", ",", "target", ",", "timingReporter", ")", ")", ";", "}" ]

[ "Wraps", "the", "given", "object", "and", "returns", "the", "reporting", "proxy", ".", "Uses", "the", "given", "timing", "reporter", "to", "report", "timings", "." ]

[ "@", "Override", "public", "Object", "invoke", "(", "Object", "proxy", ",", "Method", "method", ",", "Object", "[", "]", "args", ")", "/* CSOFF: IllegalThrows */", "throws", "Throwable", "/* CSON: IllegalThrows */", "{", "final", "long", "startTime", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "Object", "result", "=", "null", ";", "try", "{", "result", "=", "method", ".", "invoke", "(", "target", ",", "args", ")", ";", "if", "(", "(", "result", "!=", "null", ")", "&&", "!", "method", ".", "getReturnType", "(", ")", ".", "equals", "(", "Void", ".", "TYPE", ")", "&&", "method", ".", "getReturnType", "(", ")", ".", "isInterface", "(", ")", ")", "{", "result", "=", "wrapObject", "(", "method", ".", "getReturnType", "(", ")", ",", "result", ",", "reporter", ")", ";", "}", "}", "catch", "(", "InvocationTargetException", "t", ")", "{", "if", "(", "t", ".", "getCause", "(", ")", "!=", "null", ")", "{", "throw", "t", ".", "getCause", "(", ")", ";", "}", "}", "finally", "{", "final", "long", "endTime", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "reporter", ".", "reportTimedOperation", "(", "targetClass", ",", "method", ",", "startTime", ",", "endTime", ")", ";", "}", "return", "result", ";", "}" ]

[ "Handles", "method", "invocations", "on", "the", "generated", "proxy", ".", "Measures", "the", "time", "needed", "to", "execute", "the", "given", "method", "on", "the", "wrapped", "object", "." ]

[ "private", "boolean", "areNextStatesAvailable", "(", "Automaton", "source", ")", "{", "ArrayList", "<", "Transition", ">", "r", "=", "possibleTransitions", ".", "get", "(", "source", ")", ";", "if", "(", "r", "!=", "null", ")", "{", "for", "(", "Transition", "t", ":", "r", ")", "{", "if", "(", "t", ".", "evaluate", "(", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Return", "true", "if", "there", "are", "transitions", "available", "as", "true", "." ]

[ "public", "static", "boolean", "isMultiListener", "(", "String", "[", "]", "args", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "args", ".", "length", ";", "i", "++", ")", "{", "if", "(", "args", "[", "i", "]", ".", "equals", "(", "\"-ml\"", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Checks", "if", "arguments", "contains", "multilisterner", "option", "-", "lm" ]

[ "public", "static", "Collection", "<", "?", "extends", "GraphEntity", ">", "getAscendantsOfRole", "(", "GraphEntity", "ge", ")", "{", "Vector", "<", "GraphEntity", ">", "allAscendants", "=", "new", "Vector", "<", "GraphEntity", ">", "(", ")", ";", "try", "{", "Vector", "<", "GraphEntity", ">", "ascendants", "=", "Utils", ".", "getRelatedElementsVector", "(", "ge", ",", "\"ARoleInheritance\"", ",", "\"ARoleInheritancetarget\"", ")", ";", "while", "(", "!", "ascendants", ".", "isEmpty", "(", ")", ")", "{", "allAscendants", ".", "addAll", "(", "ascendants", ")", ";", "ascendants", ".", "clear", "(", ")", ";", "for", "(", "GraphEntity", "ascendant", ":", "allAscendants", ")", "{", "ascendants", ".", "addAll", "(", "Utils", ".", "getRelatedElementsVector", "(", "ascendant", ",", "\"ARoleInheritance\"", ",", "\"ARoleInheritancetarget\"", ")", ")", ";", "}", "ascendants", ".", "removeAll", "(", "allAscendants", ")", ";", "}", "}", "catch", "(", "NullEntity", "e", ")", "{", "// TODO Auto-generated catch block", "e", ".", "printStackTrace", "(", ")", ";", "}", "return", "allAscendants", ";", "}" ]

[ "It", "obtains", "all", "ascendants", "of", "a", "role", "through", "the", "ARoleInheritance", "relationship", "." ]

[ "public", "static", "Vector", "getRelatedElementsVector", "(", "String", "pathname", ",", "GraphEntity", "element", ",", "String", "relationshipname", ",", "String", "role", ")", "throws", "NullEntity", "{", "Vector", "rels", "=", "element", ".", "getAllRelationships", "(", ")", ";", "Enumeration", "enumeration", "=", "rels", ".", "elements", "(", ")", ";", "Vector", "related", "=", "new", "Vector", "(", ")", ";", "while", "(", "enumeration", ".", "hasMoreElements", "(", ")", ")", "{", "GraphRelationship", "gr", "=", "(", "GraphRelationship", ")", "enumeration", ".", "nextElement", "(", ")", ";", "String", "[", "]", "path", "=", "gr", ".", "getGraph", "(", ")", ".", "getPath", "(", ")", ";", "boolean", "found", "=", "false", ";", "for", "(", "int", "k", "=", "0", ";", "k", "<", "path", ".", "length", "&&", "!", "found", ";", "k", "++", ")", "{", "found", "=", "path", "[", "k", "]", ".", "toLowerCase", "(", ")", ".", "indexOf", "(", "pathname", ")", ">=", "0", ";", "}", "if", "(", "found", "&&", "gr", ".", "getType", "(", ")", ".", "toLowerCase", "(", ")", ".", "equals", "(", "relationshipname", ".", "toLowerCase", "(", ")", ")", ")", "{", "GraphRole", "[", "]", "roles", "=", "gr", ".", "getRoles", "(", ")", ";", "for", "(", "int", "k", "=", "0", ";", "k", "<", "roles", ".", "length", ";", "k", "++", ")", "{", "if", "(", "roles", "[", "k", "]", ".", "getName", "(", ")", ".", "toLowerCase", "(", ")", ".", "equals", "(", "role", ".", "toLowerCase", "(", ")", ")", ")", "{", "related", ".", "add", "(", "roles", "[", "k", "]", ".", "getPlayer", "(", ")", ")", ";", "}", "}", "}", "}", "return", "new", "Vector", "(", "new", "HashSet", "(", "related", ")", ")", ";", "}" ]

[ "It", "obtains", "all", "elements", "related", "with", "element", "with", "relationshipname", "and", "occupying", "the", "extreme", "role", ".", "Also", "the", "association", "where", "these", "elements", "appear", "must", "be", "allocated", "in", "the", "package", "whose", "pathname", "matches", "the", "pathname", "parameter" ]

[ "public", "static", "GraphEntity", "[", "]", "toGEArray", "(", "Object", "[", "]", "o", ")", "{", "GraphEntity", "[", "]", "result", "=", "new", "GraphEntity", "[", "o", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "o", ",", "0", ",", "result", ",", "0", ",", "o", ".", "length", ")", ";", "return", "result", ";", "}" ]

[ "It", "casts", "an", "array", "of", "objets", "to", "an", "array", "of", "GraphEntity" ]

[ "public", "static", "GraphRelationship", "[", "]", "toGRArray", "(", "Object", "[", "]", "o", ")", "{", "GraphRelationship", "[", "]", "result", "=", "new", "GraphRelationship", "[", "o", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "o", ",", "0", ",", "result", ",", "0", ",", "o", ".", "length", ")", ";", "return", "result", ";", "}" ]

[ "It", "casts", "an", "array", "of", "objets", "to", "an", "array", "of", "GraphRelationship" ]

[ "public", "static", "GraphRole", "[", "]", "toGRoArray", "(", "Object", "[", "]", "o", ")", "{", "GraphRole", "[", "]", "result", "=", "new", "GraphRole", "[", "o", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "o", ",", "0", ",", "result", ",", "0", ",", "o", ".", "length", ")", ";", "return", "result", ";", "}" ]

[ "It", "casts", "an", "array", "of", "objets", "to", "an", "array", "of", "GraphRole" ]

[ "public", "static", "GraphEntity", "[", "]", "generateEntitiesOfType", "(", "String", "type", ",", "Browser", "browser", ")", "throws", "NotInitialised", "{", "Graph", "[", "]", "gs", "=", "browser", ".", "getGraphs", "(", ")", ";", "Sequences", "p", "=", "new", "Sequences", "(", ")", ";", "GraphEntity", "[", "]", "ges", "=", "browser", ".", "getAllEntities", "(", ")", ";", "HashSet", "actors", "=", "new", "HashSet", "(", ")", ";", "for", "(", "int", "k", "=", "0", ";", "k", "<", "ges", ".", "length", ";", "k", "++", ")", "{", "if", "(", "ges", "[", "k", "]", ".", "getType", "(", ")", ".", "equals", "(", "type", ")", ")", "{", "actors", ".", "add", "(", "ges", "[", "k", "]", ")", ";", "}", "}", "return", "toGEArray", "(", "actors", ".", "toArray", "(", ")", ")", ";", "}" ]

[ "It", "obtains", "all", "entities", "in", "the", "specification", "whose", "type", "represented", "as", "string", "is", "the", "same", "as", "the", "string", "passed", "as", "parameter" ]

[ "public", "static", "GraphRole", "[", "]", "getRelatedElementsRoles", "(", "GraphEntity", "element", ",", "String", "relationshipname", ",", "String", "role", ")", "{", "Vector", "rels", "=", "element", ".", "getAllRelationships", "(", ")", ";", "Enumeration", "enumeration", "=", "rels", ".", "elements", "(", ")", ";", "Vector", "related", "=", "new", "Vector", "(", ")", ";", "while", "(", "enumeration", ".", "hasMoreElements", "(", ")", ")", "{", "GraphRelationship", "gr", "=", "(", "GraphRelationship", ")", "enumeration", ".", "nextElement", "(", ")", ";", "if", "(", "gr", ".", "getType", "(", ")", ".", "toLowerCase", "(", ")", ".", "equals", "(", "relationshipname", ".", "toLowerCase", "(", ")", ")", ")", "{", "GraphRole", "[", "]", "roles", "=", "gr", ".", "getRoles", "(", ")", ";", "for", "(", "int", "k", "=", "0", ";", "k", "<", "roles", ".", "length", ";", "k", "++", ")", "{", "if", "(", "roles", "[", "k", "]", ".", "getName", "(", ")", ".", "toLowerCase", "(", ")", ".", "equals", "(", "role", ".", "toLowerCase", "(", ")", ")", ")", "{", "related", ".", "add", "(", "roles", "[", "k", "]", ")", ";", "}", "}", "}", "}", "return", "toGRoArray", "(", "related", ".", "toArray", "(", ")", ")", ";", "}" ]

[ "It", "obtains", "the", "extremes", "of", "the", "association", "of", "type", "relationshipname", "where", "one", "of", "their", "roles", "is", "role", "and", "originated", "in", "the", "element" ]

[ "public", "static", "List", "<", "GraphEntity", ">", "getEntities", "(", "Graph", "g", ",", "String", "typeName", ")", "throws", "NullEntity", "{", "GraphEntity", "[", "]", "ge", "=", "g", ".", "getEntities", "(", ")", ";", "List", "<", "GraphEntity", ">", "result", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "int", "k", "=", "0", ";", "k", "<", "ge", ".", "length", ";", "k", "++", ")", "{", "if", "(", "ge", "[", "k", "]", ".", "getType", "(", ")", ".", "equals", "(", "typeName", ")", ")", "{", "result", ".", "add", "(", "ge", "[", "k", "]", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "It", "obtains", "the", "entities", "in", "the", "graph", "g", "whose", "type", "is", "the", "same", "as", "typeName", "." ]

[ "public", "static", "void", "listAllVoices", "(", ")", "{", "System", ".", "out", ".", "println", "(", ")", ";", "System", ".", "out", ".", "println", "(", "\"All voices available:\"", ")", ";", "VoiceManager", "voiceManager", "=", "VoiceManager", ".", "getInstance", "(", ")", ";", "Voice", "[", "]", "voices", "=", "voiceManager", ".", "getVoices", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "voices", ".", "length", ";", "i", "++", ")", "{", "System", ".", "out", ".", "println", "(", "\" \"", "+", "voices", "[", "i", "]", ".", "getName", "(", ")", "+", "\" (\"", "+", "voices", "[", "i", "]", ".", "getDomain", "(", ")", "+", "\" domain)\"", ")", ";", "}", "}" ]

[ "Example", "of", "how", "to", "list", "all", "the", "known", "voices", "." ]

[ "private", "void", "newFilter", "(", ")", "{", "RowFilter", "<", "MyTableModel", ",", "Object", ">", "rf", "=", "null", ";", "//If current expression doesn't parse, don't update.", "try", "{", "rf", "=", "RowFilter", ".", "regexFilter", "(", "filterText", ".", "getText", "(", ")", ",", "0", ")", ";", "}", "catch", "(", "java", ".", "util", ".", "regex", ".", "PatternSyntaxException", "e", ")", "{", "return", ";", "}", "sorter", ".", "setRowFilter", "(", "rf", ")", ";", "}" ]

[ "Update", "the", "row", "filter", "regular", "expression", "from", "the", "expression", "in", "the", "text", "box", "." ]

[ "private", "void", "checkForError", "(", "JsonNode", "resp", ")", "throws", "WePayException", "{", "JsonNode", "errorNode", "=", "resp", ".", "get", "(", "\"error\"", ")", ";", "if", "(", "errorNode", "!=", "null", ")", "throw", "new", "WePayException", "(", "errorNode", ".", "asText", "(", ")", ",", "resp", ".", "path", "(", "\"error_description\"", ")", ".", "asText", "(", ")", ",", "resp", ".", "path", "(", "\"error_code\"", ")", ".", "asInt", "(", ")", ")", ";", "}" ]

[ "If", "the", "response", "node", "is", "recognized", "as", "an", "error", "throw", "a", "WePayException" ]

[ "private", "HttpURLConnection", "getConnection", "(", "String", "uri", ",", "String", "postJson", ",", "String", "token", ")", "throws", "IOException", "{", "int", "tries", "=", "0", ";", "IOException", "last", "=", "null", ";", "while", "(", "tries", "++", "<=", "retries", ")", "{", "try", "{", "return", "getConnectionOnce", "(", "uri", ",", "postJson", ",", "token", ")", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "last", "=", "ex", ";", "}", "}", "throw", "last", ";", "}" ]

[ "Common", "functionality", "for", "posting", "data", ".", "Smart", "about", "retries", "." ]

[ "private", "HttpURLConnection", "getConnectionOnce", "(", "String", "uri", ",", "String", "postJson", ",", "String", "token", ")", "throws", "IOException", "{", "URL", "url", "=", "new", "URL", "(", "uri", ")", ";", "HttpURLConnection", "conn", "=", "(", "HttpURLConnection", ")", "url", ".", "openConnection", "(", ")", ";", "if", "(", "timeout", ">", "0", ")", "{", "conn", ".", "setReadTimeout", "(", "timeout", ")", ";", "conn", ".", "setConnectTimeout", "(", "timeout", ")", ";", "}", "if", "(", "postJson", "!=", "null", "&&", "postJson", ".", "equals", "(", "\"{}\"", ")", ")", "postJson", "=", "null", ";", "if", "(", "postJson", "!=", "null", ")", "{", "conn", ".", "setDoOutput", "(", "true", ")", ";", "// Triggers POST.", "}", "conn", ".", "setRequestProperty", "(", "\"Content-Type\"", ",", "\"application/json; charset=\"", "+", "UTF8", ".", "name", "(", ")", ")", ";", "conn", ".", "setRequestProperty", "(", "\"User-Agent\"", ",", "\"WePay Java SDK\"", ")", ";", "if", "(", "token", "!=", "null", ")", "{", "conn", ".", "setRequestProperty", "(", "\"Authorization\"", ",", "\"Bearer \"", "+", "token", ")", ";", "}", "if", "(", "postJson", "!=", "null", ")", "{", "OutputStreamWriter", "writer", "=", "new", "OutputStreamWriter", "(", "conn", ".", "getOutputStream", "(", ")", ",", "UTF8", ")", ";", "writer", ".", "write", "(", "postJson", ")", ";", "writer", ".", "close", "(", ")", ";", "}", "return", "conn", ";", "}" ]

[ "Sets", "up", "the", "headers", "and", "writes", "the", "post", "data", "." ]

[ "public", "static", "void", "premain", "(", "final", "String", "agentArgs", ",", "final", "Instrumentation", "instrumentation", ")", "{", "System", ".", "out", ".", "println", "(", "\"Initialiting Appmon4jAgent\"", ")", ";", "Appmon4JAgentConfiguration", "configuration", "=", "null", ";", "try", "{", "configuration", "=", "Appmon4JAgentConfiguration", ".", "load", "(", "agentArgs", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "System", ".", "err", ".", "println", "(", "\"failed to load appmon4j agent configuration from \"", "+", "agentArgs", "+", "\".\"", ")", ";", "e", ".", "printStackTrace", "(", ")", ";", "}", "if", "(", "configuration", "!=", "null", ")", "{", "new", "Appmon4JAgent", "(", "configuration", ",", "instrumentation", ")", ";", "}", "else", "{", "System", ".", "err", ".", "println", "(", "\"appmon4j Agent: Unable to start up. No valid configuration found. Will do nothing. \"", ")", ";", "}", "}" ]

[ "The", "premain", "method", "to", "be", "implemented", "by", "java", "agents", "to", "provide", "an", "entry", "point", "for", "the", "instrumentation", "." ]

[ "public", "static", "double", "stdDeviation", "(", "final", "long", "n", ",", "final", "double", "sum", ",", "final", "double", "sumOfSquares", ")", "{", "double", "stdDev", "=", "0", ";", "if", "(", "n", ">", "1", ")", "{", "// std deviation for 1 entry is 0 by definition\r", "final", "double", "numerator", "=", "sumOfSquares", "-", "(", "(", "sum", "*", "sum", ")", "/", "n", ")", ";", "stdDev", "=", "java", ".", "lang", ".", "Math", ".", "sqrt", "(", "numerator", "/", "(", "n", "-", "1", ")", ")", ";", "}", "return", "stdDev", ";", "}" ]

[ "Calculate", "the", "standard", "deviation", "from", "an", "amount", "of", "values", "n", "a", "sum", "and", "a", "sum", "of", "squares", "." ]

[ "public", "static", "void", "getScreenShotABGR", "(", "ByteBuffer", "bgraBuf", ",", "BufferedImage", "out", ")", "{", "WritableRaster", "wr", "=", "out", ".", "getRaster", "(", ")", ";", "DataBufferByte", "db", "=", "(", "DataBufferByte", ")", "wr", ".", "getDataBuffer", "(", ")", ";", "byte", "[", "]", "cpuArray", "=", "db", ".", "getData", "(", ")", ";", "// copy native memory to java memory", "bgraBuf", ".", "clear", "(", ")", ";", "bgraBuf", ".", "get", "(", "cpuArray", ")", ";", "bgraBuf", ".", "clear", "(", ")", ";", "int", "width", "=", "wr", ".", "getWidth", "(", ")", ";", "int", "height", "=", "wr", ".", "getHeight", "(", ")", ";", "// flip the components the way AWT likes them", "for", "(", "int", "y", "=", "0", ";", "y", "<", "height", "/", "2", ";", "y", "++", ")", "{", "for", "(", "int", "x", "=", "0", ";", "x", "<", "width", ";", "x", "++", ")", "{", "int", "inPtr", "=", "(", "y", "*", "width", "+", "x", ")", "*", "4", ";", "int", "outPtr", "=", "(", "(", "height", "-", "y", "-", "1", ")", "*", "width", "+", "x", ")", "*", "4", ";", "byte", "b1", "=", "cpuArray", "[", "inPtr", "+", "0", "]", ";", "byte", "g1", "=", "cpuArray", "[", "inPtr", "+", "1", "]", ";", "byte", "r1", "=", "cpuArray", "[", "inPtr", "+", "2", "]", ";", "byte", "a1", "=", "cpuArray", "[", "inPtr", "+", "3", "]", ";", "byte", "b2", "=", "cpuArray", "[", "outPtr", "+", "0", "]", ";", "byte", "g2", "=", "cpuArray", "[", "outPtr", "+", "1", "]", ";", "byte", "r2", "=", "cpuArray", "[", "outPtr", "+", "2", "]", ";", "byte", "a2", "=", "cpuArray", "[", "outPtr", "+", "3", "]", ";", "cpuArray", "[", "outPtr", "+", "0", "]", "=", "a1", ";", "cpuArray", "[", "outPtr", "+", "1", "]", "=", "b1", ";", "cpuArray", "[", "outPtr", "+", "2", "]", "=", "g1", ";", "cpuArray", "[", "outPtr", "+", "3", "]", "=", "r1", ";", "cpuArray", "[", "inPtr", "+", "0", "]", "=", "a2", ";", "cpuArray", "[", "inPtr", "+", "1", "]", "=", "b2", ";", "cpuArray", "[", "inPtr", "+", "2", "]", "=", "g2", ";", "cpuArray", "[", "inPtr", "+", "3", "]", "=", "r2", ";", "}", "}", "}" ]

[ "Good", "format", "for", "java", "swing", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "C", "downstreamConsumerFactory", "(", "Supplier", "<", "Consumer", "<", "String", ">", ">", "downstreamConsumerFactory", ")", "{", "this", ".", "downstreamConsumerFactory", "=", "requireNonNull", "(", "downstreamConsumerFactory", ")", ";", "return", "(", "C", ")", "this", ";", "}" ]

[ "Sets", "a", "downstream", "consumer", "s", "factory", "to", "this", "builder", "object", "." ]

[ "private", "static", "void", "appendMetaColumns", "(", "StringBuilder", "buffer", ",", "MetadataColumnDefinition", "[", "]", "values", ")", "{", "for", "(", "MetadataColumnDefinition", "column", ":", "values", ")", "{", "buffer", ".", "append", "(", "\", \"", ")", ".", "append", "(", "column", ".", "getColumnNamePrefix", "(", ")", ")", ";", "}", "}" ]

[ "Append", "metric", "and", "entity", "metadata", "columns", "to", "series", "requests", ".", "This", "method", "must", "not", "be", "used", "while", "processing", "meta", "tables", "." ]

[ "@", "Nonnull", "static", "Collection", "<", "MetricLocation", ">", "prepareGetMetricUrls", "(", "List", "<", "String", ">", "metricMasks", ",", "String", "tableFilter", ",", "boolean", "underscoreAsLiteral", ")", "{", "if", "(", "WildcardsUtil", ".", "isRetrieveAllPattern", "(", "tableFilter", ")", "||", "tableFilter", ".", "isEmpty", "(", ")", ")", "{", "if", "(", "metricMasks", ".", "isEmpty", "(", ")", ")", "{", "return", "Collections", ".", "emptyList", "(", ")", ";", "}", "else", "{", "return", "buildPatternDisjunction", "(", "metricMasks", ",", "underscoreAsLiteral", ")", ";", "}", "}", "else", "{", "return", "Collections", ".", "singletonList", "(", "buildAtsdPatternUrl", "(", "tableFilter", ",", "underscoreAsLiteral", ")", ")", ";", "}", "}" ]

[ "Prepare", "URL", "to", "retrieve", "metrics" ]

[ "private", "static", "String", "[", "]", "splitOnTokens", "(", "String", "text", ",", "String", "oneAnySymbolStr", ",", "String", "noneOrMoreSymbolsStr", ")", "{", "if", "(", "!", "hasWildcards", "(", "text", ",", "ONE_ANY_SYMBOL", ",", "NONE_OR_MORE_SYMBOLS", ")", ")", "{", "return", "new", "String", "[", "]", "{", "text", "}", ";", "}", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<>", "(", ")", ";", "StringBuilder", "buffer", "=", "new", "StringBuilder", "(", ")", ";", "boolean", "escapeMode", "=", "false", ";", "final", "int", "length", "=", "text", ".", "length", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "final", "char", "current", "=", "text", ".", "charAt", "(", "i", ")", ";", "switch", "(", "current", ")", "{", "case", "ESCAPE_CHAR", ":", "if", "(", "escapeMode", ")", "{", "buffer", ".", "append", "(", "current", ")", ";", "}", "else", "{", "escapeMode", "=", "true", ";", "}", "break", ";", "case", "ONE_ANY_SYMBOL", ":", "if", "(", "escapeMode", ")", "{", "buffer", ".", "append", "(", "current", ")", ";", "escapeMode", "=", "false", ";", "}", "else", "{", "flushBuffer", "(", "buffer", ",", "list", ")", ";", "if", "(", "!", "list", ".", "isEmpty", "(", ")", "&&", "noneOrMoreSymbolsStr", ".", "equals", "(", "list", ".", "get", "(", "list", ".", "size", "(", ")", "-", "1", ")", ")", ")", "{", "list", ".", "set", "(", "list", ".", "size", "(", ")", "-", "1", ",", "oneAnySymbolStr", ")", ";", "list", ".", "add", "(", "noneOrMoreSymbolsStr", ")", ";", "}", "else", "{", "list", ".", "add", "(", "oneAnySymbolStr", ")", ";", "}", "}", "break", ";", "case", "NONE_OR_MORE_SYMBOLS", ":", "if", "(", "escapeMode", ")", "{", "buffer", ".", "append", "(", "current", ")", ";", "escapeMode", "=", "false", ";", "}", "else", "{", "flushBuffer", "(", "buffer", ",", "list", ")", ";", "if", "(", "list", ".", "isEmpty", "(", ")", "||", "!", "noneOrMoreSymbolsStr", ".", "equals", "(", "list", ".", "get", "(", "list", ".", "size", "(", ")", "-", "1", ")", ")", ")", "{", "list", ".", "add", "(", "noneOrMoreSymbolsStr", ")", ";", "}", "}", "break", ";", "default", ":", "if", "(", "escapeMode", ")", "{", "buffer", ".", "append", "(", "ESCAPE_CHAR", ")", ";", "escapeMode", "=", "false", ";", "}", "buffer", ".", "append", "(", "current", ")", ";", "}", "}", "if", "(", "escapeMode", ")", "{", "buffer", ".", "append", "(", "ESCAPE_CHAR", ")", ";", "}", "if", "(", "buffer", ".", "length", "(", ")", "!=", "0", ")", "{", "list", ".", "add", "(", "buffer", ".", "toString", "(", ")", ")", ";", "}", "return", "list", ".", "toArray", "(", "ArrayUtils", ".", "EMPTY_STRING_ARRAY", ")", ";", "}" ]

[ "Splits", "a", "string", "into", "a", "number", "of", "tokens", ".", "The", "text", "is", "split", "by", "_", "and", "%", ".", "Multiple", "%", "are", "collapsed", "into", "a", "single", "%", "patterns", "like", "%_", "will", "be", "transferred", "to", "_%" ]

[ "@", "Override", "public", "boolean", "onTouchEvent", "(", "final", "@", "NotNull", "MotionEvent", "event", ")", "{", "final", "Spannable", "text", "=", "(", "Spannable", ")", "getText", "(", ")", ";", "if", "(", "text", "!=", "null", ")", "{", "if", "(", "event", ".", "getAction", "(", ")", "==", "MotionEvent", ".", "ACTION_DOWN", ")", "{", "final", "Layout", "layout", "=", "getLayout", "(", ")", ";", "if", "(", "layout", "!=", "null", ")", "{", "// final int pos = getOffsetForPosition(event.getX(), event.getY()); // API >= 14 only", "final", "int", "line", "=", "getLineAtCoordinate", "(", "layout", ",", "event", ".", "getY", "(", ")", ")", ";", "final", "int", "pos", "=", "getOffsetAtCoordinate", "(", "layout", ",", "line", ",", "event", ".", "getX", "(", ")", ")", ";", "final", "ClickableSpan", "[", "]", "links", "=", "text", ".", "getSpans", "(", "pos", ",", "pos", ",", "ClickableSpan", ".", "class", ")", ";", "if", "(", "links", "!=", "null", "&&", "links", ".", "length", ">", "0", ")", "{", "links", "[", "0", "]", ".", "onClick", "(", "this", ")", ";", "return", "true", ";", "}", "}", "}", "}", "return", "super", ".", "onTouchEvent", "(", "event", ")", ";", "}" ]

[ "We", "want", "our", "text", "to", "be", "selectable", "but", "we", "still", "want", "links", "to", "be", "clickable", "." ]

[ "protected", "void", "installDefaults", "(", ")", "{", "updateStyle", "(", "splitPane", ")", ";", "setOrientation", "(", "splitPane", ".", "getOrientation", "(", ")", ")", ";", "setContinuousLayout", "(", "splitPane", ".", "isContinuousLayout", "(", ")", ")", ";", "resetLayoutManager", "(", ")", ";", "/*\n * Install the nonContinuousLayoutDivider here to avoid having to\n * add/remove everything later.\n */", "if", "(", "nonContinuousLayoutDivider", "==", "null", ")", "{", "setNonContinuousLayoutDivider", "(", "createDefaultNonContinuousLayoutDivider", "(", ")", ",", "true", ")", ";", "}", "else", "{", "setNonContinuousLayoutDivider", "(", "nonContinuousLayoutDivider", ",", "true", ")", ";", "}", "// focus forward traversal key", "if", "(", "managingFocusForwardTraversalKeys", "==", "null", ")", "{", "managingFocusForwardTraversalKeys", "=", "new", "HashSet", "(", ")", ";", "managingFocusForwardTraversalKeys", ".", "add", "(", "KeyStroke", ".", "getKeyStroke", "(", "KeyEvent", ".", "VK_TAB", ",", "0", ")", ")", ";", "}", "splitPane", ".", "setFocusTraversalKeys", "(", "KeyboardFocusManager", ".", "FORWARD_TRAVERSAL_KEYS", ",", "managingFocusForwardTraversalKeys", ")", ";", "// focus backward traversal key", "if", "(", "managingFocusBackwardTraversalKeys", "==", "null", ")", "{", "managingFocusBackwardTraversalKeys", "=", "new", "HashSet", "(", ")", ";", "managingFocusBackwardTraversalKeys", ".", "add", "(", "KeyStroke", ".", "getKeyStroke", "(", "KeyEvent", ".", "VK_TAB", ",", "InputEvent", ".", "SHIFT_MASK", ")", ")", ";", "}", "splitPane", ".", "setFocusTraversalKeys", "(", "KeyboardFocusManager", ".", "BACKWARD_TRAVERSAL_KEYS", ",", "managingFocusBackwardTraversalKeys", ")", ";", "}" ]

[ "Installs", "the", "UI", "defaults", "." ]

[ "protected", "void", "uninstallDefaults", "(", ")", "{", "SeaGlassContext", "context", "=", "getContext", "(", "splitPane", ",", "ENABLED", ")", ";", "style", ".", "uninstallDefaults", "(", "context", ")", ";", "context", ".", "dispose", "(", ")", ";", "style", "=", "null", ";", "context", "=", "getContext", "(", "splitPane", ",", "Region", ".", "SPLIT_PANE_DIVIDER", ",", "ENABLED", ")", ";", "dividerStyle", ".", "uninstallDefaults", "(", "context", ")", ";", "context", ".", "dispose", "(", ")", ";", "dividerStyle", "=", "null", ";", "super", ".", "uninstallDefaults", "(", ")", ";", "}" ]

[ "Uninstalls", "the", "UI", "defaults", "." ]

[ "public", "BasicSplitPaneDivider", "createDefaultDivider", "(", ")", "{", "SeaGlassSplitPaneDivider", "divider", "=", "new", "SeaGlassSplitPaneDivider", "(", "this", ")", ";", "divider", ".", "setDividerSize", "(", "splitPane", ".", "getDividerSize", "(", ")", ")", ";", "return", "divider", ";", "}" ]

[ "Creates", "the", "default", "divider", "." ]

[ "public", "void", "paint", "(", "Graphics2D", "g", ")", "{", "g", ".", "setRenderingHint", "(", "RenderingHints", ".", "KEY_ANTIALIASING", ",", "RenderingHints", ".", "VALUE_ANTIALIAS_ON", ")", ";", "origAlpha", "=", "1.0f", ";", "Composite", "origComposite", "=", "g", ".", "getComposite", "(", ")", ";", "if", "(", "origComposite", "instanceof", "AlphaComposite", ")", "{", "AlphaComposite", "origAlphaComposite", "=", "(", "AlphaComposite", ")", "origComposite", ";", "if", "(", "origAlphaComposite", ".", "getRule", "(", ")", "==", "AlphaComposite", ".", "SRC_OVER", ")", "{", "origAlpha", "=", "origAlphaComposite", ".", "getAlpha", "(", ")", ";", "}", "}", "// _0", "AffineTransform", "trans_0", "=", "g", ".", "getTransform", "(", ")", ";", "paintRootGraphicsNode_0", "(", "g", ")", ";", "g", ".", "setTransform", "(", "trans_0", ")", ";", "}" ]

[ "Paints", "the", "transcoded", "SVG", "image", "on", "the", "specified", "graphics", "context", ".", "You", "can", "install", "a", "custom", "transformation", "on", "the", "graphics", "context", "to", "scale", "the", "image", "." ]

[ "@", "Override", "protected", "void", "propertyChange", "(", "PropertyChangeEvent", "evt", ")", "{", "super", ".", "propertyChange", "(", "evt", ")", ";", "String", "name", "=", "evt", ".", "getPropertyName", "(", ")", ";", "if", "(", "name", ".", "equals", "(", "\"foreground\"", ")", ")", "{", "updateForeground", "(", "(", "Color", ")", "evt", ".", "getNewValue", "(", ")", ")", ";", "}", "else", "if", "(", "name", ".", "equals", "(", "\"font\"", ")", ")", "{", "updateFont", "(", "(", "Font", ")", "evt", ".", "getNewValue", "(", ")", ")", ";", "}", "else", "if", "(", "name", ".", "equals", "(", "\"document\"", ")", ")", "{", "JComponent", "comp", "=", "getComponent", "(", ")", ";", "updateForeground", "(", "comp", ".", "getForeground", "(", ")", ")", ";", "updateFont", "(", "comp", ".", "getFont", "(", ")", ")", ";", "}", "}" ]

[ "This", "method", "gets", "called", "when", "a", "bound", "property", "is", "changed", "on", "the", "associated", "JTextComponent", ".", "This", "is", "a", "hook", "which", "UI", "implementations", "may", "change", "to", "reflect", "how", "the", "UI", "displays", "bound", "properties", "of", "JTextComponent", "subclasses", ".", "If", "the", "font", "foreground", "or", "document", "has", "changed", "the", "the", "appropriate", "property", "is", "set", "in", "the", "default", "style", "of", "the", "document", "." ]

[ "private", "void", "updateForeground", "(", "Color", "color", ")", "{", "StyledDocument", "doc", "=", "(", "StyledDocument", ")", "getComponent", "(", ")", ".", "getDocument", "(", ")", ";", "Style", "style", "=", "doc", ".", "getStyle", "(", "StyleContext", ".", "DEFAULT_STYLE", ")", ";", "if", "(", "style", "==", "null", ")", "{", "return", ";", "}", "if", "(", "color", "==", "null", ")", "{", "style", ".", "removeAttribute", "(", "StyleConstants", ".", "Foreground", ")", ";", "}", "else", "{", "StyleConstants", ".", "setForeground", "(", "style", ",", "color", ")", ";", "}", "}" ]

[ "Update", "the", "color", "in", "the", "default", "style", "of", "the", "document", "." ]

[ "private", "void", "updateFont", "(", "Font", "font", ")", "{", "StyledDocument", "doc", "=", "(", "StyledDocument", ")", "getComponent", "(", ")", ".", "getDocument", "(", ")", ";", "Style", "style", "=", "doc", ".", "getStyle", "(", "StyleContext", ".", "DEFAULT_STYLE", ")", ";", "if", "(", "style", "==", "null", ")", "{", "return", ";", "}", "if", "(", "font", "==", "null", ")", "{", "style", ".", "removeAttribute", "(", "StyleConstants", ".", "FontFamily", ")", ";", "style", ".", "removeAttribute", "(", "StyleConstants", ".", "FontSize", ")", ";", "style", ".", "removeAttribute", "(", "StyleConstants", ".", "Bold", ")", ";", "style", ".", "removeAttribute", "(", "StyleConstants", ".", "Italic", ")", ";", "}", "else", "{", "StyleConstants", ".", "setFontFamily", "(", "style", ",", "font", ".", "getName", "(", ")", ")", ";", "StyleConstants", ".", "setFontSize", "(", "style", ",", "font", ".", "getSize", "(", ")", ")", ";", "StyleConstants", ".", "setBold", "(", "style", ",", "font", ".", "isBold", "(", ")", ")", ";", "StyleConstants", ".", "setItalic", "(", "style", ",", "font", ".", "isItalic", "(", ")", ")", ";", "}", "}" ]

[ "Update", "the", "font", "in", "the", "default", "style", "of", "the", "document", "." ]

[ "private", "static", "Object", "invokeGetter", "(", "Object", "obj", ",", "String", "methodName", ",", "Object", "defaultValue", ")", "{", "try", "{", "Method", "method", "=", "obj", ".", "getClass", "(", ")", ".", "getMethod", "(", "methodName", ",", "new", "Class", "[", "0", "]", ")", ";", "Object", "result", "=", "method", ".", "invoke", "(", "obj", ",", "new", "Object", "[", "0", "]", ")", ";", "return", "result", ";", "}", "catch", "(", "NoSuchMethodException", "e", ")", "{", "return", "defaultValue", ";", "}", "catch", "(", "IllegalAccessException", "e", ")", "{", "return", "defaultValue", ";", "}", "catch", "(", "InvocationTargetException", "e", ")", "{", "return", "defaultValue", ";", "}", "}" ]

[ "Invokes", "the", "specified", "getter", "method", "if", "it", "exists", "." ]

[ "public", "Paint", "getFrameBorderPaint", "(", "Shape", "s", ")", "{", "switch", "(", "state", ")", "{", "case", "BACKGROUND_ENABLED", ":", "return", "frameBorderInactive", ";", "case", "BACKGROUND_ENABLED_WINDOWFOCUSED", ":", "return", "frameBorderActive", ";", "}", "return", "null", ";", "}" ]

[ "Get", "the", "paint", "for", "the", "border", "." ]

[ "public", "Paint", "getFrameInteriorPaint", "(", "Shape", "s", ",", "int", "titleHeight", ",", "int", "topToolBarHeight", ",", "int", "bottomToolBarHeight", ")", "{", "return", "createFrameGradient", "(", "s", ",", "titleHeight", ",", "topToolBarHeight", ",", "bottomToolBarHeight", ",", "getFrameInteriorColors", "(", ")", ")", ";", "}" ]

[ "Get", "the", "paint", "for", "the", "frame", "interior", "." ]

[ "public", "Paint", "getFrameInnerHighlightPaint", "(", "Shape", "s", ")", "{", "switch", "(", "state", ")", "{", "case", "BACKGROUND_ENABLED", ":", "return", "frameInnerHighlightInactive", ";", "case", "BACKGROUND_ENABLED_WINDOWFOCUSED", ":", "return", "frameInnerHighlightActive", ";", "}", "return", "null", ";", "}" ]

[ "Get", "the", "paint", "to", "paint", "the", "inner", "highlight", "with", "." ]

[ "public", "Paint", "getFocusPaint", "(", "Shape", "s", ",", "FocusType", "focusType", ",", "boolean", "useToolBarFocus", ")", "{", "if", "(", "focusType", "==", "FocusType", ".", "OUTER_FOCUS", ")", "{", "return", "useToolBarFocus", "?", "outerToolBarFocus", ":", "outerFocus", ";", "}", "else", "{", "return", "useToolBarFocus", "?", "innerToolBarFocus", ":", "innerFocus", ";", "}", "}" ]

[ "Get", "the", "paint", "to", "use", "for", "a", "focus", "ring", "." ]

[ "protected", "final", "Color", "decodeColor", "(", "String", "key", ",", "float", "hOffset", ",", "float", "sOffset", ",", "float", "bOffset", ",", "int", "aOffset", ")", "{", "if", "(", "UIManager", ".", "getLookAndFeel", "(", ")", "instanceof", "SeaGlassLookAndFeel", ")", "{", "SeaGlassLookAndFeel", "laf", "=", "(", "SeaGlassLookAndFeel", ")", "UIManager", ".", "getLookAndFeel", "(", ")", ";", "return", "laf", ".", "getDerivedColor", "(", "key", ",", "hOffset", ",", "sOffset", ",", "bOffset", ",", "aOffset", ",", "true", ")", ";", "}", "else", "{", "// can not give a right answer as painter should not be used outside", "// of nimbus laf but do the best we can", "return", "Color", ".", "getHSBColor", "(", "hOffset", ",", "sOffset", ",", "bOffset", ")", ";", "}", "}" ]

[ "Decodes", "and", "returns", "a", "color", "which", "is", "derived", "from", "a", "base", "color", "in", "UI", "defaults", "." ]

[ "public", "static", "int", "deriveARGB", "(", "Color", "color1", ",", "Color", "color2", ",", "float", "midPoint", ")", "{", "int", "r", "=", "color1", ".", "getRed", "(", ")", "+", "(", "int", ")", "(", "(", "color2", ".", "getRed", "(", ")", "-", "color1", ".", "getRed", "(", ")", ")", "*", "midPoint", "+", "0.5f", ")", ";", "int", "g", "=", "color1", ".", "getGreen", "(", ")", "+", "(", "int", ")", "(", "(", "color2", ".", "getGreen", "(", ")", "-", "color1", ".", "getGreen", "(", ")", ")", "*", "midPoint", "+", "0.5f", ")", ";", "int", "b", "=", "color1", ".", "getBlue", "(", ")", "+", "(", "int", ")", "(", "(", "color2", ".", "getBlue", "(", ")", "-", "color1", ".", "getBlue", "(", ")", ")", "*", "midPoint", "+", "0.5f", ")", ";", "int", "a", "=", "color1", ".", "getAlpha", "(", ")", "+", "(", "int", ")", "(", "(", "color2", ".", "getAlpha", "(", ")", "-", "color1", ".", "getAlpha", "(", ")", ")", "*", "midPoint", "+", "0.5f", ")", ";", "return", "(", "(", "a", "&", "0xFF", ")", "<<", "24", ")", "|", "(", "(", "r", "&", "0xFF", ")", "<<", "16", ")", "|", "(", "(", "g", "&", "0xFF", ")", "<<", "8", ")", "|", "(", "b", "&", "0xFF", ")", ";", "}" ]

[ "Derives", "the", "ARGB", "value", "for", "a", "color", "based", "on", "an", "offset", "between", "two", "other", "colors", "." ]

[ "protected", "final", "LinearGradientPaint", "createGradient", "(", "float", "x1", ",", "float", "y1", ",", "float", "x2", ",", "float", "y2", ",", "float", "[", "]", "midpoints", ",", "Color", "[", "]", "colors", ")", "{", "if", "(", "x1", "==", "x2", "&&", "y1", "==", "y2", ")", "{", "y2", "+=", ".00001f", ";", "}", "return", "new", "LinearGradientPaint", "(", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "midpoints", ",", "colors", ")", ";", "}" ]

[ "Given", "parameters", "for", "creating", "a", "LinearGradientPaint", "this", "method", "will", "create", "and", "return", "a", "linear", "gradient", "paint", ".", "One", "primary", "purpose", "for", "this", "method", "is", "to", "avoid", "creating", "a", "LinearGradientPaint", "where", "the", "start", "and", "end", "points", "are", "equal", ".", "In", "such", "a", "case", "the", "end", "y", "point", "is", "slightly", "increased", "to", "avoid", "the", "overlap", "." ]

[ "protected", "final", "RadialGradientPaint", "createRadialGradient", "(", "float", "x", ",", "float", "y", ",", "float", "r", ",", "float", "[", "]", "midpoints", ",", "Color", "[", "]", "colors", ")", "{", "if", "(", "r", "==", "0f", ")", "{", "r", "=", ".00001f", ";", "}", "return", "new", "RadialGradientPaint", "(", "x", ",", "y", ",", "r", ",", "midpoints", ",", "colors", ")", ";", "}" ]

[ "Given", "parameters", "for", "creating", "a", "RadialGradientPaint", "this", "method", "will", "create", "and", "return", "a", "radial", "gradient", "paint", ".", "One", "primary", "purpose", "for", "this", "method", "is", "to", "avoid", "creating", "a", "RadialGradientPaint", "where", "the", "radius", "is", "non", "-", "positive", ".", "In", "such", "a", "case", "the", "radius", "is", "just", "slightly", "increased", "to", "avoid", "0", "." ]

[ "protected", "Paint", "createVerticalGradient", "(", "Shape", "s", ",", "TwoColors", "colors", ")", "{", "Rectangle2D", "bounds", "=", "s", ".", "getBounds2D", "(", ")", ";", "float", "xCenter", "=", "(", "float", ")", "bounds", ".", "getCenterX", "(", ")", ";", "float", "yMin", "=", "(", "float", ")", "bounds", ".", "getMinY", "(", ")", ";", "float", "yMax", "=", "(", "float", ")", "bounds", ".", "getMaxY", "(", ")", ";", "return", "createGradient", "(", "xCenter", ",", "yMin", ",", "xCenter", ",", "yMax", ",", "new", "float", "[", "]", "{", "0f", ",", "1f", "}", ",", "new", "Color", "[", "]", "{", "colors", ".", "top", ",", "colors", ".", "bottom", "}", ")", ";", "}" ]

[ "Creates", "a", "simple", "vertical", "gradient", "using", "the", "shape", "for", "bounds", "and", "the", "colors", "for", "top", "and", "bottom", "colors", "." ]

[ "protected", "Paint", "createHorizontalGradient", "(", "Shape", "s", ",", "TwoColors", "colors", ")", "{", "Rectangle2D", "bounds", "=", "s", ".", "getBounds2D", "(", ")", ";", "float", "xMin", "=", "(", "float", ")", "bounds", ".", "getMinX", "(", ")", ";", "float", "xMax", "=", "(", "float", ")", "bounds", ".", "getMaxX", "(", ")", ";", "float", "yCenter", "=", "(", "float", ")", "bounds", ".", "getCenterY", "(", ")", ";", "return", "createGradient", "(", "xMin", ",", "yCenter", ",", "xMax", ",", "yCenter", ",", "new", "float", "[", "]", "{", "0f", ",", "1f", "}", ",", "new", "Color", "[", "]", "{", "colors", ".", "top", ",", "colors", ".", "bottom", "}", ")", ";", "}" ]

[ "Creates", "a", "simple", "horizontal", "gradient", "using", "the", "shape", "for", "bounds", "and", "the", "colors", "for", "top", "and", "bottom", "colors", "." ]

[ "protected", "Paint", "createHorizontalGradient", "(", "Shape", "s", ",", "FourColors", "colors", ")", "{", "Rectangle2D", "bounds", "=", "s", ".", "getBounds2D", "(", ")", ";", "float", "x", "=", "(", "float", ")", "bounds", ".", "getX", "(", ")", ";", "float", "y", "=", "(", "float", ")", "bounds", ".", "getY", "(", ")", ";", "float", "w", "=", "(", "float", ")", "bounds", ".", "getWidth", "(", ")", ";", "float", "h", "=", "(", "float", ")", "bounds", ".", "getHeight", "(", ")", ";", "return", "createGradient", "(", "x", ",", "(", "0.5f", "*", "h", ")", "+", "y", ",", "x", "+", "w", ",", "(", "0.5f", "*", "h", ")", "+", "y", ",", "new", "float", "[", "]", "{", "0f", ",", "0.45f", ",", "0.62f", ",", "1f", "}", ",", "new", "Color", "[", "]", "{", "colors", ".", "top", ",", "colors", ".", "upperMid", ",", "colors", ".", "lowerMid", ",", "colors", ".", "bottom", "}", ")", ";", "}" ]

[ "Creates", "a", "simple", "horizontal", "gradient", "using", "the", "shape", "for", "bounds", "and", "the", "colors", "for", "top", "two", "middle", "and", "bottom", "colors", "." ]

[ "protected", "Color", "desaturate", "(", "Color", "color", ")", "{", "float", "[", "]", "tmp", "=", "Color", ".", "RGBtoHSB", "(", "color", ".", "getRed", "(", ")", ",", "color", ".", "getGreen", "(", ")", ",", "color", ".", "getBlue", "(", ")", ",", "null", ")", ";", "tmp", "[", "1", "]", "/=", "3.0f", ";", "tmp", "[", "2", "]", "=", "clamp", "(", "1.0f", "-", "(", "1.0f", "-", "tmp", "[", "2", "]", ")", "/", "3f", ")", ";", "return", "new", "Color", "(", "(", "Color", ".", "HSBtoRGB", "(", "tmp", "[", "0", "]", ",", "tmp", "[", "1", "]", ",", "tmp", "[", "2", "]", ")", "&", "0xFFFFFF", ")", ")", ";", "}" ]

[ "Returns", "a", "new", "color", "with", "the", "saturation", "cut", "to", "one", "third", "the", "original", "and", "the", "brightness", "moved", "one", "third", "closer", "to", "white", "." ]

[ "private", "void", "paintWithCaching", "(", "Graphics2D", "g", ",", "JComponent", "c", ",", "int", "w", ",", "int", "h", ",", "Object", "[", "]", "extendedCacheKeys", ")", "{", "VolatileImage", "img", "=", "getImage", "(", "g", ".", "getDeviceConfiguration", "(", ")", ",", "c", ",", "w", ",", "h", ",", "extendedCacheKeys", ")", ";", "if", "(", "img", "!=", "null", ")", "{", "// render cached image", "g", ".", "drawImage", "(", "img", ",", "0", ",", "0", ",", "null", ")", ";", "}", "else", "{", "// render directly", "paintDirectly", "(", "g", ",", "c", ",", "w", ",", "h", ",", "extendedCacheKeys", ")", ";", "}", "}" ]

[ "Paint", "the", "component", "using", "a", "cached", "image", "if", "possible", "." ]

[ "private", "void", "paintDirectly", "(", "Graphics2D", "g", ",", "JComponent", "c", ",", "int", "w", ",", "int", "h", ",", "Object", "[", "]", "extendedCacheKeys", ")", "{", "g", "=", "(", "Graphics2D", ")", "g", ".", "create", "(", ")", ";", "configureGraphics", "(", "g", ")", ";", "doPaint", "(", "g", ",", "c", ",", "w", ",", "h", ",", "extendedCacheKeys", ")", ";", "g", ".", "dispose", "(", ")", ";", "}" ]

[ "Convenience", "method", "which", "creates", "a", "temporary", "graphics", "object", "by", "creating", "a", "clone", "of", "the", "passed", "in", "one", "configuring", "it", "drawing", "with", "it", "disposing", "it", ".", "These", "steps", "have", "to", "be", "taken", "to", "ensure", "that", "any", "hints", "set", "on", "the", "graphics", "are", "removed", "subsequent", "to", "painting", "." ]

[ "private", "VolatileImage", "getImage", "(", "GraphicsConfiguration", "config", ",", "JComponent", "c", ",", "int", "w", ",", "int", "h", ",", "Object", "[", "]", "extendedCacheKeys", ")", "{", "ImageCache", "imageCache", "=", "ImageCache", ".", "getInstance", "(", ")", ";", "// get the buffer for this component", "VolatileImage", "buffer", "=", "(", "VolatileImage", ")", "imageCache", ".", "getImage", "(", "config", ",", "w", ",", "h", ",", "this", ",", "extendedCacheKeys", ")", ";", "int", "renderCounter", "=", "0", ";", "// to avoid any potential, though unlikely,", "// infinite loop", "do", "{", "// validate the buffer so we can check for surface loss", "int", "bufferStatus", "=", "VolatileImage", ".", "IMAGE_INCOMPATIBLE", ";", "if", "(", "buffer", "!=", "null", ")", "{", "bufferStatus", "=", "buffer", ".", "validate", "(", "config", ")", ";", "}", "// If the buffer status is incompatible or restored, then we need to", "// re-render to the volatile image", "if", "(", "bufferStatus", "==", "VolatileImage", ".", "IMAGE_INCOMPATIBLE", "||", "bufferStatus", "==", "VolatileImage", ".", "IMAGE_RESTORED", ")", "{", "// if the buffer is null (hasn't been created), or isn't the", "// right size, or has lost its contents,", "// then recreate the buffer", "if", "(", "buffer", "==", "null", "||", "buffer", ".", "getWidth", "(", ")", "!=", "w", "||", "buffer", ".", "getHeight", "(", ")", "!=", "h", "||", "bufferStatus", "==", "VolatileImage", ".", "IMAGE_INCOMPATIBLE", ")", "{", "// clear any resources related to the old back buffer", "if", "(", "buffer", "!=", "null", ")", "{", "buffer", ".", "flush", "(", ")", ";", "buffer", "=", "null", ";", "}", "// recreate the buffer", "buffer", "=", "config", ".", "createCompatibleVolatileImage", "(", "w", ",", "h", ",", "Transparency", ".", "TRANSLUCENT", ")", ";", "// put in cache for future", "imageCache", ".", "setImage", "(", "buffer", ",", "config", ",", "w", ",", "h", ",", "this", ",", "extendedCacheKeys", ")", ";", "}", "// create the graphics context with which to paint to the buffer", "Graphics2D", "bg", "=", "buffer", ".", "createGraphics", "(", ")", ";", "// clear the background before configuring the graphics", "bg", ".", "setComposite", "(", "AlphaComposite", ".", "Clear", ")", ";", "bg", ".", "fillRect", "(", "0", ",", "0", ",", "w", ",", "h", ")", ";", "bg", ".", "setComposite", "(", "AlphaComposite", ".", "SrcOver", ")", ";", "configureGraphics", "(", "bg", ")", ";", "// paint the painter into buffer", "paintDirectly", "(", "bg", ",", "c", ",", "w", ",", "h", ",", "extendedCacheKeys", ")", ";", "// close buffer graphics", "bg", ".", "dispose", "(", ")", ";", "}", "}", "while", "(", "buffer", ".", "contentsLost", "(", ")", "&&", "renderCounter", "++", "<", "3", ")", ";", "// check if we failed", "if", "(", "renderCounter", "==", "3", ")", "return", "null", ";", "// return image", "return", "buffer", ";", "}" ]

[ "Gets", "the", "rendered", "image", "for", "this", "painter", "at", "the", "requested", "size", "either", "from", "cache", "or", "create", "a", "new", "one" ]

[ "private", "void", "updateStyle", "(", "JTabbedPane", "c", ")", "{", "SeaGlassContext", "context", "=", "getContext", "(", "c", ",", "ENABLED", ")", ";", "SynthStyle", "oldStyle", "=", "style", ";", "style", "=", "SeaGlassLookAndFeel", ".", "updateStyle", "(", "context", ",", "this", ")", ";", "tabPlacement", "=", "tabPane", ".", "getTabPlacement", "(", ")", ";", "orientation", "=", "ControlOrientation", ".", "getOrientation", "(", "tabPlacement", "==", "LEFT", "||", "tabPlacement", "==", "RIGHT", "?", "VERTICAL", ":", "HORIZONTAL", ")", ";", "closeButtonArmedIndex", "=", "-", "1", ";", "Object", "o", "=", "c", ".", "getClientProperty", "(", "\"JTabbedPane.closeButton\"", ")", ";", "if", "(", "o", "!=", "null", "&&", "\"left\"", ".", "equals", "(", "o", ")", ")", "{", "tabCloseButtonPlacement", "=", "LEFT", ";", "}", "else", "if", "(", "o", "!=", "null", "&&", "\"right\"", ".", "equals", "(", "o", ")", ")", "{", "tabCloseButtonPlacement", "=", "RIGHT", ";", "}", "else", "{", "tabCloseButtonPlacement", "=", "CENTER", ";", "}", "closeButtonSize", "=", "style", ".", "getInt", "(", "context", ",", "\"closeButtonSize\"", ",", "6", ")", ";", "closeButtonInsets", "=", "(", "Insets", ")", "style", ".", "get", "(", "context", ",", "\"closeButtonInsets\"", ")", ";", "if", "(", "closeButtonInsets", "==", "null", ")", "{", "closeButtonInsets", "=", "new", "Insets", "(", "2", ",", "2", ",", "2", ",", "2", ")", ";", "}", "o", "=", "c", ".", "getClientProperty", "(", "\"JTabbedPane.closeListener\"", ")", ";", "if", "(", "o", "!=", "null", "&&", "o", "instanceof", "SeaGlassTabCloseListener", ")", "{", "if", "(", "tabCloseListener", "==", "null", ")", "{", "tabCloseListener", "=", "(", "SeaGlassTabCloseListener", ")", "o", ";", "}", "}", "// Add properties other than JComponent colors, Borders and", "// opacity settings here:", "if", "(", "style", "!=", "oldStyle", ")", "{", "tabRunOverlay", "=", "0", ";", "textIconGap", "=", "style", ".", "getInt", "(", "context", ",", "\"TabbedPane.textIconGap\"", ",", "0", ")", ";", "selectedTabPadInsets", "=", "(", "Insets", ")", "style", ".", "get", "(", "context", ",", "\"TabbedPane.selectedTabPadInsets\"", ")", ";", "if", "(", "selectedTabPadInsets", "==", "null", ")", "{", "selectedTabPadInsets", "=", "new", "Insets", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "}", "if", "(", "oldStyle", "!=", "null", ")", "{", "uninstallKeyboardActions", "(", ")", ";", "installKeyboardActions", "(", ")", ";", "}", "}", "context", ".", "dispose", "(", ")", ";", "if", "(", "tabContext", "!=", "null", ")", "{", "tabContext", ".", "dispose", "(", ")", ";", "}", "tabContext", "=", "getContext", "(", "c", ",", "Region", ".", "TABBED_PANE_TAB", ",", "ENABLED", ")", ";", "this", ".", "tabStyle", "=", "SeaGlassLookAndFeel", ".", "updateStyle", "(", "tabContext", ",", "this", ")", ";", "tabInsets", "=", "tabStyle", ".", "getInsets", "(", "tabContext", ",", "null", ")", ";", "if", "(", "tabCloseContext", "!=", "null", ")", "{", "tabCloseContext", ".", "dispose", "(", ")", ";", "}", "tabCloseContext", "=", "getContext", "(", "c", ",", "SeaGlassRegion", ".", "TABBED_PANE_TAB_CLOSE_BUTTON", ",", "ENABLED", ")", ";", "this", ".", "tabCloseStyle", "=", "SeaGlassLookAndFeel", ".", "updateStyle", "(", "tabCloseContext", ",", "this", ")", ";", "if", "(", "tabAreaContext", "!=", "null", ")", "{", "tabAreaContext", ".", "dispose", "(", ")", ";", "}", "tabAreaContext", "=", "getContext", "(", "c", ",", "Region", ".", "TABBED_PANE_TAB_AREA", ",", "ENABLED", ")", ";", "this", ".", "tabAreaStyle", "=", "SeaGlassLookAndFeel", ".", "updateStyle", "(", "tabAreaContext", ",", "this", ")", ";", "tabAreaInsets", "=", "tabAreaStyle", ".", "getInsets", "(", "tabAreaContext", ",", "null", ")", ";", "if", "(", "tabContentContext", "!=", "null", ")", "{", "tabContentContext", ".", "dispose", "(", ")", ";", "}", "tabContentContext", "=", "getContext", "(", "c", ",", "Region", ".", "TABBED_PANE_CONTENT", ",", "ENABLED", ")", ";", "this", ".", "tabContentStyle", "=", "SeaGlassLookAndFeel", ".", "updateStyle", "(", "tabContentContext", ",", "this", ")", ";", "contentBorderInsets", "=", "tabContentStyle", ".", "getInsets", "(", "tabContentContext", ",", "null", ")", ";", "}" ]

[ "Update", "the", "Synth", "styles", "when", "something", "changes", "." ]

[ "protected", "void", "scrollBackward", "(", ")", "{", "int", "selectedIndex", "=", "tabPane", ".", "getSelectedIndex", "(", ")", ";", "if", "(", "--", "selectedIndex", "<", "0", ")", "{", "tabPane", ".", "setSelectedIndex", "(", "tabPane", ".", "getTabCount", "(", ")", "==", "0", "?", "-", "1", ":", "0", ")", ";", "}", "else", "{", "tabPane", ".", "setSelectedIndex", "(", "selectedIndex", ")", ";", "}", "tabPane", ".", "repaint", "(", ")", ";", "}" ]

[ "Scroll", "the", "tab", "buttons", "backwards", "." ]

[ "protected", "void", "scrollForward", "(", ")", "{", "int", "selectedIndex", "=", "tabPane", ".", "getSelectedIndex", "(", ")", ";", "if", "(", "++", "selectedIndex", ">=", "tabPane", ".", "getTabCount", "(", ")", ")", "{", "tabPane", ".", "setSelectedIndex", "(", "tabPane", ".", "getTabCount", "(", ")", "-", "1", ")", ";", "}", "else", "{", "tabPane", ".", "setSelectedIndex", "(", "selectedIndex", ")", ";", "}", "tabPane", ".", "repaint", "(", ")", ";", "}" ]

[ "Scroll", "the", "tab", "buttons", "forwards", "." ]

[ "public", "SeaGlassContext", "getContext", "(", "JComponent", "c", ",", "int", "state", ")", "{", "return", "SeaGlassContext", ".", "getContext", "(", "SeaGlassContext", ".", "class", ",", "c", ",", "SeaGlassLookAndFeel", ".", "getRegion", "(", "c", ")", ",", "style", ",", "state", ")", ";", "}" ]

[ "Create", "a", "SynthContext", "for", "the", "component", "and", "state", ".", "Use", "the", "default", "region", "." ]

[ "public", "SeaGlassContext", "getContext", "(", "JComponent", "c", ",", "Region", "subregion", ")", "{", "return", "getContext", "(", "c", ",", "subregion", ",", "getComponentState", "(", "c", ")", ")", ";", "}" ]

[ "Create", "a", "SynthContext", "for", "the", "component", "and", "subregion", ".", "Use", "the", "current", "state", "." ]

[ "private", "SeaGlassContext", "getContext", "(", "JComponent", "c", ",", "Region", "subregion", ",", "int", "state", ")", "{", "SynthStyle", "style", "=", "null", ";", "Class", "klass", "=", "SeaGlassContext", ".", "class", ";", "if", "(", "subregion", "==", "Region", ".", "TABBED_PANE_TAB", ")", "{", "style", "=", "tabStyle", ";", "}", "else", "if", "(", "subregion", "==", "Region", ".", "TABBED_PANE_TAB_AREA", ")", "{", "style", "=", "tabAreaStyle", ";", "}", "else", "if", "(", "subregion", "==", "Region", ".", "TABBED_PANE_CONTENT", ")", "{", "style", "=", "tabContentStyle", ";", "}", "else", "if", "(", "subregion", "==", "SeaGlassRegion", ".", "TABBED_PANE_TAB_CLOSE_BUTTON", ")", "{", "style", "=", "tabCloseStyle", ";", "}", "return", "SeaGlassContext", ".", "getContext", "(", "klass", ",", "c", ",", "subregion", ",", "style", ",", "state", ")", ";", "}" ]

[ "Create", "a", "SynthContext", "for", "the", "component", "subregion", "and", "state", "." ]

[ "public", "int", "getCloseButtonState", "(", "JComponent", "c", ",", "int", "tabIndex", ",", "boolean", "tabIsMousedOver", ")", "{", "if", "(", "!", "c", ".", "isEnabled", "(", ")", ")", "{", "return", "DISABLED", ";", "}", "else", "if", "(", "tabIndex", "==", "closeButtonArmedIndex", ")", "{", "return", "PRESSED", ";", "}", "else", "if", "(", "tabIndex", "==", "closeButtonHoverIndex", ")", "{", "return", "FOCUSED", ";", "}", "else", "if", "(", "tabIsMousedOver", ")", "{", "return", "MOUSE_OVER", ";", "}", "return", "ENABLED", ";", "}" ]

[ "Get", "the", "state", "for", "the", "specified", "tab", "s", "close", "button", "." ]

[ "protected", "void", "paint", "(", "SeaGlassContext", "context", ",", "Graphics", "g", ")", "{", "int", "selectedIndex", "=", "tabPane", ".", "getSelectedIndex", "(", ")", ";", "ensureCurrentLayout", "(", ")", ";", "// Paint content border.", "paintContentBorder", "(", "tabContentContext", ",", "g", ",", "tabPlacement", ",", "selectedIndex", ")", ";", "paintTabArea", "(", "g", ",", "tabPlacement", ",", "selectedIndex", ")", ";", "}" ]

[ "Paint", "the", "tabbed", "pane", "." ]

[ "protected", "void", "paintTabArea", "(", "SeaGlassContext", "ss", ",", "Graphics", "g", ",", "int", "tabPlacement", ",", "int", "selectedIndex", ",", "Rectangle", "tabAreaBounds", ")", "{", "Rectangle", "clipRect", "=", "g", ".", "getClipBounds", "(", ")", ";", "ss", ".", "setComponentState", "(", "SynthConstants", ".", "ENABLED", ")", ";", "// Paint the tab area.", "SeaGlassLookAndFeel", ".", "updateSubregion", "(", "ss", ",", "g", ",", "tabAreaBounds", ")", ";", "ss", ".", "getPainter", "(", ")", ".", "paintTabbedPaneTabAreaBackground", "(", "ss", ",", "g", ",", "tabAreaBounds", ".", "x", ",", "tabAreaBounds", ".", "y", ",", "tabAreaBounds", ".", "width", ",", "tabAreaBounds", ".", "height", ",", "tabPlacement", ")", ";", "ss", ".", "getPainter", "(", ")", ".", "paintTabbedPaneTabAreaBorder", "(", "ss", ",", "g", ",", "tabAreaBounds", ".", "x", ",", "tabAreaBounds", ".", "y", ",", "tabAreaBounds", ".", "width", ",", "tabAreaBounds", ".", "height", ",", "tabPlacement", ")", ";", "iconRect", ".", "setBounds", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "textRect", ".", "setBounds", "(", "0", ",", "0", ",", "0", ",", "0", ")", ";", "if", "(", "runCount", "==", "0", ")", "{", "return", ";", "}", "if", "(", "scrollBackwardButton", ".", "isVisible", "(", ")", ")", "{", "paintScrollButtonBackground", "(", "ss", ",", "g", ",", "scrollBackwardButton", ")", ";", "}", "if", "(", "scrollForwardButton", ".", "isVisible", "(", ")", ")", "{", "paintScrollButtonBackground", "(", "ss", ",", "g", ",", "scrollForwardButton", ")", ";", "}", "for", "(", "int", "i", "=", "leadingTabIndex", ";", "i", "<=", "trailingTabIndex", ";", "i", "++", ")", "{", "if", "(", "rects", "[", "i", "]", ".", "intersects", "(", "clipRect", ")", "&&", "selectedIndex", "!=", "i", ")", "{", "paintTab", "(", "tabContext", ",", "g", ",", "rects", ",", "i", ",", "iconRect", ",", "textRect", ")", ";", "}", "}", "if", "(", "selectedIndex", ">=", "0", ")", "{", "if", "(", "rects", "[", "selectedIndex", "]", ".", "intersects", "(", "clipRect", ")", ")", "{", "paintTab", "(", "tabContext", ",", "g", ",", "rects", ",", "selectedIndex", ",", "iconRect", ",", "textRect", ")", ";", "}", "}", "}" ]

[ "Paint", "the", "tab", "area", "including", "the", "tabs", "." ]

[ "protected", "void", "paintTab", "(", "SeaGlassContext", "ss", ",", "Graphics", "g", ",", "Rectangle", "[", "]", "rects", ",", "int", "tabIndex", ",", "Rectangle", "iconRect", ",", "Rectangle", "textRect", ")", "{", "Rectangle", "tabRect", "=", "rects", "[", "tabIndex", "]", ";", "int", "selectedIndex", "=", "tabPane", ".", "getSelectedIndex", "(", ")", ";", "boolean", "isSelected", "=", "selectedIndex", "==", "tabIndex", ";", "JComponent", "b", "=", "ss", ".", "getComponent", "(", ")", ";", "boolean", "flipSegments", "=", "(", "orientation", "==", "ControlOrientation", ".", "HORIZONTAL", "&&", "!", "tabPane", ".", "getComponentOrientation", "(", ")", ".", "isLeftToRight", "(", ")", ")", ";", "String", "segmentPosition", "=", "\"only\"", ";", "if", "(", "tabPane", ".", "getTabCount", "(", ")", ">", "1", ")", "{", "if", "(", "tabIndex", "==", "0", "&&", "tabIndex", "==", "leadingTabIndex", ")", "{", "segmentPosition", "=", "flipSegments", "?", "\"last\"", ":", "\"first\"", ";", "}", "else", "if", "(", "tabIndex", "==", "tabPane", ".", "getTabCount", "(", ")", "-", "1", "&&", "tabIndex", "==", "trailingTabIndex", ")", "{", "segmentPosition", "=", "flipSegments", "?", "\"first\"", ":", "\"last\"", ";", "}", "else", "{", "segmentPosition", "=", "\"middle\"", ";", "}", "}", "b", ".", "putClientProperty", "(", "\"JTabbedPane.Tab.segmentPosition\"", ",", "segmentPosition", ")", ";", "updateTabContext", "(", "tabIndex", ",", "isSelected", ",", "isSelected", "&&", "selectedTabIsPressed", ",", "getRolloverTab", "(", ")", "==", "tabIndex", ",", "getFocusIndex", "(", ")", "==", "tabIndex", ")", ";", "SeaGlassLookAndFeel", ".", "updateSubregion", "(", "ss", ",", "g", ",", "tabRect", ")", ";", "int", "x", "=", "tabRect", ".", "x", ";", "int", "y", "=", "tabRect", ".", "y", ";", "int", "height", "=", "tabRect", ".", "height", ";", "int", "width", "=", "tabRect", ".", "width", ";", "tabContext", ".", "getPainter", "(", ")", ".", "paintTabbedPaneTabBackground", "(", "tabContext", ",", "g", ",", "x", ",", "y", ",", "width", ",", "height", ",", "tabIndex", ",", "tabPlacement", ")", ";", "tabContext", ".", "getPainter", "(", ")", ".", "paintTabbedPaneTabBorder", "(", "tabContext", ",", "g", ",", "x", ",", "y", ",", "width", ",", "height", ",", "tabIndex", ",", "tabPlacement", ")", ";", "if", "(", "tabCloseButtonPlacement", "!=", "CENTER", ")", "{", "tabRect", "=", "paintCloseButton", "(", "g", ",", "tabContext", ",", "tabIndex", ")", ";", "}", "if", "(", "tabPane", ".", "getTabComponentAt", "(", "tabIndex", ")", "==", "null", ")", "{", "String", "title", "=", "tabPane", ".", "getTitleAt", "(", "tabIndex", ")", ";", "Font", "font", "=", "ss", ".", "getStyle", "(", ")", ".", "getFont", "(", "ss", ")", ";", "FontMetrics", "metrics", "=", "SwingUtilities2", ".", "getFontMetrics", "(", "tabPane", ",", "g", ",", "font", ")", ";", "Icon", "icon", "=", "getIconForTab", "(", "tabIndex", ")", ";", "layoutLabel", "(", "ss", ",", "tabPlacement", ",", "metrics", ",", "tabIndex", ",", "title", ",", "icon", ",", "tabRect", ",", "iconRect", ",", "textRect", ",", "isSelected", ")", ";", "paintText", "(", "ss", ",", "g", ",", "tabPlacement", ",", "font", ",", "metrics", ",", "tabIndex", ",", "title", ",", "textRect", ",", "isSelected", ")", ";", "paintIcon", "(", "g", ",", "tabPlacement", ",", "tabIndex", ",", "icon", ",", "iconRect", ",", "isSelected", ")", ";", "}", "}" ]

[ "Paint", "a", "tab", "." ]

[ "protected", "Rectangle", "paintCloseButton", "(", "Graphics", "g", ",", "SynthContext", "tabContext", ",", "int", "tabIndex", ")", "{", "Rectangle", "tabRect", "=", "new", "Rectangle", "(", "rects", "[", "tabIndex", "]", ")", ";", "Rectangle", "bounds", "=", "getCloseButtonBounds", "(", "tabIndex", ")", ";", "int", "offset", "=", "bounds", ".", "width", "+", "textIconGap", ";", "boolean", "onLeft", "=", "isCloseButtonOnLeft", "(", ")", ";", "if", "(", "onLeft", ")", "{", "tabRect", ".", "x", "+=", "offset", ";", "tabRect", ".", "width", "-=", "offset", ";", "}", "else", "{", "tabRect", ".", "width", "-=", "offset", ";", "}", "SeaGlassContext", "subcontext", "=", "getContext", "(", "tabPane", ",", "SeaGlassRegion", ".", "TABBED_PANE_TAB_CLOSE_BUTTON", ",", "getCloseButtonState", "(", "tabPane", ",", "tabIndex", ",", "(", "tabContext", ".", "getComponentState", "(", ")", "&", "MOUSE_OVER", ")", "!=", "0", ")", ")", ";", "SeaGlassLookAndFeel", ".", "updateSubregion", "(", "subcontext", ",", "g", ",", "bounds", ")", ";", "SeaGlassSynthPainterImpl", "painter", "=", "(", "SeaGlassSynthPainterImpl", ")", "subcontext", ".", "getPainter", "(", ")", ";", "painter", ".", "paintSearchButtonForeground", "(", "subcontext", ",", "g", ",", "bounds", ".", "x", ",", "bounds", ".", "y", ",", "bounds", ".", "width", ",", "bounds", ".", "height", ")", ";", "subcontext", ".", "dispose", "(", ")", ";", "return", "tabRect", ";", "}" ]

[ "Paint", "the", "close", "button", "for", "a", "tab", "." ]

[ "protected", "void", "paintScrollButtonBackground", "(", "SeaGlassContext", "ss", ",", "Graphics", "g", ",", "JButton", "scrollButton", ")", "{", "Rectangle", "tabRect", "=", "scrollButton", ".", "getBounds", "(", ")", ";", "int", "x", "=", "tabRect", ".", "x", ";", "int", "y", "=", "tabRect", ".", "y", ";", "int", "height", "=", "tabRect", ".", "height", ";", "int", "width", "=", "tabRect", ".", "width", ";", "boolean", "flipSegments", "=", "(", "orientation", "==", "ControlOrientation", ".", "HORIZONTAL", "&&", "!", "tabPane", ".", "getComponentOrientation", "(", ")", ".", "isLeftToRight", "(", ")", ")", ";", "SeaGlassLookAndFeel", ".", "updateSubregion", "(", "ss", ",", "g", ",", "tabRect", ")", ";", "tabPane", ".", "putClientProperty", "(", "\"JTabbedPane.Tab.segmentPosition\"", ",", "(", "(", "scrollButton", "==", "scrollBackwardButton", ")", "^", "flipSegments", ")", "?", "\"first\"", ":", "\"last\"", ")", ";", "int", "oldState", "=", "tabContext", ".", "getComponentState", "(", ")", ";", "ButtonModel", "model", "=", "scrollButton", ".", "getModel", "(", ")", ";", "int", "isPressed", "=", "model", ".", "isPressed", "(", ")", "&&", "model", ".", "isArmed", "(", ")", "?", "PRESSED", ":", "0", ";", "int", "buttonState", "=", "SeaGlassLookAndFeel", ".", "getComponentState", "(", "scrollButton", ")", "|", "isPressed", ";", "tabContext", ".", "setComponentState", "(", "buttonState", ")", ";", "tabContext", ".", "getPainter", "(", ")", ".", "paintTabbedPaneTabBackground", "(", "tabContext", ",", "g", ",", "x", ",", "y", ",", "width", ",", "height", ",", "-", "1", ",", "tabPlacement", ")", ";", "tabContext", ".", "getPainter", "(", ")", ".", "paintTabbedPaneTabBorder", "(", "tabContext", ",", "g", ",", "x", ",", "y", ",", "width", ",", "height", ",", "-", "1", ",", "tabPlacement", ")", ";", "tabContext", ".", "setComponentState", "(", "oldState", ")", ";", "}" ]

[ "Paint", "the", "background", "for", "a", "tab", "scroll", "button", "." ]

[ "protected", "void", "layoutLabel", "(", "SeaGlassContext", "ss", ",", "int", "tabPlacement", ",", "FontMetrics", "metrics", ",", "int", "tabIndex", ",", "String", "title", ",", "Icon", "icon", ",", "Rectangle", "tabRect", ",", "Rectangle", "iconRect", ",", "Rectangle", "textRect", ",", "boolean", "isSelected", ")", "{", "View", "v", "=", "getTextViewForTab", "(", "tabIndex", ")", ";", "if", "(", "v", "!=", "null", ")", "{", "tabPane", ".", "putClientProperty", "(", "\"html\"", ",", "v", ")", ";", "}", "textRect", ".", "x", "=", "textRect", ".", "y", "=", "iconRect", ".", "x", "=", "iconRect", ".", "y", "=", "0", ";", "ss", ".", "getStyle", "(", ")", ".", "getGraphicsUtils", "(", "ss", ")", ".", "layoutText", "(", "ss", ",", "metrics", ",", "title", ",", "icon", ",", "SwingUtilities", ".", "CENTER", ",", "SwingUtilities", ".", "CENTER", ",", "SwingUtilities", ".", "LEADING", ",", "SwingUtilities", ".", "TRAILING", ",", "tabRect", ",", "iconRect", ",", "textRect", ",", "textIconGap", ")", ";", "tabPane", ".", "putClientProperty", "(", "\"html\"", ",", "null", ")", ";", "int", "xNudge", "=", "getTabLabelShiftX", "(", "tabPlacement", ",", "tabIndex", ",", "isSelected", ")", ";", "int", "yNudge", "=", "getTabLabelShiftY", "(", "tabPlacement", ",", "tabIndex", ",", "isSelected", ")", ";", "iconRect", ".", "x", "+=", "xNudge", ";", "iconRect", ".", "y", "+=", "yNudge", ";", "textRect", ".", "x", "+=", "xNudge", ";", "textRect", ".", "y", "+=", "yNudge", ";", "}" ]

[ "Layout", "label", "text", "for", "a", "tab", "." ]

[ "protected", "void", "paintText", "(", "SeaGlassContext", "ss", ",", "Graphics", "g", ",", "int", "tabPlacement", ",", "Font", "font", ",", "FontMetrics", "metrics", ",", "int", "tabIndex", ",", "String", "title", ",", "Rectangle", "textRect", ",", "boolean", "isSelected", ")", "{", "g", ".", "setFont", "(", "font", ")", ";", "View", "v", "=", "getTextViewForTab", "(", "tabIndex", ")", ";", "if", "(", "v", "!=", "null", ")", "{", "// html", "v", ".", "paint", "(", "g", ",", "textRect", ")", ";", "}", "else", "{", "// plain text", "int", "mnemIndex", "=", "tabPane", ".", "getDisplayedMnemonicIndexAt", "(", "tabIndex", ")", ";", "FontMetrics", "fm", "=", "SwingUtilities2", ".", "getFontMetrics", "(", "tabPane", ",", "g", ")", ";", "title", "=", "SwingUtilities2", ".", "clipStringIfNecessary", "(", "tabPane", ",", "fm", ",", "title", ",", "textRect", ".", "width", ")", ";", "g", ".", "setColor", "(", "ss", ".", "getStyle", "(", ")", ".", "getColor", "(", "ss", ",", "ColorType", ".", "TEXT_FOREGROUND", ")", ")", ";", "ss", ".", "getStyle", "(", ")", ".", "getGraphicsUtils", "(", "ss", ")", ".", "paintText", "(", "ss", ",", "g", ",", "title", ",", "textRect", ",", "mnemIndex", ")", ";", "}", "}" ]

[ "Paint", "the", "label", "text", "for", "a", "tab", "." ]

[ "protected", "void", "paintContentBorder", "(", "SeaGlassContext", "ss", ",", "Graphics", "g", ",", "int", "tabPlacement", ",", "int", "selectedIndex", ")", "{", "int", "width", "=", "tabPane", ".", "getWidth", "(", ")", ";", "int", "height", "=", "tabPane", ".", "getHeight", "(", ")", ";", "Insets", "insets", "=", "tabPane", ".", "getInsets", "(", ")", ";", "int", "x", "=", "insets", ".", "left", ";", "int", "y", "=", "insets", ".", "top", ";", "int", "w", "=", "width", "-", "insets", ".", "right", "-", "insets", ".", "left", ";", "int", "h", "=", "height", "-", "insets", ".", "top", "-", "insets", ".", "bottom", ";", "switch", "(", "tabPlacement", ")", "{", "case", "LEFT", ":", "x", "+=", "calculateTabAreaWidth", "(", "tabPlacement", ",", "runCount", ",", "maxTabWidth", ")", ";", "w", "-=", "(", "x", "-", "insets", ".", "left", ")", ";", "break", ";", "case", "RIGHT", ":", "w", "-=", "calculateTabAreaWidth", "(", "tabPlacement", ",", "runCount", ",", "maxTabWidth", ")", ";", "break", ";", "case", "BOTTOM", ":", "h", "-=", "calculateTabAreaHeight", "(", "tabPlacement", ",", "runCount", ",", "maxTabHeight", ")", ";", "break", ";", "case", "TOP", ":", "default", ":", "y", "+=", "calculateTabAreaHeight", "(", "tabPlacement", ",", "runCount", ",", "maxTabHeight", ")", ";", "h", "-=", "(", "y", "-", "insets", ".", "top", ")", ";", "}", "SeaGlassLookAndFeel", ".", "updateSubregion", "(", "ss", ",", "g", ",", "new", "Rectangle", "(", "x", ",", "y", ",", "w", ",", "h", ")", ")", ";", "ss", ".", "getPainter", "(", ")", ".", "paintTabbedPaneContentBackground", "(", "ss", ",", "g", ",", "x", ",", "y", ",", "w", ",", "h", ")", ";", "ss", ".", "getPainter", "(", ")", ".", "paintTabbedPaneContentBorder", "(", "ss", ",", "g", ",", "x", ",", "y", ",", "w", ",", "h", ")", ";", "}" ]

[ "Paint", "the", "content", "pane", "s", "border", "." ]

[ "private", "void", "ensureCurrentLayout", "(", ")", "{", "if", "(", "!", "tabPane", ".", "isValid", "(", ")", ")", "{", "tabPane", ".", "validate", "(", ")", ";", "}", "/*\n * If tabPane doesn't have a peer yet, the validate() call will silently\n * fail. We handle that by forcing a layout if tabPane is still invalid.\n * See bug 4237677.\n */", "if", "(", "!", "tabPane", ".", "isValid", "(", ")", ")", "{", "TabbedPaneLayout", "layout", "=", "(", "TabbedPaneLayout", ")", "tabPane", ".", "getLayout", "(", ")", ";", "layout", ".", "calculateLayoutInfo", "(", ")", ";", "}", "}" ]

[ "Make", "sure", "we", "have", "laid", "out", "the", "pane", "with", "the", "current", "layout", "." ]