projects/dwt-win: dwt/custom/StyledText.d comparison

comparison dwt/custom/StyledText.d @ 213:36f5cb12e1a2

Update to SWT 3.4M7

author	Frank Benoit <benoit@tionex.de>
date	Sat, 17 May 2008 17:34:28 +0200
parents	ab60f3309436
children	a8fed3e56433

comparison

equal deleted inserted replaced

-:ab60f3309436
+:36f5cb12e1a2
 import dwt.widgets.Caret;
 import dwt.widgets.Composite;
 import dwt.widgets.Control;
 import dwt.widgets.Display;
 import dwt.widgets.Event;
+import dwt.widgets.IME;
 import dwt.widgets.Label;
 import dwt.widgets.Listener;
 import dwt.widgets.ScrollBar;
 import dwt.widgets.TypedListener;
 import dwt.custom.StyledTextContent;
 Point clipboardSelection;           // x and y are start and end caret offsets of previous selection
 int selectionAnchor;                // position of selection anchor. 0 based offset from beginning of text
 Point doubleClickSelection;         // selection after last mouse double click
 bool editable = true;
 bool wordWrap = false;
-bool doubleClickEnabled = true;  // see getDoubleClickEnabled
+bool doubleClickEnabled = true; // see getDoubleClickEnabled
-bool overwrite = false;          // insert/overwrite edit mode
+bool overwrite = false;         // insert/overwrite edit mode
 int textLimit = -1;                 // limits the number of characters the user can type in the widget. Unlimited by default.
 int[int] keyActionMap;
 Color background = null;            // workaround for bug 4791
 Color foreground = null;            //
 Clipboard clipboard;
 int lastTextChangeNewCharCount;     // event for use in the
 int lastTextChangeReplaceLineCount; // text changed handler
 int lastTextChangeReplaceCharCount;
 int lastLineBottom;                 // the bottom pixel of the last line been replaced
 bool isMirrored_;
-bool bidiColoring = false;       // apply the BIDI algorithm on text segments of the same color
+bool bidiColoring = false;      // apply the BIDI algorithm on text segments of the same color
 Image leftCaretBitmap = null;
 Image rightCaretBitmap = null;
 int caretDirection = DWT.NULL;
+int caretWidth = 0;
 Caret defaultCaret = null;
 bool updateCaretDirection = true;
 bool fixedLineHeight;
 bool dragDetect_ = true;
+IME ime;
 int alignment;
 bool justify;
 int indent;
 int lineSpacing;
 int pageWidth;                                  // width of a printer page in pixels
 int startPage;                                  // first page to print
 int endPage;                                    // last page to print
 int startLine;                                  // first (wrapped) line to print
 int endLine;                                    // last (wrapped) line to print
-bool singleLine;                             // widget single line mode
+bool singleLine;                                // widget single line mode
 Point selection = null;                 // selected text
-bool mirrored;                       // indicates the printing gc should be mirrored
+bool mirrored;                      // indicates the printing gc should be mirrored
 int lineSpacing;
 int printMargin;
 /**
 * Creates an instance of <code>Printing</code>.
 if (printOptions.printLineNumbers || printOptions.header !is null || printOptions.footer !is null) {
 printLayout = new TextLayout(printer);
 printLayout.setFont(printerFont);
 }
 if (printOptions.printLineNumbers) {
+int numberingWidth = 0;
 int count = endLine - startLine + 1;
-StringBuffer buffer = new StringBuffer("0");
+String[] lineLabels = printOptions.lineLabels;
-while ((count /= 10) > 0) buffer.append("0");
+if (lineLabels !is null) {
-printLayout.setText(buffer.toString());
+for (int i = startLine; i < Math.min(count, lineLabels.length); i++) {
-int numberingWidth = printLayout.getBounds().width + printMargin;
+if (lineLabels[i] !is null) {
+printLayout.setText(lineLabels[i]);
+int lineWidth = printLayout.getBounds().width;
+numberingWidth = Math.max(numberingWidth, lineWidth);
+}
+}
+} else {
+StringBuffer buffer = new StringBuffer("0");
+while ((count /= 10) > 0) buffer.append("0");
+printLayout.setText(buffer.toString());
+numberingWidth = printLayout.getBounds().width;
+}
+numberingWidth += printMargin;
 if (numberingWidth > width) numberingWidth = width;
 paintX += numberingWidth;
 width -= numberingWidth;
 }
 for (int i = startLine; i <= endLine && page <= endPage; i++) {
 paintY += layout.getBounds().height;
 }
 } else {
 //draw paragraph top in the current page and paragraph bottom in the next
 int height = paragraphBottom - paintY;
-gc.setClipping(paintX, paintY, width, height);
+gc.setClipping(clientArea.x, paintY, clientArea.width, height);
 printLine(paintX, paintY, gc, foreground, lineBackground, layout, printLayout, i);
+gc.setClipping(cast(Rectangle)null);
 printDecoration(page, false, printLayout);
 printer.endPage();
 page++;
 if (page <= endPage) {
 printer.startPage();
 printDecoration(page, true, printLayout);
 paintY = clientArea.y - height;
 int layoutHeight = layout.getBounds().height;
-gc.setClipping(paintX, clientArea.y, width, layoutHeight - height);
+gc.setClipping(clientArea.x, clientArea.y, clientArea.width, layoutHeight - height);
 printLine(paintX, paintY, gc, foreground, lineBackground, layout, printLayout, i);
+gc.setClipping(cast(Rectangle)null);
 paintY += layoutHeight;
 }
-gc.setClipping(cast(Rectangle)null);
 }
 }
 printerRenderer.disposeTextLayout(layout);
 }
-if (paintY > clientArea.y) {
+if (page <= endPage && paintY > clientArea.y) {
 // close partial page
 printDecoration(page, false, printLayout);
 printer.endPage();
 }
 if (printLayout !is null) printLayout.dispose();
 //              gc.fillRectangle(rect);
 //          }
 }
 if (printOptions.printLineNumbers) {
 FontMetrics metrics = layout.getLineMetrics(0);
-printLayout.setAscent(metrics.getAscent() + metrics.getDescent());
+printLayout.setAscent(metrics.getAscent() + metrics.getLeading());
 printLayout.setDescent(metrics.getDescent());
-printLayout.setText( to!(String)(index) );
+String[] lineLabels = printOptions.lineLabels;
+if (lineLabels !is null) {
+if (0 <= index && index < lineLabels.length && lineLabels[index] !is null) {
+printLayout.setText(lineLabels[index]);
+} else {
+printLayout.setText("");
+}
+} else {
+printLayout.setText( to!(String)(index) );
+}
 int paintX = x - printMargin - printLayout.getBounds().width;
 printLayout.draw(gc, paintX, y);
 printLayout.setAscent(-1);
 printLayout.setDescent(-1);
 }
 clipboard = new Clipboard(display);
 installDefaultContent();
 renderer = new StyledTextRenderer(getDisplay(), this);
 renderer.setContent(content);
 renderer.setFont(getFont(), tabLength);
-defaultCaret = new Caret(this, DWT.NULL);
+ime = new IME(this, DWT.NONE);
+defaultCaret = new Caret(this, DWT.NONE);
 if ((style & DWT.WRAP) !is 0) {
 setWordWrap(true);
 }
 if (isBidiCaret()) {
 createCaretBitmaps();
 if (getCaret() !is defaultCaret) return;
 Point newCaretPos = getPointAtOffset(caretOffset);
 setCaretLocation(newCaretPos, direction);
 }
 };
-BidiUtil.addLanguageListener(handle, runnable);
+BidiUtil.addLanguageListener(this, runnable);
 }
 setCaret(defaultCaret);
 calculateScrollBars();
 createKeyBindings();
 setCursor(display.getSystemCursor(DWT.CURSOR_IBEAM));
 if (wHint is DWT.DEFAULT || hHint is DWT.DEFAULT) {
 Display display = getDisplay();
 int maxHeight = display.getClientArea().height;
 for (int lineIndex = 0; lineIndex < lineCount; lineIndex++) {
 TextLayout layout = renderer.getTextLayout(lineIndex);
+int wrapWidth = layout.getWidth();
 if (wordWrap) layout.setWidth(wHint is 0 ? 1 : wHint);
 Rectangle rect = layout.getBounds();
 height += rect.height;
 width = Math.max(width, rect.width);
+layout.setWidth(wrapWidth);
 renderer.disposeTextLayout(layout);
 if (isFixedLineHeight() && height > maxHeight) break;
 }
 if (isFixedLineHeight()) {
 height = lineCount * renderer.getLineHeight();
 if (event.button !is 2) return false;
 } else {
 if (event.button !is 1) return false;
 }
 if (selection.x is selection.y) return false;
-int offset = getOffsetAtPoint(event.x, event.y);
+int offset = getOffsetAtPoint(event.x, event.y, null, true);
-if (offset > selection.x && offset < selection.y) {
+if (selection.x <= offset && offset < selection.y) {
 return dragDetect(event);
 }
 return false;
 }
 /**
 * </p>
 *
 * @param key the character typed by the user
 */
 void doContent(char key) {
-if (textLimit > 0 &&
-content.getCharCount() - (selection.y - selection.x) >= textLimit) {
-return;
-}
 Event event = new Event();
 event.start = selection.x;
 event.end = selection.y;
 // replace a CR line break with the widget line break
 // CR does not make sense on Windows since most (all?) applications
 event.text = [key];
 } else {
 event.text = [key];
 }
 if (event.text !is null) {
+if (textLimit > 0 && content.getCharCount() - (event.end - event.start) >= textLimit) {
+return;
+}
 sendKeyEvent(event);
 }
 }
 /**
 * Moves the caret after the last character of the widget content.
 return;
 }
 int oldCaretAlignment = caretAlignment;
 int newCaretOffset = getOffsetAtPoint(x, y);
-if (clickCount > 1) {
+if (doubleClickEnabled && clickCount > 1) {
-// double click word select the previous/next word. fixes bug 15610
 newCaretOffset = doMouseWordSelect(x, newCaretOffset, line);
 }
 int newCaretLine = content.getLineAtOffset(newCaretOffset);
 }
 return bottomIndex;
 }
 Rectangle getBoundsAtOffset(int offset) {
 int lineIndex = content.getLineAtOffset(offset);
+int lineOffset = content.getOffsetAtLine(lineIndex);
 String line = content.getLine(lineIndex);
 Rectangle bounds;
 if (line.length !is 0) {
-int offsetInLine = offset - content.getOffsetAtLine(lineIndex);
+int offsetInLine = offset - lineOffset;
 TextLayout layout = renderer.getTextLayout(lineIndex);
 bounds = layout.getBounds(offsetInLine, offsetInLine);
 renderer.disposeTextLayout(layout);
 } else {
 bounds = new Rectangle (0, 0, 0, renderer.getLineHeight());
 }
+if (offset is caretOffset) {
+int lineEnd = lineOffset + line.length;
+if (offset is lineEnd && caretAlignment is PREVIOUS_OFFSET_TRAILING) {
+bounds.width += getCaretWidth();
+}
+}
 bounds.x += leftMargin - horizontalScrollOffset;
 bounds.y += getLinePixel(lineIndex);
 return bounds;
 }
 /**
 * Returns the caret position relative to the start of the text.
 *
 * @return the caret position relative to the start of the text.
 * @exception DWTException <ul>
 offset += lineOffset;
 renderer.disposeTextLayout(layout);
 return offset;
 }
 /**
-* Returns the content implementation that is used for text storage
+* Returns the content implementation that is used for text storage.
-* or null if no user defined content implementation has been set.
+*
-*
+* @return content the user defined content implementation that is used for
-* @return content implementation that is used for text storage or null
+* text storage or the default content implementation if no user defined
-* if no user defined content implementation has been set.
+* content implementation has been set.
 * @exception DWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
 * </ul>
 */
 public int getCharCount() {
 checkWidget();
 return content.getCharCount();
+}
+/**
+* Returns the line at the given line index without delimiters.
+* Index 0 is the first line of the content. When there are not
+* any lines, getLine(0) is a valid call that answers an empty string.
+* <p>
+*
+* @param lineIndex index of the line to return.
+* @return the line text without delimiters
+*
+* @exception DWTException <ul>
+*    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
+*    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
+* </ul>
+* @exception IllegalArgumentException <ul>
+*   <li>ERROR_INVALID_RANGE when the line index is outside the valid range (< 0 or >= getLineCount())</li>
+* </ul>
+* @since 3.4
+*/
+public String getLine(int lineIndex) {
+checkWidget();
+if (lineIndex < 0 ||
+(lineIndex > 0 && lineIndex >= content.getLineCount())) {
+DWT.error(DWT.ERROR_INVALID_RANGE);
+}
+return content.getLine(lineIndex);
 }
 /**
 * Returns the alignment of the line at the given index.
 *
 * @param index the index of the line
 * @exception DWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 * @exception IllegalArgumentException <ul>
-*   <li>ERROR_INVALID_RANGE when the offset is outside the valid range (< 0 or > getCharCount())</li>
+*   <li>ERROR_INVALID_RANGE when the line index is outside the valid range (< 0 or >= getLineCount())</li>
 * </ul>
 * @since 2.0
 */
 public int getOffsetAtLine(int lineIndex) {
 checkWidget();
 public int getOffsetAtLocation(Point point) {
 checkWidget();
 if (point is null) {
 DWT.error(DWT.ERROR_NULL_ARGUMENT);
 }
-// is y above first line or is x before first column?
+int[] trailing = new int[1];
-if (point.y + getVerticalScrollOffset() < 0 || point.x + horizontalScrollOffset < 0) {
+int offset = getOffsetAtPoint(point.x, point.y, trailing, true);
+if (offset is -1) {
 DWT.error(DWT.ERROR_INVALID_ARGUMENT);
 }
-int bottomIndex = getLineIndex(clientAreaHeight);
+return offset + trailing[0];
-int height = getLinePixel(bottomIndex) + renderer.getLineHeight(bottomIndex);
-if (point.y > height) {
-DWT.error(DWT.ERROR_INVALID_ARGUMENT);
-}
-int lineIndex = getLineIndex(point.y);
-int lineOffset = content.getOffsetAtLine(lineIndex);
-TextLayout layout = renderer.getTextLayout(lineIndex);
-int[] trailing = new int[1];
-int x = point.x + horizontalScrollOffset - leftMargin ;
-int y = point.y - getLinePixel(lineIndex);
-int offsetInLine = layout.getOffset(x, y, trailing);
-String line = content.getLine(lineIndex);
-if (offsetInLine !is line.length - 1) {
-offsetInLine = Math.min(line.length, offsetInLine + trailing[0]);
-}
-Rectangle rect = layout.getLineBounds(layout.getLineIndex(offsetInLine));
-renderer.disposeTextLayout(layout);
-if (x > rect.x + rect.width) {
-DWT.error(DWT.ERROR_INVALID_ARGUMENT);
-}
-return lineOffset + offsetInLine;
 }
 int getOffsetAtPoint(int x, int y) {
 int lineIndex = getLineIndex(y);
 y -= getLinePixel(lineIndex);
 return getOffsetAtPoint(x, y, lineIndex);
 int[] trailing = new int[1];
 int offsetInLine = layout.getOffset(x, y, trailing);
 caretAlignment = OFFSET_LEADING;
 if (trailing[0] !is 0) {
 int lineInParagraph = layout.getLineIndex(offsetInLine + trailing[0]);
-//TODO handle bidi text
 int lineStart = layout.getLineOffsets()[lineInParagraph];
 if (offsetInLine + trailing[0] is lineStart) {
 offsetInLine += trailing[0];
 caretAlignment = PREVIOUS_OFFSET_TRAILING;
 } else {
 }
 }
 renderer.disposeTextLayout(layout);
 return offsetInLine + content.getOffsetAtLine(lineIndex);
 }
+int getOffsetAtPoint(int x, int y, int[] trailing, bool inTextOnly) {
+if (inTextOnly && y + getVerticalScrollOffset() < 0 || x + horizontalScrollOffset < 0) {
+return -1;
+}
+int bottomIndex = getPartialBottomIndex();
+int height = getLinePixel(bottomIndex + 1);
+if (inTextOnly && y > height) {
+return -1;
+}
+int lineIndex = getLineIndex(y);
+int lineOffset = content.getOffsetAtLine(lineIndex);
+TextLayout layout = renderer.getTextLayout(lineIndex);
+x += horizontalScrollOffset - leftMargin ;
+y -= getLinePixel(lineIndex);
+int offset = layout.getOffset(x, y, trailing);
+Rectangle rect = layout.getLineBounds(layout.getLineIndex(offset));
+renderer.disposeTextLayout(layout);
+if (inTextOnly && !(rect.x  <= x && x <=  rect.x + rect.width)) {
+return -1;
+}
+return offset + lineOffset;
+}
 /**
 * Returns the orientation of the receiver.
 *
 * @return the orientation style
 *
 */
 int getPartialBottomIndex() {
 if (isFixedLineHeight()) {
 int lineHeight = renderer.getLineHeight();
 int partialLineCount = Compatibility.ceil(clientAreaHeight, lineHeight);
-return Math.min(content.getLineCount(), topIndex + partialLineCount) - 1;
+return Math.max(0, Math.min(content.getLineCount(), topIndex + partialLineCount) - 1);
 }
 return getLineIndex(clientAreaHeight - bottomMargin);
 }
 /**
 * Returns the index of the first partially visible line.
 int height = 0;
 int left = 0x7fffffff, right = 0;
 for (int i = lineStart; i <= lineEnd; i++) {
 int lineOffset = content.getOffsetAtLine(i);
 TextLayout layout = renderer.getTextLayout(i);
-if (layout.getText().length > 0) {
+int length = layout.getText().length;
-if (i is lineStart && i is lineEnd) {
+if (length > 0) {
-rect = layout.getBounds(start - lineOffset, end - lineOffset);
+if (i is lineStart) {
-} else if (i is lineStart) {
+if (i is lineEnd) {
-String line = content.getLine(i);
+rect = layout.getBounds(start - lineOffset, end - lineOffset);
-rect = layout.getBounds(start - lineOffset, line.length);
+} else {
+rect = layout.getBounds(start - lineOffset, length);
+}
+y += rect.y;
 } else if (i is lineEnd) {
 rect = layout.getBounds(0, end - lineOffset);
 } else {
 rect = layout.getBounds();
 }
 }
 return lineIndex;
 }
 int getCaretDirection() {
 if (!isBidiCaret()) return DWT.DEFAULT;
+if (ime.getCompositionOffset() !is -1) return DWT.DEFAULT;
 if (!updateCaretDirection && caretDirection !is DWT.NULL) return caretDirection;
 updateCaretDirection = false;
 int caretLine = getCaretLine();
 int lineOffset = content.getOffsetAtLine(caretLine);
 String line = content.getLine(caretLine);
 int getCaretLine() {
 return content.getLineAtOffset(caretOffset);
 }
 int getWrapWidth () {
 if (wordWrap && !isSingleLine()) {
-int width = clientAreaWidth - leftMargin - rightMargin;
+int width = clientAreaWidth - leftMargin - rightMargin - getCaretWidth();
 return width > 0 ? width : 1;
 }
 return -1;
 }
 int getWordNext (int offset, int movement) {
 addListener(DWT.MouseUp, listener);
 addListener(DWT.MouseMove, listener);
 addListener(DWT.Paint, listener);
 addListener(DWT.Resize, listener);
 addListener(DWT.Traverse, listener);
+ime.addListener(DWT.ImeComposition, new class () Listener {
+public void handleEvent(Event event) {
+switch (event.detail) {
+case DWT.COMPOSITION_SELECTION: handleCompositionSelection(event); break;
+case DWT.COMPOSITION_CHANGED: handleCompositionChanged(event); break;
+case DWT.COMPOSITION_OFFSET: handleCompositionOffset(event); break;
+}
+}
+});
 if (verticalBar !is null) {
 verticalBar.addListener(DWT.Selection, new class() Listener {
 public void handleEvent(Event event) {
 handleVerticalScroll(event);
 }
 int y = startRect.y + startRect.height;
 if (endRect.y > y) {
 super.redraw(leftMargin, y, clientAreaWidth - rightMargin - leftMargin, endRect.y - y, false);
 }
 }
+void handleCompositionOffset (Event event) {
+int[] trailing = new int [1];
+event.index = getOffsetAtPoint(event.x, event.y, trailing, true);
+event.count = trailing[0];
+}
+void handleCompositionSelection (Event event) {
+event.start = selection.x;
+event.end = selection.y;
+event.text = getSelectionText();
+}
+void handleCompositionChanged(Event event) {
+String text = event.text;
+int start = event.start;
+int end = event.end;
+int length = text.length;
+if (length is ime.getCommitCount()) {
+content.replaceTextRange(start, end - start, "");
+caretOffset = start;
+caretWidth = 0;
+caretDirection = DWT.NULL;
+} else {
+content.replaceTextRange(start, end - start, text);
+caretOffset = ime.getCaretOffset();
+if (ime.getWideCaret()) {
+int lineIndex = getCaretLine();
+int lineOffset = content.getOffsetAtLine(lineIndex);
+TextLayout layout = renderer.getTextLayout(lineIndex);
+caretWidth = layout.getBounds(start - lineOffset, start + length - 1 - lineOffset).width;
+renderer.disposeTextLayout(layout);
+}
+}
+showCaret();
+}
 /**
 * Frees resources.
 */
 void handleDispose(Event event) {
 removeListener(DWT.Dispose, listener);
 if (rightCaretBitmap !is null) {
 rightCaretBitmap.dispose();
 rightCaretBitmap = null;
 }
 if (isBidiCaret()) {
-BidiUtil.removeLanguageListener(handle);
+BidiUtil.removeLanguageListener(this);
 }
 selectionBackground = null;
 selectionForeground = null;
 textChangeListener = null;
 selection = null;
 end = Math.min(content.getCharCount(), getWordNext(start, DWT.MOVEMENT_WORD_END));
 } else {
 start = lineOffset;
 end = lineEnd;
 }
-selection.x = selection.y = start;
+caretOffset = start;
-selectionAnchor = -1;
+resetSelection();
 caretOffset = end;
 showCaret();
 doMouseSelection();
 doubleClickSelection = new Point(selection.x, selection.y);
 }
 /**
 * Updates the caret position and selection and the scroll bars to reflect
 * the content change.
 */
 void handleTextChanged(TextChangedEvent event) {
+int offset = ime.getCompositionOffset();
+if (offset !is -1 && lastTextChangeStart < offset) {
+ime.setCompositionOffset(offset + lastTextChangeNewCharCount - lastTextChangeReplaceCharCount);
+}
 int firstLine = content.getLineAtOffset(lastTextChangeStart);
 resetCache(firstLine, 0);
 if (!isFixedLineHeight() && topIndex > firstLine) {
 topIndex = firstLine;
 topIndexY = 0;
 }
 /**
 * Temporary until DWT provides this
 */
 bool isBidi() {
-return IS_GTK || BidiUtil.isBidiPlatform() || isMirrored_;
+return IS_GTK || IS_CARBON || BidiUtil.isBidiPlatform() || isMirrored_;
 }
 bool isBidiCaret() {
 return BidiUtil.isBidiPlatform();
 }
 bool isFixedLineHeight() {
 if (destinationX > scrollWidth) {
 super.redraw(leftMargin + scrollWidth, topMargin, -pixels - scrollWidth, scrollHeight, true);
 }
 }
 horizontalScrollOffset += pixels;
-int oldColumnX = columnX;
 setCaretLocation();
-columnX = oldColumnX;
 return true;
 }
 /**
 * Scrolls the widget vertically.
 *
 calculateTopIndex(pixels);
 } else {
 calculateTopIndex(pixels);
 super.redraw();
 }
-int oldColumnX = columnX;
 setCaretLocation();
-columnX = oldColumnX;
 return true;
 }
 void scrollText(int srcY, int destY) {
 if (srcY is destY) return;
 int deltaY = destY - srcY;
 return newOffset;
 }
 /**
 * Sets the alignment of the widget. The argument should be one of <code>DWT.LEFT</code>,
 * <code>DWT.CENTER</code> or <code>DWT.RIGHT</code>. The alignment applies for all lines.
+* </p><p>
+* Note that if <code>DWT.MULTI</code> is set, then <code>DWT.WRAP</code> must also be set
+* in order to stabilize the right edge before setting alignment.
+* </p>
 *
 * @param alignment the new alignment
 *
 * @exception DWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 * @see Control#setBackground(Color)
 */
 public override void setBackground(Color color) {
 checkWidget();
 background = color;
+super.setBackground(color);
 super.redraw();
 }
 /**
 * Sets the receiver's caret.  Set the caret's height and location.
 *
 }
 if (isDefaultCaret && imageDirection is DWT.RIGHT) {
 location.x -= (caret.getSize().x - 1);
 }
 if (isDefaultCaret) {
-caret.setBounds(location.x, location.y, 0, caretHeight);
+caret.setBounds(location.x, location.y, caretWidth, caretHeight);
 } else {
 caret.setLocation(location);
 }
 getAccessible().textCaretMoved(getCaretOffset());
 if (direction !is caretDirection) {
 // illegal operation and an exception is thrown. Fixes 1GDKK3R
 DWT.error(DWT.ERROR_INVALID_ARGUMENT);
 }
 caretOffset = offset;
 }
+caretAlignment = PREVIOUS_OFFSET_TRAILING;
 // clear the selection if the caret is moved.
 // don't notify listeners about the selection change.
 clearSelection(false);
 }
 setCaretLocation();
 }
 }
 /**
 * Sets the alignment of the specified lines. The argument should be one of <code>DWT.LEFT</code>,
 * <code>DWT.CENTER</code> or <code>DWT.RIGHT</code>.
-* <p>
+* <p><p>
+* Note that if <code>DWT.MULTI</code> is set, then <code>DWT.WRAP</code> must also be set
+* in order to stabilize the right edge before setting alignment.
+* </p>
 * Should not be called if a LineStyleListener has been set since the listener
 * maintains the line attributes.
 * </p><p>
 * All line attributes are maintained relative to the line text, not the
 * line index that is specified in this method call.
 return;
 }
 if ((orientation & DWT.LEFT_TO_RIGHT) !is 0 && !isMirrored()) {
 return;
 }
-if (!BidiUtil.setOrientation(handle, orientation)) {
+if (!BidiUtil.setOrientation(this, orientation)) {
 return;
 }
 isMirrored_ = (orientation & DWT.RIGHT_TO_LEFT) !is 0;
 caretDirection = DWT.NULL;
 resetCache(0, content.getLineCount());
 caretOffset = selection.x = start;
 } else {
 selectionAnchor = selection.x = start;
 caretOffset = selection.y = end;
 }
+caretAlignment = PREVIOUS_OFFSET_TRAILING;
 internalRedrawRange(selection.x, selection.y - selection.x);
 }
 }
 /**
 * Sets the selection.
 */
 public void setTabs(int tabs) {
 checkWidget();
 tabLength = tabs;
 renderer.setFont(null, tabs);
-if (caretOffset > 0) {
-caretOffset = 0;
-showCaret();
-clearSelection(false);
-}
 resetCache(0, content.getLineCount());
+setCaretLocation();
 super.redraw();
 }
 /**
 * Sets the widget content.
 * If the widget has the DWT.SINGLE style and "text" contains more than

Mercurial > projects > dwt-win

comparison dwt/custom/StyledText.d @ 213:36f5cb12e1a2