def monitorDownloadThread(downloadThread):
    if downloadThread.is_alive():
        msg = downloadThread.getCurrentMessage()
        sublime.status_message(msg)
        sublime.set_timeout(lambda: monitorDownloadThread(downloadThread), CHECK_DOWNLOAD_THREAD_TIME_MS)
    else:
        downloadThread.showResultToPresenter()

    def on_done_filename(self, value):
        self.filename = value
        # get selected text, or the whole file if nothing selected
        if all([region.empty() for region in self.view.sel()]):
            text = self.view.substr(sublime.Region(0, self.view.size()))
        else:
            text = "\n".join([self.view.substr(region) for region in self.view.sel()])

        try:
            gist = self.gistapi.create_gist(description=self.description,
                                            filename=self.filename,
                                            content=text,
                                            public=self.public)
            self.view.settings().set('gist', gist)
            sublime.set_clipboard(gist["html_url"])
            sublime.status_message(self.MSG_SUCCESS)
        except GitHubApi.UnauthorizedException:
            # clear out the bad token so we can reset it
            self.settings.set("github_token", "")
            sublime.save_settings("GitHub.sublime-settings")
            sublime.error_message(self.ERR_UNAUTHORIZED_TOKEN)
            sublime.set_timeout(self.get_username, 50)
        except GitHubApi.UnknownException as e:
            sublime.error_message(e.message)
        except GitHubApi.ConnectionException as e:
            sublime.error_message(e.message)

	def on_complete(self, *args, **kwargs):
		self.state = 'complete'

		if kwargs['progress'].is_background:
			return

		sublime.set_timeout(lambda: sublime.status_message('PyV8 binary successfully loaded'), 0)

 def __init__(self, threads, message, success_message):
     self.threads = threads
     self.message = message
     self.success_message = success_message
     self.addend = 1
     self.size = 15
     sublime.set_timeout(lambda: self.run(0), 100)

    def defered_update(self, view):
        if not view.window():  # If view is not visible window() will be None.
            return

        if view.id() not in self.seen_views:
            self.seen_views.append(view.id())

        if view_is_widget(view):
            return

        if not self.is_enabled(view):
            return

        if view_is_too_big(view, self.max_size_setting,
                           self.default_max_file_size):
            self.view_is_too_big_callback(view)
            return

        def func():
            self.update(view)

        if self.delay:
            sublime.set_timeout(func, self.delay)
        else:
            func()

    def handle_threads(self, edit, threads, selections, offset = 0, i = 0, dir = 1):

        next_threads = []
        for thread in threads:
            if thread.is_alive():
                next_threads.append(thread)
                continue
            if thread.result == False:
                continue
            self.handle_result(edit, thread, selections, offset)
        threads = next_threads

        if len(threads):
            before = i % 8
            after = (7) - before

            dir = -1 if not after else dir
            dir = 1 if not before else dir

            i += dir

            self.view.set_status('minify', '[%s=%s]' % (' ' * before, ' ' * after))

            sublime.set_timeout(lambda: self.handle_threads(edit, threads, selections, offset, i, dir), 100)
            return

        self.view.erase_status('minify')
        sublime.status_message('Successfully minified')

    def on_done(self, text=""):
        """
        Create a class with informations from the input text

        @param text: text from input panel
        """
        self.hide_status()
        info = self.parse_create(text)
        if isinstance(info, str):
            sublime.error_message(info)
            return
        ActionHistory().add_action(
            "javatar.commands.create.create_class.on_done",
            "Create [info={info}]".format_map({
                "info": info
            })
        )
        if JavaUtils().create_package_path(
                info["directory"], True) == JavaUtils().CREATE_ERROR:
            return

        if self.create_class_file(info):
            sublime.set_timeout(lambda: StatusManager().show_status(
                "{class_type} \"{class_name}\" is created within".format_map({
                    "class_type": self.args["create_type"],
                    "class_name": info["class_name"]
                }) + " package \"{readable_package_path}\"".format_map({
                    "readable_package_path": JavaUtils().to_readable_class_path(
                        info["package"].as_class_path(),
                        as_class_path=True
                    )
                })
            ), 500)

	def lint_view(cls, view_id, filename, code, sections, callback):
		if view_id in cls.linters:
			selectors = Linter.get_selectors(view_id)

			linters = tuple(cls.linters[view_id])
			for linter in linters:
				if not linter.selector:
					linter.filename = filename
					linter.pre_lint(code)

			for sel, linter in selectors:
				if sel in sections:
					highlight = Highlight(code, scope=linter.scope, outline=linter.outline)
					errors = {}

					for line_offset, left, right in sections[sel]:
						highlight.shift(line_offset, left)
						linter.pre_lint(code[left:right], highlight=highlight)

						for line, error in linter.errors.items():
							errors[line+line_offset] = error

					linter.errors = errors

			# merge our result back to the main thread
			sublime.set_timeout(lambda: callback(linters[0].view, linters), 0)

 def read_handle(self, handle):
     chunk_size = 2 ** 13
     out = b''
     while True:
         try:
             data = os.read(handle.fileno(), chunk_size)
             # If exactly the requested number of bytes was
             # read, there may be more data, and the current
             # data may contain part of a multibyte char
             out += data
             if len(data) == chunk_size:
                 continue
             if data == b'' and out == b'':
                 raise IOError('EOF')
             # We pass out to a function to ensure the
             # timeout gets the value of out right now,
             # rather than a future (mutated) version
             self.queue_write(out.decode(self.encoding))
             if data == b'':
                 raise IOError('EOF')
             out = b''
         except (UnicodeDecodeError) as e:
             msg = 'Error decoding output using %s - %s'
             self.queue_write(msg  % (self.encoding, str(e)))
             break
         except (IOError):
             if self.killed:
                 msg = 'Cancelled'
             else:
                 msg = 'Finished'
             sublime.set_timeout(self.finished, 1)
             self.queue_write('\n[%s]' % msg)
             break

    def output(self, stdout, stderr, q):
        errs = []

        for line in iter(stdout.readline, b''):
            if len(errs) == 0 and ('error' not in line.lower().decode('utf-8')):
                q.put(line)
                print(line.decode('utf-8'))
            else:
                errs.append(line)

            # print(str(line))

        for line in iter(stderr.readline, b''):
            errs.append(line)

        if len(errs) != 0:
            message = ''
            sublime.set_timeout(lambda: self.show_status('Error'), 0)
            for line in errs:
                message += line.decode('utf-8')

            sublime.error_message(message)
        else:
            sublime.set_timeout(lambda: self.show_status('Success'), 0)

        stderr.close()
        stdout.close()

 def run(self, edit):
     for region in self.view.sel():
         self.view.insert(edit, region.end(), ".")
     caret = self.view.sel()[0].begin()
     line = self.view.substr(sublime.Region(self.view.word(caret-1).a, caret))
     if member_regex.search(line) != None:
         sublime.set_timeout(self.delayed_complete, 1)

    def run(self, paths=[]):
        self.paths = paths

        if (sys.version_info > (3, 0)):
            q = Queue()
        else:
            q = Queue.Queue()

        for path in self.paths:
            proc = subprocess.Popen(
                self.build_cmd(path),
                bufsize=bufsize,
                cwd=os.path.dirname(path),
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                close_fds=ON_POSIX)

            thread = Thread(
                target=self.output,
                args=(proc.stdout, proc.stderr, q))
            thread.daemon = True
            thread.start()

        self.thread = thread
        self.message = 'Compiling'
        self.addend = 1
        self.size = 8
        sublime.set_timeout(lambda: self.show_progress(0), 100)

    def set_status(self):
        global server, client

        if server or client:
            if server:
                server_status = "running"
            else:
                server_status = "off"

            if client:
                host = client.socket.host
                state = client.state
                client_status = "client:%(host)s...%(state)s" % locals()
            else:
                client_status = "disconnected"

            status_value = "Collab (server:%(server_status)s; %(client_status)s)" % locals()
        else:
            status_value = ""

        def _set_status():
            for window in sublime.windows():
                for view in window.views():
                    view.set_status("collab_server_status", status_value)

        sublime.set_timeout(_set_status, 0)

 def on_load(self, view):
     DbgPrint("ReadOnly Protect: on_load of view %d" %(view.id()))
     global config
     UpdateViewModeStatus(view, config.protect_mode, isFileReadonly(view))
     if(config.protect_mode == 1):
         sublime.set_timeout(lambda: start_polling(), 1000)
     DumpAll()

def when_file_opened(window, file_path, view_settings, callback, result_queue):
    """
    Periodic polling callback used by open_file() to find the newly-opened file

    :param window:
        The sublime.Window to look for the view in

    :param file_path:
        The file path of the file that was opened

    :param view_settings:
        A dict of settings to set to the view's "golang" setting key

    :param callback:
        The callback to execute when the file is opened

    :param result_queue:
        A Queue() object the callback can use to communicate with the test
    """

    view = window.active_view()
    if view and view.file_name() == file_path:
        view.settings().set('golang', view_settings)
        callback(view, result_queue)
        return
    # If the view was not ready, retry a short while later
    sublime.set_timeout(lambda: when_file_opened(window, file_path, view_settings, callback, result_queue), 50)

	def cb(res, err):
		out = '\n'.join(s for s in (res.get('out'), res.get('err'), err) if s)
		def f():
			gs.end(tid)
			push_output(view, rkey, out, hourglass_repl='| done: %s' % res.get('dur', ''))

		sublime.set_timeout(f, 0)

    def on_select_action(self, selected_index):
        """Triggers on select from quick panel."""

        if selected_index == -1:
            return

        # Create new file
        elif selected_index == 0:
            # TODO: Set Syntax of the new file to be python
            view = self.view.window().new_file()

            # Append snippet to the view
            sublime.set_timeout(
                lambda: self._append_snippet(view, new=True), 10)

        # Select existing file
        else:
            # Subtract one to account for the "Create file" item
            directory_index = selected_index - 1

            current_root = self.view.window().folders()[0]

            # The paths are relative to the project root
            file_directory = os.path.join(
                current_root,
                self.step_file_paths[directory_index])
            view = self.view.window().open_file(file_directory)

            # Append snippet to the view
            sublime.set_timeout(lambda: self._append_snippet(view), 10)

 def on_load(self, view):
     Pref.time = time()
     Pref.modified = True
     view.settings().set('function_name_status_row', -1)
     sublime.set_timeout(
         lambda: self.display_current_class_and_function(view,
             'on_load'), 0)

    def create_class_file(self, info):
        """
        Create a specified Java class and returns the status

        @param info: class informations
        """
        contents = self.get_file_contents(info)
        if contents is None:
            return False
        if os.path.exists(info["file"]):
            sublime.error_message(
                "{class_type} \"{class_name}\" already exists".format_map({
                    "class_type": self.args["create_type"],
                    "class_name": info["class_name"]
                })
            )
            return False
        open(info["file"], "w").close()
        view = sublime.active_window().open_file(info["file"])
        view.set_syntax_file("Packages/Java/Java.tmLanguage")
        # File Header override
        view.settings().set("enable_add_template_to_empty_file", False)
        sublime.set_timeout(
            lambda: self.insert_and_save(view, contents, info),
            100
        )
        return True

  def handle_threads(self, edit, threads, offset=0, i=0, dir=1):
    next_threads = []
    for thread in threads:
      if thread.is_alive():
        next_threads.append(thread)
        continue
      if thread.result == False:
        continue
      offset = self.replace(edit, thread, offset)

    threads = next_threads

    if len(threads):
      # This animates a little activity indicator in the status area
      before = i % 8
      after = (7) - before
      if not after:
        dir = -1
      if not before:
        dir = 1
      i += dir
      self.view.set_status('bitly', 'Bitly [%s=%s]' % (' ' * before, ' ' * after))

      sublime.set_timeout(lambda: self.handle_threads(edit, threads, offset, i, dir), 100)
      return

    self.view.end_edit(edit)

    self.view.erase_status('bitly')
    matches = len(self.urls)
    sublime.status_message('Bitly successfully run on %s selection%s' % (matches, '' if matches == 1 else 's'))