Merge pull request #55 from nguillot/multiline-improvements
Add multiline line breaking improvements for mathematical equations
This commit is contained in:
mgriebling
556
MULTILINE_IMPLEMENTATION_NOTES.md
Normal file
556
MULTILINE_IMPLEMENTATION_NOTES.md
Normal file
@@ -0,0 +1,556 @@
|
||||
# Multiline/Line Breaking Implementation Notes
|
||||
|
||||
## Overview
|
||||
|
||||
SwiftMath now supports automatic line breaking (multiline display) for mathematical equations. This document provides technical details about the implementation, supported cases, limitations, and potential areas for improvement.
|
||||
|
||||
## Implementation Architecture
|
||||
|
||||
### Two-Tier Breaking System
|
||||
|
||||
#### 1. **Interatom Line Breaking** (Primary - NEW)
|
||||
**Location**: `MTTypesetter.swift:845-846`
|
||||
|
||||
**Mechanism**:
|
||||
- Checks **before** adding each atom to the current line
|
||||
- Calculates projected width: `currentLineWidth + atomWidth + interElementSpacing`
|
||||
- If projected width > maxWidth: flushes current line, moves down, starts new line
|
||||
- Line spacing: `fontSize × 1.5`
|
||||
|
||||
**Applies to atom types**:
|
||||
- `.ordinary` - Variables, text, regular symbols
|
||||
- `.binaryOperator` - `+`, `-`, `×`, `÷`
|
||||
- `.relation` - `=`, `<`, `>`, `≤`, `≥`
|
||||
- `.open` - Opening brackets `(`
|
||||
- `.close` - Closing brackets `)`
|
||||
- `.placeholder` - Placeholder squares
|
||||
- `.punctuation` - Commas, periods
|
||||
|
||||
**Advantages**:
|
||||
- ✅ Clean semantic breaks between mathematical elements
|
||||
- ✅ Respects TeX inter-element spacing rules
|
||||
- ✅ Fast width calculations using Core Text
|
||||
- ✅ Preserves mathematical structure
|
||||
|
||||
#### 2. **Universal Line Breaking** (Fallback - EXISTING)
|
||||
**Location**: `MTTypesetter.swift:877-950`
|
||||
|
||||
**Mechanism**:
|
||||
- Checks **after** adding atom (for simple atoms without scripts)
|
||||
- Uses Core Text's `CTTypesetterSuggestLineBreak` for Unicode-aware breaking
|
||||
- Protects numbers from splitting (3.14, 1,000, etc.)
|
||||
- Supports multiple locales (EN, FR, CH)
|
||||
|
||||
**Applies when**:
|
||||
- Atoms have no superscripts/subscripts
|
||||
- Used for very long single text atoms
|
||||
- Fallback for cases where interatom breaking doesn't apply
|
||||
|
||||
## Fully Supported Cases
|
||||
|
||||
### ✅ Simple Equations
|
||||
```swift
|
||||
"a + b + c + d + e + f"
|
||||
"x = 1, y = 2, z = 3"
|
||||
"α + β + γ + δ"
|
||||
```
|
||||
**Works perfectly**: Breaks between operators and variables.
|
||||
|
||||
### ✅ Mixed Text and Math
|
||||
```swift
|
||||
"\\text{Calculate } Δ = b^{2} - 4ac \\text{ with } a=1"
|
||||
```
|
||||
**Works perfectly**: Breaks between text and math atoms naturally.
|
||||
|
||||
### ✅ Long Sequences
|
||||
```swift
|
||||
"1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10"
|
||||
```
|
||||
**Works perfectly**: Breaks between numbers and operators.
|
||||
|
||||
### ✅ Relational Expressions
|
||||
```swift
|
||||
"a < b, b > c, c ≤ d, d ≥ e"
|
||||
```
|
||||
**Works perfectly**: Breaks after punctuation and relations.
|
||||
|
||||
### ✅ Fractions (NEWLY SUPPORTED!)
|
||||
```swift
|
||||
"a + \\frac{1}{2} + b + \\frac{3}{4} + c"
|
||||
```
|
||||
**Now works perfectly**: Fractions stay inline when they fit within width constraint. No longer forces line breaks!
|
||||
|
||||
**Implementation**: Lines 701-721 in MTTypesetter.swift
|
||||
- Creates fraction display first
|
||||
- Checks if adding it would exceed maxWidth
|
||||
- Only breaks to new line if necessary
|
||||
- Otherwise adds inline with proper spacing
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐⭐ HUGE improvement for mathematical expressions!
|
||||
|
||||
### ✅ Radicals (NEWLY SUPPORTED!)
|
||||
```swift
|
||||
"x + \\sqrt{2} + y + \\sqrt{3} + z"
|
||||
```
|
||||
**Now works perfectly**: Radicals stay inline when they fit. Handles both simple radicals and those with degrees (cube roots, etc.).
|
||||
|
||||
**Implementation**: Lines 677-705 in MTTypesetter.swift
|
||||
- Creates radical display first (including degree if present)
|
||||
- Checks if adding it would exceed maxWidth
|
||||
- Only breaks to new line if necessary
|
||||
- Otherwise adds inline with proper spacing
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐⭐ HUGE improvement for mathematical expressions!
|
||||
|
||||
### ✅ Mixed Complex Expressions (NEWLY SUPPORTED!)
|
||||
```swift
|
||||
"a + \\frac{1}{2} + \\sqrt{3} + b"
|
||||
```
|
||||
**Now works perfectly**: Intelligently mixes fractions, radicals, and simple atoms. Each element stays inline if it fits.
|
||||
|
||||
### ✅ Large Operators (NEWLY SUPPORTED!)
|
||||
```swift
|
||||
"a + \\sum x_i + \\int f(x)dx + b"
|
||||
```
|
||||
**Now works perfectly**: Large operators (∑, ∫, ∏, lim) stay inline when they fit within width constraints. Includes intelligent height checking for operators with limits.
|
||||
|
||||
**Implementation**: Lines 729-748 in MTTypesetter.swift
|
||||
- Creates operator display first (including limits if present)
|
||||
- Checks both width AND height (breaks if height > fontSize * 2.5)
|
||||
- Only breaks to new line if necessary
|
||||
- Otherwise adds inline with proper spacing
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐⭐ HUGE improvement for mathematical expressions!
|
||||
|
||||
### ✅ Delimited Expressions (NEWLY SUPPORTED!)
|
||||
```swift
|
||||
"(a+b) + \\left(\\frac{c}{d}\\right) + e"
|
||||
```
|
||||
**Now works perfectly**: Delimiters stay inline when they fit. Inner content respects width constraints and can wrap naturally.
|
||||
|
||||
**Implementation**: Lines 750-776 in MTTypesetter.swift
|
||||
- Creates delimited display first with maxWidth propagation
|
||||
- Checks if adding it would exceed maxWidth
|
||||
- Only breaks to new line if necessary
|
||||
- Passes maxWidth to inner content for proper wrapping
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐⭐ HUGE improvement for complex equations!
|
||||
|
||||
### ✅ Colored Expressions (NEWLY SUPPORTED!)
|
||||
```swift
|
||||
"a + \\color{red}{b + c + d} + e"
|
||||
```
|
||||
**Now works perfectly**: Colored sections stay inline when they fit. Inner content respects width constraints and wraps properly.
|
||||
|
||||
**Implementation**: Lines 622-685 in MTTypesetter.swift (all three color types: .color, .textcolor, .colorBox)
|
||||
- Creates colored display first with maxWidth propagation
|
||||
- Checks if adding it would exceed maxWidth
|
||||
- Only breaks to new line if necessary
|
||||
- Passes maxWidth to inner content for proper wrapping
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐ VERY GOOD improvement for emphasized content!
|
||||
|
||||
### ✅ Matrices/Tables (NEWLY SUPPORTED!)
|
||||
```swift
|
||||
"A = \\begin{pmatrix} 1 & 2 \\end{pmatrix} + B"
|
||||
```
|
||||
**Now works perfectly**: Small matrices stay inline when they fit within width constraints.
|
||||
|
||||
**Implementation**: Lines 899-916 in MTTypesetter.swift
|
||||
- Creates matrix display first
|
||||
- Checks if adding it would exceed maxWidth
|
||||
- Only breaks to new line if necessary
|
||||
- Otherwise adds inline with proper spacing
|
||||
|
||||
**Impact**: ⭐⭐⭐ GOOD improvement for small matrices and vectors!
|
||||
|
||||
### ✅ Atoms with Scripts (NEWLY IMPROVED!)
|
||||
```swift
|
||||
"a^{2} + b^{2} + c^{2} + d^{2}"
|
||||
```
|
||||
**Now works much better**: Atoms with superscripts and subscripts now participate in intelligent width-based breaking!
|
||||
|
||||
**Implementation**: Lines 1123-1137 in MTTypesetter.swift
|
||||
- Estimates total width of atom including scripts before adding
|
||||
- Checks if adding scripted atom would exceed maxWidth
|
||||
- Only breaks to new line if necessary
|
||||
- Otherwise adds inline with proper spacing
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐ SIGNIFICANT improvement for mathematical expressions with exponents!
|
||||
|
||||
## Limited Support Cases
|
||||
|
||||
### ⚠️ Very Long Text Atoms
|
||||
```swift
|
||||
"\\text{This is an extremely long piece of text within a single text command}"
|
||||
```
|
||||
**Works**: Uses Core Text's word boundary breaking with number protection.
|
||||
|
||||
**Limitation**: Breaks within the text atom, not between atoms.
|
||||
|
||||
## Remaining Unsupported Cases
|
||||
|
||||
**GREAT NEWS**: As of the latest update, ALL major complex atom types now support intelligent inline layout! 🎉
|
||||
|
||||
### ✅ Previously Unsupported - NOW FIXED!
|
||||
|
||||
The following cases that previously forced line breaks now work perfectly:
|
||||
- ✅ **Large operators** (∑, ∫, ∏) - Now stay inline with height/width checking
|
||||
- ✅ **Delimiters** (\left...\right) - Now stay inline with width propagation
|
||||
- ✅ **Colored expressions** - Now stay inline with width propagation
|
||||
- ✅ **Matrices/tables** - Now stay inline when they fit
|
||||
|
||||
### ℹ️ Special Note: Accents
|
||||
|
||||
**Code location**: `MTTypesetter.swift:751-824`
|
||||
|
||||
```swift
|
||||
"\\hat{x} + \\tilde{y}"
|
||||
```
|
||||
|
||||
**Status**: Already partially supported when maxWidth > 0. Simple accents work well; complex accents may need minor polish but are generally functional.
|
||||
|
||||
## Recent Improvements (Implemented!)
|
||||
|
||||
### ✅ FIXED: Over-Breaking with Fractions and Radicals
|
||||
**Previous Problem**: Expressions mixing simple atoms with fractions/radicals had too many breaks.
|
||||
|
||||
**Previous Example**:
|
||||
```swift
|
||||
"a + \\frac{1}{2} + b + \\sqrt{3} + c"
|
||||
// Previously became 5 lines
|
||||
```
|
||||
|
||||
**Solution Implemented**: Check if complex atom + current line width fits within constraint before flushing.
|
||||
|
||||
**Current Behavior**: Now stays on 1-2 lines as expected! ✅
|
||||
|
||||
**Implementation Details**:
|
||||
- Added `shouldBreakBeforeDisplay()` helper function (line 552-573)
|
||||
- Added `performLineBreak()` helper function (line 575-582)
|
||||
- Modified fraction handling (lines 701-721) to check width before breaking
|
||||
- Modified radical handling (lines 677-705) to check width before breaking
|
||||
- Added 8 comprehensive tests (MTTypesetterTests.swift:1712-1869)
|
||||
- All 43 tests pass on both iOS and macOS
|
||||
|
||||
## Remaining Issues and Edge Cases
|
||||
|
||||
### 1. No Look-Ahead Optimization
|
||||
**Problem**: Greedy algorithm breaks immediately without considering slightly better break points nearby.
|
||||
|
||||
**Example**:
|
||||
```swift
|
||||
"abc + defgh"
|
||||
// With narrow width might break: "abc +"
|
||||
// "defgh"
|
||||
// Better might be: "abc"
|
||||
// "+ defgh"
|
||||
```
|
||||
|
||||
**Root cause**: Algorithm doesn't look ahead to see if next few atoms would create a better break point.
|
||||
|
||||
**Possible solution**: Implement k-atom look-ahead with break quality scoring.
|
||||
|
||||
### 2. Fixed Line Height
|
||||
**Problem**: All lines use `fontSize × 1.5` regardless of content height.
|
||||
|
||||
**Example**: A line with a fraction is much taller than a line with just variables, but spacing is uniform.
|
||||
|
||||
**Possible solution**: Calculate actual line height based on ascent/descent of atoms on each line.
|
||||
|
||||
### 3. ✅ FIXED: Scripts Disable Interatom Breaking
|
||||
**Previous Problem**: Atoms with superscripts/subscripts fell back to universal breaking.
|
||||
|
||||
**Solution Implemented**: Now checks width before flushing for scripted atoms!
|
||||
- Added `estimateAtomWidthWithScripts()` helper function
|
||||
- Checks if atom with scripts would exceed width constraint BEFORE flushing
|
||||
- Only breaks line if necessary
|
||||
- Scripted atoms now participate in intelligent width-based breaking
|
||||
|
||||
**Result**: ✅ Much better breaking behavior for expressions with exponents!
|
||||
|
||||
### 4. No Break Quality Scoring
|
||||
**Problem**: All break points are treated equally - no preference for breaking after operators vs. before.
|
||||
|
||||
**Example**: Breaking after `+` is generally better than breaking before it for readability.
|
||||
|
||||
**Possible solution**: Implement break penalty system:
|
||||
- Low penalty: after binary operators, after relations, after punctuation
|
||||
- Medium penalty: after ordinary atoms
|
||||
- High penalty: after opening brackets, before closing brackets
|
||||
|
||||
### 5. No Widow/Orphan Control
|
||||
**Problem**: Single atoms can end up alone on lines.
|
||||
|
||||
**Example**:
|
||||
```swift
|
||||
// Last line might just be: "+ e"
|
||||
```
|
||||
|
||||
**Possible solution**: Minimum atoms per line constraint.
|
||||
|
||||
### 6. ✅ FIXED: Inconsistent Behavior with Recursion
|
||||
**Previous Problem**: Nested math lists (inner, color, etc.) created their own displays recursively without width constraints.
|
||||
|
||||
**Solution**: Now propagates `maxWidth` to all recursive `createLineForMathList()` calls in:
|
||||
- `.color` atoms (line 625)
|
||||
- `.textcolor` atoms (line 637)
|
||||
- `.colorBox` atoms (line 667)
|
||||
- `.inner` atoms (lines 755, 762)
|
||||
- `makeLeftRight()` helper (line 1867)
|
||||
|
||||
**Result**: ✅ Inner content now wraps properly!
|
||||
|
||||
## Future Enhancement Opportunities
|
||||
|
||||
### ✅ COMPLETED: Priority 1 - Fix ALL Complex Atom Line Flushing
|
||||
**Status**: ✅ 100% IMPLEMENTED AND TESTED
|
||||
|
||||
**What was done**:
|
||||
1. Added `shouldBreakBeforeDisplay()` helper to check width before flushing
|
||||
2. Modified `.fraction` case to check width before breaking ✅
|
||||
3. Modified `.radical` case to check width before breaking ✅
|
||||
4. Modified `.largeOperator` case with height+width checking ✅
|
||||
5. Modified `.inner` case with maxWidth propagation ✅
|
||||
6. Modified all 3 color cases (.color, .textcolor, .colorBox) with maxWidth propagation ✅
|
||||
7. Modified `.table` case to check width before breaking ✅
|
||||
8. Added 20 comprehensive tests covering all newly fixed scenarios ✅
|
||||
9. Fixed 6 old tests that checked exact pixel values ✅
|
||||
10. All 76 tests pass on both iOS and macOS ✅
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐⭐ TRANSFORMATIONAL! ALL complex atom types now intelligently stay inline!
|
||||
|
||||
**Progress**: 100% complete! 🎉
|
||||
|
||||
### ✅ COMPLETED: Priority 1 - Improve Script Handling
|
||||
**Status**: ✅ IMPLEMENTED AND TESTED
|
||||
|
||||
**What was done**:
|
||||
1. Added `estimateAtomWidthWithScripts()` helper function to calculate atom width including scripts
|
||||
2. Check width constraint BEFORE flushing for scripted atoms (lines 1123-1137)
|
||||
3. Only break line if adding scripted atom would exceed maxWidth
|
||||
4. Otherwise add inline with proper spacing
|
||||
5. Added 8 comprehensive tests covering all scenarios
|
||||
6. All 232 tests pass on iOS ✅
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐ SIGNIFICANT improvement! Expressions with exponents now break intelligently based on width!
|
||||
|
||||
**Progress**: Scripted atoms now participate in interatom breaking decisions while preserving correct script positioning!
|
||||
|
||||
### ✅ Break Quality Scoring (NEWLY COMPLETED!)
|
||||
**Goal**: Prefer better break points aesthetically (e.g., after operators rather than in the middle of expressions).
|
||||
|
||||
**Implementation**: Lines 517-607 in MTTypesetter.swift
|
||||
- Added `calculateBreakPenalty()` function that assigns penalty scores:
|
||||
* Penalty 0 (best): After binary operators (+, -, ×, ÷), relations (=, <, >), punctuation
|
||||
* Penalty 10 (good): After ordinary atoms (variables, numbers)
|
||||
* Penalty 100 (bad): After open brackets or before close brackets
|
||||
* Penalty 150 (worse): After unary/large operators
|
||||
- Modified `checkAndPerformInteratomLineBreak()` with look-ahead logic:
|
||||
* When width is slightly exceeded (100%-120% of maxWidth), looks ahead up to 3 atoms
|
||||
* Calculates penalties for each potential break point in window
|
||||
* Chooses break point with lowest penalty
|
||||
* Defers breaking if better point found within look-ahead window
|
||||
- Updated to handle special atom types (Space, Style) that don't participate in width calculations
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐ SIGNIFICANT aesthetic improvement! Expressions now break at natural, readable points!
|
||||
|
||||
**Progress**: COMPLETED with 8 comprehensive tests!
|
||||
|
||||
### ✅ Dynamic Line Height (NEWLY COMPLETED!)
|
||||
**Goal**: Adjust vertical spacing based on actual line content height rather than fixed fontSize × 1.5.
|
||||
|
||||
**Implementation**: Lines 366-367, 421-423, 654-689 in MTTypesetter.swift
|
||||
- Added `currentLineStartIndex: Int` to track where each line's displays begin in displayAtoms array
|
||||
- Added `minimumLineSpacing: CGFloat` set to 20% of fontSize for breathing room between lines
|
||||
- Created `calculateCurrentLineHeight()` function that:
|
||||
* Iterates through all displays added for the current line (from currentLineStartIndex to displayAtoms.count)
|
||||
* Finds maximum ascent and maximum descent across all displays
|
||||
* Returns total height = maxAscent + maxDescent + minimumLineSpacing
|
||||
* Ensures at least fontSize × 1.2 spacing for readability
|
||||
- Modified all line breaking functions to use dynamic height:
|
||||
* `performInteratomLineBreak()` - for interatom breaks (lines 606-624)
|
||||
* `performLineBreak()` - for complex display breaks (lines 649-664)
|
||||
* Universal line breaking - two locations (lines 1237-1241, 1260-1264)
|
||||
* Scripted atom breaking (lines 1290-1293)
|
||||
* `checkAndBreakLine()` helper - two locations (lines 1486-1490, 1510-1514)
|
||||
- All break locations now:
|
||||
* Calculate line height based on actual content
|
||||
* Update currentPosition.y using dynamic height
|
||||
* Update currentLineStartIndex for next line
|
||||
|
||||
**Impact**: ⭐⭐⭐⭐ SIGNIFICANT improvement! Lines with tall content (fractions, large operators) get appropriate spacing, while regular lines don't have excessive gaps!
|
||||
|
||||
**Progress**: COMPLETED with 8 comprehensive tests!
|
||||
|
||||
## Testing Strategy
|
||||
|
||||
### Current Test Coverage
|
||||
✅ Simple equations (6 tests in `MTTypesetterTests.swift:1577-1711`)
|
||||
✅ Text and math mixing
|
||||
✅ Atoms at boundaries
|
||||
✅ Superscripts (limited)
|
||||
✅ No breaking when not needed
|
||||
✅ Breaking after operators
|
||||
✅ **Fractions inline** (8 tests in `MTTypesetterTests.swift:1712-1869`)
|
||||
✅ **Radicals inline** (included in above)
|
||||
✅ **Mixed fractions and radicals** (included in above)
|
||||
✅ **Fractions with complex content** (included in above)
|
||||
✅ **Radicals with degrees** (included in above)
|
||||
✅ **No breaking without width constraint** (included in above)
|
||||
✅ **Very narrow widths (edge cases)** (NEW - line 1873)
|
||||
✅ **Very wide atoms (overflow handling)** (NEW - line 1895)
|
||||
✅ **Mixed scripts and non-scripts** (NEW - line 1913)
|
||||
✅ **Multiple line breaks (4+ lines)** (NEW - line 1930)
|
||||
✅ **Unicode text wrapping** (NEW - line 1962)
|
||||
✅ **Number protection** (NEW - line 1983)
|
||||
✅ **Large operators inline** (NEW - 3 tests in lines 2111-2165)
|
||||
✅ **Delimiters inline** (NEW - 4 tests in lines 2167-2246)
|
||||
✅ **Colored expressions inline** (NEW - 3 tests in lines 2248-2304)
|
||||
✅ **Matrices inline** (NEW - 3 tests in lines 2306-2362)
|
||||
✅ **Integration tests** (NEW - 2 tests in lines 2364-2415)
|
||||
✅ **Real-world examples** (NEW - 3 tests in lines 2417-2492)
|
||||
✅ **Edge cases** (NEW - 2 tests in lines 2494-2534)
|
||||
✅ **Scripted atoms inline** (NEW - 8 tests in lines 2609-2780)
|
||||
✅ **Break quality scoring** (NEW - 8 tests in lines 2797-3006)
|
||||
✅ **Dynamic line height** (NEW - 8 tests in lines 3007-3218)
|
||||
|
||||
**Total: 97 tests in MTTypesetterTests.swift, all passing on iOS**
|
||||
**Overall: 248 tests across entire test suite, all passing**
|
||||
|
||||
### Coverage Summary by Category
|
||||
|
||||
**Complex Atoms - Inline Layout:** (20 tests)
|
||||
- Large operators: 3 tests (inline when fit, break when too wide, multiple operators)
|
||||
- Delimiters: 4 tests (inline when fit, break when too wide, nested delimiters, multiple delimiters)
|
||||
- Colored expressions: 3 tests (inline when fit, break when too wide, multiple colored sections)
|
||||
- Matrices: 3 tests (small inline, break when too wide, with surrounding content)
|
||||
- Integration: 2 tests (mixed complex elements, no breaking without constraints)
|
||||
- Real-world: 3 tests (quadratic formula with color, complex fractions, mixed operations)
|
||||
- Edge cases: 2 tests (very narrow width, very wide atom)
|
||||
|
||||
**Improved Script Handling:** (8 tests)
|
||||
- Scripted atoms inline when fit
|
||||
- Scripted atoms break when too wide
|
||||
- Mixed scripted and non-scripted atoms
|
||||
- Both subscripts and superscripts
|
||||
- Real-world: Quadratic expansion with exponents
|
||||
- Real-world: Polynomial with multiple exponent terms
|
||||
- No breaking without width constraint
|
||||
- Complex expressions mixing fractions and scripts
|
||||
|
||||
**Break Quality Scoring:** (8 tests)
|
||||
- Prefer breaking after binary operators (+, -, ×, ÷)
|
||||
- Prefer breaking after relation operators (=, <, >)
|
||||
- Avoid breaking after open brackets
|
||||
- Look-ahead finds better break points
|
||||
- Multiple operators break at best available points
|
||||
- Complex expressions with various atom types
|
||||
- No unnecessary breaks when content fits
|
||||
- Penalty ordering validates break preferences
|
||||
|
||||
**Dynamic Line Height:** (8 NEW tests)
|
||||
- Tall content (fractions) gets more spacing
|
||||
- Regular content has reasonable spacing (not excessive)
|
||||
- Mixed content varies spacing appropriately per line
|
||||
- Large operators with limits get adequate vertical space
|
||||
- Similar content gets consistent spacing
|
||||
- No regression on single-line expressions
|
||||
- Deep/nested fractions get extra space
|
||||
- Radicals with indices (cube roots) get adequate spacing
|
||||
|
||||
**Edge Cases & Stress Tests:** (4 tests)
|
||||
- Very narrow widths (30pt)
|
||||
- Very wide atoms (overflow)
|
||||
- Mixed scripts and non-scripts
|
||||
- Multiple line breaks (4+ lines)
|
||||
|
||||
**Internationalization:** (2 tests)
|
||||
- Unicode text wrapping (CJK, Arabic, etc.)
|
||||
- Number protection across locales
|
||||
|
||||
**Real-World Examples:** (3 tests)
|
||||
- Quadratic formula
|
||||
- Complex nested fractions (continued fractions)
|
||||
- Multiple fractions in sequence
|
||||
|
||||
## Performance Considerations
|
||||
|
||||
### Current Performance
|
||||
- Width calculations use Core Text (relatively fast)
|
||||
- No caching of calculated widths
|
||||
- Greedy algorithm is O(n) where n = number of atoms
|
||||
- ✅ **NEW**: Early exit optimization when remaining content fits (IMPLEMENTED!)
|
||||
|
||||
### ✅ COMPLETED: Early Exit Optimization
|
||||
**Goal**: Skip expensive line breaking checks when we know all remaining content will fit.
|
||||
|
||||
**Implementation**: Lines 376, 549-606 in MTTypesetter.swift
|
||||
- Added `remainingContentFits` flag to track when optimization applies
|
||||
- In `checkAndPerformInteratomLineBreak()`:
|
||||
* After confirming current atom fits, estimates remaining content width
|
||||
* If current usage < 60% of maxWidth with ≤5 atoms remaining: sets flag (conservative)
|
||||
* If current usage < 75%: estimates remaining width via `estimateRemainingAtomsWidth()`
|
||||
* Sets flag if projected total width ≤ maxWidth
|
||||
- Once flag is set, all subsequent breaking checks return immediately (fast path)
|
||||
- Flag is reset when line break actually occurs
|
||||
- `estimateRemainingAtomsWidth()` uses character count × average char width heuristic with 1.5× safety margin
|
||||
|
||||
**Impact**: ⭐⭐⭐ GOOD performance improvement for short expressions! Avoids width calculations for atoms that definitely fit.
|
||||
|
||||
**Benefit**: Most mathematical expressions fit on one line - this optimization makes them render faster by skipping unnecessary width checks after determining the line has plenty of space.
|
||||
|
||||
**Progress**: COMPLETED and tested!
|
||||
|
||||
### Remaining Potential Optimizations
|
||||
1. **Width caching**: Cache calculated atom widths
|
||||
2. **Batch processing**: Calculate multiple atom widths together
|
||||
|
||||
## Conclusion
|
||||
|
||||
### 🎉 COMPLETE: Major Transformation Achieved!
|
||||
|
||||
The multiline line breaking implementation now provides **comprehensive support** for ALL complex atom types!
|
||||
|
||||
### ✅ What's Now Excellent (All Major Features Complete!)
|
||||
|
||||
The implementation now provides **excellent support** for:
|
||||
- ✅ Simple equations with operators
|
||||
- ✅ Text and math mixing
|
||||
- ✅ Long sequences of variables/numbers
|
||||
- ✅ **Fractions inline** (COMPLETED!)
|
||||
- ✅ **Radicals/square roots inline** (COMPLETED!)
|
||||
- ✅ **Large operators inline** (COMPLETED!)
|
||||
- ✅ **Delimited expressions inline** (COMPLETED!)
|
||||
- ✅ **Colored expressions inline** (COMPLETED!)
|
||||
- ✅ **Matrices/tables inline** (COMPLETED!)
|
||||
- ✅ **Scripted atoms (superscripts/subscripts)** (COMPLETED!)
|
||||
- ✅ **Mixed complex expressions** (COMPLETED!)
|
||||
- ✅ **Width constraint propagation to nested content** (COMPLETED!)
|
||||
|
||||
**Transformational achievements**:
|
||||
- ✅ Expressions like `a + \frac{1}{2} + \sqrt{3} + b` now stay on **1-2 lines** instead of 5!
|
||||
- ✅ Equations like `a + \sum x_i + \int f(x)dx + b` now flow naturally instead of forcing breaks!
|
||||
- ✅ Delimited content like `(a+b) + \left(\frac{c}{d}\right) + e` stays inline with proper wrapping!
|
||||
- ✅ Colored sections respect width constraints with proper nested wrapping!
|
||||
- ✅ Small matrices and tables can stay inline with surrounding content!
|
||||
- ✅ **NEW**: Scripted atoms like `a^{2} + b^{2} + c^{2}` break intelligently based on width!
|
||||
|
||||
### ⚠️ Remaining Limitations (Minor Cases Only)
|
||||
|
||||
**Still need work** for:
|
||||
- ⚠️ Very long text atoms - break within atom rather than between atoms (already implemented via universal line breaking but could be further optimized)
|
||||
|
||||
**Note**: This is a minor edge case rather than a fundamental limitation!
|
||||
|
||||
### 🎯 Future Enhancements (All Core Features Complete!)
|
||||
|
||||
All major priorities have been completed! Possible future enhancements:
|
||||
1. **Further optimize very long text atom breaking** - fine-tune Unicode-aware breaking for edge cases
|
||||
2. **Configurable line spacing multiplier** - allow users to adjust minimum spacing
|
||||
3. **Alignment options** - left/center/right alignment for multiline expressions
|
||||
|
||||
**Progress**: 🎉 **100% COMPLETE for all major features!** All atom types (simple, complex, and scripted) now support:
|
||||
- ✅ Intelligent inline layout with width-based breaking
|
||||
- ✅ Aesthetically-pleasing break point selection (after operators, avoiding bad breaks)
|
||||
- ✅ Dynamic line height based on actual content (tall fractions get more space, regular content stays compact)
|
||||
230
README.md
230
README.md
@@ -193,7 +193,7 @@ struct MathView: NSViewRepresentable {
|
||||
|
||||
### Automatic Line Wrapping
|
||||
|
||||
`SwiftMath` supports automatic line wrapping for text and simple math expressions. When the content exceeds the available width, it will wrap at word boundaries to fit within the constrained space.
|
||||
`SwiftMath` supports automatic line wrapping (multiline display) for mathematical content. The implementation uses **interatom line breaking** which breaks equations at atom boundaries (between mathematical elements) rather than within them, preserving the semantic structure of the mathematics.
|
||||
|
||||
#### Using Line Wrapping with UIKit/AppKit
|
||||
|
||||
@@ -201,18 +201,17 @@ For direct `MTMathUILabel` usage, set the `preferredMaxLayoutWidth` property:
|
||||
|
||||
```swift
|
||||
let label = MTMathUILabel()
|
||||
label.latex = "\\(\\text{Remember the conversion: 1 km equals 1000 meters.}\\)"
|
||||
label.latex = "\\text{Calculer le discriminant }\\Delta=b^{2}-4ac\\text{ avec }a=1\\text{, }b=-1\\text{, }c=-5"
|
||||
label.font = MTFontManager.fontManager.defaultFont
|
||||
label.labelMode = .text
|
||||
|
||||
// Enable line wrapping by setting a maximum width
|
||||
label.preferredMaxLayoutWidth = 300
|
||||
label.preferredMaxLayoutWidth = 235
|
||||
```
|
||||
|
||||
You can also use `sizeThatFits` to calculate the size with a width constraint:
|
||||
|
||||
```swift
|
||||
let constrainedSize = label.sizeThatFits(CGSize(width: 300, height: .greatestFiniteMagnitude))
|
||||
let constrainedSize = label.sizeThatFits(CGSize(width: 235, height: .greatestFiniteMagnitude))
|
||||
```
|
||||
|
||||
#### Using Line Wrapping with SwiftUI
|
||||
@@ -222,64 +221,217 @@ The `MathView` examples above include `sizeThatFits()` which automatically enabl
|
||||
```swift
|
||||
VStack(alignment: .leading, spacing: 8) {
|
||||
MathView(
|
||||
equation: "\\(\\text{Remember the conversion: 1 km equals 1000 meters.}\\)",
|
||||
equation: "\\text{Calculer le discriminant }\\Delta=b^{2}-4ac\\text{ avec }a=1\\text{, }b=-1\\text{, }c=-5",
|
||||
fontSize: 17,
|
||||
labelMode: .text
|
||||
)
|
||||
}
|
||||
.frame(maxWidth: 300) // The text will wrap to fit within 300pt
|
||||
.frame(maxWidth: 235) // The equation will break across multiple lines
|
||||
```
|
||||
|
||||
#### Line Wrapping Behavior
|
||||
#### Line Wrapping Behavior and Capabilities
|
||||
|
||||
- **Works for**: Text content (`\text{...}`), mixed text with simple math, and simple equations
|
||||
- **Breaks at**: Word boundaries (spaces)
|
||||
- **Preserves**: Complex math layout (fractions, superscripts, matrices remain on single lines)
|
||||
- **Respects**: Unicode text including CJK characters with proper word boundaries
|
||||
SwiftMath implements **two complementary line breaking mechanisms**:
|
||||
|
||||
##### 1. Interatom Line Breaking (Primary)
|
||||
Breaks equations **between atoms** (mathematical elements) when content exceeds the width constraint. This is the preferred method as it maintains semantic integrity.
|
||||
|
||||
##### 2. Universal Line Breaking (Fallback)
|
||||
For very long text within single atoms, breaks at Unicode word boundaries using Core Text with number protection (prevents splitting numbers like "3.14").
|
||||
|
||||
#### Fully Supported Cases
|
||||
|
||||
These atom types work perfectly with interatom line breaking:
|
||||
|
||||
**✅ Variables and ordinary text:**
|
||||
```swift
|
||||
label.latex = "a b c d e f g h i j k l m n o p"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// Breaks between individual variables at natural boundaries
|
||||
```
|
||||
|
||||
**✅ Binary operators (+, -, ×, ÷):**
|
||||
```swift
|
||||
label.latex = "a+b+c+d+e+f+g+h"
|
||||
label.preferredMaxLayoutWidth = 100
|
||||
// Breaks cleanly: "a+b+c+d+"
|
||||
// "e+f+g+h"
|
||||
```
|
||||
|
||||
**✅ Relations (=, <, >, ≤, ≥, etc.):**
|
||||
```swift
|
||||
label.latex = "a=1, b=2, c=3, d=4, e=5"
|
||||
label.preferredMaxLayoutWidth = 120
|
||||
// Breaks after commas and operators
|
||||
```
|
||||
|
||||
**✅ Mixed text and simple math:**
|
||||
```swift
|
||||
label.latex = "\\text{Calculer }\\Delta=b^{2}-4ac\\text{ avec }a=1\\text{, }b=-1"
|
||||
label.preferredMaxLayoutWidth = 200
|
||||
// Breaks between text and math atoms naturally
|
||||
```
|
||||
|
||||
**✅ Punctuation (commas, periods):**
|
||||
```swift
|
||||
label.latex = "\\text{First, second, third, fourth, fifth}"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// Breaks at commas and spaces
|
||||
```
|
||||
|
||||
**✅ Brackets and parentheses (simple):**
|
||||
```swift
|
||||
label.latex = "(a+b)+(c+d)+(e+f)"
|
||||
label.preferredMaxLayoutWidth = 120
|
||||
// Breaks between parenthesized groups
|
||||
```
|
||||
|
||||
**✅ Greek letters and symbols:**
|
||||
```swift
|
||||
label.latex = "\\alpha+\\beta+\\gamma+\\delta+\\epsilon+\\zeta"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// Breaks between Greek letters
|
||||
```
|
||||
|
||||
**✅ Fractions (NEW!):**
|
||||
```swift
|
||||
label.latex = "a+\\frac{1}{2}+b+\\frac{3}{4}+c"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// Fractions stay inline if they fit, break to new line only when needed
|
||||
// Example: "a + ½ + b" stays on one line if it fits
|
||||
```
|
||||
|
||||
**✅ Radicals/Square roots (NEW!):**
|
||||
```swift
|
||||
label.latex = "x+\\sqrt{2}+y+\\sqrt{3}+z"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// Radicals stay inline if they fit, break to new line only when needed
|
||||
// Example: "x + √2 + y" stays on one line if it fits
|
||||
```
|
||||
|
||||
**✅ Mixed fractions and radicals (NEW!):**
|
||||
```swift
|
||||
label.latex = "a+\\frac{1}{2}+\\sqrt{3}+b"
|
||||
label.preferredMaxLayoutWidth = 200
|
||||
// Intelligently breaks between complex mathematical elements
|
||||
```
|
||||
|
||||
#### Limited Support Cases
|
||||
|
||||
These cases work but with some constraints:
|
||||
|
||||
**⚠️ Atoms with superscripts/subscripts:**
|
||||
```swift
|
||||
label.latex = "a^{2}+b^{2}+c^{2}+d^{2}+e^{2}"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// Works, but uses fallback breaking mechanism
|
||||
// May not break at the most optimal positions
|
||||
```
|
||||
**Note**: Scripted atoms (with superscripts/subscripts) trigger the universal breaking mechanism which breaks within accumulated text rather than at atom boundaries. This still works but may not be as clean as pure interatom breaking.
|
||||
|
||||
**⚠️ Very long single text atoms:**
|
||||
```swift
|
||||
label.latex = "\\text{This is an extremely long piece of text within a single text command}"
|
||||
label.preferredMaxLayoutWidth = 200
|
||||
// Uses Unicode word boundary breaking with Core Text
|
||||
// Protects numbers from being split (e.g., "3.14" stays together)
|
||||
```
|
||||
|
||||
#### Remaining Unsupported Cases
|
||||
|
||||
These atom types still force line breaks (not yet optimized):
|
||||
|
||||
**⚠️ Large operators (∑, ∫, ∏, lim):**
|
||||
```swift
|
||||
label.latex = "\\sum_{i=1}^{n} x_i + \\int_{0}^{1} f(x)dx"
|
||||
// Each operator forces a new line
|
||||
```
|
||||
|
||||
**⚠️ Matrices and tables:**
|
||||
```swift
|
||||
label.latex = "A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix}"
|
||||
// Matrix always on own line
|
||||
```
|
||||
|
||||
**⚠️ Delimited expressions (\left...\right):**
|
||||
```swift
|
||||
label.latex = "\\left(\\frac{a}{b}\\right) + c"
|
||||
// The parenthesized group forces line breaks
|
||||
```
|
||||
|
||||
**⚠️ Colored expressions:**
|
||||
```swift
|
||||
label.latex = "a + \\color{red}{b} + c"
|
||||
// Colored portion causes line break
|
||||
```
|
||||
|
||||
**⚠️ Math accents:**
|
||||
```swift
|
||||
label.latex = "\\hat{x} + \\tilde{y} + \\bar{z}"
|
||||
// Accents may cause line breaks
|
||||
```
|
||||
|
||||
#### Best Practices
|
||||
|
||||
**DO:**
|
||||
- Use interatom breaking for simple equations with operators and relations
|
||||
- Use for mixed text and math where you want natural breaks
|
||||
- Use for long sequences of variables, numbers, and operators
|
||||
- Set appropriate `preferredMaxLayoutWidth` based on your layout needs
|
||||
|
||||
**DON'T:**
|
||||
- Expect natural breaking in expressions with large operators (∑, ∫, etc. - not yet optimized)
|
||||
- Expect natural breaking in expressions with \left...\right delimiters (not yet optimized)
|
||||
- Use extremely narrow widths (less than ~80pt) which may cause poor breaks
|
||||
|
||||
#### Examples
|
||||
|
||||
**Simple text wrapping:**
|
||||
**Excellent use case (discriminant formula):**
|
||||
```swift
|
||||
// Long text will wrap to multiple lines
|
||||
label.latex = "\\(\\text{The quadratic formula is used to solve equations of the form } ax^2 + bx + c = 0\\)"
|
||||
label.preferredMaxLayoutWidth = 250
|
||||
label.latex = "\\text{Calculer le discriminant }\\Delta=b^{2}-4ac\\text{ avec }a=1\\text{, }b=-1\\text{, }c=-5"
|
||||
label.preferredMaxLayoutWidth = 235
|
||||
// ✅ Breaks naturally at good points between atoms
|
||||
```
|
||||
|
||||
**Simple equation with operators:**
|
||||
**Good use case (simple arithmetic):**
|
||||
```swift
|
||||
// Long equations can break between operators if too long
|
||||
label.latex = "\\(5 + 10 + 15 + 20 + 25 + 30\\)"
|
||||
label.latex = "5+10+15+20+25+30+35+40+45+50"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// Will wrap: "5 + 10 + 15 + 20 +"
|
||||
// "25 + 30"
|
||||
// ✅ Breaks between operators cleanly
|
||||
```
|
||||
|
||||
**Mixed text and math:**
|
||||
**Excellent use case (fractions inline - NEW!):**
|
||||
```swift
|
||||
// Text wraps but math expressions stay intact
|
||||
label.latex = "\\(\\text{Result: } 5 \\times 1000 = 5000 \\text{ meters}\\)"
|
||||
label.latex = "a+\\frac{1}{2}+b+\\frac{3}{4}+c"
|
||||
label.preferredMaxLayoutWidth = 200
|
||||
// Will wrap at spaces between text and operators
|
||||
// ✅ Fractions stay inline when they fit!
|
||||
// Breaks intelligently: "a + ½ + b" on line 1, "+ ¾ + c" on line 2
|
||||
```
|
||||
|
||||
**Multiple lines in SwiftUI:**
|
||||
**Excellent use case (radicals inline - NEW!):**
|
||||
```swift
|
||||
ScrollView {
|
||||
VStack(alignment: .leading, spacing: 12) {
|
||||
ForEach(steps) { step in
|
||||
MathView(
|
||||
equation: step.description,
|
||||
fontSize: 17,
|
||||
labelMode: .text
|
||||
)
|
||||
}
|
||||
}
|
||||
.padding()
|
||||
}
|
||||
// Each MathView will automatically wrap based on available width
|
||||
label.latex = "x+\\sqrt{2}+y+\\sqrt{3}+z"
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
// ✅ Radicals stay inline when they fit!
|
||||
// Example: "x + √2 + y" on line 1, "+ √3 + z" on line 2
|
||||
```
|
||||
|
||||
**Alternative for complex expressions:**
|
||||
```swift
|
||||
// Instead of trying to break this:
|
||||
label.latex = "x = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}"
|
||||
// Consider it as a single display equation without width constraint
|
||||
label.preferredMaxLayoutWidth = 0 // No breaking
|
||||
```
|
||||
|
||||
#### Technical Details
|
||||
|
||||
- **Line spacing**: New lines are positioned at `fontSize × 1.5` below the previous line
|
||||
- **Breaking algorithm**: Greedy - breaks immediately when projected width exceeds constraint
|
||||
- **Width calculation**: Includes inter-element spacing according to TeX spacing rules
|
||||
- **Number protection**: Numbers in patterns like "3.14", "1,000", etc. are kept intact
|
||||
- **Supports locales**: English, French, Swiss number formats
|
||||
|
||||
### Included Features
|
||||
This is a list of formula types that the library currently supports:
|
||||
|
||||
|
||||
@@ -285,7 +285,7 @@ public class MTMathAtom: NSObject {
|
||||
assert(self.superScript == nil, "Cannot fuse into an atom which has a superscript: \(self)");
|
||||
assert(atom.type == self.type, "Only atoms of the same type can be fused. \(self), \(atom)");
|
||||
guard self.subScript == nil, self.superScript == nil, self.type == atom.type
|
||||
else { print("Can't fuse these 2 atoms"); return }
|
||||
else { return }
|
||||
|
||||
// Update the fused atoms list
|
||||
if self.fusedAtoms.isEmpty {
|
||||
|
||||
@@ -271,7 +271,11 @@ public struct MTMathListBuilder {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Optionally: Add style hint for inline mode
|
||||
// Note: For inline mode, we insert \textstyle to match LaTeX behavior.
|
||||
// However, fractionStyle() has been modified to keep fractions at the
|
||||
// same font size in both display and text modes (not one level smaller).
|
||||
// Large operators show limits above/below in text style due to the updated
|
||||
// condition in makeLargeOp() that checks both .display and .text styles.
|
||||
if mode == .inline && list != nil && !list!.atoms.isEmpty {
|
||||
// Prepend \textstyle to force inline rendering
|
||||
let styleAtom = MTMathStyle(style: .text)
|
||||
|
||||
@@ -185,6 +185,7 @@ public class MTMathUILabel : MTView {
|
||||
public var preferredMaxLayoutWidth: CGFloat {
|
||||
set {
|
||||
_preferredMaxLayoutWidth = newValue
|
||||
_displayList = nil // Clear cached display list when width constraint changes
|
||||
self.invalidateIntrinsicContentSize()
|
||||
self.setNeedsLayout()
|
||||
}
|
||||
@@ -244,42 +245,67 @@ public class MTMathUILabel : MTView {
|
||||
override public func draw(_ dirtyRect: MTRect) {
|
||||
super.draw(dirtyRect)
|
||||
if self.mathList == nil { return }
|
||||
if self.font == nil { return }
|
||||
|
||||
// Ensure display list is created before drawing
|
||||
if _displayList == nil {
|
||||
_layoutSubviews()
|
||||
}
|
||||
|
||||
guard let displayList = _displayList else { return }
|
||||
|
||||
// drawing code
|
||||
let context = MTGraphicsGetCurrentContext()!
|
||||
context.saveGState()
|
||||
displayList!.draw(context)
|
||||
|
||||
displayList.draw(context)
|
||||
context.restoreGState()
|
||||
}
|
||||
|
||||
func _layoutSubviews() {
|
||||
if _mathList != nil {
|
||||
// Use the effective width for layout
|
||||
let effectiveWidth = _preferredMaxLayoutWidth > 0 ? _preferredMaxLayoutWidth : bounds.size.width
|
||||
let availableWidth = effectiveWidth - contentInsets.left - contentInsets.right
|
||||
|
||||
// print("Pre list = \(_mathList!)")
|
||||
_displayList = MTTypesetter.createLineForMathList(_mathList, font: font, style: currentStyle, maxWidth: availableWidth)
|
||||
_displayList!.textColor = textColor
|
||||
// print("Post list = \(_mathList!)")
|
||||
var textX = CGFloat(0)
|
||||
switch self.textAlignment {
|
||||
case .left: textX = contentInsets.left
|
||||
case .center: textX = (bounds.size.width - contentInsets.left - contentInsets.right - _displayList!.width) / 2 + contentInsets.left
|
||||
case .right: textX = bounds.size.width - _displayList!.width - contentInsets.right
|
||||
}
|
||||
let availableHeight = bounds.size.height - contentInsets.bottom - contentInsets.top
|
||||
|
||||
// center things vertically
|
||||
var height = _displayList!.ascent + _displayList!.descent
|
||||
if height < fontSize/2 {
|
||||
height = fontSize/2 // set height to half the font size
|
||||
}
|
||||
let textY = (availableHeight - height) / 2 + _displayList!.descent + contentInsets.bottom
|
||||
_displayList!.position = CGPointMake(textX, textY)
|
||||
} else {
|
||||
guard _mathList != nil && self.font != nil else {
|
||||
_displayList = nil
|
||||
errorLabel?.frame = self.bounds
|
||||
self.setNeedsDisplay()
|
||||
return
|
||||
}
|
||||
// Ensure we have a valid font before attempting to typeset
|
||||
if self.font == nil {
|
||||
// No valid font - try to get default font
|
||||
if let defaultFont = MTFontManager.fontManager.defaultFont {
|
||||
self._font = defaultFont
|
||||
} else {
|
||||
// Cannot typeset without a font, clear display list
|
||||
_displayList = nil
|
||||
errorLabel?.frame = self.bounds
|
||||
self.setNeedsDisplay()
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
// Use the effective width for layout
|
||||
let effectiveWidth = _preferredMaxLayoutWidth > 0 ? _preferredMaxLayoutWidth : bounds.size.width
|
||||
let availableWidth = effectiveWidth - contentInsets.left - contentInsets.right
|
||||
|
||||
_displayList = MTTypesetter.createLineForMathList(_mathList, font: self.font, style: currentStyle, maxWidth: availableWidth)
|
||||
|
||||
_displayList!.textColor = textColor
|
||||
var textX = CGFloat(0)
|
||||
switch self.textAlignment {
|
||||
case .left: textX = contentInsets.left
|
||||
case .center: textX = (bounds.size.width - contentInsets.left - contentInsets.right - _displayList!.width) / 2 + contentInsets.left
|
||||
case .right: textX = bounds.size.width - _displayList!.width - contentInsets.right
|
||||
}
|
||||
let availableHeight = bounds.size.height - contentInsets.bottom - contentInsets.top
|
||||
|
||||
// center things vertically
|
||||
var height = _displayList!.ascent + _displayList!.descent
|
||||
if height < fontSize/2 {
|
||||
height = fontSize/2 // set height to half the font size
|
||||
}
|
||||
let textY = (availableHeight - height) / 2 + _displayList!.descent + contentInsets.bottom
|
||||
|
||||
_displayList!.position = CGPointMake(textX, textY)
|
||||
errorLabel?.frame = self.bounds
|
||||
self.setNeedsDisplay()
|
||||
}
|
||||
@@ -290,6 +316,17 @@ public class MTMathUILabel : MTView {
|
||||
return CGSize(width: -1, height: -1)
|
||||
}
|
||||
|
||||
// Ensure we have a valid font before attempting to typeset
|
||||
if self.font == nil {
|
||||
// No valid font - try to get default font
|
||||
if let defaultFont = MTFontManager.fontManager.defaultFont {
|
||||
self._font = defaultFont
|
||||
} else {
|
||||
// Cannot typeset without a font
|
||||
return CGSize(width: -1, height: -1)
|
||||
}
|
||||
}
|
||||
|
||||
// Determine the maximum width to use
|
||||
var maxWidth: CGFloat = 0
|
||||
if _preferredMaxLayoutWidth > 0 {
|
||||
@@ -299,7 +336,7 @@ public class MTMathUILabel : MTView {
|
||||
}
|
||||
|
||||
var displayList:MTMathListDisplay? = nil
|
||||
displayList = MTTypesetter.createLineForMathList(_mathList, font: font, style: currentStyle, maxWidth: maxWidth)
|
||||
displayList = MTTypesetter.createLineForMathList(_mathList, font: self.font, style: currentStyle, maxWidth: maxWidth)
|
||||
|
||||
guard displayList != nil else {
|
||||
// Failed to create display list
|
||||
@@ -334,7 +371,6 @@ public class MTMathUILabel : MTView {
|
||||
func setNeedsLayout() { self.needsLayout = true }
|
||||
public override var fittingSize: CGSize { _sizeThatFits(CGSizeZero) }
|
||||
public override var intrinsicContentSize: CGSize { _sizeThatFits(CGSizeZero) }
|
||||
override public var isFlipped: Bool { false }
|
||||
override public func layout() {
|
||||
self._layoutSubviews()
|
||||
super.layout()
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -22,7 +22,6 @@ final class MTFontMathTableV2Tests: XCTestCase {
|
||||
mTable?.fractionNumeratorDisplayStyleGapMin,
|
||||
mTable?.fractionNumeratorGapMin,
|
||||
].compactMap{$0}
|
||||
print("\($0.rawValue).plist: \(values)")
|
||||
}
|
||||
}
|
||||
private let executionQueue = DispatchQueue(label: "com.swiftmath.mathbundle", attributes: .concurrent)
|
||||
@@ -40,7 +39,6 @@ final class MTFontMathTableV2Tests: XCTestCase {
|
||||
executionGroup.notify(queue: .main) { [weak self] in
|
||||
guard let self = self else { return }
|
||||
XCTAssertEqual(self.testCount, totalCases)
|
||||
print("\(self.testCount) completed =================")
|
||||
}
|
||||
executionGroup.wait()
|
||||
}
|
||||
|
||||
@@ -31,7 +31,6 @@ final class MTFontV2Tests: XCTestCase {
|
||||
executionGroup.notify(queue: .main) { [weak self] in
|
||||
guard let self = self else { return }
|
||||
XCTAssertEqual(self.testCount, totalCases)
|
||||
print("\(self.testCount) completed =================")
|
||||
}
|
||||
executionGroup.wait()
|
||||
}
|
||||
@@ -68,7 +67,6 @@ final class MTFontV2Tests: XCTestCase {
|
||||
executionGroup.notify(queue: .main) { [weak self] in
|
||||
guard let self = self else { return }
|
||||
XCTAssertEqual(self.testCount, totalCases)
|
||||
print("\(self.testCount) completed =================")
|
||||
}
|
||||
executionGroup.wait()
|
||||
}
|
||||
|
||||
@@ -2187,19 +2187,9 @@ final class MTMathListBuilderTests: XCTestCase {
|
||||
]
|
||||
|
||||
for (latex, desc) in testCases {
|
||||
print("Testing: \(desc)")
|
||||
print(" LaTeX: \(latex)")
|
||||
var error: NSError? = nil
|
||||
let list = MTMathListBuilder.build(fromString: latex, error: &error)
|
||||
|
||||
if let err = error {
|
||||
print(" ERROR: \(err.localizedDescription)")
|
||||
} else if list == nil {
|
||||
print(" List is nil but no error")
|
||||
} else {
|
||||
print(" SUCCESS: Got \(list!.atoms.count) atoms")
|
||||
}
|
||||
|
||||
let unwrappedList = try XCTUnwrap(list, "Should parse: \(desc)")
|
||||
XCTAssertNil(error, "Should not error on \(desc): \(error?.localizedDescription ?? "")")
|
||||
XCTAssertTrue(unwrappedList.atoms.count >= 1, "\(desc) should have atoms")
|
||||
@@ -2474,19 +2464,9 @@ final class MTMathListBuilderTests: XCTestCase {
|
||||
]
|
||||
|
||||
for (latex, desc) in testCases {
|
||||
print("Testing: \(desc)")
|
||||
print(" LaTeX: \(latex)")
|
||||
var error: NSError? = nil
|
||||
let list = MTMathListBuilder.build(fromString: latex, error: &error)
|
||||
|
||||
if let err = error {
|
||||
print(" ERROR: \(err.localizedDescription)")
|
||||
} else if list == nil {
|
||||
print(" List is nil but no error")
|
||||
} else {
|
||||
print(" SUCCESS: Got \(list!.atoms.count) atoms")
|
||||
}
|
||||
|
||||
let unwrappedList = try XCTUnwrap(list, "Should parse: \(desc)")
|
||||
XCTAssertNil(error, "Should not error on \(desc): \(error?.localizedDescription ?? "")")
|
||||
XCTAssertTrue(unwrappedList.atoms.count >= 1, "\(desc) should have atoms")
|
||||
@@ -2521,19 +2501,9 @@ final class MTMathListBuilderTests: XCTestCase {
|
||||
]
|
||||
|
||||
for (latex, desc) in testCases {
|
||||
print("Testing: \(desc)")
|
||||
print(" LaTeX: \(latex)")
|
||||
var error: NSError? = nil
|
||||
let list = MTMathListBuilder.build(fromString: latex, error: &error)
|
||||
|
||||
if let err = error {
|
||||
print(" ERROR: \(err.localizedDescription)")
|
||||
} else if list == nil {
|
||||
print(" List is nil but no error")
|
||||
} else {
|
||||
print(" SUCCESS: Got \(list!.atoms.count) atoms")
|
||||
}
|
||||
|
||||
let unwrappedList = try XCTUnwrap(list, "Should parse: \(desc)")
|
||||
XCTAssertNil(error, "Should not error on \(desc): \(error?.localizedDescription ?? "")")
|
||||
XCTAssertTrue(unwrappedList.atoms.count >= 1, "\(desc) should have atoms")
|
||||
|
||||
@@ -192,6 +192,71 @@ class MTMathUILabelLineWrappingTests: XCTestCase {
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
}
|
||||
|
||||
func testUnicodeWordBreaking_EquivautCase() {
|
||||
// Specific test for the reported issue: "équivaut" should not break at "é"
|
||||
let label = MTMathUILabel()
|
||||
label.latex = "\\(\\text{Rappelons la conversion : 1 km équivaut à 1000 m.}\\)"
|
||||
label.font = MTFontManager.fontManager.defaultFont
|
||||
label.labelMode = .text
|
||||
|
||||
// Set the exact width constraint from the bug report
|
||||
label.preferredMaxLayoutWidth = 235
|
||||
let constrainedSize = label.intrinsicContentSize
|
||||
|
||||
// Verify the label can render without errors
|
||||
label.frame = CGRect(origin: .zero, size: constrainedSize)
|
||||
#if os(macOS)
|
||||
label.layout()
|
||||
#else
|
||||
label.layoutSubviews()
|
||||
#endif
|
||||
|
||||
XCTAssertNotNil(label.displayList, "Display list should be created")
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
|
||||
// Verify that the text wrapped (multiple lines)
|
||||
XCTAssertGreaterThan(constrainedSize.height, 20, "Should have wrapped to multiple lines")
|
||||
|
||||
// The critical check: ensure "équivaut" is not broken in the middle
|
||||
// We can't easily check the exact line breaks, but we can verify:
|
||||
// 1. The rendering succeeded without crashes
|
||||
// 2. The display has reasonable dimensions
|
||||
XCTAssertGreaterThan(constrainedSize.width, 100, "Width should be reasonable")
|
||||
XCTAssertLessThan(constrainedSize.width, 250, "Width should respect constraint")
|
||||
}
|
||||
|
||||
func testMixedTextMathNoTruncation() {
|
||||
// Test for truncation bug: content should wrap, not be lost
|
||||
// Input: \(\text{Calculer le discriminant }\Delta=b^{2}-4ac\text{ avec }a=1\text{, }b=-1\text{, }c=-5\)
|
||||
let label = MTMathUILabel()
|
||||
label.latex = "\\(\\text{Calculer le discriminant }\\Delta=b^{2}-4ac\\text{ avec }a=1\\text{, }b=-1\\text{, }c=-5\\)"
|
||||
label.font = MTFontManager.fontManager.defaultFont
|
||||
label.labelMode = .text
|
||||
|
||||
// Set width constraint that should cause wrapping
|
||||
label.preferredMaxLayoutWidth = 235
|
||||
let constrainedSize = label.intrinsicContentSize
|
||||
|
||||
// Verify the label can render without errors
|
||||
label.frame = CGRect(origin: .zero, size: constrainedSize)
|
||||
#if os(macOS)
|
||||
label.layout()
|
||||
#else
|
||||
label.layoutSubviews()
|
||||
#endif
|
||||
|
||||
XCTAssertNotNil(label.displayList, "Display list should be created")
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
|
||||
// Verify content is not truncated - should wrap to multiple lines
|
||||
XCTAssertGreaterThan(constrainedSize.height, 30, "Should wrap to multiple lines (not truncate)")
|
||||
|
||||
// Check that we have multiple display elements (wrapped content)
|
||||
if let displayList = label.displayList {
|
||||
XCTAssertGreaterThan(displayList.subDisplays.count, 1, "Should have multiple display elements from wrapping")
|
||||
}
|
||||
}
|
||||
|
||||
func testNumberProtection_FrenchDecimal() {
|
||||
let label = MTMathUILabel()
|
||||
// French decimal number should NOT be broken
|
||||
@@ -475,4 +540,202 @@ class MTMathUILabelLineWrappingTests: XCTestCase {
|
||||
XCTAssertNotNil(label.displayList, "Display list should be created")
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
}
|
||||
|
||||
// MARK: - Tests for Complex Math Expressions with Line Breaking
|
||||
|
||||
func testComplexExpressionWithRadicalWrapping() {
|
||||
// This is the reported issue: y=x^{2}+3x+4x+9x+8x+8+\sqrt{\dfrac{3x^{2}+5x}{\cos x}}
|
||||
// The sqrt part is displayed on the second line and overlaps the first line
|
||||
let label = MTMathUILabel()
|
||||
label.latex = "y=x^{2}+3x+4x+9x+8x+8+\\sqrt{\\dfrac{3x^{2}+5x}{\\cos x}}"
|
||||
label.font = MTFontManager.fontManager.defaultFont
|
||||
|
||||
// Get unconstrained size first
|
||||
let unconstrainedSize = label.intrinsicContentSize
|
||||
XCTAssertGreaterThan(unconstrainedSize.width, 0, "Unconstrained width should be > 0")
|
||||
XCTAssertGreaterThan(unconstrainedSize.height, 0, "Unconstrained height should be > 0")
|
||||
|
||||
// Now constrain the width to force wrapping
|
||||
label.preferredMaxLayoutWidth = 200
|
||||
let constrainedSize = label.intrinsicContentSize
|
||||
|
||||
XCTAssertGreaterThan(constrainedSize.width, 0, "Width should be > 0")
|
||||
XCTAssertLessThanOrEqual(constrainedSize.width, 200, "Width should not exceed constraint")
|
||||
XCTAssertGreaterThan(constrainedSize.height, unconstrainedSize.height, "Height should increase when wrapped")
|
||||
|
||||
// Layout and check for overlapping
|
||||
label.frame = CGRect(origin: .zero, size: constrainedSize)
|
||||
#if os(macOS)
|
||||
label.layout()
|
||||
#else
|
||||
label.layoutSubviews()
|
||||
#endif
|
||||
|
||||
XCTAssertNotNil(label.displayList, "Display list should be created")
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
|
||||
// Check that displays don't overlap by examining positions
|
||||
// Group displays by line (similar y positions) and check for overlap between lines
|
||||
if let displayList = label.displayList {
|
||||
// Group displays by line based on their y position
|
||||
var lineGroups: [[MTDisplay]] = []
|
||||
var currentLineDisplays: [MTDisplay] = []
|
||||
var currentLineY: CGFloat? = nil
|
||||
let yTolerance: CGFloat = 15.0 // Displays within 15 units are considered on same line (accounts for superscripts/subscripts)
|
||||
|
||||
for display in displayList.subDisplays {
|
||||
if let lineY = currentLineY {
|
||||
if abs(display.position.y - lineY) < yTolerance {
|
||||
// Same line
|
||||
currentLineDisplays.append(display)
|
||||
} else {
|
||||
// New line
|
||||
lineGroups.append(currentLineDisplays)
|
||||
currentLineDisplays = [display]
|
||||
currentLineY = display.position.y
|
||||
}
|
||||
} else {
|
||||
// First display
|
||||
currentLineDisplays = [display]
|
||||
currentLineY = display.position.y
|
||||
}
|
||||
}
|
||||
if !currentLineDisplays.isEmpty {
|
||||
lineGroups.append(currentLineDisplays)
|
||||
}
|
||||
|
||||
// Check for overlap between consecutive lines
|
||||
for i in 1..<lineGroups.count {
|
||||
let previousLine = lineGroups[i-1]
|
||||
let currentLine = lineGroups[i]
|
||||
|
||||
// Find the minimum bottom edge of previous line (Y-up: bottom = pos - desc, smaller Y)
|
||||
let previousLineMinBottom = previousLine.map { $0.position.y - $0.descent }.min() ?? 0
|
||||
|
||||
// Find the maximum top edge of current line (Y-up: top = pos + asc, larger Y)
|
||||
let currentLineMaxTop = currentLine.map { $0.position.y + $0.ascent }.max() ?? 0
|
||||
|
||||
// Check for overlap: if current line's top > previous line's bottom, they overlap
|
||||
// (In Y-up coordinate system: positive Y is upward, negative Y is downward)
|
||||
// Allow 0.5 points tolerance for floating-point precision and small adjustments
|
||||
XCTAssertLessThanOrEqual(currentLineMaxTop, previousLineMinBottom + 0.5,
|
||||
"Line \(i) (top at \(currentLineMaxTop)) overlaps with line \(i-1) (bottom at \(previousLineMinBottom))")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testRadicalWithFractionInsideWrapping() {
|
||||
// Simplified version: just a radical with a fraction inside
|
||||
let label = MTMathUILabel()
|
||||
label.latex = "x+y+z+\\sqrt{\\dfrac{a}{b}}"
|
||||
label.font = MTFontManager.fontManager.defaultFont
|
||||
|
||||
let unconstrainedSize = label.intrinsicContentSize
|
||||
|
||||
label.preferredMaxLayoutWidth = 100
|
||||
let constrainedSize = label.intrinsicContentSize
|
||||
|
||||
XCTAssertGreaterThan(constrainedSize.width, 0, "Width should be > 0")
|
||||
XCTAssertGreaterThan(constrainedSize.height, unconstrainedSize.height, "Height should increase when wrapped")
|
||||
|
||||
label.frame = CGRect(origin: .zero, size: constrainedSize)
|
||||
#if os(macOS)
|
||||
label.layout()
|
||||
#else
|
||||
label.layoutSubviews()
|
||||
#endif
|
||||
|
||||
XCTAssertNotNil(label.displayList, "Display list should be created")
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
}
|
||||
|
||||
func testTallElementsOnSecondLine() {
|
||||
// Test case with tall fractions and radicals breaking to second line
|
||||
let label = MTMathUILabel()
|
||||
label.latex = "a+b+c+\\dfrac{x^2+y^2}{z^2}+\\sqrt{\\dfrac{p}{q}}"
|
||||
label.font = MTFontManager.fontManager.defaultFont
|
||||
|
||||
let unconstrainedSize = label.intrinsicContentSize
|
||||
|
||||
label.preferredMaxLayoutWidth = 150
|
||||
let constrainedSize = label.intrinsicContentSize
|
||||
|
||||
XCTAssertGreaterThan(constrainedSize.width, 0, "Width should be > 0")
|
||||
XCTAssertGreaterThan(constrainedSize.height, unconstrainedSize.height, "Height should increase when wrapped")
|
||||
|
||||
label.frame = CGRect(origin: .zero, size: constrainedSize)
|
||||
#if os(macOS)
|
||||
label.layout()
|
||||
#else
|
||||
label.layoutSubviews()
|
||||
#endif
|
||||
|
||||
XCTAssertNotNil(label.displayList, "Display list should be created")
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
|
||||
// Verify no overlapping displays between lines
|
||||
if let displayList = label.displayList {
|
||||
// Group displays by line
|
||||
var lineGroups: [[MTDisplay]] = []
|
||||
var currentLineDisplays: [MTDisplay] = []
|
||||
var currentLineY: CGFloat? = nil
|
||||
let yTolerance: CGFloat = 15.0
|
||||
|
||||
for display in displayList.subDisplays {
|
||||
if let lineY = currentLineY {
|
||||
if abs(display.position.y - lineY) < yTolerance {
|
||||
currentLineDisplays.append(display)
|
||||
} else {
|
||||
lineGroups.append(currentLineDisplays)
|
||||
currentLineDisplays = [display]
|
||||
currentLineY = display.position.y
|
||||
}
|
||||
} else {
|
||||
currentLineDisplays = [display]
|
||||
currentLineY = display.position.y
|
||||
}
|
||||
}
|
||||
if !currentLineDisplays.isEmpty {
|
||||
lineGroups.append(currentLineDisplays)
|
||||
}
|
||||
|
||||
// Check for overlap between consecutive lines
|
||||
for i in 1..<lineGroups.count {
|
||||
let previousLine = lineGroups[i-1]
|
||||
let currentLine = lineGroups[i]
|
||||
|
||||
let previousLineMinBottom = previousLine.map { $0.position.y - $0.descent }.min() ?? 0
|
||||
let currentLineMaxTop = currentLine.map { $0.position.y + $0.ascent }.max() ?? 0
|
||||
|
||||
// Allow 0.5 points tolerance for floating-point precision
|
||||
XCTAssertLessThanOrEqual(currentLineMaxTop, previousLineMinBottom + 0.5,
|
||||
"Line \(i) overlaps with line \(i-1)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testMultipleLinesWithVaryingHeights() {
|
||||
// Test expression that should wrap to multiple lines with different heights
|
||||
let label = MTMathUILabel()
|
||||
label.latex = "x+y+z+a+b+c+\\sqrt{d}+e+f+g+h+\\dfrac{i}{j}+k"
|
||||
label.font = MTFontManager.fontManager.defaultFont
|
||||
|
||||
let unconstrainedSize = label.intrinsicContentSize
|
||||
|
||||
label.preferredMaxLayoutWidth = 120
|
||||
let constrainedSize = label.intrinsicContentSize
|
||||
|
||||
XCTAssertGreaterThan(constrainedSize.width, 0, "Width should be > 0")
|
||||
XCTAssertGreaterThan(constrainedSize.height, unconstrainedSize.height, "Height should increase when wrapped")
|
||||
|
||||
label.frame = CGRect(origin: .zero, size: constrainedSize)
|
||||
#if os(macOS)
|
||||
label.layout()
|
||||
#else
|
||||
label.layoutSubviews()
|
||||
#endif
|
||||
|
||||
XCTAssertNotNil(label.displayList, "Display list should be created")
|
||||
XCTAssertNil(label.error, "Should have no rendering error")
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -76,7 +76,6 @@ final class MathFontTests: XCTestCase {
|
||||
executionGroup.notify(queue: .main) { [weak self] in
|
||||
guard let self = self else { return }
|
||||
XCTAssertEqual(self.testCount, totalCases)
|
||||
print("\(self.testCount) completed =================")
|
||||
}
|
||||
executionGroup.wait()
|
||||
}
|
||||
|
||||
@@ -24,8 +24,6 @@ final class MathImageTests: XCTestCase {
|
||||
XCTAssertNotNil(result.layoutInfo)
|
||||
if result.error == nil, let image = result.image, let imageData = image.pngData() {
|
||||
safeImage(fileName: "test", pngData: imageData)
|
||||
let fileUrl = URL(fileURLWithPath: NSTemporaryDirectory())
|
||||
print("completed, check \(fileUrl.path) image-test.png =================")
|
||||
}
|
||||
}
|
||||
func testSequentialMultipleImageScript() throws {
|
||||
@@ -42,8 +40,6 @@ final class MathImageTests: XCTestCase {
|
||||
XCTAssertNotNil(result.layoutInfo)
|
||||
if result.error == nil, let image = result.image, let imageData = image.pngData() {
|
||||
safeImage(fileName: "\(caseNumber)", pngData: imageData)
|
||||
//let fileUrl = URL(fileURLWithPath: NSTemporaryDirectory())
|
||||
print("completed image-\(caseNumber).png")
|
||||
}
|
||||
default:
|
||||
result = SwiftMathImageResult.useMTMathImage(latex: latex, font: mathfont, fontSize: fontsize)
|
||||
@@ -51,12 +47,9 @@ final class MathImageTests: XCTestCase {
|
||||
XCTAssertNotNil(result.image)
|
||||
if result.error == nil, let image = result.image, let imageData = image.pngData() {
|
||||
safeImage(fileName: "\(caseNumber)", pngData: imageData)
|
||||
//let fileUrl = URL(fileURLWithPath: NSTemporaryDirectory())
|
||||
print("completed image-\(caseNumber).png")
|
||||
}
|
||||
}
|
||||
}
|
||||
print("check: \(URL(fileURLWithPath: NSTemporaryDirectory()).path) ==")
|
||||
}
|
||||
|
||||
private let executionQueue = DispatchQueue(label: "com.swiftmath.mathbundle", attributes: .concurrent)
|
||||
@@ -78,8 +71,6 @@ final class MathImageTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
executionGroup.notify(queue: .main) { [weak self] in
|
||||
let fileUrl = URL(fileURLWithPath: NSTemporaryDirectory())
|
||||
print("\(self!.testCount)/\(self!.totalCases) completed, check \(fileUrl.path) ===")
|
||||
XCTAssertEqual(self?.testCount,self?.totalCases)
|
||||
}
|
||||
executionGroup.wait()
|
||||
|
||||
Reference in New Issue
Block a user