displaymanager.java

开源的java 编辑器源代码

			}

			callChanged = true;

			// JEditTextArea.scrollTo() needs this to simplify
			// its code
			if(screenAmount < 0)
				scrollUp(-screenAmount);
			else if(screenAmount > 0)
				scrollDown(screenAmount);
		} //}}}

		//{{{ physUp() method
		// scroll up by physical line amount
		void physUp(int amount, int screenAmount)
		{
			if(Debug.SCROLL_DEBUG)
			{
				Log.log(Log.DEBUG,this,"physUp() start: "
					+ physicalLine + ":" + scrollLine);
			}

			skew = 0;

			if(!isLineVisible(physicalLine))
			{
				int firstVisibleLine = getFirstVisibleLine();
				if(physicalLine < firstVisibleLine)
					physicalLine = firstVisibleLine;
				else
				{
					int prevPhysicalLine = getPrevVisibleLine(physicalLine);
					amount -= (physicalLine - prevPhysicalLine);
				}
			}

			for(;;)
			{
				int prevPhysicalLine = getPrevVisibleLine(
					physicalLine);
				if(prevPhysicalLine == -1)
					break;
				else if(prevPhysicalLine < physicalLine - amount)
					break;
				else
				{
					amount -= (physicalLine - prevPhysicalLine);
					physicalLine = prevPhysicalLine;
					scrollLine -= getScreenLineCount(
						prevPhysicalLine);
				}
			}

			if(Debug.SCROLL_DEBUG)
			{
				Log.log(Log.DEBUG,this,"physUp() end: "
					+ physicalLine + ":" + scrollLine);
			}

			callChanged = true;

			// JEditTextArea.scrollTo() needs this to simplify
			// its code
			if(screenAmount < 0)
				scrollUp(-screenAmount);
			else if(screenAmount > 0)
				scrollDown(screenAmount);
		} //}}}

		//{{{ scrollDown() method
		// scroll down by screen line amount
		void scrollDown(int amount)
		{
			if(Debug.SCROLL_DEBUG)
				Log.log(Log.DEBUG,this,"scrollDown()");

			ensurePhysicalLineIsVisible();

			amount += skew;

			skew = 0;

			while(amount > 0)
			{
				int screenLines = getScreenLineCount(physicalLine);
				if(amount < screenLines)
				{
					skew = amount;
					break;
				}
				else
				{
					int nextLine = getNextVisibleLine(physicalLine);
					if(nextLine == -1)
						break;
					boolean visible = isLineVisible(physicalLine);
					physicalLine = nextLine;
					if(visible)
					{
						amount -= screenLines;
						scrollLine += screenLines;
					}
				}
			}

			callChanged = true;
		} //}}}

		//{{{ scrollUp() method
		// scroll up by screen line amount
		void scrollUp(int amount)
		{
			if(Debug.SCROLL_DEBUG)
				Log.log(Log.DEBUG,this,"scrollUp()");

			ensurePhysicalLineIsVisible();

			if(amount <= skew)
			{
				skew -= amount;
			}
			else
			{
				amount -= skew;
				skew = 0;

				while(amount > 0)
				{
					int prevLine = getPrevVisibleLine(physicalLine);
					if(prevLine == -1)
						break;
					physicalLine = prevLine;

					int screenLines = getScreenLineCount(physicalLine);
					scrollLine -= screenLines;
					if(amount < screenLines)
					{
						skew = screenLines - amount;
						break;
					}
					else
						amount -= screenLines;
				}
			}

			callChanged = true;
		} //}}}

		//{{{ ensurePhysicalLineIsVisible() method
		private void ensurePhysicalLineIsVisible()
		{
			if(!isLineVisible(physicalLine))
			{
				if(physicalLine > getLastVisibleLine())
				{
					physicalLine = getLastVisibleLine();
					scrollLine = getScrollLineCount() - 1;
				}
				else if(physicalLine < getFirstVisibleLine())
				{
					physicalLine = getFirstVisibleLine();
					scrollLine = 0;
				}
				else
				{
					physicalLine = getNextVisibleLine(physicalLine);
					scrollLine += getScreenLineCount(physicalLine);
				}
			}
		} //}}}
	} //}}}

	//{{{ BufferChangeHandler class
	/**
	 * Note that in this class we take great care to defer complicated
	 * calculations to the end of the current transaction if the buffer
	 * informs us a compound edit is in progress
	 * (<code>isTransactionInProgress()</code>).
	 *
	 * This greatly speeds up replace all for example, by only doing certain
	 * things once, particularly in <code>moveCaretPosition()</code>.
	 *
	 * Try doing a replace all in a large file, for example. It is very slow
	 * in 3.2, faster in 4.0 (where the transaction optimization was
	 * introduced) and faster still in 4.1 (where it was further improved).
	 *
	 * There is still work to do; see TODO.txt.
	 */
	class BufferChangeHandler extends BufferChangeAdapter
	{
		boolean delayedUpdate;
		boolean delayedMultilineUpdate;
		int delayedUpdateStart;
		int delayedUpdateEnd;

		//{{{ foldHandlerChanged() method
		public void foldHandlerChanged(Buffer buffer)
		{
			fvmreset();

			firstLine.callReset = true;
			scrollLineCount.callReset = true;

			int collapseFolds = buffer.getIntegerProperty(
				"collapseFolds",0);
			if(collapseFolds != 0)
				expandFolds(collapseFolds);

			_notifyScreenLineChanges();
		} //}}}

		//{{{ foldLevelChanged() method
		public void foldLevelChanged(Buffer buffer, int start, int end)
		{
			if(textArea.getDisplayManager() == DisplayManager.this
				&& end != 0 && buffer.isLoaded())
			{
				textArea.invalidateLineRange(start - 1,
					textArea.getLastPhysicalLine());
			}
		} //}}}

		//{{{ contentInserted() method
		public void contentInserted(Buffer buffer, int startLine,
			int offset, int numLines, int length)
		{
			if(!buffer.isLoaded())
				return;

			int endLine = startLine + numLines;

			if(numLines != 0)
			{
				delayedMultilineUpdate = true;

				/* this is a sloppy hack to fix bug
				   "[ 677902 ] hitting return after collapsed
				   fold"

				   the idea is that if we extend the range then
				   the problem described in the bug happends, so
				   if the insert is at the very end of the range
				   we don't extend it, instead we push the
				   insert into the next range, however for this
				   to work properly we also have to mess with
				   screen line counts. */
				int index = fvmget(startLine);
				int start = index + 1;
				/* if(start + 1 < fvmcount && fvm[start]
					== startLine + 1)
				{
					if(index % 2 == 0)
					{
						System.err.println("case 1");
						scrollLineCount.scrollLine -=
							getScreenLineCount(
							startLine + 1);
						start++;
					}
				} */

				for(int i = start; i < fvmcount; i++)
				{
					fvm[i] += numLines;
				}

				lastfvmget = -1;
				fvmdump();

			}

			if(textArea.getDisplayManager() == DisplayManager.this)
			{
				if(numLines != 0)
				{
					contentInserted(firstLine,startLine,numLines);
					contentInserted(scrollLineCount,startLine,numLines);
				}

				if(delayedUpdateEnd >= startLine)
					delayedUpdateEnd += numLines;
				delayedUpdate(startLine,endLine);

				//{{{ resize selections if necessary
				for(int i = 0; i < textArea.selection.size(); i++)
				{
					Selection s = (Selection)textArea
						.selection.elementAt(i);
	
					if(s.contentInserted(buffer,startLine,offset,
						numLines,length))
					{
						delayedUpdate(s.startLine,s.endLine);
					}
				} //}}}

				int caret = textArea.getCaretPosition();
				if(caret >= offset)
				{
					int scrollMode = (caretAutoScroll()
						? JEditTextArea.ELECTRIC_SCROLL
						: JEditTextArea.NO_SCROLL);
					textArea.moveCaretPosition(
						caret + length,scrollMode);
				}
				else
				{
					int scrollMode = (caretAutoScroll()
						? JEditTextArea.NORMAL_SCROLL
						: JEditTextArea.NO_SCROLL);
					textArea.moveCaretPosition(
						caret,scrollMode);
				}
			}
			else
			{
				firstLine.callReset = true;
				scrollLineCount.callReset = true;
			}
		} //}}}

		//{{{ preContentRemoved() method
		public void preContentRemoved(Buffer buffer, int startLine,
			int offset, int numLines, int length)
		{
			if(!buffer.isLoaded())
				return;

			if(textArea.getDisplayManager() == DisplayManager.this)
			{
				if(numLines != 0)
				{
					preContentRemoved(firstLine,startLine,numLines);
					preContentRemoved(scrollLineCount,startLine,numLines);
				}

				if(delayedUpdateEnd >= startLine)
					delayedUpdateEnd -= numLines;
				delayedUpdate(startLine,startLine);
			}
			else
			{
				firstLine.callReset = true;
				scrollLineCount.callReset = true;
			}

			if(numLines != 0)
			{
				delayedMultilineUpdate = true;

				int endLine = startLine + numLines;

				/* update fold visibility map. */
				int starti = fvmget(startLine);
				int endi = fvmget(endLine);

				/* both have same visibility; just remove
				 * anything in between. */
				if(Math.abs(starti % 2) == Math.abs(endi % 2))
				{
					if(endi - starti == fvmcount)
					{
						// we're removing from before
						// the first visible to after
						// the last visible
						fvmreset();
						firstLine.callReset = true;
						scrollLineCount.callReset = true;
					}
					else
					{
						fvmput(starti + 1,endi + 1,null);
						starti++;
					}
				}
				/* collapse 2 */
				else if(starti != -1 && fvm[starti] == startLine)
				{
					//int newStart = fvm[endi + 1] - 1;
					fvmput(starti,endi + 1,null);
					//fvm[starti] = newStart;
					//starti++;
				}
				/* shift */
				else
				{
					fvmput(starti + 1,endi,null);
					fvm[starti + 1] = startLine;
					starti += 2;
				}

				/* update */
				for(int i = starti; i < fvmcount; i++)
					fvm[i] -= numLines;

				if(firstLine.physicalLine
					> getLastVisibleLine()
					|| firstLine.physicalLine
					< getFirstVisibleLine())
				{
					// will be handled later.
					// see comments at the end of
					// transactionComplete().
				}
				// very subtle... if we leave this for
				// ensurePhysicalLineIsVisible(), an
				// extra line will be added to the
				// scroll line count.
				else if(!isLineVisible(
					firstLine.physicalLine))
				{
					firstLine.physicalLine =
						getNextVisibleLine(
						firstLine.physicalLine);
				}

				lastfvmget = -1;
				fvmdump();
			}
		} //}}}

		//{{{ contentRemoved() method
		public void contentRemoved(Buffer buffer, int startLine,
			int start, int numLines, int length)
		{
			if(!buffer.isLoaded())
				return;

			if(textArea.getDisplayManager() == DisplayManager.this)
			{
				int endLine = startLine + numLines;

				//{{{ resize selections if necessary
				for(int i = 0; i < textArea.selection.size(); i++)
				{
					Selection s = (Selection)textArea
						.selection.elementAt(i);
	
					if(s.contentRemoved(buffer,startLine,
						start,numLines,length))
					{
						delayedUpdate(s.startLine,s.endLine);
						if(s.start == s.end)
						{
							textArea.selection.removeElementAt(i);
							i--;
						}
					}
				} //}}}

				int caret = textArea.getCaretPosition();

				if(caret >= start + length)
				{
					int scrollMode = (caretAutoScroll()
						? JEditTextArea.ELECTRIC_SCROLL
						: JEditTextArea.NO_SCROLL);
					textArea.moveCaretPosition(
						caret - length,
						scrollMode);
				}
				else if(caret >= start)
				{
					int scrollMode = (caretAutoScroll()
						? JEditTextArea.ELECTRIC_SCROLL
						: JEditTextArea.NO_SCROLL);
					textArea.moveCaretPosition(
						start,scrollMode);
				}
				else
				{
					int scrollMode = (caretAutoScroll()
						? JEditTextArea.NORMAL_SCROLL
						: JEditTextArea.NO_SCROLL);
					textArea.moveCaretPosition(caret,scrollMode);
				}
			}
		}
		//}}}

		//{{{ transactionComplete() method
		public void transactionComplete(Buffer buffer)
		{
			if(textArea.getDisplayManager() == DisplayManager.this)
			{
				if(delayedUpdate)
				{
					// must be before the below call
					// so that the chunk cache is not
					// updated with an invisible first
					// line (see above)
					_notifyScreenLineChanges();

					if(delayedMultilineUpdate)
					{
						textArea.invalidateScreenLineRange(
							textArea.chunkCache
							.getScreenLineOfOffset(
							delayedUpdateStart,0),
							textArea.getVisibleLines());
						delayedMultilineUpdate = false;
					}
					else
					{
						textArea.invalidateLineRange(
							delayedUpdateStart,
							delayedUpdateEnd);
					}

					int _firstLine = textArea.getFirstPhysicalLine();
					int _lastLine = textArea.getLastPhysicalLine();

					int line = delayedUpdateStart;
					if(!isLineVisible(line))
						line = getNextVisibleLine(line);
					while(line != -1 && line <= delayedUpdateEnd)
					{
						if(line < _firstLine
							|| line > _lastLine)
						{
							getScreenLineCount(line);
						}
						line = getNextVisibleLine(line);
					}

					// update visible lines
					int visibleLines = textArea
						.getVisibleLines();
					if(visibleLines != 0)
					{
						textArea.chunkCache.getLineInfo(
							visibleLines - 1);
					}
				}

				textArea._finishCaretUpdate();
			}

			//{{{ Debug code
			if(Debug.SCROLL_VERIFY)
			{
				int scrollLineCount = 0;
				for(int i = 0; i < textArea.getLineCount(); i++)
				{
					if(isLineVisible(i))
					{
						scrollLineCount +=
							getScreenLineCount(i);
					}
				}
				if(scrollLineCount != getScrollLineCount())
				{
					throw new InternalError(scrollLineCount
						+ " != "
						+ getScrollLineCount());
				}
			} //}}}

			delayedUpdate = false;
		} //}}}

		//{{{ contentInserted() method
		private void contentInserted(Anchor anchor, int startLine,
			int numLines)
		{
			if(anchor.physicalLine >= startLine)
			{
				if(anchor.physicalLine != startLine)
					anchor.physicalLine += numLines;
				anchor.callChanged = true;
			}
		} //}}}

		//{{{ preContentRemoved() method
		private void preContentRemoved(Anchor anchor, int startLine,
			int numLines)
		{
			if(anchor.physicalLine >= startLine)
			{
				if(anchor.physicalLine == startLine)
					anchor.callChanged = true;
				else
				{
					int end = Math.min(startLine + numLines,
						anchor.physicalLine);
					for(int i = startLine; i < end; i++)
					{
						//XXX
						if(isLineVisible(i))
						{
							anchor.scrollLine -=
								lineMgr
								.getScreenLineCount(i);
						}
					}
					anchor.physicalLine -= (end - startLine);
					anchor.callChanged = true;
				}
			}
		} //}}}

		//{{{ delayedUpdate() method
		private void delayedUpdate(int startLine, int endLine)
		{
			textArea.chunkCache.invalidateChunksFromPhys(startLine);
			if(!delayedUpdate)
			{
				delayedUpdateStart = startLine;
				delayedUpdateEnd = endLine;
				delayedUpdate = true;
			}
			else
			{
				delayedUpdateStart = Math.min(
					delayedUpdateStart,
					startLine);
				delayedUpdateEnd = Math.max(
					delayedUpdateEnd,
					endLine);
			}
		} //}}}

		//{{{ caretAutoScroll() method
		/**
		 * Return if change in buffer should scroll this text area.
		 */
		private boolean caretAutoScroll()
		{
			View view = textArea.getView();
			return view == jEdit.getActiveView()
				&& view.getTextArea() == textArea;
		} //}}}
	} //}}}
}