getBaseline, This returns the baseline value of the dateTextField.
430478
@Override
    public int getBaseline(int width, int height) {
        if (dateTextField.isVisible()) {
            return dateTextField.getBaseline(width, height);
        }
        return super.getBaseline(width, height);
    }
292103
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
	public float getLineSpacingExtra (){
		if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
			return mInputView.getLineSpacingExtra();
		return 0f;
	}
1268858
@SuppressWarnings("unchecked")
    static <T> RuntimeFieldFactory<T> getInline(String className)
    {
        return (RuntimeFieldFactory<T>) __inlineValues.get(className);
    }
716110
public void setBaselineFixedCost(int baselineNumber, Number value)
   {
      set(selectField(TaskFieldLists.BASELINE_FIXED_COSTS, baselineNumber), value);
   }
430610
public void setBaselineCost(int baselineNumber, Number value)
   {
      set(selectField(AssignmentFieldLists.BASELINE_COSTS, baselineNumber), value);
   }
8916
protected function _getBaseString($baseField, $data) {
        $type = $baseField['type'];
        $method = '_getBaseStringFrom' . ucfirst($type);
        return $this->{$method}($data, $baseField);
    }
794468
public void setBaselineWork(int baselineNumber, Duration value)
   {
      set(selectField(ResourceFieldLists.BASELINE_WORKS, baselineNumber), value);
   }
422729
private void readAssignmentBaselines(Project.Assignments.Assignment assignment, ResourceAssignment mpx)
   {
      for (Project.Assignments.Assignment.Baseline baseline : assignment.getBaseline())
      {
         int number = NumberHelper.getInt(baseline.getNumber());

         //baseline.getBCWP()
         //baseline.getBCWS()
         Number cost = DatatypeConverter.parseExtendedAttributeCurrency(baseline.getCost());
         Date finish = DatatypeConverter.parseExtendedAttributeDate(baseline.getFinish());
         //baseline.getNumber()
         Date start = DatatypeConverter.parseExtendedAttributeDate(baseline.getStart());
         Duration work = DatatypeConverter.parseDuration(m_projectFile, TimeUnit.HOURS, baseline.getWork());

         if (number == 0)
         {
            mpx.setBaselineCost(cost);
            mpx.setBaselineFinish(finish);
            mpx.setBaselineStart(start);
            mpx.setBaselineWork(work);
         }
         else
         {
            mpx.setBaselineCost(number, cost);
            mpx.setBaselineWork(number, work);
            mpx.setBaselineStart(number, start);
            mpx.setBaselineFinish(number, finish);
         }
      }
   }
311165
public void createBaseLine(List<VersionDescription> versions, ExcludeIncludeList excludesIncludes, Path descDest, Path jdkRoot) throws IOException {
        ClassList classes = new ClassList();

        for (VersionDescription desc : versions) {
            ClassList currentVersionClasses = new ClassList();
            try (BufferedReader descIn = Files.newBufferedReader(Paths.get(desc.classes))) {
                String classFileData;

                while ((classFileData = descIn.readLine()) != null) {
                    ByteArrayOutputStream data = new ByteArrayOutputStream();
                    for (int i = 0; i < classFileData.length(); i += 2) {
                        data.write(Integer.parseInt(classFileData.substring(i, i + 2), 16));
                    }
                    try (InputStream in = new ByteArrayInputStream(data.toByteArray())) {
                        inspectClassFile(in, currentVersionClasses, excludesIncludes, desc.version);
                    } catch (IOException | ConstantPoolException ex) {
                        throw new IllegalStateException(ex);
                    }
                }
            }

            Set<String> includedClasses = new HashSet<>();
            boolean modified;

            do {
                modified = false;

                for (ClassDescription clazz : currentVersionClasses) {
                    ClassHeaderDescription header = clazz.header.get(0);

                    if (includeEffectiveAccess(currentVersionClasses, clazz)) {
                        modified |= include(includedClasses, currentVersionClasses, clazz.name);
                    }

                    if (includedClasses.contains(clazz.name)) {
                        modified |= include(includedClasses, currentVersionClasses, header.extendsAttr);
                        for (String i : header.implementsAttr) {
                            modified |= include(includedClasses, currentVersionClasses, i);
                        }

                        modified |= includeOutputType(Collections.singleton(header),
                                                      h -> "",
                                                      includedClasses,
                                                      currentVersionClasses);
                        modified |= includeOutputType(clazz.fields,
                                                      f -> f.descriptor,
                                                      includedClasses,
                                                      currentVersionClasses);
                        modified |= includeOutputType(clazz.methods,
                                                      m -> m.descriptor,
                                                      includedClasses,
                                                      currentVersionClasses);
                    }
                }
            } while (modified);

            for (ClassDescription clazz : currentVersionClasses) {
                if (!includedClasses.contains(clazz.name)) {
                    continue;
                }

                ClassHeaderDescription header = clazz.header.get(0);

                if (header.innerClasses != null) {
                    Iterator<InnerClassInfo> innerClassIt = header.innerClasses.iterator();

                    while(innerClassIt.hasNext()) {
                        InnerClassInfo ici = innerClassIt.next();
                        if (!includedClasses.contains(ici.innerClass))
                            innerClassIt.remove();
                    }
                }

                ClassDescription existing = classes.find(clazz.name, true);

                if (existing != null) {
                    addClassHeader(existing, header, desc.version);
                    for (MethodDescription currentMethod : clazz.methods) {
                        addMethod(existing, currentMethod, desc.version);
                    }
                    for (FieldDescription currentField : clazz.fields) {
                        addField(existing, currentField, desc.version);
                    }
                } else {
                    classes.add(clazz);
                }
            }
        }

        classes.sort();

        Map<String, String> package2Modules = buildPackage2Modules(jdkRoot);
        Map<String, List<ClassDescription>> module2Classes = new HashMap<>();

        for (ClassDescription clazz : classes) {
            String pack;
            int lastSlash = clazz.name.lastIndexOf('/');
            if (lastSlash != (-1)) {
                pack = clazz.name.substring(0, lastSlash).replace('/', '.');
            } else {
                pack = "";
            }
            String module = package2Modules.get(pack);

            if (module == null) {
                module = "java.base";

                OUTER: while (!pack.isEmpty()) {
                    for (Entry<String, String> p2M : package2Modules.entrySet()) {
                        if (p2M.getKey().startsWith(pack)) {
                            module = p2M.getValue();
                            break OUTER;
                        }
                    }
                    int dot = pack.lastIndexOf('.');
                    if (dot == (-1))
                        break;
                    pack = pack.substring(0, dot);
                }
            }
            module2Classes.computeIfAbsent(module, m -> new ArrayList<>())
                    .add(clazz);
        }

        Path symbolsFile = descDest.resolve("symbols");

        Files.createDirectories(symbolsFile.getParent());

        try (Writer symbolsOut = Files.newBufferedWriter(symbolsFile)) {
            Map<VersionDescription, List<Path>> outputFiles = new LinkedHashMap<>();

            for (Entry<String, List<ClassDescription>> e : module2Classes.entrySet()) {
                for (VersionDescription desc : versions) {
                    Path f = descDest.resolve(e.getKey() + "-" + desc.version + ".sym.txt");
                    try (Writer out = Files.newBufferedWriter(f)) {
                        for (ClassDescription clazz : e.getValue()) {
                            clazz.write(out, desc.primaryBaseline, desc.version);
                        }
                    }
                    outputFiles.computeIfAbsent(desc, d -> new ArrayList<>())
                               .add(f);
                }
            }
            symbolsOut.append("generate platforms ")
                      .append(versions.stream()
                                      .map(v -> v.version)
                                      .collect(Collectors.joining(":")))
                      .append("\n");
            for (Entry<VersionDescription, List<Path>> versionFileEntry : outputFiles.entrySet()) {
                symbolsOut.append("platform version ")
                          .append(versionFileEntry.getKey().version);
                if (versionFileEntry.getKey().primaryBaseline != null) {
                    symbolsOut.append(" base ")
                              .append(versionFileEntry.getKey().primaryBaseline);
                }
                symbolsOut.append(" files ")
                          .append(versionFileEntry.getValue()
                                                  .stream()
                                                  .map(p -> p.getFileName().toString())
                                                  .sorted()
                                                  .collect(Collectors.joining(":")))
                          .append("\n");
            }
        }
    }
129673
public DateTextField getDateTextField(){
		DateTextField component = visitChildren(DateTextField.class, new IVisitor<DateTextField, DateTextField>() {
			@Override
			public void component(DateTextField arg0, IVisit<DateTextField> arg1) {
				arg1.stop(arg0);
			}
		});

		if (component == null)
			throw new WicketRuntimeException("BootstrapDatepicker didn't have any DateTextField child!");

		return component;
	}
217720
public void setBaselineFixedCostAccrual(int baselineNumber, AccrueType value)
   {
      set(selectField(TaskFieldLists.BASELINE_FIXED_COST_ACCRUALS, baselineNumber), value);
   }
510890
public Date getBaselineFinish()
   {
      Object result = getCachedValue(TaskField.BASELINE_FINISH);
      if (result == null)
      {
         result = getCachedValue(TaskField.BASELINE_ESTIMATED_FINISH);
      }

      if (!(result instanceof Date))
      {
         result = null;
      }
      return (Date) result;
   }
1310634
public String getBaselineDurationText()
   {
      Object result = getCachedValue(TaskField.BASELINE_DURATION);
      if (result == null)
      {
         result = getCachedValue(TaskField.BASELINE_ESTIMATED_DURATION);
      }

      if (!(result instanceof String))
      {
         result = null;
      }
      return (String) result;
   }
405442
public String getBaselineFinishText(int baselineNumber)
   {
      Object result = getCachedValue(selectField(TaskFieldLists.BASELINE_FINISHES, baselineNumber));
      if (result == null)
      {
         result = getCachedValue(selectField(TaskFieldLists.BASELINE_ESTIMATED_FINISHES, baselineNumber));
      }

      if (!(result instanceof String))
      {
         result = null;
      }
      return (String) result;
   }
963609
public Duration getBaselineEstimatedDuration(int baselineNumber)
   {
      Object result = getCachedValue(selectField(TaskFieldLists.BASELINE_ESTIMATED_DURATIONS, baselineNumber));
      if (!(result instanceof Duration))
      {
         result = null;
      }
      return (Duration) result;
   }
1192477
public Date getBaselineEstimatedFinish(int baselineNumber)
   {
      Object result = getCachedValue(selectField(TaskFieldLists.BASELINE_ESTIMATED_FINISHES, baselineNumber));
      if (!(result instanceof Date))
      {
         result = null;
      }
      return (Date) result;
   }
1120670
public void setBaselineCost(int baselineNumber, Number value)
   {
      set(selectField(TaskFieldLists.BASELINE_COSTS, baselineNumber), value);
   }