@breakside/jskit 2022.22.3 → 2022.25.0

package/Root/Frameworks/Foundation/JSParagraphStyle.js

@@ -0,0 +1,71 @@
+// #import "JSObject.js"
+// #import "CoreTypes.js"
+"use strict";
+
+JSClass("JSParagraphStyle", JSObject, {
+
+    textAlignment: JSTextAlignment.left,
+    lineBreakMode: JSLineBreakMode.truncateTail,
+    lineSpacing: 0,
+    minimumLineHeight: 0,
+    lineHeightMultiple: 0,
+    paragraphSpacing: 0,
+    beforeParagraphSpacing: 0,
+    firstLineHeadIndent: 0,
+    headIndent: 0,
+    tailIndent: 0,
+
+    init: function(){
+    },
+
+    styleWithAttributes: function(attributes){
+        var style = this.copy();
+        if (attributes.textAlignment !== undefined){
+            style.textAlignment = attributes.textAlignment;
+        }
+        if (attributes.lineBreakMode !== undefined){
+            style.lineBreakMode = attributes.lineBreakMode;
+        }
+        if (attributes.lineSpacing !== undefined){
+            style.lineSpacing = attributes.lineSpacing;
+        }
+        if (attributes.minimumLineHeight !== undefined){
+            style.minimumLineHeight = attributes.minimumLineHeight;
+        }
+        if (attributes.lineHeightMultiple !== undefined){
+            style.lineHeightMultiple = attributes.lineHeightMultiple;
+        }
+        if (attributes.paragraphSpacing !== undefined){
+            style.paragraphSpacing = attributes.paragraphSpacing;
+        }
+        if (attributes.beforeParagraphSpacing !== undefined){
+            style.beforeParagraphSpacing = attributes.beforeParagraphSpacing;
+        }
+        if (attributes.firstLineHeadIndent !== undefined){
+            style.firstLineHeadIndent = attributes.firstLineHeadIndent;
+        }
+        if (attributes.headIndent !== undefined){
+            style.headIndent = attributes.headIndent;
+        }
+        if (attributes.tailIndent !== undefined){
+            style.tailIndent = attributes.tailIndent;
+        }
+        return style;
+    },
+
+    copy: function(){
+        var style = JSParagraphStyle.init();
+        style.textAlignment = this.textAlignment;
+        style.lineBreakMode = this.lineBreakMode;
+        style.lineSpacing = this.lineSpacing;
+        style.minimumLineHeight = this.minimumLineHeight;
+        style.lineHeightMultiple = this.lineHeightMultiple;
+        style.paragraphSpacing = this.paragraphSpacing;
+        style.beforeParagraphSpacing = this.beforeParagraphSpacing;
+        style.firstLineHeadIndent = this.firstLineHeadIndent;
+        style.headIndent = this.headIndent;
+        style.tailIndent = this.tailIndent;
+        return style;
+    }
+
+});

package/Root/Frameworks/Foundation/JSTextAttachment.js

@@ -32,7 +32,7 @@ JSClass("JSTextAttachment", JSObject, {
         this._image = image;
         var ratio = image.size.width / image.size.height;
         this._size = JSSize(ratio * font.displayLineHeight, font.displayLineHeight);
-        this.baselineAdjustment = font.displayDescender;
+        this.baselineAdjustment = -font.displayDescender;
     },
 
     initWithImage: function(image, size){

package/Root/Frameworks/Foundation/JSTextContainer.js

@@ -21,37 +21,13 @@
 
 (function(){
 
-var JSTextContainerAttributeProperty = function(){
-    if (this === undefined){
-        return new JSTextContainerAttributeProperty();
-    }
-};
-
-JSTextContainerAttributeProperty.prototype = Object.create(JSCustomProperty.prototype);
-
-JSTextContainerAttributeProperty.prototype.define = function(C, key, extensions){
-    Object.defineProperty(C.prototype, key, {
-        configurable: false,
-        enumerable: false,
-        set: function JSTextContainer_setAttributeProperty(value){
-            this.framesetter.attributes[key] = value;
-            this._notifyLayoutManager();
-        },
-        get: function JSTextContainer_getAttributeProperty(){
-            return this.framesetter.attributes[key];
-        }
-    });
-};
+var logger = JSLog("foundation", "text");
 
 JSClass("JSTextContainer", JSObject, {
 
     origin: JSDynamicProperty('_origin', JSPoint.Zero),
     size: JSDynamicProperty('_size', null),
     range: JSReadOnlyProperty(),
-    lineBreakMode: JSTextContainerAttributeProperty(),
-    textAlignment: JSTextContainerAttributeProperty(),
-    lineSpacing: JSTextContainerAttributeProperty(),
-    minimumLineHeight: JSTextContainerAttributeProperty(),
     textLayoutManager: JSDynamicProperty('_textLayoutManager', null),
     maximumNumberOfLines: JSDynamicProperty('_maximumNumberOfLines', 0),
     framesetter: null,
@@ -83,10 +59,10 @@ JSClass("JSTextContainer", JSObject, {
                     // If we are a single line label and we have all of the string, we *may not* need to do a new layout
                     if (this._maximumNumberOfLines == 1 && this._textFrame.range.location === 0 && this._textFrame.range.length >= this._textLayoutManager.textStorage.string.length){
                         // If the new size can still fit the entire layout, then no need to do a new layout manager layout
-                        if (size.width >= this._textFrame.usedSize.width && size.height >= this._textFrame.usedSize.height){
+                        if (size.width < Number.MAX_VALUE && size.height < Number.MAX_VALUE && size.width >= this._textFrame.usedSize.width && size.height >= this._textFrame.usedSize.height){
                             // Text frame can do a shortcut update by trimming excess size without affecting truncation
                             shouldNotify = false;
-                            this._textFrame.adjustSize(size);
+                            this.framesetter._resizeFrame(this._textFrame, size);
                         }
                     }
                     if (shouldNotify){
@@ -110,6 +86,7 @@ JSClass("JSTextContainer", JSObject, {
 
     createTextFrame: function(attributedString, range){
         this.framesetter.attributedString = attributedString;
+        this.framesetter.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle;
         this._textFrame = this.framesetter.createFrame(this.size, range, this._maximumNumberOfLines);
     },
 
@@ -125,7 +102,7 @@ JSClass("JSTextContainer", JSObject, {
     rectForCharacterAtIndex: function(index, useLineHeight){
         var line = this.lineForCharacterAtIndex(index);
         if (line !== null){
-            var rect = line.rectForCharacterAtIndex(index - (line.range.location - this._textFrame.range.location));
+            var rect = line.rectForCharacterAtIndex(index);
             if (useLineHeight){
                 rect.origin.y = line.origin.y;
                 rect.size.height = line.size.height;
@@ -167,7 +144,57 @@ JSClass("JSTextContainer", JSObject, {
         if (this._textLayoutManager !== null){
             this._textLayoutManager.setNeedsLayout();
         }
-    }
+    },
+
+    // MARK: - Deprecated
+
+    lineBreakMode: JSDynamicProperty(),
+
+    getLineBreakMode: function(){
+        logger.warn("JSTextContainer.lineBreakMode is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.lineBreakMode;
+    },
+
+    setLineBreakMode: function(lineBreakMode){
+        logger.warn("JSTextContainer.lineBreakMode is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({lineBreakMode: lineBreakMode});
+    },
+
+    textAlignment: JSDynamicProperty(),
+
+    getTextAlignment: function(){
+        logger.warn("JSTextContainer.textAlignment is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.textAlignment;
+    },
+
+    setTextAlignment: function(textAlignment){
+        logger.warn("JSTextContainer.textAlignment is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({textAlignment: textAlignment});
+    },
+
+    lineSpacing: JSDynamicProperty(),
+
+    getLineSpacing: function(){
+        logger.warn("JSTextContainer.lineSpacing is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.lineSpacing;
+    },
+
+    setLineSpacing: function(lineSpacing){
+        logger.warn("JSTextContainer.lineSpacing is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({lineSpacing: lineSpacing});
+    },
+
+    minimumLineHeight: JSDynamicProperty(),
+
+    getMinimumLineHeight: function(){
+        logger.warn("JSTextContainer.minimumLineHeight is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.minimumLineHeight;
+    },
+
+    setMinimumLineHeight: function(minimumLineHeight){
+        logger.warn("JSTextContainer.minimumLineHeight is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({minimumLineHeight: minimumLineHeight});
+    },
 
 });
 

package/Root/Frameworks/Foundation/JSTextFrame.js

@@ -25,9 +25,8 @@ JSClass("JSTextFrame", JSObject, {
     usedSize: JSReadOnlyProperty('_usedSize', null),
     range: JSReadOnlyProperty('_range', null),
     lines: JSReadOnlyProperty('_lines', null),
-    _alignment: JSTextAlignment.left,
 
-    initWithLines: function(lines, size, attributes){
+    initWithLines: function(lines, size){
         if (lines.length > 0){
             this._range = JSRange(lines[0].range.location, lines[lines.length - 1].range.end - lines[0].range.location);   
         }else{
@@ -52,35 +51,6 @@ JSClass("JSTextFrame", JSObject, {
         if (this._size.height === 0 || this._size.height === Number.MAX_VALUE){
             this._size.height = y;
         }
-        this._alignment = attributes.textAlignment;
-        this._alignLines();
-    },
-
-    adjustSize: function(newSize){
-        if (newSize.width < this._usedSize.width || newSize.height < this._usedSize.height){
-            throw new Error("Cannot adjust text frame to smaller than its used size");
-        }
-        this._size = JSSize(newSize);
-        this._alignLines();
-    },
-
-    _alignLines: function(){
-        var i, l;
-        var line;
-        switch (this._alignment){
-            case JSTextAlignment.center:
-                for (i = 0, l = this.lines.length; i < l; ++i){
-                    line = this.lines[i];
-                    line.origin.x = (this._size.width - line.size.width + line.trailingWhitespaceWidth) / 2.0;
-                }
-                break;
-            case JSTextAlignment.right:
-                for (i = 0, l = this.lines.length; i < l; ++i){
-                    line = this.lines[i];
-                    line.origin.x = (this._size.width - line.size.width + line.trailingWhitespaceWidth);
-                }
-                break;
-        }
     },
 
     drawInContextAtPoint: function(context, point){
@@ -107,7 +77,7 @@ JSClass("JSTextFrame", JSObject, {
         while (min < max){
             mid = Math.floor(min + (max - min) / 2);
             line = this._lines[mid];
-            i = line.range.location - this.range.location;
+            i = line.range.location;
             l = line.range.length;
             if (index < i){
                 max = mid;

package/Root/Frameworks/Foundation/JSTextFramesetter.js

@@ -18,15 +18,18 @@
 // #import "JSTextTypesetter.js"
 // #import "JSTextFrame.js"
 // #import "JSAttributedString.js"
+// #import "JSParagraphStyle.js"
 'use strict';
 
 (function(){
 
+var logger = JSLog("foundation", "text");
+
 JSClass("JSTextFramesetter", JSObject, {
 
     typesetter: JSReadOnlyProperty('_typesetter', null),
     attributedString: JSDynamicProperty(),
-    attributes: null,
+    defaultParagraphStyle: JSDynamicProperty("_defaultParagraphStyle", null),
 
     init: function(){
         this.initWithTypesetter(JSTextTypesetter.init());
@@ -34,7 +37,7 @@ JSClass("JSTextFramesetter", JSObject, {
 
     initWithTypesetter: function(typesetter){
         this._typesetter = typesetter;
-        this.attributes = Object.create(JSTextParagraphAttributes);
+        this._defaultParagraphStyle = JSParagraphStyle.init();
     },
 
     getAttributedString: function(){
@@ -45,8 +48,8 @@ JSClass("JSTextFramesetter", JSObject, {
         this._typesetter.attributedString = attributedString;
     },
 
-    constructFrame: function(lines, size, attributes){
-        return JSTextFrame.initWithLines(lines, size, attributes);
+    constructFrame: function(lines, size){
+        return JSTextFrame.initWithLines(lines, size);
     },
 
     createFrame: function(size, range, maximumLines){
@@ -61,35 +64,96 @@ JSClass("JSTextFramesetter", JSObject, {
         var widthLimit = size.width || Number.MAX_VALUE;
         var heightLimit = size.height || Number.MAX_VALUE;
         var lineLimit = maximumLines || Number.MAX_VALUE;
-        var spacing = 0;
+        var lineWidthLimit;
+        var attributes = this._typesetter.resolveAttributes(this._typesetter.attributedString.attributesAtIndex(remianingRange.location));
+        var paragraphStyle = this._defaultParagraphStyle.styleWithAttributes(attributes);
+        var characterIterator = this._typesetter.attributedString.string.userPerceivedCharacterIterator(remianingRange.location);
+        characterIterator.decrement();
         do{
-            lineRange = this._typesetter.suggestLineBreak(widthLimit, remianingRange, this.effectiveLineBreakMode(this.attributes.lineBreakMode, lines.length + 1, lineLimit));
+            lineWidthLimit = widthLimit;
+            if (lineWidthLimit < Number.MAX_VALUE){
+                if (characterIterator.isParagraphBreak){
+                    lineWidthLimit -= paragraphStyle.firstLineHeadIndent;
+                }else{
+                    lineWidthLimit -= paragraphStyle.headIndent;
+                }
+                lineWidthLimit -= paragraphStyle.tailIndent;
+            }
+            lineRange = this._typesetter.suggestLineBreak(lineWidthLimit, remianingRange, this.effectiveLineBreakMode(paragraphStyle.lineBreakMode, lines.length + 1, lineLimit));
             line = this._typesetter.createLine(lineRange);
             line.origin.y = y;
+            if (paragraphStyle.lineHeightMultiple > 0){
+                line.size.height *= paragraphStyle.lineHeightMultiple;
+            }
+            if (line.size.height < paragraphStyle.minimumLineHeight){
+                line.size.height = paragraphStyle.minimumLineHeight;
+            }
             y += line.size.height;
             if (y <= heightLimit){
-                spacing = Math.min(heightLimit - y, (this.attributes.lineSpacing - 1.0) * line.size.height);
-                line.size.height += Math.max(0, spacing);
-                y += spacing;
-                lines.push(line);
                 remianingRange.advance(line.range.length);
-            }else{
-                spacing = 0;
+                characterIterator = this._typesetter.attributedString.string.userPerceivedCharacterIterator(remianingRange.location);
+                characterIterator.decrement();
+                if (characterIterator.isParagraphBreak){
+                    y += Math.max(0, Math.min(heightLimit - y, paragraphStyle.paragraphSpacing));
+                    attributes = this._typesetter.resolveAttributes(this._typesetter.attributedString.attributesAtIndex(remianingRange.location));
+                    paragraphStyle = this._defaultParagraphStyle.styleWithAttributes(attributes);
+                    y += Math.max(0, Math.min(heightLimit - y, paragraphStyle.beforeParagraphSpacing));
+                }
+                y += Math.max(0, Math.min(heightLimit - y, paragraphStyle.lineSpacing));
+                lines.push(line);
             }
         } while (lineRange.length > 0 && remianingRange.length > 0 && y < heightLimit && lines.length < lineLimit);
 
-        if (this.attributes.lineBreakMode == JSLineBreakMode.truncateTail && lines.length > 0){
+        if (paragraphStyle.lineBreakMode == JSLineBreakMode.truncateTail && lines.length > 0){
             line = lines.pop();
             if (remianingRange.length > 0 && lineLimit > lines.length + 1){
                 // we got truncated because of height.  Re-run the last line so it
                 // gets broken according to truncation rules rather than word break
-                lineRange = this._typesetter.suggestLineBreak(widthLimit, JSRange(line.range.location, line.range.length + remianingRange.length), this.attributes.lineBreakMode);
+                lineRange = this._typesetter.suggestLineBreak(widthLimit, JSRange(line.range.location, line.range.length + remianingRange.length), paragraphStyle.lineBreakMode);
                 line = this._typesetter.createLine(lineRange);
             }
             var truncated = line.truncatedLine(widthLimit);
             lines.push(truncated);
         }
-        return this.constructFrame(lines, size, this.attributes);
+        var frame = this.constructFrame(lines, size);
+        this._alignLinesInFrame(frame);
+        return frame;
+    },
+
+    _resizeFrame: function(frame, size){
+        if (size.width < frame._usedSize.width || size.height < frame._usedSize.height){
+            throw new Error("Cannot adjust text frame to smaller than its used size");
+        }
+        frame._size = JSSize(size);
+        this._alignLinesInFrame(frame);
+    },
+
+    _alignLinesInFrame: function(frame){
+        var i, l;
+        var line;
+        var attributes;
+        var headIndent = 0;
+        var characterIterator;
+        var paragraphStyle;
+        for (i = 0, l = frame.lines.length; i < l; ++i){
+            line = frame.lines[i];
+            attributes = this._typesetter.resolveAttributes(this._typesetter.attributedString.attributesAtIndex(line.range.location));
+            paragraphStyle = this._defaultParagraphStyle.styleWithAttributes(attributes);
+            characterIterator = this._typesetter.attributedString.string.userPerceivedCharacterIterator(line.range.location);
+            characterIterator.decrement();
+            if (characterIterator.isParagraphBreak){
+                headIndent = paragraphStyle.firstLineHeadIndent;
+            }else{
+                headIndent = paragraphStyle.headIndent;
+            }
+            if (paragraphStyle.textAlignment === JSTextAlignment.left){
+                line.origin.x = headIndent;
+            }else if (paragraphStyle.textAlignment === JSTextAlignment.center){
+                line.origin.x = headIndent + (frame._size.width - headIndent - paragraphStyle.tailIndent - line.size.width + line.trailingWhitespaceWidth) / 2.0;
+            }else if (paragraphStyle.textAlignment === JSTextAlignment.right){
+                line.origin.x = (frame._size.width - line.size.width + line.trailingWhitespaceWidth) - paragraphStyle.tailIndent;
+            }
+        }
     },
 
     effectiveLineBreakMode: function(frameLineBreakMode, lineNumber, lineLimit){
@@ -104,15 +168,54 @@ JSClass("JSTextFramesetter", JSObject, {
             case JSLineBreakMode.characterWrap:
                 return frameLineBreakMode;
         }
+    },
+
+    // Deprecated:
+
+    attributes: JSReadOnlyProperty("_attributes", null),
+
+    getAttributes: function(){
+        logger.warn("JSTextFramesetter.attributes is deprecated");
+        if (this._attributes === null){
+            var framesetter = this;
+            this._attributes = Object.create({}, {
+                lineBreakMode: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.lineBreakMode;
+                    },
+                    set: function(lineBreakMode){
+                        framesetter._defaultParagraphStyle.lineBreakMode = lineBreakMode;
+                    }
+                },
+                textAlignment: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.textAlignment;
+                    },
+                    set: function(textAlignment){
+                        framesetter._defaultParagraphStyle.textAlignment = textAlignment;
+                    }
+                },
+                lineSpacing: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.lineHeightMultiple > 0 ? framesetter._defaultParagraphStyle.lineHeightMultiple : 1.0;
+                    },
+                    set: function(lineSpacing){
+                        framesetter._defaultParagraphStyle.lineHeightMultiple = lineSpacing;
+                    }
+                },
+                minimumLineHeight: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.minimumLineHeight;
+                    },
+                    set: function(minimumLineHeight){
+                        framesetter._defaultParagraphStyle.minimumLineHeight = minimumLineHeight;
+                    }
+                }
+            });
+        }
+        return this._attributes;
     }
 
 });
 
-var JSTextParagraphAttributes = {
-    minimumLineHeight: 0,
-    lineSpacing: 1.0,
-    textAlignment: JSTextAlignment.left,
-    lineBreakMode: JSLineBreakMode.truncateTail
-};
-
 })();

package/Root/Frameworks/Foundation/JSTextLayoutManager.js

@@ -17,6 +17,7 @@
 // #import "CoreTypes.js"
 // #import "JSAttributedString.js"
 // #import "JSColor.js"
+// #import "JSParagraphStyle.js"
 'use strict';
 
 (function(){
@@ -26,6 +27,7 @@ JSClass("JSTextLayoutManager", JSObject, {
     textStorage: JSDynamicProperty('_textStorage', null),
     defaultFont: JSDynamicProperty('_defaultFont', null),
     defaultTextColor: JSDynamicProperty('_defaultTextColor', null),
+    defaultParagraphStyle: JSDynamicProperty("_defaultParagraphStyle", null),
     includeEmptyFinalLine: false,
 
     delegate: null,
@@ -37,6 +39,7 @@ JSClass("JSTextLayoutManager", JSObject, {
     init: function(){
         this._textContainers = [];
         this._defaultTextColor = JSColor.black;
+        this._defaultParagraphStyle = JSParagraphStyle.init();
     },
 
     // MARK: - Managing Containers
@@ -106,6 +109,11 @@ JSClass("JSTextLayoutManager", JSObject, {
         this.setNeedsLayout();
     },
 
+    setDefaultParagraphStyle: function(paragraphStyle){
+        this._defaultParagraphStyle = paragraphStyle;
+        this.setNeedsLayout();
+    },
+
     // MARK: - Private Helpers for finalizing runs
 
     effectiveAttributedString: function(){
@@ -353,13 +361,13 @@ JSClass("JSTextLayoutManager", JSObject, {
                     rightX += 8;
                 }
             }else{
-                characterRect = line.rectForCharacterAtIndex(remainingRange.end - line.range.location);
+                characterRect = line.rectForCharacterAtIndex(remainingRange.end);
                 rightX = characterRect.origin.x;
             }
             if (remainingRange.location === line.range.location){
                 leftX = 0;
             }else{
-                characterRect = line.rectForCharacterAtIndex(remainingRange.location - line.range.location);
+                characterRect = line.rectForCharacterAtIndex(remainingRange.location);
                 leftX = characterRect.origin.x;
             }
             rect = JSRect(line.origin.x + leftX, line.origin.y, rightX - leftX, line.size.height);
@@ -406,7 +414,7 @@ var JSTextLayoutManagerLineEnumerator = function(layoutManager, index){
         this._containerIndex = layoutManager._textContainerIndexForCharacterAtIndex(index);
         var container = this.container;
         if (container !== null){
-            this._lineIndex = container.lineIndexForCharacterAtIndex(index - container.range.location);
+            this._lineIndex = container.lineIndexForCharacterAtIndex(index);
         }else{
             this._lineIndex = 0;
         }

package/Root/Frameworks/Foundation/JSTextLine.js

@@ -72,6 +72,7 @@ JSClass("JSTextLine", JSObject, {
         }
         var height = this._size.height;
         for (i = 0, l = this._runs.length; i < l; ++i){
+            run = this._runs[i];
             if (run.size.height - run.baseline + baseline > height){
                 height = run.size.height - run.baseline + baseline;
             }
@@ -105,7 +106,7 @@ JSClass("JSTextLine", JSObject, {
     rectForCharacterAtIndex: function(index){
         var run = this.runForCharacterAtIndex(index);
         if (run !== null){
-            var rect = run.rectForCharacterAtIndex(index - (run.range.location - this.range.location));
+            var rect = run.rectForCharacterAtIndex(index);
             rect.origin.x += run.origin.x;
             rect.origin.y += run.origin.y;
             return rect;
@@ -132,7 +133,7 @@ JSClass("JSTextLine", JSObject, {
         while (min < max){
             mid = Math.floor(min + (max - min) / 2);
             run = this._runs[mid];
-            i = run.range.location - this.range.location;
+            i = run.range.location;
             l = run.range.length;
             if (index < i){
                 max = mid;
@@ -178,7 +179,7 @@ JSClass("JSTextLine", JSObject, {
     },
 
     copy: function(){
-        var line = JSTextLine.init();
+        var line = this.$class.init();
         line._origin = JSPoint(this._origin);
         line._size = JSSize(this._size);
         line._trailingWhitespaceWidth = this._trailingWhitespaceWidth;

package/Root/Frameworks/Foundation/JSTextRun.js

@@ -39,7 +39,7 @@ JSClass("JSTextRun", JSObject, {
         this.attachment = attributes[JSAttributedString.Attribute.attachment] || null;
         if (this.attachment){
             this.baseline = this.attachment.baselineAdjustment;
-            this._size = JSSize(this.attachment.size.width, this.attachment.size.height - Math.min(0, this.attachment.baselineAdjustment));
+            this._size = JSSize(this.attachment.size);
         }else{
             this.font = font;
             this.baseline = -font.descender;
@@ -113,7 +113,7 @@ JSClass("JSTextRun", JSObject, {
         var glyph = null;
         var width;
         var characterLength;
-        var runningIndex = 0;
+        var runningIndex = this.range.location;
         for (var i = 0, l = this.glyphs.length; runningIndex < index && i < l; ++i){
             glyph = this.glyphs[i];
             width = this.font.widthOfGlyph(glyph);
@@ -130,11 +130,13 @@ JSClass("JSTextRun", JSObject, {
     },
 
     copy: function(){
-        var run = JSTextRun.init();
+        var run = this.$class.init();
         run._origin = JSPoint(this._origin);
         run._size = JSSize(this._size);
+        run.baseline = this.baseline;
         run._range = JSRange(this._range);
         run.attributes = this.attributes;
+        run.attachment = this.attachment;
         run.font = this.font;
         run.glyphs = [];
         run.glyphCharacterLengths = [];