 			ide.$scope.$broadcast("flush-changes")
 
 			options.rootDocOverride_id = getRootDocOverride_id()
+
+			$scope.$apply()
 
 			sendCompileRequest(options)
 				.then (response) ->

					$scope.pdf.error = true
					$scope.pdf.view = 'errors'
				.finally () ->
					$scope.recompiledAt = Date.now()

		# This needs to be public.
		ide.$scope.recompile = $scope.recompile

			$scope.pdf.view = 'errors'
			$scope.pdf.renderingError = true

		autoCompileInterval = null
		autoCompileIfReady = () ->
			if $scope.pdf.compiling
				return

			# Only checking linting if syntaxValidation is on and visible to the user
			autoCompileLintingError = ide.$scope.hasLintingError and ide.$scope.settings.syntaxValidation
			if $scope.autoCompileLintingError != autoCompileLintingError
				$scope.$apply () ->
					$scope.autoCompileLintingError = autoCompileLintingError
					# We've likely been waiting a while until the user fixed the linting, but we
					# don't want to compile as soon as it is fixed, so reset the timeout.
					$scope.startedTryingAutoCompileAt = Date.now()
					$scope.docLastChangedAt = Date.now()
			if autoCompileLintingError
				return

			# If there's a longish compile, don't compile immediately after if user is still typing
			startedTryingAt = Math.max($scope.startedTryingAutoCompileAt, $scope.lastFinishedCompileAt || 0)

			timeSinceStartedTrying = Date.now() - startedTryingAt
			timeSinceLastChange = Date.now() - $scope.docLastChangedAt

			shouldCompile = false
			if timeSinceLastChange > AUTO_COMPILE_DEBOUNCE # Don't compile in the middle of the user typing
				shouldCompile = true
			else if timeSinceStartedTrying > AUTO_COMPILE_MAX_WAIT # Unless they type for a long time
				shouldCompile = true
			else if timeSinceStartedTrying < 0 or timeSinceLastChange < 0
				# If time is non-monotonic, assume that the user's system clock has been
				# changed and continue with compile
				shouldCompile = true

			if shouldCompile
				triggerAutoCompile()

		triggerAutoCompile = () ->
			$scope.recompile(isAutoCompileOnChange: true)

		startTryingAutoCompile = () ->
			return if autoCompileInterval?
			$scope.startedTryingAutoCompileAt = Date.now()
			autoCompileInterval = setInterval autoCompileIfReady, 200

		stopTryingAutoCompile = () ->
			clearInterval autoCompileInterval
			autoCompileInterval = null

		$scope.$watch "uncompiledChanges", (uncompiledChanges) ->
			if uncompiledChanges
				startTryingAutoCompile()
			else
				stopTryingAutoCompile()

		$scope.uncompiledChanges = false
		recalculateUncompiledChanges = () ->
			if $scope.ui.pdfHidden
				# Don't both auto-compiling if pdf isn't visible
				$scope.uncompiledChanges = false
			else if !$scope.docLastChangedAt?
				$scope.uncompiledChanges = false
			else if !$scope.lastStartedCompileAt? or $scope.docLastChangedAt > $scope.lastStartedCompileAt
				$scope.uncompiledChanges = true
			else
				$scope.uncompiledChanges = false

		_updateDocLastChangedAt = () ->
			$scope.docLastChangedAt = Date.now()
			recalculateUncompiledChanges()

		onDocChanged = () ->
			$scope.autoCompileLintingError = false
			_updateDocLastChangedAt()

		onDocSaved = () ->
			# We use the save as a trigger too, to account for the delay between the client
			# and server. Otherwise, we might have compiled after the user made
			# the change on the client, but before the server had it.
			_updateDocLastChangedAt()

		onCompilingStateChanged = (compiling) ->
			recalculateUncompiledChanges()

		autoCompileListeners = []
		toggleAutoCompile = (enabling) ->
			if enabling
				autoCompileListeners = [
					ide.$scope.$on "doc:changed", onDocChanged
					ide.$scope.$on "doc:saved", onDocSaved
					$scope.$watch "pdf.compiling", onCompilingStateChanged
				]
			else
				for unbind in autoCompileListeners
