def _on_mouse_released(self, event):
     """ mouse pressed callback """
     if event.button() == 1 and self._deco:
         cursor = TextHelper(self.editor).word_under_mouse_cursor()
         if cursor and cursor.selectedText():
             self._timer.request_job(
                 self.word_clicked.emit, cursor)

 def _on_item_activated(item, *args):
     assert isinstance(item, QtWidgets.QTreeWidgetItem)
     data = item.data(0, QtCore.Qt.UserRole)
     try:
         l = data['line']
     except TypeError:
         return  # file item or root item
     start = data['start']
     lenght = data['end'] - start
     if data is not None:
         # open editor and go to line/column
         e = editor.open_file(data['path'], data['line'], data['start'])
         if e is None:
             return
         # select text
         helper = TextHelper(e)
         try:
             cursor = helper.select_lines(start=l, end=l)
         except AttributeError:
             _logger().debug('failed to select occurent line in editor, not'
                             ' a subclass of QPlainTextEdit')
         else:
             assert isinstance(cursor, QtGui.QTextCursor)
             cursor.movePosition(cursor.StartOfBlock)
             cursor.movePosition(cursor.Right, cursor.MoveAnchor, start)
             cursor.movePosition(cursor.Right, cursor.KeepAnchor, lenght)
             e.setTextCursor(cursor)

    def _check_word_cursor(self, tc=None):
        """
        Request a go to assignment.

        :param tc: Text cursor which contains the text that we must look for
                   its assignment. Can be None to go to the text that is under
                   the text cursor.
        :type tc: QtGui.QTextCursor
        """
        if not tc:
            tc = TextHelper(self.editor).word_under_cursor()

        request_data = {
            'code': self.editor.toPlainText(),
            'line': tc.blockNumber(),
            'column': tc.columnNumber(),
            'path': self.editor.file.path,
            'encoding': self.editor.file.encoding
        }
        try:
            self.editor.backend.send_request(
                workers.goto_assignments, request_data,
                on_receive=self._on_results_available)
        except NotRunning:
            pass

 def _select_word_under_mouse_cursor(self):
     """ Selects the word under the mouse cursor. """
     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()

 def _on_key_pressed(self, event):
     helper = TextHelper(self.editor)
     indent = helper.line_indent() * ' '
     if self.editor.textCursor().positionInBlock() == len(indent):
         self.QUOTES_FORMATS['"'] = '%s:'
     else:
         self.QUOTES_FORMATS['"'] = '%s'
     self.QUOTES_FORMATS['{'] = '\n' + indent + '%s'
     self.QUOTES_FORMATS['['] = '\n' + indent + '%s'
     super(AutoCompleteMode, self)._on_key_pressed(event)

 def _on_mouse_moved(self, event):
     """ mouse moved callback """
     if event.modifiers() & QtCore.Qt.ControlModifier:
         cursor = TextHelper(self.editor).word_under_mouse_cursor()
         if not self._cursor or cursor.position() != self._cursor.position():
             self._check_word_cursor(cursor)
         self._cursor = cursor
     else:
         self._cursor = None
         self._clear_selection()

 def _on_action_quick_doc_triggered(self):
     tc = TextHelper(self.editor).word_under_cursor(select_whole_word=True)
     request_data = {
         'code': self.editor.toPlainText(),
         'line': tc.blockNumber(),
         'column': tc.columnNumber(),
         'path': self.editor.file.path,
         'encoding': self.editor.file.encoding
     }
     self.editor.backend.send_request(
         quick_doc, request_data, on_receive=self._on_results_available)

def test_dynamic_folding_insert_section():
    # test insert section under empty data division
    # data division (which is not a fold trigger initially) block will become a fold trigger
    editor = CobolCodeEdit()
    editor.setPlainText(section_code, '', '')
    th = TextHelper(editor)
    block = editor.document().findBlockByNumber(2)
    assert TextBlockHelper.is_fold_trigger(block) is False
    cursor = th.goto_line(2, column=len('       DATA DIVISION.'))
    cursor.insertText('\n       WORKING-STORAGE SECTION.')
    assert TextBlockHelper.is_fold_trigger(block) is True

 def _in_method_call(self):
     helper = TextHelper(self.editor)
     line_nbr = helper.current_line_nbr() - 1
     expected_indent = helper.line_indent() - 4
     while line_nbr >= 0:
         text = helper.line_text(line_nbr)
         indent = len(text) - len(text.lstrip())
         if indent == expected_indent and 'class' in text:
             return True
         line_nbr -= 1
     return False

def test_add_decoration(editor):
    helper = TextHelper(editor)
    helper.goto_line(2, 2)
    cursor = helper.word_under_cursor(select_whole_word=True)
    deco = TextDecoration(cursor)
    deco.set_as_bold()
    deco.set_as_underlined(QtGui.QColor("#FF0000"))
    editor.decorations.append(deco)
    assert not editor.decorations.append(deco)
    assert deco.contains_cursor(cursor)
    # keep editor clean for next tests
    editor.decorations.clear()

 def _on_post_key_pressed(self, event):
     if not event.isAccepted() and not self._ignore_post:
         txt = event.text()
         next_char = TextHelper(self.editor).get_right_character()
         if txt in self.MAPPING:
             to_insert = self.MAPPING[txt]
             if (not next_char or next_char in self.MAPPING.keys() or
                     next_char in self.MAPPING.values() or
                     next_char.isspace()):
                 TextHelper(self.editor).insert_text(
                     self.QUOTES_FORMATS[txt] % to_insert)
     self._ignore_post = False

 def _on_item_clicked(self, item):
     """
     Go to the item position in the editor.
     """
     if item:
         name = item.data(0, QtCore.Qt.UserRole)
         if name:
             go = name.block.blockNumber()
             helper = TextHelper(self._editor)
             if helper.current_line_nbr() != go:
                 helper.goto_line(go, column=name.column)
             self._editor.setFocus()

def test_clear_decoration(editor):
    # should work even when there are no more decorations
    helper = TextHelper(editor)
    editor.decorations.clear()
    cursor = helper.word_under_cursor(select_whole_word=True)
    deco = TextDecoration(cursor)
    deco.set_as_bold()
    deco.set_as_underlined(QtGui.QColor("#FF0000"))
    editor.decorations.append(deco)
    assert not editor.decorations.append(deco)
    editor.decorations.clear()
    assert editor.decorations.append(deco)
    assert editor.decorations.remove(deco)

def test_remove_decoration(editor):
    helper = TextHelper(editor)
    TextHelper(editor).goto_line(1, 2)
    cursor = helper.word_under_cursor(select_whole_word=True)
    deco = TextDecoration(cursor)
    deco.set_as_bold()
    deco.set_as_underlined(QtGui.QColor("#FF0000"))
    editor.decorations.append(deco)
    assert editor.decorations.remove(deco)
    # already removed, return False
    assert not editor.decorations.remove(deco)
    assert editor.decorations.append(deco)
    # keep editor clean for next tests
    editor.decorations.clear()

 def _on_bt_toggled(self, *ar):
     if not self._lock:
         self._lock = True
         for w in self._widgets:
             if w == self.sender():
                 break
         if self._toggled:
             self._toggled.setChecked(False)
         self._toggled = w
         th = TextHelper(self.editor)
         line = w.scope.blockNumber()
         th.goto_line(line, column=th.line_indent(line))
         self._lock = False
         self.editor.setFocus()

 def _compute_offsets(self):
     original_tc = self.editor.textCursor()
     tc = self.editor.textCursor()
     start = tc.selectionStart()
     end = tc.selectionEnd()
     tc.setPosition(start)
     start_line = tc.blockNumber()
     tc.setPosition(end)
     end_line = tc.blockNumber()
     th = TextHelper(self.editor)
     th.select_lines(start=start_line, end=end_line, apply_selection=True)
     source = th.selected_text()
     results = get_field_infos(source, self.editor.free_format)
     self.editor.setTextCursor(original_tc)
     self.pic_infos_available.emit(results)

 def _computeOffsets(self):
     original_tc = self.editor.textCursor()
     tc = self.editor.textCursor()
     assert isinstance(tc, QTextCursor)
     start = tc.selectionStart()
     end = tc.selectionEnd()
     tc.setPosition(start)
     start_line = tc.blockNumber() + 1
     tc.setPosition(end)
     end_line = tc.blockNumber() + 1
     th = TextHelper(self.editor)
     th.select_lines(start=start_line, end=end_line, apply_selection=True)
     source = th.selected_text()
     self.picInfosAvailable.emit(get_field_infos(source))
     self.editor.setTextCursor(original_tc)

def test_dynamic_folding_insert_end_if():
    # test insert section under empty data division
    # data division (which is not a fold trigger initially) block will become a fold trigger
    editor = CobolCodeEdit()
    editor.setPlainText(end_if_code, '', '')
    th = TextHelper(editor)
    block = editor.document().findBlockByNumber(4)
    first, last = FoldScope(block).get_range()
    assert first == 4
    assert last == 5
    cursor = th.goto_line(5, column=len('          DISPLAY "FOO"'))
    cursor.insertText('\n       END-IF')
    first, last = FoldScope(block).get_range()
    assert first == 4
    assert last == 6
    editor.close()

 def _on_post_key_pressed(self, event):
     if not event.isAccepted() and not self._ignore_post:
         txt = event.text()
         trav = self.editor.textCursor()
         assert isinstance(trav, QtGui.QTextCursor)
         trav.movePosition(trav.Left, trav.MoveAnchor, 2)
         literal = TextHelper(self.editor).is_comment_or_string(trav)
         if not literal:
             next_char = TextHelper(self.editor).get_right_character()
             if txt in self.MAPPING:
                 to_insert = self.MAPPING[txt]
                 if (not next_char or next_char in self.MAPPING.keys() or
                         next_char in self.MAPPING.values() or
                         next_char.isspace()):
                     TextHelper(self.editor).insert_text(
                         self.QUOTES_FORMATS[txt] % to_insert)
     self._ignore_post = False

    def requestGoTo(self, tc=None):
        """
        Request a go to assignment.

        :param tc: Text cursor which contains the text that we must look for
                   its assignment. Can be None to go to the text that is under
                   the text cursor.
        :type tc: QtGui.QTextCursor
        """
        if not tc:
            tc = TextHelper(self.editor).word_under_cursor(
                select_whole_word=True)
        symbol = tc.selectedText()
        analyser = getattr(self.editor, "analyserMode")
        if analyser:
            node = analyser.root_node.find(symbol)
            if node:
                self._definition = node
                QTimer.singleShot(100, self._goToDefinition)