CLightningFastViewerWidget: int -> qsizetype

VioletGiraffe · VioletGiraffe · commit ad436d6461e2 · 2026-02-02T21:32:16.000+02:00
diff --git a/plugins/viewer/textviewer/src/clightningfastviewer.cpp b/plugins/viewer/textviewer/src/clightningfastviewer.cpp
@@ -105,7 +105,7 @@ void CLightningFastViewerWidget::paintEvent(QPaintEvent*)
 		}
 		else
 		{
-			drawTextLine(painter, static_cast<int>(line), y, _fontMetrics);
+			drawTextLine(painter, line, y, _fontMetrics);
 		}
 		y += _lineHeight;
 	}
@@ -267,13 +267,12 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)
 		else
 		{
 			// Find previous line
-			int currentLine = findLineContainingOffset(cursorPos);
+			const qsizetype currentLine = findLineContainingOffset(cursorPos);
 			if (currentLine > 0)
 			{
 				// Try to maintain column position
-				int colInLine = cursorPos - _lineOffsets[currentLine];
-				newPos = qMin((qsizetype)(_lineOffsets[currentLine - 1] + colInLine),
-					(qsizetype)(_lineOffsets[currentLine - 1] + _lineLengths[currentLine - 1] - 1));
+				const qsizetype colInLine = cursorPos - _lineOffsets[currentLine];
+				newPos = qMin(_lineOffsets[currentLine - 1] + colInLine, _lineOffsets[currentLine - 1] + _lineLengths[currentLine - 1] - 1);
 			}
 		}
 		break;
@@ -285,13 +284,12 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)
 		else
 		{
 			// Find next line
-			int currentLine = findLineContainingOffset(cursorPos);
-			if (currentLine >= 0 && currentLine < static_cast<int>(_lineOffsets.size()) - 1)
+			const qsizetype currentLine = findLineContainingOffset(cursorPos);
+			if (currentLine >= 0 && currentLine < static_cast<qsizetype>(_lineOffsets.size()) - 1)
 			{
 				// Try to maintain column position
-				int colInLine = cursorPos - _lineOffsets[currentLine];
-				newPos = qMin((qsizetype)(_lineOffsets[currentLine + 1] + colInLine),
-					(qsizetype)(_lineOffsets[currentLine + 1] + _lineLengths[currentLine + 1] - 1));
+				const qsizetype colInLine = cursorPos - _lineOffsets[currentLine];
+				newPos = qMin(_lineOffsets[currentLine + 1] + colInLine, _lineOffsets[currentLine + 1] + _lineLengths[currentLine + 1] - 1);
 			}
 		}
 		break;
@@ -313,7 +311,7 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)
 		else
 		{
 			// Find start of current line
-			int currentLine = findLineContainingOffset(cursorPos);
+			const qsizetype currentLine = findLineContainingOffset(cursorPos);
 			if (currentLine >= 0)
 			{
 				newPos = _lineOffsets[currentLine];
@@ -333,10 +331,10 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)
 		else
 		{
 			// Find end of current line
-			int currentLine = findLineContainingOffset(cursorPos);
+			const qsizetype currentLine = findLineContainingOffset(cursorPos);
 			if (currentLine >= 0)
 			{
-				newPos = qMin(maxOffset, (qsizetype)(_lineOffsets[currentLine] + _lineLengths[currentLine] - 1));
+				newPos = qMin(maxOffset, _lineOffsets[currentLine] + _lineLengths[currentLine] - 1);
 			}
 		}
 		break;
@@ -361,17 +359,17 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)
 	}
 }
 
-int CLightningFastViewerWidget::totalLines() const
+qsizetype CLightningFastViewerWidget::totalLines() const
 {
 	if (_mode == HEX)
 	{
 		if (_data.isEmpty())
 			return 0;
-		return static_cast<int>((_data.size() + (qsizetype)_bytesPerLine - 1) / (qsizetype)_bytesPerLine);
+		return (_data.size() + _bytesPerLine - 1) / _bytesPerLine;
 	}
 	else
 	{
-		return static_cast<int>(_lineOffsets.size());
+		return static_cast<qsizetype>(_lineOffsets.size());
 	}
 }
 
@@ -494,26 +492,26 @@ void CLightningFastViewerWidget::drawHexLine(QPainter& painter, qsizetype offset
 	}
 }
 
-void CLightningFastViewerWidget::drawTextLine(QPainter& painter, int lineIndex, int y, const QFontMetrics& fm)
+void CLightningFastViewerWidget::drawTextLine(QPainter& painter, qsizetype lineIndex, int y, const QFontMetrics& fm)
 {
-	if (lineIndex < 0 || lineIndex >= static_cast<int>(_lineOffsets.size()))
+	if (lineIndex < 0 || lineIndex >= static_cast<qsizetype>(_lineOffsets.size()))
 		return;
 
 	const int hScroll = horizontalScrollBar()->value();
 
-	const int lineStart = _lineOffsets[lineIndex];
-	const int lineLen = _lineLengths[lineIndex];
+	const qsizetype lineStart = _lineOffsets[lineIndex];
+	const qsizetype lineLen = _lineLengths[lineIndex];
 	QString lineText = _text.mid(lineStart, lineLen);
 
 	// Draw the line character by character to handle selection
 	int x = Layout::LEFT_MARGIN_PIXELS - hScroll;
-	for (int i = 0; i < lineText.length(); ++i)
+	for (qsizetype i = 0; i < lineText.length(); ++i)
 	{
 		qsizetype charOffset = lineStart + i;
 
 		if (isSelected(charOffset))
 		{
-			int charWidth = fm.horizontalAdvance(lineText[i]);
+			const int charWidth = fm.horizontalAdvance(lineText[i]);
 			QRect selRect(x, y, charWidth, _lineHeight);
 			painter.fillRect(selRect, palette().highlight());
 			painter.setPen(palette().highlightedText().color());
@@ -548,25 +546,25 @@ void CLightningFastViewerWidget::updateScrollBarsAndHexLayout()
 	{
 		// In text mode, estimate max line width based on character count
 		// For monospace fonts, this is much faster than measuring each line
-		int maxChars = 0;
+		qsizetype maxChars = 0;
 		for (size_t i = 0; i < _lineOffsets.size(); ++i)
 		{
-			const int lineChars = _lineLengths[i];
+			const qsizetype lineChars = _lineLengths[i];
 
 			// Quick scan for tabs in this line to adjust estimate
-			int tabCount = 0;
-			for (int j = _lineOffsets[i], end = j + lineChars; j < end; ++j)
+			qsizetype tabCount = 0;
+			for (qsizetype j = _lineOffsets[i], end = j + lineChars; j < end; ++j)
 			{
 				if (_text[j] == '\t') [[unlikely]]
 					++tabCount;
 			}
 
 			// Estimate: each tab expands based on measured _tabWidthInChars
-			const int estimatedChars = lineChars + (tabCount * (_tabWidthInChars - 1));
+			const qsizetype estimatedChars = lineChars + (tabCount * (_tabWidthInChars - 1));
 			maxChars = qMax(maxChars, estimatedChars);
 		}
 
-		const int maxWidth = maxChars * _charWidth;
+		const qsizetype maxWidth = maxChars * _charWidth;
 		horizontalScrollBar()->setRange(0, qMax(0, maxWidth - viewport()->width() + _charWidth * Layout::TEXT_HORIZONTAL_MARGIN_CHARS));
 	}
 	horizontalScrollBar()->setPageStep(viewport()->width());
@@ -639,14 +637,14 @@ qsizetype CLightningFastViewerWidget::textPosToOffset(const QPoint& pos) const
 		return -1;
 
 	int x = pos.x() + horizontalScrollBar()->value();
-	int lineStart = _lineOffsets[line];
-	int lineLen = _lineLengths[line];
-	QString lineText = _text.mid(lineStart, lineLen);
+	const qsizetype lineStart = _lineOffsets[line];
+	const qsizetype lineLen = _lineLengths[line];
+	const QString lineText = _text.mid(lineStart, lineLen);
 
 	// Find character at position
 	int currentX = Layout::LEFT_MARGIN_PIXELS;
 
-	for (int i = 0; i < lineText.length(); ++i)
+	for (qsizetype i = 0; i < lineText.length(); ++i)
 	{
 		int charWidth = _fontMetrics.horizontalAdvance(lineText[i]);
 		if (x < currentX + charWidth / 2)
@@ -660,11 +658,11 @@ qsizetype CLightningFastViewerWidget::textPosToOffset(const QPoint& pos) const
 
 void CLightningFastViewerWidget::ensureVisible(qsizetype offset)
 {
-	int line = 0;
+	qsizetype line = 0;
 
 	if (_mode == HEX)
 	{
-		line = static_cast<int>(offset / _bytesPerLine);
+		line = offset / _bytesPerLine;
 	}
 	else
 	{
@@ -674,8 +672,8 @@ void CLightningFastViewerWidget::ensureVisible(qsizetype offset)
 			return;
 	}
 
-	int firstVisible = verticalScrollBar()->value();
-	int visibleLines = viewport()->height() / _lineHeight;
+	const int firstVisible = verticalScrollBar()->value();
+	const int visibleLines = viewport()->height() / _lineHeight;
 
 	if (line < firstVisible)
 	{
@@ -779,8 +777,8 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()
 		clearWrappingData();
 
 		// No wrapping - split on newlines only
-		int start = 0;
-		int newlinePos;
+		qsizetype start = 0;
+		qsizetype newlinePos;
 
 		while ((newlinePos = _text.indexOf('\n', start)) != -1)
 		{
@@ -810,14 +808,14 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()
 	if (maxCharsPerLine <= 0)
 		return; // Guard against too small viewport
 
-	int currentLineStart = 0;
-	int currentCharCount = 0; // Character count in current line
-	int lastBreakPos = -1; // Last position where we could break
-	int lastBreakCharCount = 0; // Character count at last break position
+	qsizetype currentLineStart = 0;
+	qsizetype currentCharCount = 0; // Character count in current line
+	qsizetype lastBreakPos = -1; // Last position where we could break
+	qsizetype lastBreakCharCount = 0; // Character count at last break position
 
 	for (qsizetype i = 0, n = _text.length(); i < n; ++i)
 	{
-		QChar ch = _text[i];
+		const QChar ch = _text[i];
 
 		// Handle explicit newlines
 		if (ch == '\n')
@@ -832,11 +830,11 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()
 		}
 
 		// Calculate character width in monospace units
-		int charWidth = 1; // Default for most characters
+		qsizetype charWidth = 1; // Default for most characters
 		if (ch == '\t')
 		{
 			// Tab width: advance to next multiple of _tabWidthInChars
-			int nextTabStop = ((currentCharCount / _tabWidthInChars) + 1) * _tabWidthInChars;
+			qsizetype nextTabStop = ((currentCharCount / _tabWidthInChars) + 1) * _tabWidthInChars;
 			charWidth = nextTabStop - currentCharCount;
 		}
 		else if (ch.unicode() < 32 || ch.category() == QChar::Other_Control)
@@ -857,7 +855,7 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()
 		// Line is too long
 		if (currentCharCount > maxCharsPerLine && i > currentLineStart)
 		{
-			int breakPos;
+			qsizetype breakPos = -1;
 
 			// Try to break at last space
 			if (lastBreakPos > currentLineStart)
@@ -914,13 +912,13 @@ void CLightningFastViewerWidget::updateFontMetrics()
 	_tabWidthInChars = qMax(1, tabWidth / _charWidth); // Ensure at least 1
 }
 
-int CLightningFastViewerWidget::findLineContainingOffset(qsizetype offset) const
+qsizetype CLightningFastViewerWidget::findLineContainingOffset(qsizetype offset) const
 {
 	for (size_t i = 0; i < _lineOffsets.size(); ++i)
 	{
 		if (_lineOffsets[i] <= offset && offset < _lineOffsets[i] + _lineLengths[i])
 		{
-			return static_cast<int>(i);
+			return static_cast<qsizetype>(i);
 		}
 	}
 	return -1;
diff --git a/plugins/viewer/textviewer/src/clightningfastviewer.h b/plugins/viewer/textviewer/src/clightningfastviewer.h
@@ -42,7 +42,7 @@ class CLightningFastViewerWidget final : public QAbstractScrollArea
 	};
 
 	// Common methods
-	[[nodiscard]] int totalLines() const;
+	[[nodiscard]] qsizetype totalLines() const;
 	void updateScrollBarsAndHexLayout();
 	void ensureVisible(qsizetype offset);
 	void copySelection();
@@ -65,31 +65,31 @@ class CLightningFastViewerWidget final : public QAbstractScrollArea
 	[[nodiscard]] qsizetype hexPosToOffset(const QPoint& pos) const;
 
 	// Text mode methods
-	void drawTextLine(QPainter& painter, int lineIndex, int y, const QFontMetrics& fm);
+	void drawTextLine(QPainter& painter, qsizetype lineIndex, int y, const QFontMetrics& fm);
 	[[nodiscard]] qsizetype textPosToOffset(const QPoint& pos) const;
 
 	void wrapTextIfNeeded();
 	void clearWrappingData();
-	[[nodiscard]] int findLineContainingOffset(qsizetype offset) const;
+	[[nodiscard]] qsizetype findLineContainingOffset(qsizetype offset) const;
 
 private:
 	Mode _mode = HEX;
 
 	// Hex mode data
 	QByteArray _data;
-	int _bytesPerLine = 16;
+	qsizetype _bytesPerLine = 16;
 
 	// Text mode data
 	QString _text;
-	std::vector<int> _lineOffsets; // Starting character offset for each wrapped line
-	std::vector<int> _lineLengths; // Length of each wrapped line
+	std::vector<qsizetype> _lineOffsets; // Starting character offset for each wrapped line
+	std::vector<qsizetype> _lineLengths; // Length of each wrapped line
 	size_t _wordWrapParamsHash = 0;
 	bool _wordWrap = true;
 
 	// Common display data
 	int _lineHeight = 0;
 	int _charWidth = 0;
-	int _tabWidthInChars = 4; // Default tab width in character positions
+	qsizetype _tabWidthInChars = 4; // Default tab width in character positions
 	QFontMetrics _fontMetrics;
 	Selection _selection;
 	bool _initialized = false;

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ void CLightningFastViewerWidget::paintEvent(QPaintEvent*)`
`105`	`105`	`}`
`106`	`106`	`else`
`107`	`107`	`{`
`108`		`- drawTextLine(painter, static_cast<int>(line), y, _fontMetrics);`
	`108`	`+ drawTextLine(painter, line, y, _fontMetrics);`
`109`	`109`	`}`
`110`	`110`	`y += _lineHeight;`
`111`	`111`	`}`
`@@ -267,13 +267,12 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)`
`267`	`267`	`else`
`268`	`268`	`{`
`269`	`269`	`// Find previous line`
`270`		`- int currentLine = findLineContainingOffset(cursorPos);`
	`270`	`+ const qsizetype currentLine = findLineContainingOffset(cursorPos);`
`271`	`271`	`if (currentLine > 0)`
`272`	`272`	`{`
`273`	`273`	`// Try to maintain column position`
`274`		`- int colInLine = cursorPos - _lineOffsets[currentLine];`
`275`		`- newPos = qMin((qsizetype)(_lineOffsets[currentLine - 1] + colInLine),`
`276`		`- (qsizetype)(_lineOffsets[currentLine - 1] + _lineLengths[currentLine - 1] - 1));`
	`274`	`+ const qsizetype colInLine = cursorPos - _lineOffsets[currentLine];`
	`275`	`+ newPos = qMin(_lineOffsets[currentLine - 1] + colInLine, _lineOffsets[currentLine - 1] + _lineLengths[currentLine - 1] - 1);`
`277`	`276`	`}`
`278`	`277`	`}`
`279`	`278`	`break;`
`@@ -285,13 +284,12 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)`
`285`	`284`	`else`
`286`	`285`	`{`
`287`	`286`	`// Find next line`
`288`		`- int currentLine = findLineContainingOffset(cursorPos);`
`289`		`- if (currentLine >= 0 && currentLine < static_cast<int>(_lineOffsets.size()) - 1)`
	`287`	`+ const qsizetype currentLine = findLineContainingOffset(cursorPos);`
	`288`	`+ if (currentLine >= 0 && currentLine < static_cast<qsizetype>(_lineOffsets.size()) - 1)`
`290`	`289`	`{`
`291`	`290`	`// Try to maintain column position`
`292`		`- int colInLine = cursorPos - _lineOffsets[currentLine];`
`293`		`- newPos = qMin((qsizetype)(_lineOffsets[currentLine + 1] + colInLine),`
`294`		`- (qsizetype)(_lineOffsets[currentLine + 1] + _lineLengths[currentLine + 1] - 1));`
	`291`	`+ const qsizetype colInLine = cursorPos - _lineOffsets[currentLine];`
	`292`	`+ newPos = qMin(_lineOffsets[currentLine + 1] + colInLine, _lineOffsets[currentLine + 1] + _lineLengths[currentLine + 1] - 1);`
`295`	`293`	`}`
`296`	`294`	`}`
`297`	`295`	`break;`
`@@ -313,7 +311,7 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)`
`313`	`311`	`else`
`314`	`312`	`{`
`315`	`313`	`// Find start of current line`
`316`		`- int currentLine = findLineContainingOffset(cursorPos);`
	`314`	`+ const qsizetype currentLine = findLineContainingOffset(cursorPos);`
`317`	`315`	`if (currentLine >= 0)`
`318`	`316`	`{`
`319`	`317`	`newPos = _lineOffsets[currentLine];`
`@@ -333,10 +331,10 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)`
`333`	`331`	`else`
`334`	`332`	`{`
`335`	`333`	`// Find end of current line`
`336`		`- int currentLine = findLineContainingOffset(cursorPos);`
	`334`	`+ const qsizetype currentLine = findLineContainingOffset(cursorPos);`
`337`	`335`	`if (currentLine >= 0)`
`338`	`336`	`{`
`339`		`- newPos = qMin(maxOffset, (qsizetype)(_lineOffsets[currentLine] + _lineLengths[currentLine] - 1));`
	`337`	`+ newPos = qMin(maxOffset, _lineOffsets[currentLine] + _lineLengths[currentLine] - 1);`
`340`	`338`	`}`
`341`	`339`	`}`
`342`	`340`	`break;`
`@@ -361,17 +359,17 @@ void CLightningFastViewerWidget::keyPressEvent(QKeyEvent* event)`
`361`	`359`	`}`
`362`	`360`	`}`
`363`	`361`
`364`		`-int CLightningFastViewerWidget::totalLines() const`
	`362`	`+qsizetype CLightningFastViewerWidget::totalLines() const`
`365`	`363`	`{`
`366`	`364`	`if (_mode == HEX)`
`367`	`365`	`{`
`368`	`366`	`if (_data.isEmpty())`
`369`	`367`	`return 0;`
`370`		`- return static_cast<int>((_data.size() + (qsizetype)_bytesPerLine - 1) / (qsizetype)_bytesPerLine);`
	`368`	`+ return (_data.size() + _bytesPerLine - 1) / _bytesPerLine;`
`371`	`369`	`}`
`372`	`370`	`else`
`373`	`371`	`{`
`374`		`- return static_cast<int>(_lineOffsets.size());`
	`372`	`+ return static_cast<qsizetype>(_lineOffsets.size());`
`375`	`373`	`}`
`376`	`374`	`}`
`377`	`375`
`@@ -494,26 +492,26 @@ void CLightningFastViewerWidget::drawHexLine(QPainter& painter, qsizetype offset`
`494`	`492`	`}`
`495`	`493`	`}`
`496`	`494`
`497`		`-void CLightningFastViewerWidget::drawTextLine(QPainter& painter, int lineIndex, int y, const QFontMetrics& fm)`
	`495`	`+void CLightningFastViewerWidget::drawTextLine(QPainter& painter, qsizetype lineIndex, int y, const QFontMetrics& fm)`
`498`	`496`	`{`
`499`		`- if (lineIndex < 0 \|\| lineIndex >= static_cast<int>(_lineOffsets.size()))`
	`497`	`+ if (lineIndex < 0 \|\| lineIndex >= static_cast<qsizetype>(_lineOffsets.size()))`
`500`	`498`	`return;`
`501`	`499`
`502`	`500`	`const int hScroll = horizontalScrollBar()->value();`
`503`	`501`
`504`		`- const int lineStart = _lineOffsets[lineIndex];`
`505`		`- const int lineLen = _lineLengths[lineIndex];`
	`502`	`+ const qsizetype lineStart = _lineOffsets[lineIndex];`
	`503`	`+ const qsizetype lineLen = _lineLengths[lineIndex];`
`506`	`504`	`QString lineText = _text.mid(lineStart, lineLen);`
`507`	`505`
`508`	`506`	`// Draw the line character by character to handle selection`
`509`	`507`	`int x = Layout::LEFT_MARGIN_PIXELS - hScroll;`
`510`		`- for (int i = 0; i < lineText.length(); ++i)`
	`508`	`+ for (qsizetype i = 0; i < lineText.length(); ++i)`
`511`	`509`	`{`
`512`	`510`	`qsizetype charOffset = lineStart + i;`
`513`	`511`
`514`	`512`	`if (isSelected(charOffset))`
`515`	`513`	`{`
`516`		`- int charWidth = fm.horizontalAdvance(lineText[i]);`
	`514`	`+ const int charWidth = fm.horizontalAdvance(lineText[i]);`
`517`	`515`	`QRect selRect(x, y, charWidth, _lineHeight);`
`518`	`516`	`painter.fillRect(selRect, palette().highlight());`
`519`	`517`	`painter.setPen(palette().highlightedText().color());`
`@@ -548,25 +546,25 @@ void CLightningFastViewerWidget::updateScrollBarsAndHexLayout()`
`548`	`546`	`{`
`549`	`547`	`// In text mode, estimate max line width based on character count`
`550`	`548`	`// For monospace fonts, this is much faster than measuring each line`
`551`		`- int maxChars = 0;`
	`549`	`+ qsizetype maxChars = 0;`
`552`	`550`	`for (size_t i = 0; i < _lineOffsets.size(); ++i)`
`553`	`551`	`{`
`554`		`- const int lineChars = _lineLengths[i];`
	`552`	`+ const qsizetype lineChars = _lineLengths[i];`
`555`	`553`
`556`	`554`	`// Quick scan for tabs in this line to adjust estimate`
`557`		`- int tabCount = 0;`
`558`		`- for (int j = _lineOffsets[i], end = j + lineChars; j < end; ++j)`
	`555`	`+ qsizetype tabCount = 0;`
	`556`	`+ for (qsizetype j = _lineOffsets[i], end = j + lineChars; j < end; ++j)`
`559`	`557`	`{`
`560`	`558`	`if (_text[j] == '\t') [[unlikely]]`
`561`	`559`	`++tabCount;`
`562`	`560`	`}`
`563`	`561`
`564`	`562`	`// Estimate: each tab expands based on measured _tabWidthInChars`
`565`		`- const int estimatedChars = lineChars + (tabCount * (_tabWidthInChars - 1));`
	`563`	`+ const qsizetype estimatedChars = lineChars + (tabCount * (_tabWidthInChars - 1));`
`566`	`564`	`maxChars = qMax(maxChars, estimatedChars);`
`567`	`565`	`}`
`568`	`566`
`569`		`- const int maxWidth = maxChars * _charWidth;`
	`567`	`+ const qsizetype maxWidth = maxChars * _charWidth;`
`570`	`568`	`horizontalScrollBar()->setRange(0, qMax(0, maxWidth - viewport()->width() + _charWidth * Layout::TEXT_HORIZONTAL_MARGIN_CHARS));`
`571`	`569`	`}`
`572`	`570`	`horizontalScrollBar()->setPageStep(viewport()->width());`
`@@ -639,14 +637,14 @@ qsizetype CLightningFastViewerWidget::textPosToOffset(const QPoint& pos) const`
`639`	`637`	`return -1;`
`640`	`638`
`641`	`639`	`int x = pos.x() + horizontalScrollBar()->value();`
`642`		`- int lineStart = _lineOffsets[line];`
`643`		`- int lineLen = _lineLengths[line];`
`644`		`- QString lineText = _text.mid(lineStart, lineLen);`
	`640`	`+ const qsizetype lineStart = _lineOffsets[line];`
	`641`	`+ const qsizetype lineLen = _lineLengths[line];`
	`642`	`+ const QString lineText = _text.mid(lineStart, lineLen);`
`645`	`643`
`646`	`644`	`// Find character at position`
`647`	`645`	`int currentX = Layout::LEFT_MARGIN_PIXELS;`
`648`	`646`
`649`		`- for (int i = 0; i < lineText.length(); ++i)`
	`647`	`+ for (qsizetype i = 0; i < lineText.length(); ++i)`
`650`	`648`	`{`
`651`	`649`	`int charWidth = _fontMetrics.horizontalAdvance(lineText[i]);`
`652`	`650`	`if (x < currentX + charWidth / 2)`
`@@ -660,11 +658,11 @@ qsizetype CLightningFastViewerWidget::textPosToOffset(const QPoint& pos) const`
`660`	`658`
`661`	`659`	`void CLightningFastViewerWidget::ensureVisible(qsizetype offset)`
`662`	`660`	`{`
`663`		`- int line = 0;`
	`661`	`+ qsizetype line = 0;`
`664`	`662`
`665`	`663`	`if (_mode == HEX)`
`666`	`664`	`{`
`667`		`- line = static_cast<int>(offset / _bytesPerLine);`
	`665`	`+ line = offset / _bytesPerLine;`
`668`	`666`	`}`
`669`	`667`	`else`
`670`	`668`	`{`
`@@ -674,8 +672,8 @@ void CLightningFastViewerWidget::ensureVisible(qsizetype offset)`
`674`	`672`	`return;`
`675`	`673`	`}`
`676`	`674`
`677`		`- int firstVisible = verticalScrollBar()->value();`
`678`		`- int visibleLines = viewport()->height() / _lineHeight;`
	`675`	`+ const int firstVisible = verticalScrollBar()->value();`
	`676`	`+ const int visibleLines = viewport()->height() / _lineHeight;`
`679`	`677`
`680`	`678`	`if (line < firstVisible)`
`681`	`679`	`{`
`@@ -779,8 +777,8 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()`
`779`	`777`	`clearWrappingData();`
`780`	`778`
`781`	`779`	`// No wrapping - split on newlines only`
`782`		`- int start = 0;`
`783`		`- int newlinePos;`
	`780`	`+ qsizetype start = 0;`
	`781`	`+ qsizetype newlinePos;`
`784`	`782`
`785`	`783`	`while ((newlinePos = _text.indexOf('\n', start)) != -1)`
`786`	`784`	`{`
`@@ -810,14 +808,14 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()`
`810`	`808`	`if (maxCharsPerLine <= 0)`
`811`	`809`	`return; // Guard against too small viewport`
`812`	`810`
`813`		`- int currentLineStart = 0;`
`814`		`- int currentCharCount = 0; // Character count in current line`
`815`		`- int lastBreakPos = -1; // Last position where we could break`
`816`		`- int lastBreakCharCount = 0; // Character count at last break position`
	`811`	`+ qsizetype currentLineStart = 0;`
	`812`	`+ qsizetype currentCharCount = 0; // Character count in current line`
	`813`	`+ qsizetype lastBreakPos = -1; // Last position where we could break`
	`814`	`+ qsizetype lastBreakCharCount = 0; // Character count at last break position`
`817`	`815`
`818`	`816`	`for (qsizetype i = 0, n = _text.length(); i < n; ++i)`
`819`	`817`	`{`
`820`		`- QChar ch = _text[i];`
	`818`	`+ const QChar ch = _text[i];`
`821`	`819`
`822`	`820`	`// Handle explicit newlines`
`823`	`821`	`if (ch == '\n')`
`@@ -832,11 +830,11 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()`
`832`	`830`	`}`
`833`	`831`
`834`	`832`	`// Calculate character width in monospace units`
`835`		`- int charWidth = 1; // Default for most characters`
	`833`	`+ qsizetype charWidth = 1; // Default for most characters`
`836`	`834`	`if (ch == '\t')`
`837`	`835`	`{`
`838`	`836`	`// Tab width: advance to next multiple of _tabWidthInChars`
`839`		`- int nextTabStop = ((currentCharCount / _tabWidthInChars) + 1) * _tabWidthInChars;`
	`837`	`+ qsizetype nextTabStop = ((currentCharCount / _tabWidthInChars) + 1) * _tabWidthInChars;`
`840`	`838`	`charWidth = nextTabStop - currentCharCount;`
`841`	`839`	`}`
`842`	`840`	`else if (ch.unicode() < 32 \|\| ch.category() == QChar::Other_Control)`
`@@ -857,7 +855,7 @@ void CLightningFastViewerWidget::wrapTextIfNeeded()`
`857`	`855`	`// Line is too long`
`858`	`856`	`if (currentCharCount > maxCharsPerLine && i > currentLineStart)`
`859`	`857`	`{`
`860`		`- int breakPos;`
	`858`	`+ qsizetype breakPos = -1;`
`861`	`859`
`862`	`860`	`// Try to break at last space`
`863`	`861`	`if (lastBreakPos > currentLineStart)`
`@@ -914,13 +912,13 @@ void CLightningFastViewerWidget::updateFontMetrics()`
`914`	`912`	`_tabWidthInChars = qMax(1, tabWidth / _charWidth); // Ensure at least 1`
`915`	`913`	`}`
`916`	`914`
`917`		`-int CLightningFastViewerWidget::findLineContainingOffset(qsizetype offset) const`
	`915`	`+qsizetype CLightningFastViewerWidget::findLineContainingOffset(qsizetype offset) const`
`918`	`916`	`{`
`919`	`917`	`for (size_t i = 0; i < _lineOffsets.size(); ++i)`
`920`	`918`	`{`
`921`	`919`	`if (_lineOffsets[i] <= offset && offset < _lineOffsets[i] + _lineLengths[i])`
`922`	`920`	`{`
`923`		`- return static_cast<int>(i);`
	`921`	`+ return static_cast<qsizetype>(i);`
`924`	`922`	`}`
`925`	`923`	`}`
`926`	`924`	`return -1;`