mirror of
https://github.com/cappuccino/cappuccino.git
synced 2026-08-25 13:07:02 +00:00
David Richardson
a1ac821678
Replaced the CPTextView.j import with forward declarations for CPTextView and CPTextContainer (the latter previously reached via the removed import). The previous import graph created a circular dependency (_CPTableTextAttachment.j -> CPTextView.j -> _CPRTFParser.j / _CPRTFProducer.j -> _CPTableTextAttachment.j). This caused the legacy compiler to emit a class registration warning during clean builds, as the class was unregistered at the time of resolution. Incremental builds masked this warning via cached symbol tables. Using forward declarations breaks the cycle and ensures warning-free clean and incremental builds.
559 lines
19 KiB
Plaintext
559 lines
19 KiB
Plaintext
/* _CPTableTextAttachment.j
|
|
* A self-contained, renderable text attachment representation of a table.
|
|
*
|
|
* Copyright (C) 2026 Daniel Boehringer
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
@import "CPView.j"
|
|
@class CPTextView;
|
|
@class CPTextContainer;
|
|
@import "CPTextField.j"
|
|
@import <Foundation/CPAttributedString.j>
|
|
|
|
@implementation _CPTableTextAttachment : CPView
|
|
{
|
|
CPArray _headers;
|
|
CPArray _rows;
|
|
BOOL _isResizing;
|
|
BOOL _isEditable;
|
|
BOOL _acceptsRichText;
|
|
}
|
|
|
|
- (id)initWithHeaders:(CPArray)headers rows:(CPArray)rows
|
|
{
|
|
return [self initWithHeaders:headers rows:rows width:500.0 isEditable:YES acceptsRichText:YES];
|
|
}
|
|
|
|
- (id)initWithHeaders:(CPArray)headers rows:(CPArray)rows width:(float)totalWidth
|
|
{
|
|
return [self initWithHeaders:headers rows:rows width:totalWidth isEditable:YES acceptsRichText:YES];
|
|
}
|
|
|
|
- (id)initWithHeaders:(CPArray)headers rows:(CPArray)rows width:(float)totalWidth isEditable:(BOOL)isEditable acceptsRichText:(BOOL)acceptsRichText
|
|
{
|
|
self = [super initWithFrame:CGRectMake(0, 0, totalWidth, 20)];
|
|
if (self)
|
|
{
|
|
_headers = headers;
|
|
_rows = rows;
|
|
_isEditable = isEditable;
|
|
_acceptsRichText = acceptsRichText;
|
|
_isResizing = NO;
|
|
|
|
[self _rebuildTableWithWidth:totalWidth];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)_rebuildTableWithWidth:(float)totalWidth
|
|
{
|
|
var numCols = _headers ? [_headers count] : 0;
|
|
|
|
if (numCols == 0 && _rows && [_rows count] > 0)
|
|
numCols = [[_rows objectAtIndex:0] count];
|
|
|
|
// Apply borders on the outer left and top container edges
|
|
if (self._DOMElement) {
|
|
self._DOMElement.style.borderTop = "1px solid #e0e0e0";
|
|
self._DOMElement.style.borderLeft = "1px solid #e0e0e0";
|
|
self._DOMElement.style.boxSizing = "border-box";
|
|
}
|
|
|
|
// Initialize header cells
|
|
if (_headers && [_headers count] > 0) {
|
|
for (var c = 0; c < numCols; c++) {
|
|
var headerText = [_headers objectAtIndex:c];
|
|
var cellView = [self createCellWithText:headerText frame:CGRectMakeZero() isHeader:YES];
|
|
[self addSubview:cellView];
|
|
}
|
|
}
|
|
|
|
// Initialize body rows
|
|
if (_rows) {
|
|
for (var r = 0; r < [_rows count]; r++) {
|
|
var rowData = [_rows objectAtIndex:r];
|
|
for (var c = 0; c < numCols; c++) {
|
|
var cellText = @"";
|
|
|
|
if (c < [rowData count])
|
|
cellText = [rowData objectAtIndex:c];
|
|
|
|
var cellView = [self createCellWithText:cellText frame:CGRectMakeZero() isHeader:NO];
|
|
[self addSubview:cellView];
|
|
}
|
|
}
|
|
}
|
|
|
|
[self resizeToWidth:totalWidth];
|
|
|
|
// Trigger parent layout engine re-calculation
|
|
var textView = [self superview];
|
|
|
|
if (textView && [textView isKindOfClass:[CPTextView class]])
|
|
{
|
|
var layoutManager = [textView layoutManager];
|
|
|
|
if (layoutManager)
|
|
{
|
|
var charRange = [self _findCharacterRangeInLayoutManager:layoutManager];
|
|
if (charRange && charRange.location !== CPNotFound)
|
|
{
|
|
[layoutManager invalidateLayoutForCharacterRange:charRange isSoft:NO actualCharacterRange:nil];
|
|
[layoutManager invalidateDisplayForGlyphRange:charRange];
|
|
[layoutManager _validateLayoutAndGlyphs];
|
|
[textView sizeToFit];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
- (CPRange)_findCharacterRangeInLayoutManager:(CPLayoutManager)layoutManager
|
|
{
|
|
var lineFragments = layoutManager._lineFragments;
|
|
if (lineFragments)
|
|
{
|
|
var l = lineFragments.length;
|
|
for (var i = 0; i < l; i++)
|
|
{
|
|
var fragment = lineFragments[i];
|
|
var runs = fragment._runs;
|
|
if (runs)
|
|
{
|
|
var rc = runs.length;
|
|
for (var j = 0; j < rc; j++)
|
|
{
|
|
if (runs[j].view === self)
|
|
{
|
|
return runs[j]._range;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return CPMakeRange(CPNotFound, 0);
|
|
}
|
|
|
|
- (CPArray)headers
|
|
{
|
|
var numCols = _headers ? [_headers count] : 0;
|
|
if (numCols == 0 && _rows && [_rows count] > 0)
|
|
numCols = [[_rows objectAtIndex:0] count];
|
|
|
|
if (numCols == 0)
|
|
return _headers;
|
|
|
|
var subviews = [self subviews];
|
|
if ([subviews count] < numCols)
|
|
return _headers; // Subviews are not yet rendered, return cached fallback
|
|
|
|
var currentHeaders = [CPMutableArray array];
|
|
for (var c = 0; c < numCols; c++)
|
|
{
|
|
var cellView = [subviews objectAtIndex:c];
|
|
var textView = [self getTextViewFromCell:cellView];
|
|
var text = @"";
|
|
if (textView)
|
|
{
|
|
text = _acceptsRichText ? [[textView textStorage] copy] : [textView string];
|
|
}
|
|
[currentHeaders addObject:text];
|
|
}
|
|
|
|
_headers = currentHeaders;
|
|
return _headers;
|
|
}
|
|
|
|
- (CPArray)rows
|
|
{
|
|
var numCols = _headers ? [_headers count] : 0;
|
|
if (numCols == 0 && _rows && [_rows count] > 0)
|
|
numCols = [[_rows objectAtIndex:0] count];
|
|
|
|
if (numCols == 0 || !_rows)
|
|
return _rows;
|
|
|
|
var subviews = [self subviews];
|
|
var headerOffset = (_headers && [_headers count] > 0) ? numCols : 0;
|
|
var expectedCount = headerOffset + ([_rows count] * numCols);
|
|
|
|
if ([subviews count] < expectedCount)
|
|
return _rows; // Subviews are not yet rendered, return cached fallback
|
|
|
|
var currentRows = [CPMutableArray array];
|
|
var cellIndex = headerOffset;
|
|
|
|
for (var r = 0; r < [_rows count]; r++)
|
|
{
|
|
var rowData = [CPMutableArray array];
|
|
for (var c = 0; c < numCols; c++)
|
|
{
|
|
var cellView = [subviews objectAtIndex:cellIndex++];
|
|
var textView = [self getTextViewFromCell:cellView];
|
|
var text = @"";
|
|
if (textView)
|
|
{
|
|
text = _acceptsRichText ? [[textView textStorage] copy] : [textView string];
|
|
}
|
|
[rowData addObject:text];
|
|
}
|
|
[currentRows addObject:rowData];
|
|
}
|
|
|
|
_rows = currentRows;
|
|
return _rows;
|
|
}
|
|
|
|
- (CPView)viewForWidth:(float)width
|
|
{
|
|
[self resizeToWidth:width];
|
|
return self;
|
|
}
|
|
|
|
- (CPView)createCellWithText:(id)text frame:(CGRect)frame isHeader:(BOOL)isHeader
|
|
{
|
|
var initialWidth = (frame.size.width > 0) ? frame.size.width : 120.0;
|
|
var initialHeight = (frame.size.height > 0) ? frame.size.height : 28.0;
|
|
|
|
var cellContainer = [[CPView alloc] initWithFrame:CGRectMake(frame.origin.x, frame.origin.y, initialWidth, initialHeight)];
|
|
[cellContainer setBackgroundColor:isHeader ? [CPColor colorWithWhite:0.92 alpha:1.0] : [CPColor whiteColor]];
|
|
|
|
// Bottom and right edge borders to construct the grid
|
|
var borderView = [[CPView alloc] initWithFrame:CGRectMake(0, 0, initialWidth, initialHeight)];
|
|
[borderView setBackgroundColor:[CPColor clearColor]];
|
|
[borderView setAutoresizingMask:CPViewWidthSizable | CPViewHeightSizable];
|
|
|
|
if (borderView._DOMElement)
|
|
{
|
|
borderView._DOMElement.style.borderBottom = "1px solid #e0e0e0";
|
|
borderView._DOMElement.style.borderRight = "1px solid #e0e0e0";
|
|
borderView._DOMElement.style.boxSizing = "border-box";
|
|
}
|
|
[cellContainer addSubview:borderView];
|
|
|
|
var textContainer = [[CPTextContainer alloc] initWithContainerSize:CGSizeMake(initialWidth - 8, 1e7)];
|
|
var textView = [[CPTextView alloc] initWithFrame:CGRectMake(4, 2, initialWidth - 8, initialHeight - 4) textContainer:textContainer];
|
|
|
|
// Set explicit zero margins inside the text view to keep height measurements aligned with usedRect
|
|
[textView setTextContainerInset:CGSizeMake(0, 0)];
|
|
|
|
[textView setEditable:_isEditable];
|
|
[textView setSelectable:YES];
|
|
[textView setBackgroundColor:[CPColor clearColor]];
|
|
[textView setVerticallyResizable:YES];
|
|
[textView setHorizontallyResizable:NO];
|
|
[[textView textContainer] setWidthTracksTextView:YES];
|
|
|
|
// Configure cell rich text mode
|
|
[textView setRichText:_acceptsRichText];
|
|
|
|
// Intercept changes within cell TextViews to notify the table
|
|
[textView setDelegate:self];
|
|
|
|
// Configure cell text style using standard CPTextView APIs
|
|
var cellFont = isHeader ? [CPFont boldSystemFontOfSize:11.0] : [CPFont systemFontOfSize:11.0];
|
|
[textView setFont:cellFont];
|
|
[textView setTextColor:[CPColor blackColor]];
|
|
|
|
if (text)
|
|
[textView insertText:text];
|
|
|
|
[cellContainer addSubview:textView];
|
|
|
|
return cellContainer;
|
|
}
|
|
|
|
- (void)textDidChange:(CPNotification)aNotification
|
|
{
|
|
// Live update cell layouts and heights when changes are typed
|
|
[self resizeToWidth:CGRectGetWidth([self frame])];
|
|
}
|
|
|
|
- (CPTextView)getTextViewFromCell:(CPView)cellView
|
|
{
|
|
var subviews = [cellView subviews];
|
|
for (var i = 0; i < [subviews count]; i++) {
|
|
var sub = [subviews objectAtIndex:i];
|
|
if ([sub isKindOfClass:[CPTextView class]]) {
|
|
return sub;
|
|
}
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
- (void)resizeToWidth:(float)newWidth
|
|
{
|
|
if (_isResizing)
|
|
return;
|
|
|
|
_isResizing = YES;
|
|
|
|
// Use dynamic getters to fetch live edited strings
|
|
var currentHeaders = [self headers];
|
|
var currentRows = [self rows];
|
|
|
|
var numCols = currentHeaders ? [currentHeaders count] : 0;
|
|
if (numCols == 0 && currentRows && [currentRows count] > 0) {
|
|
numCols = [[currentRows objectAtIndex:0] count];
|
|
}
|
|
if (numCols == 0) {
|
|
_isResizing = NO;
|
|
return;
|
|
}
|
|
|
|
var subviews = [self subviews];
|
|
var colNaturalWidths = [];
|
|
var colMinWidths = [];
|
|
for (var c = 0; c < numCols; c++) {
|
|
colNaturalWidths[c] = 80.0;
|
|
colMinWidths[c] = 60.0;
|
|
}
|
|
|
|
var measureTextField = [[CPTextField alloc] initWithFrame:CGRectMake(0, 0, 10000.0, 24.0)];
|
|
[measureTextField setFont:[CPFont systemFontOfSize:13.0]];
|
|
|
|
var measureCell = function(cellText, isHeader, colIndex) {
|
|
var cellFont = isHeader ? [CPFont boldSystemFontOfSize:11.0] : [CPFont systemFontOfSize:11.0];
|
|
[measureTextField setFont:cellFont];
|
|
|
|
var plainText = (cellText && typeof cellText.string === "function") ? [cellText string] : (cellText || @"");
|
|
plainText = String(plainText);
|
|
|
|
if (cellText && typeof cellText.string === "function") {
|
|
if ([measureTextField respondsToSelector:@selector(setAttributedStringValue:)]) {
|
|
[measureTextField setAttributedStringValue:cellText];
|
|
} else {
|
|
[measureTextField setStringValue:plainText];
|
|
}
|
|
} else {
|
|
[measureTextField setStringValue:plainText];
|
|
}
|
|
|
|
[measureTextField sizeToFit];
|
|
var naturalW = CGRectGetWidth([measureTextField frame]) + 24.0;
|
|
if (naturalW > colNaturalWidths[colIndex]) {
|
|
colNaturalWidths[colIndex] = naturalW;
|
|
}
|
|
|
|
var words = plainText.split(/[\s\-]/);
|
|
var maxWordW = 50.0;
|
|
for (var w = 0; w < words.length; w++) {
|
|
var word = words[w].trim();
|
|
if (word.length === 0) continue;
|
|
[measureTextField setStringValue:word];
|
|
[measureTextField sizeToFit];
|
|
var wordW = CGRectGetWidth([measureTextField frame]) + 30.0;
|
|
if (wordW > maxWordW) {
|
|
maxWordW = wordW;
|
|
}
|
|
}
|
|
if (maxWordW > colMinWidths[colIndex]) {
|
|
colMinWidths[colIndex] = maxWordW;
|
|
}
|
|
};
|
|
|
|
if (currentHeaders) {
|
|
for (var c = 0; c < [currentHeaders count]; c++) {
|
|
measureCell([currentHeaders objectAtIndex:c], YES, c);
|
|
}
|
|
}
|
|
|
|
if (currentRows) {
|
|
for (var r = 0; r < [currentRows count]; r++) {
|
|
var rowData = [currentRows objectAtIndex:r];
|
|
for (var c = 0; c < numCols; c++) {
|
|
var cellText = @"";
|
|
if (c < [rowData count]) {
|
|
cellText = [rowData objectAtIndex:c];
|
|
}
|
|
measureCell(cellText, NO, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
var totalMinWidth = 0.0;
|
|
for (var c = 0; c < numCols; c++) {
|
|
totalMinWidth += colMinWidths[c];
|
|
}
|
|
|
|
var colWidths = [];
|
|
|
|
if (newWidth <= totalMinWidth) {
|
|
var remainingWidth = newWidth;
|
|
for (var c = 0; c < numCols; c++) {
|
|
var w = Math.floor((colMinWidths[c] / totalMinWidth) * newWidth);
|
|
colWidths[c] = w;
|
|
remainingWidth -= w;
|
|
}
|
|
if (numCols > 0) colWidths[numCols - 1] += remainingWidth;
|
|
} else {
|
|
for (var c = 0; c < numCols; c++) {
|
|
colWidths[c] = colMinWidths[c];
|
|
}
|
|
|
|
var totalGrowthCapacity = 0.0;
|
|
var growthCapacities = [];
|
|
for (var c = 0; c < numCols; c++) {
|
|
var capacity = Math.max(0.0, colNaturalWidths[c] - colMinWidths[c]);
|
|
growthCapacities[c] = capacity;
|
|
totalGrowthCapacity += capacity;
|
|
}
|
|
|
|
var extraWidth = newWidth - totalMinWidth;
|
|
var remainingExtra = extraWidth;
|
|
|
|
for (var c = 0; c < numCols; c++) {
|
|
if (totalGrowthCapacity > 0) {
|
|
var w = Math.floor((growthCapacities[c] / totalGrowthCapacity) * extraWidth);
|
|
colWidths[c] += w;
|
|
remainingExtra -= w;
|
|
}
|
|
}
|
|
if (numCols > 0) {
|
|
colWidths[numCols - 1] += remainingExtra;
|
|
}
|
|
}
|
|
|
|
var cellIndex = 0;
|
|
var currentY = 0;
|
|
|
|
var layoutRow = function(startIndex) {
|
|
var maxCellHeight = 28.0;
|
|
|
|
for (var c = 0; c < numCols; c++) {
|
|
var idx = startIndex + c;
|
|
|
|
if (idx < [subviews count]) {
|
|
var cellView = [subviews objectAtIndex:idx];
|
|
var textView = [self getTextViewFromCell:cellView];
|
|
|
|
if (textView)
|
|
{
|
|
var targetWidth = Math.max(10.0, colWidths[c] - 8);
|
|
|
|
// Update frame size directly so that textContainer auto-resizes.
|
|
// Set a large temporary height to allow accurate wrapping measurements.
|
|
[textView setFrameSize:CGSizeMake(targetWidth, 1e7)];
|
|
|
|
var layoutManager = [textView layoutManager];
|
|
if (layoutManager)
|
|
{
|
|
// FORCE LAYOUT RECALCULATION:
|
|
// Because the width changed, we must force the lazy layout manager
|
|
// to synchronously calculate glyphs and wraps at the new width.
|
|
[layoutManager glyphRangeForTextContainer:[textView textContainer]];
|
|
}
|
|
|
|
var usedRect = layoutManager ? [layoutManager usedRectForTextContainer:[textView textContainer]] : nil;
|
|
var textHeight = usedRect ? CGRectGetHeight(usedRect) : 0.0;
|
|
|
|
// Exact height + 8.0px padding (4.0px top, 4.0px bottom margin) inside the cell
|
|
var wrappedHeight = textHeight + 8.0;
|
|
|
|
if (wrappedHeight > maxCellHeight)
|
|
maxCellHeight = wrappedHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
var currentX = 0;
|
|
|
|
for (var c = 0; c < numCols; c++)
|
|
{
|
|
var idx = startIndex + c;
|
|
|
|
if (idx < [subviews count])
|
|
{
|
|
var cellView = [subviews objectAtIndex:idx];
|
|
[cellView setFrame:CGRectMake(currentX, currentY, colWidths[c], maxCellHeight)];
|
|
|
|
var textView = [self getTextViewFromCell:cellView];
|
|
|
|
if (textView)
|
|
{
|
|
var targetWidth = Math.max(10.0, colWidths[c] - 8);
|
|
var textY = 4.0;
|
|
var finalTextViewHeight = maxCellHeight - 8.0;
|
|
[textView setFrame:CGRectMake(4, textY, targetWidth, finalTextViewHeight)];
|
|
}
|
|
|
|
var cellSubviews = [cellView subviews];
|
|
|
|
if ([cellSubviews count] > 0)
|
|
[[cellSubviews objectAtIndex:0] setFrame:CGRectMake(0, 0, colWidths[c], maxCellHeight)];
|
|
}
|
|
currentX += colWidths[c];
|
|
}
|
|
|
|
return maxCellHeight;
|
|
};
|
|
|
|
if (currentHeaders && [currentHeaders count] > 0)
|
|
{
|
|
var headerHeight = layoutRow(cellIndex);
|
|
cellIndex += numCols;
|
|
currentY += headerHeight;
|
|
}
|
|
|
|
if (currentRows)
|
|
{
|
|
for (var r = 0; r < [currentRows count]; r++)
|
|
{
|
|
var rowHeight = layoutRow(cellIndex);
|
|
cellIndex += numCols;
|
|
currentY += rowHeight;
|
|
}
|
|
}
|
|
|
|
// GUARD FRAME SIZE MUTATIONS
|
|
var currentSize = [self frame].size;
|
|
|
|
if (ABS(currentSize.width - newWidth) > 0.1 || ABS(currentSize.height - currentY) > 0.1)
|
|
{
|
|
[self setFrameSize:CGSizeMake(newWidth, currentY)];
|
|
}
|
|
|
|
// we need to re-layout the textview here.
|
|
// but this is not easy as the layout engine is not re-entrant
|
|
// this does not work: (delay does not matter), layout is always off
|
|
// setTimeout(function() {
|
|
// var textView = [self superview];
|
|
//
|
|
// if (textView && [textView isKindOfClass:[CPTextView class]])
|
|
// {
|
|
// var layoutManager = [textView layoutManager];
|
|
//
|
|
// if (layoutManager)
|
|
// {
|
|
// var charRange = [self _findCharacterRangeInLayoutManager:layoutManager];
|
|
//
|
|
// if (charRange && charRange.location !== CPNotFound)
|
|
// {
|
|
// [layoutManager invalidateLayoutForCharacterRange:charRange isSoft:NO actualCharacterRange:nil];
|
|
// [layoutManager invalidateDisplayForGlyphRange:charRange];
|
|
// [layoutManager _validateLayoutAndGlyphs];
|
|
// [textView sizeToFit];
|
|
// }
|
|
// }
|
|
// }
|
|
// }, 0);
|
|
|
|
_isResizing = NO;
|
|
}
|
|
|
|
@end
|