Changeset 227:b74b74ce5c7d

Show
Ignore:
Timestamp:
05/19/08 16:30:33 (4 months ago)
Author:
Frank Benoit <benoit@tionex.de>
branch:
default
Message:

reworked TextLayout?

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • dwt/graphics/TextLayout.d

    r214 r227  
    3737import dwt.dwthelper.System; 
    3838 
     39 
    3940/** 
    4041 * <code>TextLayout</code> is a graphic object that represents 
     
    5354 */ 
    5455public final class TextLayout : Resource { 
     56 
    5557    alias Resource.init_ init_; 
     58 
     59/++ 
     60  DWT doku 
     61  The styles has at minimum 2 member, each with a start. The last element is the end marker. 
     62++/ 
     63 
     64    invariant{ 
     65        assert( stylesCount >= 2 ); 
     66        assert( stylesCount <= styles.length ); 
     67        assert( styles[stylesCount-1] ); 
     68        assert( styles[stylesCount-1].start is text.length ); 
     69    } 
    5670 
    5771    Font font; 
     
    13841398    checkLayout(); 
    13851399    computeRuns(null); 
    1386     int length_ = text.length; 
    1387     if (length_ is 0) return new Rectangle(0, 0, 0, 0); 
     1400    int length = text.length; 
     1401    if (length is 0) return new Rectangle(0, 0, 0, 0); 
    13881402    if (start > end) return new Rectangle(0, 0, 0, 0); 
    1389     start = Math.min(Math.max(0, start), length_ - 1); 
    1390     end = Math.min(Math.max(0, end), length_ - 1); 
     1403    start = Math.min(Math.max(0, start), length - 1); 
     1404    end = Math.min(Math.max(0, end), length - 1); 
    13911405    start = translateOffset(start); 
    13921406    end = translateOffset(end); 
     
    15411555    checkLayout(); 
    15421556    computeRuns(null); 
    1543     int length_ = text.length; 
    1544     if (!(0 <= offset && offset <= length_)) DWT.error(DWT.ERROR_INVALID_RANGE); 
     1557    int length = text.length; 
     1558    if (!(0 <= offset && offset <= length)) DWT.error(DWT.ERROR_INVALID_RANGE); 
    15451559    offset = translateOffset(offset); 
    15461560    for (int i=1; i<allRuns.length; i++) { 
     
    16401654    checkLayout(); 
    16411655    computeRuns(null); 
    1642     int length_ = text.length; 
    1643     if (!(0 <= offset && offset <= length_)) DWT.error(DWT.ERROR_INVALID_RANGE); 
     1656    int length = text.length; 
     1657    if (!(0 <= offset && offset <= length)) DWT.error(DWT.ERROR_INVALID_RANGE); 
    16441658    offset = translateOffset(offset); 
    16451659    for (int line=0; line<runs.length; line++) { 
     
    17381752    checkLayout(); 
    17391753    computeRuns(null); 
    1740     int length_ = text.length; 
    1741     if (!(0 <= offset && offset <= length_)) DWT.error(DWT.ERROR_INVALID_RANGE); 
    1742     length_ = segmentsText.length; 
     1754    int length = text.length; 
     1755    if (!(0 <= offset && offset <= length)) DWT.error(DWT.ERROR_INVALID_RANGE); 
     1756    length = segmentsText.length; 
    17431757    offset = translateOffset(offset); 
    17441758    int line; 
     
    17471761    } 
    17481762    line = Math.min(line, runs.length - 1); 
    1749     if (offset is length_) { 
     1763    if (offset is length) { 
    17501764        return new Point(getLineIndent(line) + lineWidth[line], lineY[line]); 
    17511765    } 
     
    17651779                width = metrics.width * (offset - run.start + (trailing ? 1 : 0)); 
    17661780            } else if (run.tab) { 
    1767                 width = (trailing || (offset is length_)) ? run.width : 0; 
     1781                width = (trailing || (offset is length)) ? run.width : 0; 
    17681782            } else { 
    17691783                int runOffset = offset - run.start; 
     
    18071821int _getOffset(int offset, int movement, bool forward) { 
    18081822    computeRuns(null); 
    1809     int length_ = text.length; 
    1810     if (!(0 <= offset && offset <= length_)) DWT.error(DWT.ERROR_INVALID_RANGE); 
    1811     if (forward && offset is length_) return length_
     1823    int length = text.length; 
     1824    if (!(0 <= offset && offset <= length)) DWT.error(DWT.ERROR_INVALID_RANGE); 
     1825    if (forward && offset is length) return length
    18121826    if (!forward && offset is 0) return 0; 
    18131827    int step = forward ? 1 : -1; 
    18141828    if ((movement & DWT.MOVEMENT_CHAR) !is 0) return offset + step; 
    1815     length_ = segmentsText.length; 
     1829    length = segmentsText.length; 
    18161830    offset = translateOffset(offset); 
    1817     SCRIPT_LOGATTR* logAttr
    1818     SCRIPT_PROPERTIES* properties
     1831    SCRIPT_LOGATTR* logAttr = new SCRIPT_LOGATTR()
     1832    SCRIPT_PROPERTIES* properties = new SCRIPT_PROPERTIES()
    18191833    int i = forward ? 0 : allRuns.length - 1; 
    18201834    offset = validadeOffset(offset, step); 
     
    18241838            if (run.lineBreak && !run.softBreak) return untranslateOffset(run.start); 
    18251839            if (run.tab) return untranslateOffset(run.start); 
    1826             properties = device.scripts[run.analysis.eScript]
     1840            OS.MoveMemory(properties, device.scripts[run.analysis.eScript], SCRIPT_PROPERTIES.sizeof)
    18271841            bool isComplex = properties.fNeedsCaretInfo || properties.fNeedsWordBreaking; 
    18281842            if (isComplex) breakRun(run); 
    18291843            while (run.start <= offset && offset < run.start + run.length) { 
    18301844                if (isComplex) { 
    1831                     logAttr = run.psla + (offset - run.start); 
     1845                    OS.MoveMemory(logAttr, run.psla + (offset - run.start), SCRIPT_LOGATTR.sizeof); 
    18321846                } 
    18331847                switch (movement) { 
     
    18731887        } 
    18741888        i += step; 
    1875     } while (0 <= i && i < allRuns.length - 1 && 0 <= offset && offset < length_); 
     1889    } while (0 <= i && i < allRuns.length - 1 && 0 <= offset && offset < length); 
    18761890    return forward ? text.length : 0; 
    18771891} 
     
    21262140public TextStyle getStyle (int offset) { 
    21272141    checkLayout(); 
    2128     int length_ = text.length; 
    2129     if (!(0 <= offset && offset < length_)) DWT.error(DWT.ERROR_INVALID_RANGE); 
     2142    int length = text.length; 
     2143    if (!(0 <= offset && offset < length)) DWT.error(DWT.ERROR_INVALID_RANGE); 
    21302144    for (int i=1; i<stylesCount; i++) { 
    21312145        if (styles[i].start > offset) { 
     
    22292243StyleItem[] itemize () { 
    22302244    segmentsText = getSegmentsText(); 
    2231     int length_ = segmentsText.length; 
     2245    int length = segmentsText.length; 
    22322246    SCRIPT_CONTROL scriptControl; 
    22332247    SCRIPT_STATE scriptState; 
    2234     final int MAX_ITEM = length_ + 1; 
     2248    final int MAX_ITEM = length + 1; 
    22352249 
    22362250    if ((orientation & DWT.RIGHT_TO_LEFT) !is 0) { 
     
    22732287        item.style = styles[styleIndex].style; 
    22742288        runs[count++] = item; 
    2275         *scriptItem = items[itemIndex]
     2289        OS.MoveMemory(scriptItem, (cast(void*)items) + itemIndex * SCRIPT_ITEM.sizeof, SCRIPT_ITEM.sizeof)
    22762290        item.analysis = scriptItem.a; 
    22772291        if (linkBefore) { 
     
    22802294        } 
    22812295        //scriptItem.a = new SCRIPT_ANALYSIS(); 
    2282         *scriptItem = items[ itemIndex + 1]
     2296        OS.MoveMemory(scriptItem, (cast(void*)items) + (itemIndex + 1) * SCRIPT_ITEM.sizeof, SCRIPT_ITEM.sizeof)
    22832297        int itemLimit = scriptItem.iCharPos; 
    22842298        int styleLimit = translateOffset(styles[styleIndex + 1].start); 
     
    23032317    StyleItem item = new StyleItem(); 
    23042318    item.start = end; 
    2305     *scriptItem = items[ itemCount ]
     2319    OS.MoveMemory(scriptItem, (cast(void*)items) + itemCount * SCRIPT_ITEM.sizeof, SCRIPT_ITEM.sizeof)
    23062320    item.analysis = scriptItem.a; 
    23072321    runs[count++] = item; 
     
    25892603public void setStyle (TextStyle style, int start, int end) { 
    25902604    checkLayout(); 
    2591     int length_ = text.length; 
    2592     if (length_ is 0) return; 
     2605    int length = text.length; 
     2606    if (length is 0) return; 
    25932607    if (start > end) return; 
    2594     start = Math.min(Math.max(0, start), length_ - 1); 
    2595     end = Math.min(Math.max(0, end), length_ - 1); 
     2608    start = Math.min(Math.max(0, start), length - 1); 
     2609    end = Math.min(Math.max(0, end), length - 1); 
    25962610    int low = -1; 
    25972611    int high = stylesCount; 
     
    26102624                if (item.style is null) return; 
    26112625            } else { 
    2612                 if (style ==/*eq*/ item.style) return; 
     2626                if (style.opEquals(item.style)) return; 
    26132627            } 
    26142628        } 
     
    27102724    //PORTING_CHANGE: allow null argument 
    27112725    //if (text is null) DWT.error(DWT.ERROR_NULL_ARGUMENT); 
    2712     if (text==/*eq*/this.text) return; 
     2726    if (text.equals(this.text)) return; 
    27132727    freeRuns(); 
    27142728    this.text = text; 
     
    30013015    int nSegments = segments.length; 
    30023016    if (nSegments <= 1) return offset; 
    3003     int length_ = text.length; 
    3004     if (length_ is 0) return offset; 
     3017    int length = text.length; 
     3018    if (length is 0) return offset; 
    30053019    if (nSegments is 2) { 
    3006         if (segments[0] is 0 && segments[1] is length_) return offset; 
     3020        if (segments[0] is 0 && segments[1] is length) return offset; 
    30073021    } 
    30083022    for (int i = 0; i < nSegments && offset - i >= segments[i]; i++) { 
     
    30163030    int nSegments = segments.length; 
    30173031    if (nSegments <= 1) return offset; 
    3018     int length_ = text.length; 
    3019     if (length_ is 0) return offset; 
     3032    int length = text.length; 
     3033    if (length is 0) return offset; 
    30203034    if (nSegments is 2) { 
    3021         if (segments[0] is 0 && segments[1] is length_) return offset; 
     3035        if (segments[0] is 0 && segments[1] is length) return offset; 
    30223036    } 
    30233037    for (int i = 0; i < nSegments && offset > segments[i]; i++) {