JTextPane inside a JScrollPane: any way to display a certain section?

Question

I have a GUI with a JTextPane inside a JScrollPane.
The text of the JTextPane is the contents of a text file, so it typically has many lines.
I want the JScrollPane (whose preferred size has already been previously set to display 11 rows of text) to always show one target line as the middle row, and the 5 rows before and after it as the remaining 10 rows.
In other words, I want to show a certain line and its surrounding context.
Do you guys know how to achieve this? I have already tried calling
JTextPane.setCaretPositionbut this is inadequate because it merely guarantees that the line with the caret is visible--but it does not guarantee to center the caret line in the middle of the JScrollPane.
I also tried calling
textPane.scrollRectToVisible( textPane.modelToView(caretPos) );where textPane is my JTextPane, but this failed completely (seems to always display the final lines of the file).
Anyone have any suggestions?

Answer 1

Daryl: thanks for your response.
My original code looked like this:
int caretPos = 0;
for (int i = 0; i <= index; i++) {
     caretPos += lines.length();
textPane.setCaretPosition(caretPos);
With *just* the above, you get the behavior that I originally described, namely, the line in question (which is lines[index]) always gets displayed, but it is not necessarily in the middle of the JScrollPane.
I tried commenting out the line above which calls setCaretPosition, and used essentially your code instead:Rectangle caretRectangle = textPane.modelToView(caretPos);
Rectangle viewRectangle = new Rectangle(
     0, caretRectangle.y - (scrollPane.getHeight() - caretRectangle.height) / 2,
     scrollPane.getWidth(), scrollPane.getHeight()
textPane.scrollRectToVisible(viewRectangle);This fails too: the JScrollPane now always shows the bottom of the JTextPane.
What does work is to use *both* techniques, namely, call setCaretPosition as well as scrollRectToVisible:     // set the caret to the line in question (i.e. at index); this merely guarantees that this line is visible, but not necessarily centered
int caretPos = 0;
for (int i = 0; i <= index; i++) {
     caretPos += lines[i].length();
textPane.setCaretPosition(caretPos);
     // and IN ADDITION cause scrollPane's viewport to be centered around the line
Rectangle caretRectangle = textPane.modelToView(caretPos);
Rectangle viewRectangle = new Rectangle(
     0, caretRectangle.y - (scrollPane.getHeight() - caretRectangle.height) / 2,
     scrollPane.getWidth(), scrollPane.getHeight()
textPane.scrollRectToVisible(viewRectangle);The interesting question is why do you need to do both steps?
I think that I know the reason, but I would love to see someone confirm or deny this.  What follows is my speculation.
The above code is inside a method that is call by a run method of the class in question which is always executed by the event dispatch thread (EDT), so it is not an illegal thread use case.  However, in the method that has the code above, I am clearing all existing text of the JTextPane and then repopulating it (with that String[] lines used above, which came from parsing a file).
Now, in  [this posting|http://forums.sun.com/thread.jspa?messageID=10289999#10289999], camickr claimed:
"When text is inserted into a Document, behind the scenes a call to setCaretPosition() is made to position the caret after the newly inserted text. However inserting text into a document is a complex procedure since Elements need to be created as the text inserted into the Document is parsed. So the call to the setCaretPosition() method is placed in a SwingUtilities.invokeLater(), which means tha code gets added to the end of the GUI EDT to be executed once the Document is in a complete state. So basically what is happening is that your call to set the view position does execute, but then is gets overridden by the setCaretPosition() method call."
If the above claim is true, then all the calls in that method to add the file's text result in implicit calls to setCaretPosition which will be executed AFTER the method above ends (i.e. asynchronously, later on by the event dispatch thread).  Hence, I need to do an explicit setCaretPosition call of my own to override these implicit calls.
Now, I am not sure that I totally buy this explanation.  I would like to see more proof of camickr's claims for one: I did a quick code review of some of the classes involved, and do not see where calling AbstractDocument.insertString generates an implicit call to setCaretPosition on the EDT.  To be sure, the code is complex, and I do not know where exactly to look, and maybe this is done by some listener or something, who knows.  Furthermore, my explicit call to setCaretPosition is done synchronously on the EDT (recall: that method above in my class is called by its run which is executed by the EDT).  So, my explicit call to setCaretPosition should occur in time before all of those delayed implicit calls, and thus should actually be overridden by them, no?
I would love to hear from someone who really knows Swing...