Clear bookmarks on block range including start and end
175731
def clear(self, startBlock, endBlock):
        
        for block in qutepart.iterateBlocksFrom(startBlock):
            self._setBlockMarked(block, False)
            if block == endBlock:
                break
1109358
function (rangeLength) {
            var i, l;
            // remove out-of-range SVG from DOM
            for (i = 0, l = pages.length; i < l; ++i) {
                if (shouldUnloadPage(i, rangeLength)) {
                    this.unloadPage(i);
                }
            }
        }
946034
function () {
          data = [];
          index = 0;
          self.typing = false;
          self.data = data;
          editor.fire('ClearUndos');
        }
96295
function clearCache() {
  require('./AboutTable.js').clearCache();
  require('./CalendarTable.js').clearCache();
  require('./HolidayTable.js').clearCache();
  require('./LineGraphTable.js').clearCache();
  require('./LinksTable.js').clearCache();
  require('./RouteGraphTable.js').clearCache();
  require('./RoutesTable.js').clearCache();
  require('./StopsTable.js').clearCache();
  require('./StopTimesTable.js').clearCache();
  require('./TripsTable.js').clearCache();
}
1074795
function()
		{
			var startContainer = this.startContainer,
				startOffset = this.startOffset;

			// If the starting node is a text node, and non-empty before the offset,
			// then we're surely not at the start of block.
			if ( startOffset && startContainer.type == CKEDITOR.NODE_TEXT )
			{
				var textBefore = CKEDITOR.tools.ltrim( startContainer.substring( 0, startOffset ) );
				if ( textBefore.length )
					return false;
			}

			// Antecipate the trim() call here, so the walker will not make
			// changes to the DOM, which would not get reflected into this
			// range otherwise.
			this.trim();

			// We need to grab the block element holding the start boundary, so
			// let's use an element path for it.
			var path = new CKEDITOR.dom.elementPath( this.startContainer );

			// Creates a range starting at the block start until the range start.
			var walkerRange = this.clone();
			walkerRange.collapse( true );
			walkerRange.setStartAt( path.block || path.blockLimit, CKEDITOR.POSITION_AFTER_START );

			var walker = new CKEDITOR.dom.walker( walkerRange );
			walker.evaluator = getCheckStartEndBlockEvalFunction( true );

			return walker.checkBackward();
		}
591133
function clearSelection () {
                    if ($window.getSelection) {
                        if ($window.getSelection().empty) {  // Chrome
                            $window.getSelection().empty();
                        } else if ($window.getSelection().removeAllRanges) {  // Firefox
                            $window.getSelection().removeAllRanges();
                        }
                    } else if ($document.selection) {  // IE?
                        $document.selection.empty();
                    }
                }
873854
def remove_range(self, start, end):
        '''
        '''
        return self._sl.remove_range(
            start, end, callback=lambda sc, value: self._dict.pop(value))
1107348
public void clearBlockMarks() {
    for (StorageTierView tierView : mTierViews) {
      for (StorageDirView dirView : tierView.getDirViews()) {
        dirView.clearBlockMarks();
      }
    }
  }
753683
def _clear(self, fully=True):
        """"""
        pages = self.pages
        if not pages:
            return
        self._keyframe = pages[0]
        if fully:
            # delete all but first TiffPage/TiffFrame
            for i, page in enumerate(pages[1:]):
                if not isinstance(page, inttypes) and page.offset is not None:
                    pages[i+1] = page.offset
        elif TiffFrame is not TiffPage:
            # delete only TiffFrames
            for i, page in enumerate(pages):
                if isinstance(page, TiffFrame) and page.offset is not None:
                    pages[i] = page.offset
        self._cached = False
81742
def clear(board, term, height):
    """"""
    for y in xrange(height):
        print term.move(y, 0) + term.clear_eol,
322893
def erase_start_of_line (self): # <ESC>[1K
        ''''''

        self.fill_region (self.cur_r, 1, self.cur_r, self.cur_c)
1011314
def clear(self):
        """"""
        # Adapted from http://stackoverflow.com/a/13103617/1198772
        for i in reversed(list(range(self.extra_keywords_layout.count()))):
            self.extra_keywords_layout.itemAt(i).widget().setParent(None)
        self.widgets_dict = OrderedDict()
377721
private void excludeTemplateRange(int tPosBegin, int tPosEnd) {
        if (blockTabCnt > 0) {
            // Check whether we can extend the previous block.
            BlockTabRec btr = blockTab[blockTabCnt - 1];
            if (btr.dummy && btr.tPosEnd == tPosBegin) {
                btr.tPosContentsEnd = tPosEnd;
                btr.tPosEnd = tPosEnd;
                return;
            }
        }
        int blockNo = registerBlock(null);
        BlockTabRec btr = blockTab[blockNo];
        btr.tPosBegin = tPosBegin;
        btr.tPosContentsBegin = tPosBegin;
        btr.tPosContentsEnd = tPosEnd;
        btr.tPosEnd = tPosEnd;
        btr.definitionIsOpen = false;
        btr.dummy = true;
    }
734780
function clearCache() {
  cache_stopById.clear();
  cache_stopByName.clear();
  cache_stopByStatusId.clear();
  cache_stops.clear();
  cache_stopsByRoute.clear();
}
746629
def _onPrevBookmark(self):
        
        for block in qutepart.iterateBlocksBackFrom(self._qpart.textCursor().block().previous()):
            if self.isBlockMarked(block):
                self._qpart.setTextCursor(QTextCursor(block))
                return
89978
synchronized void trim(long startKey, long endKey) {
        /*
         * [3, 4, 5, 9] -> [10, 13, 14, 15] -> [21, 24, 29, 30] -> [31] :: start layout
         *       |5______________________________23|                    :: trim(5, 23)
         *       [5, 9] -> [10, 13, 14, 15] -> [21]                     :: result layout
         */
        final Iterator<Chunk> descendingIterator = chunks.descendingIterator();
        while (descendingIterator.hasNext()) {
            final Chunk currentTail = descendingIterator.next();
            if (isFirstElementIsEmptyOrGreaterEqualThanKey(currentTail, endKey)) {
                freeChunk(currentTail);
                descendingIterator.remove();
            } else {
                currentTail.cursor = findFirstIndexOfGreaterEqualElements(currentTail.keys, currentTail.startIndex,
                        currentTail.cursor, endKey);
                break;
            }
        }

        final Iterator<Chunk> iterator = chunks.iterator();
        while (iterator.hasNext()) {
            final Chunk currentHead = iterator.next();
            if (isLastElementIsLessThanKey(currentHead, startKey)) {
                freeChunk(currentHead);
                iterator.remove();
            } else {
                final int newStartIndex = findFirstIndexOfGreaterEqualElements(currentHead.keys, currentHead.startIndex,
                        currentHead.cursor, startKey);
                if (currentHead.startIndex != newStartIndex) {
                    currentHead.startIndex = newStartIndex;
                    currentHead.chunkSize = currentHead.cursor - currentHead.startIndex;
                }
                break;
            }
        }
    }
237475
def clear(self):
        """"""
        if self.prefix is not None:
            self._current_page = [self.prefix]
            self._count = len(self.prefix) + 1 # prefix + newline
        else:
            self._current_page = []
            self._count = 0
        self._pages = []