Add tickmarks to the editor's tickmark track, if it's visible
@param curEditor {!Editor}
@param posArray {!Array.<{line:Number, ch:Number}>}
348195
function addTickmarks(curEditor, posArray) {
        console.assert(editor === curEditor);

        marks = marks.concat(posArray);
        _renderMarks(posArray);
    }
1113947
void addInProgressCheckpoint(PendingCheckpointStats pending) {
		if (readOnly) {
			throw new UnsupportedOperationException("Can't create a snapshot of a read-only history.");
		}

		if (maxSize == 0) {
			return;
		}

		checkNotNull(pending, "Pending checkpoint");

		// Grow the array if required. This happens only for the first entries
		// and makes the iterator logic easier, because we don't have any
		// null elements with the growing array.
		if (checkpointsArray.length < maxSize) {
			checkpointsArray = Arrays.copyOf(checkpointsArray, checkpointsArray.length + 1);
		}

		// Wrap around if we are at the end. The next pos is the least recently
		// added checkpoint.
		if (nextPos == checkpointsArray.length) {
			nextPos = 0;
		}

		checkpointsArray[nextPos++] = pending;
	}
867416
private void drawTicks() {
		// Abort if not attached
		if (!isAttached()) {
			return;
		}

		// Draw the ticks
		int lineWidth = lineElement.getOffsetWidth();
		if (numTicks > 0) {
			// Create the ticks or make them visible
			for (int i = 0; i <= numTicks; i++) {
				Element tick = null;
				if (i < tickElements.size()) {
					tick = tickElements.get(i);
				} else { // Create the new tick
					tick = DOM.createDiv();
					DOM.setStyleAttribute(tick, "position", "absolute");
					DOM.setStyleAttribute(tick, "display", "none");
					DOM.appendChild(getElement(), tick);
					tickElements.add(tick);
				}
				if (enabled) {
					DOM.setElementProperty(tick, "className", SLIDER_TICK);
				} else {
					DOM.setElementProperty(tick, "className", SLIDER_TICK + " "
							+ SLIDER_TICK_SLIDING);
				}
				// Position the tick and make it visible
				DOM.setStyleAttribute(tick, "visibility", "hidden");
				DOM.setStyleAttribute(tick, "display", "");
				int tickWidth = tick.getOffsetWidth();
				int tickLeftOffset = lineLeftOffset + (lineWidth * i / numTicks) - (tickWidth / 2);
				tickLeftOffset = Math.min(tickLeftOffset, lineLeftOffset + lineWidth - tickWidth);
				DOM.setStyleAttribute(tick, "left", tickLeftOffset + "px");
				DOM.setStyleAttribute(tick, "visibility", "visible");
			}

			// Hide unused ticks
			for (int i = (numTicks + 1); i < tickElements.size(); i++) {
				DOM.setStyleAttribute(tickElements.get(i), "display", "none");
			}
		} else { // Hide all ticks
			for (Element elem : tickElements) {
				DOM.setStyleAttribute(elem, "display", "none");
			}
		}
	}
546900
void markAsProcessed(final CtClass ctClass) {
        final ClassFile classFile = ctClass.getClassFile();
        for (final Object attributeObject : classFile.getAttributes()) {
            if (attributeObject instanceof AnnotationsAttribute) {
                final AnnotationsAttribute annotationAttribute = (AnnotationsAttribute) attributeObject;
                final javassist.bytecode.annotation.Annotation annotation = annotationAttribute.getAnnotation(PROCESSED_ANNOTATION_CLASS);
                if (annotation != null) {
                    return;
                }
            }
        }

        final javassist.bytecode.annotation.Annotation annotation =
                new javassist.bytecode.annotation.Annotation(PROCESSED_ANNOTATION_CLASS, classFile.getConstPool());
        final AnnotationsAttribute annotationAttribute =
                new AnnotationsAttribute(classFile.getConstPool(), AnnotationsAttribute.visibleTag);
        annotationAttribute.addAnnotation(annotation);
        classFile.addAttribute(annotationAttribute);
    }
626590
public void addMarker(final Marker MARKER) {
        if (null == MARKER) return;
        markers.add(MARKER);
        Collections.sort(markers, new MarkerComparator());
        fireUpdateEvent(REDRAW_EVENT);
    }
1314115
function _reinstateMarkers(editor, frames) {
        var index, frame;
        for (index in frames) {
            frame = frames[index];
            if (!frame.cm && frame.filePath === editor.document.file._path) {
                frame._reinstateMarkers(editor);
            }
        }
    }
141685
private void addPoint() {
		ControlPoint point = new ControlPoint(Color.white, 0.5f);
		for (int i=0;i<list.size()-1;i++) {
			ControlPoint now = (ControlPoint) list.get(i);
			ControlPoint next = (ControlPoint) list.get(i+1);
			if ((now.pos <= 0.5f) && (next.pos >=0.5f)) {
				list.add(i+1,point);
				break;
			}
			
		}
		selected = point;
		sortPoints();
		repaint(0);
		
		fireUpdate();
	}
169921
void markAsProcessed(
            final CtClass ctClass,
            final ClassProcessor processor) {
        final ClassFile classFile = ctClass.getClassFile();
        AnnotationsAttribute annotationAttribute = null;
        Annotation annotation = null;
        for (final Object attributeObject : classFile.getAttributes()) {
            if (attributeObject instanceof AnnotationsAttribute) {
                annotationAttribute = (AnnotationsAttribute) attributeObject;
                annotation = annotationAttribute.getAnnotation(PROCESSED_ANNOTATION_CLASS);
                if (annotation != null) {
                    break;
                }
            }
        }
        if (annotation == null) {
            _log.debug("Creating annotation attribute on: " + ctClass.getName());
            annotationAttribute = new AnnotationsAttribute(classFile.getConstPool(), AnnotationsAttribute.invisibleTag);
            classFile.addAttribute(annotationAttribute);
            _log.debug("Creating processed annotation on: " + ctClass.getName());
            annotation = new Annotation(PROCESSED_ANNOTATION_CLASS, classFile.getConstPool());
        }
        MemberValue value = annotation.getMemberValue("value");
        if (value == null) {
            value = new ArrayMemberValue(classFile.getConstPool());
            annotation.addMemberValue("value", value);
        }
        final ArrayMemberValue valueArray = (ArrayMemberValue) value;
        final MemberValue[] existingProcessorValues = valueArray.getValue();
        final MemberValue[] newProcessorValues;
        if (existingProcessorValues != null) {
            newProcessorValues = Arrays.copyOf(valueArray.getValue(), valueArray.getValue().length + 1);
        } else {
            newProcessorValues = new MemberValue[1];
        }
        newProcessorValues[newProcessorValues.length - 1] = new StringMemberValue(
                processor.getClass().getName(),
                classFile.getConstPool());
        valueArray.setValue(newProcessorValues);
        _log.debug("New processed annotation value on: " + ctClass.getName() + " = " + valueArray);
        annotationAttribute.addAnnotation(annotation);
    }
1029424
public void updateEditorMode() {

        CmsClientSitemapEntry entry = getSitemapEntry();
        getListItemWidget().setIcon(CmsSitemapView.getInstance().getIconForEntry(entry));
        setAdditionalStyles(entry, getListItemWidget());
        for (Widget child : m_children) {
            if (child instanceof CmsSitemapTreeItem) {
                ((CmsSitemapTreeItem)child).updateEditorMode();
            }
        }
    }
1066492
public void setMinorTickMarksVisible(final boolean VISIBLE) {
        if (null == minorTickMarksVisible) {
            _minorTickMarksVisible = VISIBLE;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            minorTickMarksVisible.set(VISIBLE);
        }
    }
1093255
private static void addMarkerLine(String label, Double value, Double offset, Axis axis) {
    if (value != null) {
      MarkerLine markerLine = MarkerLineImpl.create(axis, NumberDataElementImpl.create(value + (offset != null ? offset : 0d)));
      markerLine.getLineAttributes().setStyle(LineStyle.DASHED_LITERAL);
      markerLine.getLabel().getCaption().setValue(label);
      markerLine.setLabelAnchor(Anchor.NORTH_EAST_LITERAL);
    }
  }
301461
public void setHourTickMarksVisible(final boolean VISIBLE) {
        if (null == hourTickMarksVisible) {
            _hourTickMarksVisible = VISIBLE;
            fireTileEvent(REDRAW_EVENT);
        } else {
            hourTickMarksVisible.set(VISIBLE);
        }
    }
580076
public void setHourTickMarksVisible(final boolean VISIBLE) {
        if (null == hourTickMarksVisible) {
            _hourTickMarksVisible = VISIBLE;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            hourTickMarksVisible.set(VISIBLE);
        }
    }
1049734
public void note(DiagnosticPosition pos, Note noteKey) {
        report(diags.note(source, pos, noteKey));
    }
618988
public static <K, V> void initOrAddList(Map<K, List<V>> orginMap, K key, V needAdd) {
        List<V> listeners = orginMap.get(key);
        if (listeners == null) {
            listeners = new CopyOnWriteArrayList<V>();
            listeners.add(needAdd);
            orginMap.put(key, listeners);
        } else {
            listeners.add(needAdd);
        }
    }
56549
public void add(int numberOfParagraph, int startOfSentencePosition, int nextSentencePosition, SingleProofreadingError[] errorArray) {
    entries.add(new CacheEntry(numberOfParagraph, startOfSentencePosition, nextSentencePosition, errorArray));
  }
1135343
public static void addProblemToCompilationResult(char[] fileNameArray, CompilationResult result,
			boolean isWarning, String message, int sourceStart, int sourceEnd) {
		if (result == null) return;
		if (fileNameArray == null) fileNameArray = "(unknown).java".toCharArray();
		int lineNumber = 0;
		int columnNumber = 1;
		int[] lineEnds = null;
		lineNumber = sourceStart >= 0
				? Util.getLineNumber(sourceStart, lineEnds = result.getLineSeparatorPositions(), 0, lineEnds.length-1)
				: 0;
		columnNumber = sourceStart >= 0
				? Util.searchColumnNumber(result.getLineSeparatorPositions(), lineNumber,sourceStart)
				: 0;
		
		CategorizedProblem ecProblem = new LombokProblem(
				fileNameArray, message, 0, new String[0],
				isWarning ? ProblemSeverities.Warning : ProblemSeverities.Error,
				sourceStart, sourceEnd, lineNumber, columnNumber);
		result.record(ecProblem, null);
	}