Gets the character on the right of the text cursor.

        :param cursor: QTextCursor where the search will start.

        :return: The word that is on the right of the text cursor.
438607
def get_right_word(self, cursor=None):
        
        if cursor is None:
            cursor = self._editor.textCursor()
        cursor.movePosition(QtGui.QTextCursor.WordRight,
                            QtGui.QTextCursor.KeepAnchor)
        return cursor.selectedText().strip()
1030624
def _get_mouse_cursor(self):
        
        if self.mouse_cursor is not None:
            return self.mouse_cursor
        elif self.interactive and self.draggable:
            return gdk.CursorType.FLEUR
        elif self.interactive:
            return gdk.CursorType.HAND2
239916
public String getRightOf(String srcStr, int charCount) {

        String retVal = "";

        if (isNotBlank(srcStr)) {

            int length = srcStr.length();

            if (charCount < length) {
                retVal = srcStr.substring(length - charCount, length);
            } else {
                retVal = srcStr;
            }
        } else {

        }

        return retVal;
    }
270200
def cursor_to_line(self, line=None):
        
        self.cursor.y = (line or 1) - 1

        # If origin mode (DECOM) is set, line number are relative to
        # the top scrolling margin.
        if mo.DECOM in self.mode:
            self.cursor.y += self.margins.top

            # FIXME: should we also restrict the cursor to the scrolling
            # region?

        self.ensure_vbounds()
1170906
def word_under_cursor_pos(self):
        """"""
        self._vim.command('normal e')
        end = self.cursor()
        self._vim.command('normal b')
        beg = self.cursor()
        return beg, end
1297537
def forward_word(event):
    
    buff = event.current_buffer
    pos = buff.document.find_next_word_ending(count=event.arg)

    if pos:
        buff.cursor_position += pos
306285
def get_string(self):
    
    return self.left.chr+':'+str(self.left.end)+'-'+self.right.chr+':'+str(self.right.start)
772142
def word_right(_keyboard_args)
      if @edit_posn < length
        right = @edit_buffer[(@edit_posn+1)..-1]
        @edit_posn = (posn = right.index(/\s\S/)) ? @edit_posn+posn+2 : length
      else
        MiniTerm.beep
      end
    end
1168029
@Override
   public CursorPosition getCursor()
   {
      if (settings.isAnsiConsole() && Config.isOSPOSIXCompatible())
      {
         try
         {
            StringBuilder col = new StringBuilder(4);
            StringBuilder row = new StringBuilder(4);
            out().print(ANSI.CURSOR_ROW);
            out().flush();
            boolean gotSep = false;
            // read the position
            int[] input = read();

            for (int i = 2; i < input.length - 1; i++)
            {
               if (input[i] == 59) // we got a ';' which is the separator
                  gotSep = true;
               else
               {
                  if (gotSep)
                     col.append((char) input[i]);
                  else
                     row.append((char) input[i]);
               }
            }
            return new CursorPosition(Integer.parseInt(row.toString()),
                     Integer.parseInt(col.toString()));
         }
         catch (Exception e)
         {
            if (settings.isLogging())
               logger.log(Level.SEVERE,
                        "Failed to find current row with ansi code: ", e);
            return new CursorPosition(-1, -1);
         }
      }
      return new CursorPosition(-1, -1);
   }
880864
def get_word_under_cursor(self, WORD=False):
        
        start, end = self.find_boundaries_of_current_word(WORD=WORD)
        return self.text[self.cursor_position + start: self.cursor_position + end]
691105
function (streamer) {
	var character   = streamer.current(),
		start_index = streamer.cursor.index, end;

	while (character && character > ' ' && DELIMITERS.indexOf(character) === -1) {
		end       = streamer.get_cursor();
		character = streamer.next();
	}
	streamer.cursor = end;

	return streamer.seek(start_index, end.index + 1);
}
711226
def get_start_of_line_position(self, after_whitespace=False):
        
        if after_whitespace:
            current_line = self.current_line
            return len(current_line) - len(current_line.lstrip()) - self.cursor_position_col
        else:
            return - len(self.current_line_before_cursor)
409484
def get_cursor(cls):
        """"""
        db = SqliteConnection.get()
        db.row_factory = sqlite3.Row
        return db.cursor()
674165
def cursor_position(self):
        
        return (self._editor.textCursor().blockNumber(),
                self._editor.textCursor().columnNumber())
537021
def _select_word_cursor(self):
        
        cursor = TextHelper(self.editor).word_under_mouse_cursor()
        if (self._previous_cursor_start != cursor.selectionStart() and
                self._previous_cursor_end != cursor.selectionEnd()):
            self._remove_decoration()
            self._add_decoration(cursor)
        self._previous_cursor_start = cursor.selectionStart()
        self._previous_cursor_end = cursor.selectionEnd()
162769
def get_word_at(self, coordinates):
        """"""
        cursor = self.cursorForPosition(coordinates)
        cursor.select(QTextCursor.WordUnderCursor)
        return to_text_string(cursor.selectedText())
256763
def has_match_at_current_position(self, sub):
        
        return self.text.find(sub, self.cursor_position) == self.cursor_position