Show
Ignore:
Timestamp:
05/17/08 11:34:28 (8 months ago)
Author:
Frank Benoit <benoit@tionex.de>
branch:
default
Message:

Update to SWT 3.4M7

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • dwt/custom/StyledText.d

    r212 r213  
    5757import dwt.widgets.Display; 
    5858import dwt.widgets.Event; 
     59import dwt.widgets.IME; 
    5960import dwt.widgets.Label; 
    6061import dwt.widgets.Listener; 
     
    197198    bool editable = true; 
    198199    bool wordWrap = false; 
    199     bool doubleClickEnabled = true; // see getDoubleClickEnabled 
    200     bool overwrite = false;          // insert/overwrite edit mode 
     200    bool doubleClickEnabled = true; // see getDoubleClickEnabled 
     201    bool overwrite = false;         // insert/overwrite edit mode 
    201202    int textLimit = -1;                 // limits the number of characters the user can type in the widget. Unlimited by default. 
    202203    int[int] keyActionMap; 
     
    214215    int lastLineBottom;                 // the bottom pixel of the last line been replaced 
    215216    bool isMirrored_; 
    216     bool bidiColoring = false;      // apply the BIDI algorithm on text segments of the same color 
     217    bool bidiColoring = false;      // apply the BIDI algorithm on text segments of the same color 
    217218    Image leftCaretBitmap = null; 
    218219    Image rightCaretBitmap = null; 
    219220    int caretDirection = DWT.NULL; 
     221    int caretWidth = 0; 
    220222    Caret defaultCaret = null; 
    221223    bool updateCaretDirection = true; 
    222224    bool fixedLineHeight; 
    223225    bool dragDetect_ = true; 
     226    IME ime; 
    224227 
    225228    int alignment; 
     
    261264        int startLine;                                  // first (wrapped) line to print 
    262265        int endLine;                                    // last (wrapped) line to print 
    263         bool singleLine;                             // widget single line mode 
     266        bool singleLine;                                // widget single line mode 
    264267        Point selection = null;                 // selected text 
    265         bool mirrored;                      // indicates the printing gc should be mirrored 
     268        bool mirrored;                      // indicates the printing gc should be mirrored 
    266269        int lineSpacing; 
    267270        int printMargin; 
     
    527530        } 
    528531        if (printOptions.printLineNumbers) { 
     532            int numberingWidth = 0; 
    529533            int count = endLine - startLine + 1; 
    530             StringBuffer buffer = new StringBuffer("0"); 
    531             while ((count /= 10) > 0) buffer.append("0"); 
    532             printLayout.setText(buffer.toString()); 
    533             int numberingWidth = printLayout.getBounds().width + printMargin; 
     534            String[] lineLabels = printOptions.lineLabels; 
     535            if (lineLabels !is null) { 
     536                for (int i = startLine; i < Math.min(count, lineLabels.length); i++) { 
     537                    if (lineLabels[i] !is null) { 
     538                        printLayout.setText(lineLabels[i]); 
     539                        int lineWidth = printLayout.getBounds().width; 
     540                        numberingWidth = Math.max(numberingWidth, lineWidth); 
     541                    } 
     542                } 
     543            } else { 
     544                StringBuffer buffer = new StringBuffer("0"); 
     545                while ((count /= 10) > 0) buffer.append("0"); 
     546                printLayout.setText(buffer.toString()); 
     547                numberingWidth = printLayout.getBounds().width; 
     548            } 
     549            numberingWidth += printMargin; 
    534550            if (numberingWidth > width) numberingWidth = width; 
    535551            paintX += numberingWidth; 
     
    569585                    //draw paragraph top in the current page and paragraph bottom in the next 
    570586                    int height = paragraphBottom - paintY; 
    571                     gc.setClipping(paintX, paintY, width, height); 
     587                    gc.setClipping(clientArea.x, paintY, clientArea.width, height); 
    572588                    printLine(paintX, paintY, gc, foreground, lineBackground, layout, printLayout, i); 
     589                    gc.setClipping(cast(Rectangle)null); 
    573590                    printDecoration(page, false, printLayout); 
    574591                    printer.endPage(); 
     
    579596                        paintY = clientArea.y - height; 
    580597                        int layoutHeight = layout.getBounds().height; 
    581                         gc.setClipping(paintX, clientArea.y, width, layoutHeight - height); 
     598                        gc.setClipping(clientArea.x, clientArea.y, clientArea.width, layoutHeight - height); 
    582599                        printLine(paintX, paintY, gc, foreground, lineBackground, layout, printLayout, i); 
     600                        gc.setClipping(cast(Rectangle)null); 
    583601                        paintY += layoutHeight; 
    584602                    } 
    585                     gc.setClipping(cast(Rectangle)null); 
    586603                } 
    587604            } 
    588605            printerRenderer.disposeTextLayout(layout); 
    589606        } 
    590         if (paintY > clientArea.y) { 
     607        if (page <= endPage && paintY > clientArea.y) { 
    591608            // close partial page 
    592609            printDecoration(page, false, printLayout); 
     
    675692        if (printOptions.printLineNumbers) { 
    676693            FontMetrics metrics = layout.getLineMetrics(0); 
    677             printLayout.setAscent(metrics.getAscent() + metrics.getDescent()); 
     694            printLayout.setAscent(metrics.getAscent() + metrics.getLeading()); 
    678695            printLayout.setDescent(metrics.getDescent()); 
    679             printLayout.setText( to!(String)(index) ); 
     696            String[] lineLabels = printOptions.lineLabels; 
     697            if (lineLabels !is null) { 
     698                if (0 <= index && index < lineLabels.length && lineLabels[index] !is null) { 
     699                    printLayout.setText(lineLabels[index]); 
     700                } else { 
     701                    printLayout.setText(""); 
     702                } 
     703            } else { 
     704                printLayout.setText( to!(String)(index) ); 
     705            } 
    680706            int paintX = x - printMargin - printLayout.getBounds().width; 
    681707            printLayout.draw(gc, paintX, y); 
     
    13131339    renderer.setContent(content); 
    13141340    renderer.setFont(getFont(), tabLength); 
    1315     defaultCaret = new Caret(this, DWT.NULL); 
     1341    ime = new IME(this, DWT.NONE); 
     1342    defaultCaret = new Caret(this, DWT.NONE); 
    13161343    if ((style & DWT.WRAP) !is 0) { 
    13171344        setWordWrap(true); 
     
    13281355            } 
    13291356        }; 
    1330         BidiUtil.addLanguageListener(handle, runnable); 
     1357        BidiUtil.addLanguageListener(this, runnable); 
    13311358    } 
    13321359    setCaret(defaultCaret); 
     
    17521779        for (int lineIndex = 0; lineIndex < lineCount; lineIndex++) { 
    17531780            TextLayout layout = renderer.getTextLayout(lineIndex); 
     1781            int wrapWidth = layout.getWidth(); 
    17541782            if (wordWrap) layout.setWidth(wHint is 0 ? 1 : wHint); 
    17551783            Rectangle rect = layout.getBounds(); 
    17561784            height += rect.height; 
    17571785            width = Math.max(width, rect.width); 
     1786            layout.setWidth(wrapWidth); 
    17581787            renderer.disposeTextLayout(layout); 
    17591788            if (isFixedLineHeight() && height > maxHeight) break; 
     
    19441973    } 
    19451974    if (selection.x is selection.y) return false; 
    1946     int offset = getOffsetAtPoint(event.x, event.y); 
    1947     if (offset > selection.x && offset < selection.y) { 
     1975    int offset = getOffsetAtPoint(event.x, event.y, null, true); 
     1976    if (selection.x <= offset && offset < selection.y) { 
    19481977        return dragDetect(event); 
    19491978    } 
     
    22372266 */ 
    22382267void doContent(char key) { 
    2239     if (textLimit > 0 && 
    2240         content.getCharCount() - (selection.y - selection.x) >= textLimit) { 
    2241         return; 
    2242     } 
    22432268    Event event = new Event(); 
    22442269    event.start = selection.x; 
     
    22672292    } 
    22682293    if (event.text !is null) { 
     2294        if (textLimit > 0 && content.getCharCount() - (event.end - event.start) >= textLimit) { 
     2295            return; 
     2296        } 
    22692297        sendKeyEvent(event); 
    22702298    } 
     
    25312559    int newCaretOffset = getOffsetAtPoint(x, y); 
    25322560 
    2533     if (clickCount > 1) { 
    2534         // double click word select the previous/next word. fixes bug 15610 
     2561    if (doubleClickEnabled && clickCount > 1) { 
    25352562        newCaretOffset = doMouseWordSelect(x, newCaretOffset, line); 
    25362563    } 
     
    32473274Rectangle getBoundsAtOffset(int offset) { 
    32483275    int lineIndex = content.getLineAtOffset(offset); 
     3276    int lineOffset = content.getOffsetAtLine(lineIndex); 
    32493277    String line = content.getLine(lineIndex); 
    32503278    Rectangle bounds; 
    32513279    if (line.length !is 0) { 
    3252         int offsetInLine = offset - content.getOffsetAtLine(lineIndex)
     3280        int offsetInLine = offset - lineOffset
    32533281        TextLayout layout = renderer.getTextLayout(lineIndex); 
    32543282        bounds = layout.getBounds(offsetInLine, offsetInLine); 
     
    32573285        bounds = new Rectangle (0, 0, 0, renderer.getLineHeight()); 
    32583286    } 
     3287    if (offset is caretOffset) { 
     3288        int lineEnd = lineOffset + line.length; 
     3289        if (offset is lineEnd && caretAlignment is PREVIOUS_OFFSET_TRAILING) { 
     3290            bounds.width += getCaretWidth(); 
     3291        } 
     3292    } 
    32593293    bounds.x += leftMargin - horizontalScrollOffset; 
    32603294    bounds.y += getLinePixel(lineIndex); 
    32613295    return bounds; 
    32623296} 
    3263  
    32643297/** 
    32653298 * Returns the caret position relative to the start of the text. 
     
    33083341} 
    33093342/** 
    3310  * Returns the content implementation that is used for text storage 
    3311  * or null if no user defined content implementation has been set. 
    3312  * 
    3313  * @return content implementation that is used for text storage or null 
    3314  * if no user defined content implementation has been set. 
     3343 * Returns the content implementation that is used for text storage. 
     3344 * 
     3345 * @return content the user defined content implementation that is used for 
     3346 * text storage or the default content implementation if no user defined 
     3347 * content implementation has been set. 
    33153348 * @exception DWTException <ul> 
    33163349 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> 
     
    34673500    checkWidget(); 
    34683501    return content.getCharCount(); 
     3502} 
     3503/** 
     3504 * Returns the line at the given line index without delimiters. 
     3505 * Index 0 is the first line of the content. When there are not 
     3506 * any lines, getLine(0) is a valid call that answers an empty string. 
     3507 * <p> 
     3508 * 
     3509 * @param lineIndex index of the line to return. 
     3510 * @return the line text without delimiters 
     3511 * 
     3512 * @exception DWTException <ul> 
     3513 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> 
     3514 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> 
     3515 * </ul> 
     3516 * @exception IllegalArgumentException <ul> 
     3517 *   <li>ERROR_INVALID_RANGE when the line index is outside the valid range (< 0 or >= getLineCount())</li> 
     3518 * </ul> 
     3519 * @since 3.4 
     3520 */ 
     3521public String getLine(int lineIndex) { 
     3522    checkWidget(); 
     3523    if (lineIndex < 0 || 
     3524        (lineIndex > 0 && lineIndex >= content.getLineCount())) { 
     3525        DWT.error(DWT.ERROR_INVALID_RANGE); 
     3526    } 
     3527    return content.getLine(lineIndex); 
    34693528} 
    34703529/** 
     
    38603919 * </ul> 
    38613920 * @exception IllegalArgumentException <ul> 
    3862  *   <li>ERROR_INVALID_RANGE when the offset is outside the valid range (< 0 or > getCharCount())</li> 
     3921 *   <li>ERROR_INVALID_RANGE when the line index is outside the valid range (< 0 or >= getLineCount())</li> 
    38633922 * </ul> 
    38643923 * @since 2.0 
     
    39003959        DWT.error(DWT.ERROR_NULL_ARGUMENT); 
    39013960    } 
    3902     // is y above first line or is x before first column? 
    3903     if (point.y + getVerticalScrollOffset() < 0 || point.x + horizontalScrollOffset < 0) { 
     3961    int[] trailing = new int[1]; 
     3962    int offset = getOffsetAtPoint(point.x, point.y, trailing, true); 
     3963    if (offset is -1) { 
    39043964        DWT.error(DWT.ERROR_INVALID_ARGUMENT); 
    39053965    } 
    3906     int bottomIndex = getLineIndex(clientAreaHeight); 
    3907     int height = getLinePixel(bottomIndex) + renderer.getLineHeight(bottomIndex); 
    3908     if (point.y > height) { 
    3909         DWT.error(DWT.ERROR_INVALID_ARGUMENT); 
    3910     } 
    3911     int lineIndex = getLineIndex(point.y); 
    3912     int lineOffset = content.getOffsetAtLine(lineIndex); 
    3913     TextLayout layout = renderer.getTextLayout(lineIndex); 
    3914     int[] trailing = new int[1]; 
    3915     int x = point.x + horizontalScrollOffset - leftMargin ; 
    3916     int y = point.y - getLinePixel(lineIndex); 
    3917     int offsetInLine = layout.getOffset(x, y, trailing); 
    3918     String line = content.getLine(lineIndex); 
    3919     if (offsetInLine !is line.length - 1) { 
    3920         offsetInLine = Math.min(line.length, offsetInLine + trailing[0]); 
    3921     } 
    3922     Rectangle rect = layout.getLineBounds(layout.getLineIndex(offsetInLine)); 
    3923     renderer.disposeTextLayout(layout); 
    3924     if (x > rect.x + rect.width) { 
    3925         DWT.error(DWT.ERROR_INVALID_ARGUMENT); 
    3926     } 
    3927     return lineOffset + offsetInLine; 
     3966    return offset + trailing[0]; 
    39283967} 
    39293968int getOffsetAtPoint(int x, int y) { 
     
    39483987    if (trailing[0] !is 0) { 
    39493988        int lineInParagraph = layout.getLineIndex(offsetInLine + trailing[0]); 
    3950         //TODO handle bidi text 
    39513989        int lineStart = layout.getLineOffsets()[lineInParagraph]; 
    39523990        if (offsetInLine + trailing[0] is lineStart) { 
     
    39754013    return offsetInLine + content.getOffsetAtLine(lineIndex); 
    39764014} 
     4015int getOffsetAtPoint(int x, int y, int[] trailing, bool inTextOnly) { 
     4016    if (inTextOnly && y + getVerticalScrollOffset() < 0 || x + horizontalScrollOffset < 0) { 
     4017        return -1; 
     4018    } 
     4019    int bottomIndex = getPartialBottomIndex(); 
     4020    int height = getLinePixel(bottomIndex + 1); 
     4021    if (inTextOnly && y > height) { 
     4022        return -1; 
     4023    } 
     4024    int lineIndex = getLineIndex(y); 
     4025    int lineOffset = content.getOffsetAtLine(lineIndex); 
     4026    TextLayout layout = renderer.getTextLayout(lineIndex); 
     4027    x += horizontalScrollOffset - leftMargin ; 
     4028    y -= getLinePixel(lineIndex); 
     4029    int offset = layout.getOffset(x, y, trailing); 
     4030    Rectangle rect = layout.getLineBounds(layout.getLineIndex(offset)); 
     4031    renderer.disposeTextLayout(layout); 
     4032    if (inTextOnly && !(rect.x  <= x && x <=  rect.x + rect.width)) { 
     4033        return -1; 
     4034    } 
     4035    return offset + lineOffset; 
     4036} 
    39774037/** 
    39784038 * Returns the orientation of the receiver. 
     
    40004060        int lineHeight = renderer.getLineHeight(); 
    40014061        int partialLineCount = Compatibility.ceil(clientAreaHeight, lineHeight); 
    4002         return Math.min(content.getLineCount(), topIndex + partialLineCount) - 1
     4062        return Math.max(0, Math.min(content.getLineCount(), topIndex + partialLineCount) - 1)
    40034063    } 
    40044064    return getLineIndex(clientAreaHeight - bottomMargin); 
     
    45974657        int lineOffset = content.getOffsetAtLine(i); 
    45984658        TextLayout layout = renderer.getTextLayout(i); 
    4599         if (layout.getText().length > 0) { 
    4600             if (i is lineStart && i is lineEnd) { 
    4601                 rect = layout.getBounds(start - lineOffset, end - lineOffset); 
    4602             } else if (i is lineStart) { 
    4603                 String line = content.getLine(i); 
    4604                 rect = layout.getBounds(start - lineOffset, line.length); 
     4659        int length = layout.getText().length; 
     4660        if (length > 0) { 
     4661            if (i is lineStart) { 
     4662                if (i is lineEnd) { 
     4663                    rect = layout.getBounds(start - lineOffset, end - lineOffset); 
     4664                } else { 
     4665                    rect = layout.getBounds(start - lineOffset, length); 
     4666                } 
     4667                y += rect.y; 
    46054668            } else if (i is lineEnd) { 
    46064669                rect = layout.getBounds(0, end - lineOffset); 
     
    47274790int getCaretDirection() { 
    47284791    if (!isBidiCaret()) return DWT.DEFAULT; 
     4792    if (ime.getCompositionOffset() !is -1) return DWT.DEFAULT; 
    47294793    if (!updateCaretDirection && caretDirection !is DWT.NULL) return caretDirection; 
    47304794    updateCaretDirection = false; 
     
    47544818int getWrapWidth () { 
    47554819    if (wordWrap && !isSingleLine()) { 
    4756         int width = clientAreaWidth - leftMargin - rightMargin
     4820        int width = clientAreaWidth - leftMargin - rightMargin - getCaretWidth()
    47574821        return width > 0 ? width : 1; 
    47584822    } 
     
    49354999    addListener(DWT.Resize, listener); 
    49365000    addListener(DWT.Traverse, listener); 
     5001    ime.addListener(DWT.ImeComposition, new class () Listener { 
     5002        public void handleEvent(Event event) { 
     5003            switch (event.detail) { 
     5004                case DWT.COMPOSITION_SELECTION: handleCompositionSelection(event); break; 
     5005                case DWT.COMPOSITION_CHANGED: handleCompositionChanged(event); break; 
     5006                case DWT.COMPOSITION_OFFSET: handleCompositionOffset(event); break; 
     5007            } 
     5008        } 
     5009    }); 
    49375010    if (verticalBar !is null) { 
    49385011        verticalBar.addListener(DWT.Selection, new class() Listener { 
     
    50385111    } 
    50395112} 
     5113void handleCompositionOffset (Event event) { 
     5114    int[] trailing = new int [1]; 
     5115    event.index = getOffsetAtPoint(event.x, event.y, trailing, true); 
     5116    event.count = trailing[0]; 
     5117} 
     5118void handleCompositionSelection (Event event) { 
     5119    event.start = selection.x; 
     5120    event.end = selection.y; 
     5121    event.text = getSelectionText(); 
     5122} 
     5123void handleCompositionChanged(Event event) { 
     5124    String text = event.text; 
     5125    int start = event.start; 
     5126    int end = event.end; 
     5127    int length = text.length; 
     5128    if (length is ime.getCommitCount()) { 
     5129        content.replaceTextRange(start, end - start, ""); 
     5130        caretOffset = start; 
     5131        caretWidth = 0; 
     5132        caretDirection = DWT.NULL; 
     5133    } else { 
     5134        content.replaceTextRange(start, end - start, text); 
     5135        caretOffset = ime.getCaretOffset(); 
     5136        if (ime.getWideCaret()) { 
     5137            int lineIndex = getCaretLine(); 
     5138            int lineOffset = content.getOffsetAtLine(lineIndex); 
     5139            TextLayout layout = renderer.getTextLayout(lineIndex); 
     5140            caretWidth = layout.getBounds(start - lineOffset, start + length - 1 - lineOffset).width; 
     5141            renderer.disposeTextLayout(layout); 
     5142        } 
     5143    } 
     5144    showCaret(); 
     5145} 
    50405146/** 
    50415147 * Frees resources. 
     
    50685174    } 
    50695175    if (isBidiCaret()) { 
    5070         BidiUtil.removeLanguageListener(handle); 
     5176        BidiUtil.removeLanguageListener(this); 
    50715177    } 
    50725178    selectionBackground = null; 
     
    52505356                end = lineEnd; 
    52515357            } 
    5252             selection.x = selection.y = start; 
    5253             selectionAnchor = -1
     5358            caretOffset = start; 
     5359            resetSelection()
    52545360            caretOffset = end; 
    52555361            showCaret(); 
     
    53965502 */ 
    53975503void handleTextChanged(TextChangedEvent event) { 
     5504    int offset = ime.getCompositionOffset(); 
     5505    if (offset !is -1 && lastTextChangeStart < offset) { 
     5506        ime.setCompositionOffset(offset + lastTextChangeNewCharCount - lastTextChangeReplaceCharCount); 
     5507    } 
    53985508    int firstLine = content.getLineAtOffset(lastTextChangeStart); 
    53995509    resetCache(firstLine, 0); 
     
    57865896 */ 
    57875897bool isBidi() { 
    5788     return IS_GTK || BidiUtil.isBidiPlatform() || isMirrored_; 
     5898    return IS_GTK || IS_CARBON || BidiUtil.isBidiPlatform() || isMirrored_; 
    57895899} 
    57905900bool isBidiCaret() { 
     
    65136623    } 
    65146624    horizontalScrollOffset += pixels; 
    6515     int oldColumnX = columnX; 
    65166625    setCaretLocation(); 
    6517     columnX = oldColumnX; 
    65186626    return true; 
    65196627} 
     
    65686676        super.redraw(); 
    65696677    } 
    6570     int oldColumnX = columnX; 
    65716678    setCaretLocation(); 
    6572     columnX = oldColumnX; 
    65736679    return true; 
    65746680} 
     
    67056811 * Sets the alignment of the widget. The argument should be one of <code>DWT.LEFT</code>, 
    67066812 * <code>DWT.CENTER</code> or <code>DWT.RIGHT</code>. The alignment applies for all lines. 
     6813 * </p><p> 
     6814 * Note that if <code>DWT.MULTI</code> is set, then <code>DWT.WRAP</code> must also be set 
     6815 * in order to stabilize the right edge before setting alignment. 
     6816 * </p> 
    67076817 * 
    67086818 * @param alignment the new alignment 
     
    67326842    checkWidget(); 
    67336843    background = color; 
     6844    super.setBackground(color); 
    67346845    super.redraw(); 
    67356846} 
     
    68016912        } 
    68026913        if (isDefaultCaret) { 
    6803             caret.setBounds(location.x, location.y, 0, caretHeight); 
     6914            caret.setBounds(location.x, location.y, caretWidth, caretHeight); 
    68046915        } else { 
    68056916            caret.setLocation(location); 
     
    68556966            caretOffset = offset; 
    68566967        } 
     6968        caretAlignment = PREVIOUS_OFFSET_TRAILING; 
    68576969        // clear the selection if the caret is moved. 
    68586970        // don't notify listeners about the selection change. 
     
    71847296 * Sets the alignment of the specified lines. The argument should be one of <code>DWT.LEFT</code>, 
    71857297 * <code>DWT.CENTER</code> or <code>DWT.RIGHT</code>. 
    7186  * <p> 
     7298 * <p><p> 
     7299 * Note that if <code>DWT.MULTI</code> is set, then <code>DWT.WRAP</code> must also be set 
     7300 * in order to stabilize the right edge before setting alignment. 
     7301 * </p> 
    71877302 * Should not be called if a LineStyleListener has been set since the listener 
    71887303 * maintains the line attributes. 
     
    74907605        return; 
    74917606    } 
    7492     if (!BidiUtil.setOrientation(handle, orientation)) { 
     7607    if (!BidiUtil.setOrientation(this, orientation)) { 
    74937608        return; 
    74947609    } 
     
    77067821            caretOffset = selection.y = end; 
    77077822        } 
     7823        caretAlignment = PREVIOUS_OFFSET_TRAILING; 
    77087824        internalRedrawRange(selection.x, selection.y - selection.x); 
    77097825    } 
     
    80058121    tabLength = tabs; 
    80068122    renderer.setFont(null, tabs); 
    8007     if (caretOffset > 0) { 
    8008         caretOffset = 0; 
    8009         showCaret(); 
    8010         clearSelection(false); 
    8011     } 
    80128123    resetCache(0, content.getLineCount()); 
     8124    setCaretLocation(); 
    80138125    super.redraw(); 
    80148126}