Differential D20697 Diff 56625 src/view/kateviewhelpers.cpp

Changeset View

Standalone View

View Options

src/view/kateviewhelpers.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Line(s)1424KateIconBorder::KateIconBorder(KateViewInternal *internalView, QWidget *parent)
1428 , m_viewInternal(internalView) 1428​ , m_viewInternal(internalView)
1429 , m_iconBorderOn(false) 1429​ , m_iconBorderOn(false)
1430 , m_lineNumbersOn(false) 1430​ , m_lineNumbersOn(false)
1431 , m_relLineNumbersOn(false) 1431​ , m_relLineNumbersOn(false)
1432 , m_updateRelLineNumbers(false) 1432​ , m_updateRelLineNumbers(false)
1433 , m_foldingMarkersOn(false) 1433​ , m_foldingMarkersOn(false)
1434 , m_dynWrapIndicatorsOn(false) 1434​ , m_dynWrapIndicatorsOn(false)
1435 , m_annotationBorderOn(false) 1435​ , m_annotationBorderOn(false)
1436 , m_dynWrapIndicators(0) 1436​ , m_updatePositionToArea(true)
1437 , m_lastClickedLine(-1) ​
1438 , m_cachedLNWidth(0) ​
1439 , m_maxCharWidth(0.0) ​
1440 , iconPaneWidth(16) ​
1441 , m_annotationBorderWidth(6) ​
1442 , m_annotationItemDelegate(new KateAnnotationItemDelegate(m_viewInternal, this)) 1437​ , m_annotationItemDelegate(new KateAnnotationItemDelegate(m_viewInternal, this))
1443 , m_foldingPreview(nullptr) 1438​ , m_foldingPreview(nullptr)
1444 , m_foldingRange(nullptr) 1439​ , m_foldingRange(nullptr)
1445 , m_nextHighlightBlock(-2) 1440​ , m_nextHighlightBlock(-2)
1446 , m_currentBlockLine(-1) 1441​ , m_currentBlockLine(-1)
1447{ 1442​{
1448 setAcceptDrops(true); 1443​ setAcceptDrops(true);
1449 setAttribute(Qt::WA_StaticContents); 1444​ setAttribute(Qt::WA_StaticContents);
Show All 24 Lines
1474void KateIconBorder::setIconBorderOn(bool enable) 1469​void KateIconBorder::setIconBorderOn(bool enable)
1475{ 1470​{
1476 if (enable == m_iconBorderOn) { 1471​ if (enable == m_iconBorderOn) {
1477 return; 1472​ return;
1478 } 1473​ }
1479 1474​
1480 m_iconBorderOn = enable; 1475​ m_iconBorderOn = enable;
1481 1476​
1482 updateGeometry(); 1477​ m_updatePositionToArea = true;
1483 1478​
1484 QTimer::singleShot(0, this, SLOT(update())); 1479​ QTimer::singleShot(0, this, SLOT(update()));
1485} 1480​}
1486 1481​
1487void KateIconBorder::setAnnotationBorderOn(bool enable) 1482​void KateIconBorder::setAnnotationBorderOn(bool enable)
1488{ 1483​{
1489 if (enable == m_annotationBorderOn) { 1484​ if (enable == m_annotationBorderOn) {
1490 return; 1485​ return;
1491 } 1486​ }
1492 1487​
1493 m_annotationBorderOn = enable; 1488​ m_annotationBorderOn = enable;
1494 1489​
1495 // make sure the tooltip is hidden 1490​ // make sure the tooltip is hidden
1496 if (!m_annotationBorderOn && !m_hoveredAnnotationGroupIdentifier.isEmpty()) { 1491​ if (!m_annotationBorderOn && !m_hoveredAnnotationGroupIdentifier.isEmpty()) {
1497 m_hoveredAnnotationGroupIdentifier.clear(); 1492​ m_hoveredAnnotationGroupIdentifier.clear();
1498 hideAnnotationTooltip(); 1493​ hideAnnotationTooltip();
1499 } 1494​ }
1500 1495​
1501 emit m_view->annotationBorderVisibilityChanged(m_view, enable); 1496​ emit m_view->annotationBorderVisibilityChanged(m_view, enable);
1502 1497​
1503 updateGeometry(); 1498​ m_updatePositionToArea = true;
1504 1499​
1505 QTimer::singleShot(0, this, SLOT(update())); 1500​ QTimer::singleShot(0, this, SLOT(update()));
1506} 1501​}
1507 1502​
1508void KateIconBorder::removeAnnotationHovering() 1503​void KateIconBorder::removeAnnotationHovering()
1509{ 1504​{
1510 // remove hovering if it's still there 1505​ // remove hovering if it's still there
1511 if (m_annotationBorderOn && !m_hoveredAnnotationGroupIdentifier.isEmpty()) { 1506​ if (m_annotationBorderOn && !m_hoveredAnnotationGroupIdentifier.isEmpty()) {
1512 m_hoveredAnnotationGroupIdentifier.clear(); 1507​ m_hoveredAnnotationGroupIdentifier.clear();
1513 QTimer::singleShot(0, this, SLOT(update())); 1508​ QTimer::singleShot(0, this, SLOT(update()));
1514 } 1509​ }
1515} 1510​}
1516 1511​
1517void KateIconBorder::setLineNumbersOn(bool enable) 1512​void KateIconBorder::setLineNumbersOn(bool enable)
1518{ 1513​{
1519 if (enable == m_lineNumbersOn) { 1514​ if (enable == m_lineNumbersOn) {
1520 return; 1515​ return;
1521 } 1516​ }
1522 1517​
1523 m_lineNumbersOn = enable; 1518​ m_lineNumbersOn = enable;
1524 m_dynWrapIndicatorsOn = (m_dynWrapIndicators == 1) ? enable : m_dynWrapIndicators; 1519​ m_dynWrapIndicatorsOn = (m_dynWrapIndicators == 1) ? enable : m_dynWrapIndicators;
1525 1520​
1526 updateGeometry(); 1521​ m_updatePositionToArea = true;
1527 1522​
1528 QTimer::singleShot(0, this, SLOT(update())); 1523​ QTimer::singleShot(0, this, SLOT(update()));
1529} 1524​}
1530 1525​
1531void KateIconBorder::setRelLineNumbersOn(bool enable) 1526​void KateIconBorder::setRelLineNumbersOn(bool enable)
1532{ 1527​{
1533 if (enable == m_relLineNumbersOn) { 1528​ if (enable == m_relLineNumbersOn) {
1534 return; 1529​ return;
1535 } 1530​ }
1536 1531​
1537 m_relLineNumbersOn = enable; 1532​ m_relLineNumbersOn = enable;
1538 /* 1533​ /*
1539 * We don't have to touch the m_dynWrapIndicatorsOn because 1534​ * We don't have to touch the m_dynWrapIndicatorsOn because
1540 * we already got it right from the m_lineNumbersOn 1535​ * we already got it right from the m_lineNumbersOn
1541 */ 1536​ */
1542 updateGeometry(); 1537​ m_updatePositionToArea = true;
1543 1538​
1544 QTimer::singleShot( 0, this, SLOT(update()) ); 1539​ QTimer::singleShot( 0, this, SLOT(update()) );
1545} 1540​}
1546 1541​
1547void KateIconBorder::updateForCursorLineChange() 1542​void KateIconBorder::updateForCursorLineChange()
1548{ 1543​{
1549 if (m_relLineNumbersOn) { 1544​ if (m_relLineNumbersOn) {
1550 m_updateRelLineNumbers = true; 1545​ m_updateRelLineNumbers = true;
1551 } 1546​ }
1552 1547​
1553 // always do normal update, e.g. for different current line color! 1548​ // always do normal update, e.g. for different current line color!
1554 update(); 1549​ update();
1555} 1550​}
1556 1551​
1557void KateIconBorder::setDynWrapIndicators(int state) 1552​void KateIconBorder::setDynWrapIndicators(int state)
1558{ 1553​{
1559 if (state == m_dynWrapIndicators) { 1554​ if (state == m_dynWrapIndicators) {
1560 return; 1555​ return;
1561 } 1556​ }
1562 1557​
1563 m_dynWrapIndicators = state; 1558​ m_dynWrapIndicators = state;
1564 m_dynWrapIndicatorsOn = (state == 1) ? m_lineNumbersOn : state; 1559​ m_dynWrapIndicatorsOn = (state == 1) ? m_lineNumbersOn : state;
1565 1560​
1566 updateGeometry(); 1561​ m_updatePositionToArea = true;
1567 1562​
1568 QTimer::singleShot(0, this, SLOT(update())); 1563​ QTimer::singleShot(0, this, SLOT(update()));
1569} 1564​}
1570 1565​
1571void KateIconBorder::setFoldingMarkersOn(bool enable) 1566​void KateIconBorder::setFoldingMarkersOn(bool enable)
1572{ 1567​{
1573 if (enable == m_foldingMarkersOn) { 1568​ if (enable == m_foldingMarkersOn) {
1574 return; 1569​ return;
1575 } 1570​ }
1576 1571​
1577 m_foldingMarkersOn = enable; 1572​ m_foldingMarkersOn = enable;
1578 1573​
1579 updateGeometry(); 1574​ m_updatePositionToArea = true;
1580 1575​
1581 QTimer::singleShot(0, this, SLOT(update())); 1576​ QTimer::singleShot(0, this, SLOT(update()));
1582} 1577​}
1583 1578​
1584QSize KateIconBorder::sizeHint() const 1579​QSize KateIconBorder::sizeHint() const
1585{ 1580​{
1586 int w = 0; 1581​ int w = 1; // Must be any value != 0 or we will never painted!
1587 ​
1588 if (m_iconBorderOn) { ​
1589 w += iconPaneWidth + 2; ​
1590 } ​
1591 ​
1592 if (m_annotationBorderOn) { ​
1593 w += m_annotationBorderWidth + 2; ​
1594 } ​
1595 ​
1596 if (m_lineNumbersOn || (m_dynWrapIndicatorsOn && m_view->config()->dynWordWrap())) { ​
1597 w += lineNumberWidth() + 2; ​
1598 } ​
1599 ​
1600 if (m_foldingMarkersOn) { ​
1601 w += iconPaneWidth; ​
1602 } ​
1603 1582​
1604 // space for the line modification system border 1583​ const int i = m_positionToArea.size();
1605 if (m_view->config()->lineModification()) { 1584​ if (i > 0) {
1606 w += 3; 1585​ w = m_positionToArea.at(i -1).first;
1607 } 1586​ }
1608 1587​
1609 // two pixel space ​
1610 w += 2; ​
1611 ​
1612 return QSize(w, 0); 1588​ return QSize(w, 0);
1613} 1589​}
1614 1590​
1615// This function (re)calculates the maximum width of any of the digit characters (0 -> 9) 1591​// This function (re)calculates the maximum width of any of the digit characters (0 -> 9)
1616// for graceful handling of variable-width fonts as the linenumber font. 1592​// for graceful handling of variable-width fonts as the linenumber font.
1617void KateIconBorder::updateFont() 1593​void KateIconBorder::updateFont()
1618{ 1594​{
1619 const QFontMetricsF &fm = m_view->renderer()->config()->fontMetrics(); 1595​ const QFontMetricsF &fm = m_view->renderer()->config()->fontMetrics();
1620 m_maxCharWidth = 0.0; 1596​ m_maxCharWidth = 0.0;
1621 // Loop to determine the widest numeric character in the current font. 1597​ // Loop to determine the widest numeric character in the current font.
1622 // 48 is ascii '0' 1598​ // 48 is ascii '0'
1623 for (int i = 48; i < 58; i++) { 1599​ for (int i = 48; i < 58; i++) {
1624 const qreal charWidth = ceil(fm.width(QChar(i))); 1600​ const qreal charWidth = ceil(fm.width(QChar(i)));
1625 m_maxCharWidth = qMax(m_maxCharWidth, charWidth); 1601​ m_maxCharWidth = qMax(m_maxCharWidth, charWidth);
1626 } 1602​ }
1627 1603​
1628 // NOTE/TODO(or not) Take size of m_dynWrapIndicatorChar into account. 1604​ // NOTE/TODO(or not) Take size of m_dynWrapIndicatorChar into account.
1629 // It's a multi-char and it's reported size is, even with a mono-space font, 1605​ // It's a multi-char and it's reported size is, even with a mono-space font,
1630 // bigger than each digit, e.g. 10 vs 12. Currently it seems to work even with 1606​ // bigger than each digit, e.g. 10 vs 12. Currently it seems to work even with
1631 // "Line Numbers Off" but all these width calculating looks slightly hacky 1607​ // "Line Numbers Off" but all these width calculating looks slightly hacky
1632 1608​
1633 // the icon pane scales with the font... 1609​ // the icon pane scales with the font...
1634 iconPaneWidth = fm.height(); 1610​ m_iconAreaWidth = fm.height();
1611​
1612​ // Only for now, later may that become an own value
1613​ m_foldingAreaWidth = m_iconAreaWidth;
1635 1614​
1636 calcAnnotationBorderWidth(); 1615​ calcAnnotationBorderWidth();
1637 1616​
1638 updateGeometry(); 1617​ m_updatePositionToArea = true;
1639 1618​
1640 QTimer::singleShot(0, this, SLOT(update())); 1619​ QTimer::singleShot(0, this, SLOT(update()));
1641} 1620​}
1642 1621​
1643int KateIconBorder::lineNumberWidth() const 1622​int KateIconBorder::lineNumberWidth() const
1644{ 1623​{
1645 // width = (number of digits + 1) * char width 1624​ // width = (number of digits + 1) * char width
1646 const int digits = (int) ceil(log10((double)(m_view->doc()->lines() + 1))); 1625​ const int digits = (int) ceil(log10((double)(m_view->doc()->lines() + 1)));
Show All 29 Lines
1676} 1655​}
1677 1656​
1678static void paintTriangle(QPainter &painter, QColor c, int xOffset, int yOffset, int width, int height, bool open) 1657​static void paintTriangle(QPainter &painter, QColor c, int xOffset, int yOffset, int width, int height, bool open)
1679{ 1658​{
1680 painter.setRenderHint(QPainter::Antialiasing); 1659​ painter.setRenderHint(QPainter::Antialiasing);
1681 1660​
1682 qreal size = qMin(width, height); 1661​ qreal size = qMin(width, height);
1683 1662​
1684 if (KColorUtils::luma(c) > 0.25) { 1663​ // Paint unfolded icon less pushy
1664​ if (open) { // if (KColorUtils::luma(c) > 0.25) {
1685 c = KColorUtils::darken(c); 1665​ c = KColorUtils::darken(c);
1686 } else { 1666​ } else {
1687 c = KColorUtils::shade(c, 0.1); 1667​ c = KColorUtils::shade(c, 0.1);
1688 } 1668​ }
1689 1669​
1690 QPen pen; 1670​ QPen pen;
1691 pen.setJoinStyle(Qt::RoundJoin); 1671​ pen.setJoinStyle(Qt::RoundJoin);
1692 pen.setColor(c); 1672​ pen.setColor(c);
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Line(s)1840{
1919 1899​
1920 m_lastAnnotationGroupIdentifier = m_nextAnnotationGroupIdentifier; 1900​ m_lastAnnotationGroupIdentifier = m_nextAnnotationGroupIdentifier;
1921 m_isSameAnnotationGroupsSinceLast = isSameAnnotationGroupsSinceThis; 1901​ m_isSameAnnotationGroupsSinceLast = isSameAnnotationGroupsSinceThis;
1922} 1902​}
1923 1903​
1924 1904​
1925void KateIconBorder::paintBorder(int /*x*/, int y, int /*width*/, int height) 1905​void KateIconBorder::paintBorder(int /*x*/, int y, int /*width*/, int height)
1926{ 1906​{
1927 uint h = m_view->renderer()->lineHeight(); 1907​ const uint h = m_view->renderer()->lineHeight();
1928 uint startz = (y / h); 1908​ const uint startz = (y / h);
1929 uint endz = startz + 1 + (height / h); 1909​ const uint endz = qMin(startz + 1 + (height / h), static_cast<uint>(m_viewInternal->cache()->viewCacheLineCount()));
1930 uint lineRangesSize = m_viewInternal->cache()->viewCacheLineCount(); 1910​ const uint currentLine = m_view->cursorPosition().line();
1931 uint currentLine = m_view->cursorPosition().line(); ​
1932 1911​
1933 // center the folding boxes 1912​ // center the folding boxes
1934 int m_px = (h - 11) / 2; 1913​ int m_px = (h - 11) / 2;
1935 if (m_px < 0) { 1914​ if (m_px < 0) {
1936 m_px = 0; 1915​ m_px = 0;
1937 } 1916​ }
1938 1917​
1939 int lnWidth(0); 1918​ if (m_updatePositionToArea) {
1940 if (m_lineNumbersOn || m_dynWrapIndicatorsOn) { // avoid calculating unless needed ;-) 1919​ m_lineNumberAreaWidth = lineNumberWidth();
1941 lnWidth = lineNumberWidth(); 1920​ m_positionToArea.clear();
1942 if (lnWidth != m_cachedLNWidth || m_oldBackgroundColor != m_view->renderer()->config()->iconBarColor()) { ​
1943 // we went from n0 ->n9 lines or vice versa ​
1944 // this causes an extra updateGeometry() first time the line numbers ​
1945 // are displayed, but sizeHint() is supposed to be const so we can't set ​
1946 // the cached value there. ​
1947 m_cachedLNWidth = lnWidth; ​
1948 m_oldBackgroundColor = m_view->renderer()->config()->iconBarColor(); ​
1949 updateGeometry(); ​
1950 update(); ​
1951 return; ​
1952 } ​
1953 } 1921​ }
1954 1922​
1955 int w(this->width()); // sane value/calc only once ​
1956 ​
1957 QPainter p(this); 1923​ QPainter p(this);
1958 p.setRenderHints(QPainter::TextAntialiasing); 1924​ p.setRenderHints(QPainter::TextAntialiasing);
1959 p.setFont(m_view->renderer()->config()->font()); // for line numbers 1925​ p.setFont(m_view->renderer()->config()->font()); // for line numbers
1960 1926​
1961 KTextEditor::AnnotationModel *model = m_view->annotationModel() ? 1927​ KTextEditor::AnnotationModel *model = m_view->annotationModel() ?
1962 m_view->annotationModel() : m_doc->annotationModel(); 1928​ m_view->annotationModel() : m_doc->annotationModel();
1963 KateAnnotationGroupPositionState annotationGroupPositionState(m_viewInternal, model, 1929​ KateAnnotationGroupPositionState annotationGroupPositionState(m_viewInternal, model,
1964 m_hoveredAnnotationGroupIdentifier, 1930​ m_hoveredAnnotationGroupIdentifier,
1965 startz, m_annotationBorderOn); 1931​ startz, m_annotationBorderOn);
1966 1932​ // Paint the border in chunks line by line
1967 for (uint z = startz; z <= endz; z++) { 1933​ for (uint z = startz; z < endz; z++) {
1968 int y = h * z; 1934​ const KateTextLayout lineLayout = m_viewInternal->cache()->viewLine(z);
1969 int realLine = -1; 1935​ int realLine = lineLayout.line();
1970 1936​ if (realLine < 0) {
1971 if (z < lineRangesSize) { 1937​ // We have reached the end of the document, nothing more to do
1972 realLine = m_viewInternal->cache()->viewLine(z).line(); 1938​ break;
1973 } 1939​ }
1974 1940​
1975 int lnX = 0; 1941​ // Painting coordinates, lineHeight * lineNumber
1976 1942​ const uint y = h * z;
1977 p.fillRect(0, y, w - 5, h, m_view->renderer()->config()->iconBarColor()); 1943​ // Paint the border in chunks left->right, remember used width
1978 p.fillRect(w - 5, y, 5, h, m_view->renderer()->config()->backgroundColor()); 1944​ uint lnX = 0;
1979 1945​
1980 // icon pane 1946​ // icon pane
1981 if (m_iconBorderOn) { 1947​ if (m_iconBorderOn) {
1982 p.setPen(m_view->renderer()->config()->separatorColor()); 1948​ p.setPen(m_view->renderer()->config()->separatorColor());
1983 p.setBrush(m_view->renderer()->config()->separatorColor()); 1949​ p.setBrush(m_view->renderer()->config()->separatorColor());
1984 p.drawLine(lnX + iconPaneWidth + 1, y, lnX + iconPaneWidth + 1, y + h); 1950​ p.drawLine(lnX + m_iconAreaWidth, y, lnX + m_iconAreaWidth, y + h);
1985 1951​
1986 if ((realLine > -1) && (m_viewInternal->cache()->viewLine(z).startCol() == 0)) { 1952​ const uint mrk(m_doc->mark(realLine)); // call only once
1987 uint mrk(m_doc->mark(realLine)); // call only once 1953​ if (mrk && lineLayout.startCol() == 0) {
1988 1954​ for (uint bit = 0; bit < 32; bit++) {
1989 if (mrk) { 1955​ MarkInterface::MarkTypes markType = (MarkInterface::MarkTypes)(1 << bit);
1990 for (uint bit = 0; bit < 32; bit++) { 1956​ if (mrk & markType) {
1991 MarkInterface::MarkTypes markType = (MarkInterface::MarkTypes)(1 << bit); 1957​ QPixmap px_mark(m_doc->markPixmap(markType));
1992 if (mrk & markType) { 1958​ px_mark.setDevicePixelRatio(devicePixelRatioF());
1993 QPixmap px_mark(m_doc->markPixmap(markType)); 1959​
1994 px_mark.setDevicePixelRatio(devicePixelRatioF()); 1960​ if (!px_mark.isNull() && h > 0 && m_iconAreaWidth > 0) {
1995 1961​ // scale up to a usable size
1996 if (!px_mark.isNull() && h > 0 && iconPaneWidth > 0) { 1962​ px_mark = px_mark.scaled(m_iconAreaWidth * devicePixelRatio(), h * devicePixelRatio(), Qt::KeepAspectRatio);
1997 // scale up to a usable size 1963​
1998 px_mark = px_mark.scaled(iconPaneWidth * devicePixelRatio(), h * devicePixelRatio(), Qt::KeepAspectRatio); 1964​ // center the mark pixmap
1999 1965​ int x_px = (m_iconAreaWidth - px_mark.width()/ devicePixelRatio()) / 2;
2000 // center the mark pixmap 1966​ if (x_px < 0) {
2001 int x_px = (iconPaneWidth - px_mark.width()/ devicePixelRatio()) / 2; 1967​ x_px = 0;
2002 if (x_px < 0) { 1968​ }
2003 x_px = 0; 1969​
2004 } 1970​ int y_px = (h - px_mark.height() / devicePixelRatio()) / 2;
2005 1971​ if (y_px < 0) {
2006 int y_px = (h - px_mark.height() / devicePixelRatio()) / 2; 1972​ y_px = 0;
2007 if (y_px < 0) { ​
2008 y_px = 0; ​
2009 } ​
2010 ​
2011 p.drawPixmap(lnX + x_px, y + y_px, px_mark); ​
2012 } 1973​ }
1974​
1975​ p.drawPixmap(lnX + x_px, y + y_px, px_mark);
2013 } 1976​ }
2014 } 1977​ }
2015 } 1978​ }
2016 } 1979​ }
2017 1980​
2018 lnX += iconPaneWidth + 2; 1981​ lnX += m_iconAreaWidth + m_separatorWidth;
1982​ if (m_updatePositionToArea) {
1983​ m_positionToArea.append(AreaPosition(lnX, IconBorder));
1984​ }
2019 } 1985​ }
2020 1986​
2021 // annotation information 1987​ // annotation information
2022 if (m_annotationBorderOn) { 1988​ if (m_annotationBorderOn) {
2023 // Draw a border line between annotations and the line numbers 1989​ // Draw a border line between annotations and the line numbers
2024 p.setPen(m_view->renderer()->config()->lineNumberColor()); 1990​ p.setPen(m_view->renderer()->config()->lineNumberColor());
2025 p.setBrush(m_view->renderer()->config()->lineNumberColor()); 1991​ p.setBrush(m_view->renderer()->config()->lineNumberColor());
2026 1992​
2027 const qreal borderX = lnX + m_annotationBorderWidth + 0.5; 1993​ const qreal borderX = lnX + m_annotationAreaWidth + 0.5;
2028 p.drawLine(QPointF(borderX, y+0.5), QPointF(borderX, y + h - 0.5)); 1994​ p.drawLine(QPointF(borderX, y+0.5), QPointF(borderX, y + h - 0.5));
2029 1995​
2030 if ((realLine > -1) && model) { 1996​ if (model) {
2031 KTextEditor::StyleOptionAnnotationItem styleOption; 1997​ KTextEditor::StyleOptionAnnotationItem styleOption;
2032 initStyleOption(&styleOption); 1998​ initStyleOption(&styleOption);
2033 styleOption.rect.setRect(lnX, y, m_annotationBorderWidth, h); 1999​ styleOption.rect.setRect(lnX, y, m_annotationAreaWidth, h);
2034 annotationGroupPositionState.nextLine(styleOption, z, realLine); 2000​ annotationGroupPositionState.nextLine(styleOption, z, realLine);
2035 2001​
2036 m_annotationItemDelegate->paint(&p, styleOption, model, realLine); 2002​ m_annotationItemDelegate->paint(&p, styleOption, model, realLine);
2037 } 2003​ }
2038 2004​
2039 // adjust current X position 2005​ lnX += m_annotationAreaWidth + m_separatorWidth;
2040 lnX += m_annotationBorderWidth + /* separator line width */1; 2006​ if (m_updatePositionToArea) {
2007​ m_positionToArea.append(AreaPosition(lnX, AnnotationBorder));
2008​ }
2041 } 2009​ }
2042 2010​
2043 // line number 2011​ // line number
2012​ QColor lineNumberColor; // Remember color for folding below
2044 if (m_lineNumbersOn || m_dynWrapIndicatorsOn) { 2013​ if (m_lineNumbersOn || m_dynWrapIndicatorsOn) {
2045 if (realLine > -1) { 2014​ const int distanceToCurrent = abs(realLine - static_cast<int>(currentLine));
2046 int distanceToCurrent = abs(realLine - static_cast<int>(currentLine)); 2015​ if (distanceToCurrent == 0) {
2047 QColor color; 2016​ lineNumberColor = m_view->renderer()->config()->currentLineNumberColor();
2048 2017​ } else {
2049 if (distanceToCurrent == 0) { 2018​ lineNumberColor = m_view->renderer()->config()->lineNumberColor();
2050 color = m_view->renderer()->config()->currentLineNumberColor(); 2019​ }
2051 } else { 2020​ p.setPen(lineNumberColor);
2052 color = m_view->renderer()->config()->lineNumberColor(); 2021​ p.setBrush(lineNumberColor);
2053 } 2022​
2054 p.setPen(color); 2023​ if (lineLayout.startCol() == 0) {
2055 p.setBrush(color); 2024​ if (m_relLineNumbersOn) {
2056 2025​ if (distanceToCurrent == 0) {
2057 if (m_viewInternal->cache()->viewLine(z).startCol() == 0) { 2026​ p.drawText(lnX + m_maxCharWidth / 2, y, m_lineNumberAreaWidth - m_maxCharWidth, h,
2058 if (m_relLineNumbersOn) { 2027​ Qt::TextDontClip | Qt::AlignLeft | Qt::AlignVCenter, QString::number(realLine + 1));
2059 if (distanceToCurrent == 0) { 2028​ } else {
2060 p.drawText(lnX + m_maxCharWidth / 2, y, lnWidth - m_maxCharWidth, h, 2029​ p.drawText(lnX + m_maxCharWidth / 2, y, m_lineNumberAreaWidth - m_maxCharWidth, h,
2061 Qt::TextDontClip|Qt::AlignLeft|Qt::AlignVCenter, QString::number(realLine + 1)); 2030​ Qt::TextDontClip | Qt::AlignRight | Qt::AlignVCenter, QString::number(distanceToCurrent));
2062 } else { 2031​ }
2063 p.drawText(lnX + m_maxCharWidth / 2, y, lnWidth - m_maxCharWidth, h, 2032​ if (m_updateRelLineNumbers) {
2064 Qt::TextDontClip|Qt::AlignRight|Qt::AlignVCenter, QString::number(distanceToCurrent)); 2033​ m_updateRelLineNumbers = false;
2065 } 2034​ update();
2066 if (m_updateRelLineNumbers) { ​
2067 m_updateRelLineNumbers = false; ​
2068 update(); ​
2069 } ​
2070 } else if (m_lineNumbersOn) { ​
2071 p.drawText(lnX + m_maxCharWidth / 2, y, lnWidth - m_maxCharWidth, h, ​
2072 Qt::TextDontClip | Qt::AlignRight | Qt::AlignVCenter, QString::number(realLine + 1)); ​
2073 } 2035​ }
2074 } else if (m_dynWrapIndicatorsOn) { 2036​ } else if (m_lineNumbersOn) {
2075 p.drawText(lnX + m_maxCharWidth / 2, y, lnWidth - m_maxCharWidth, h, 2037​ p.drawText(lnX + m_maxCharWidth / 2, y, m_lineNumberAreaWidth - m_maxCharWidth, h,
2076 Qt::TextDontClip | Qt::AlignRight | Qt::AlignVCenter, m_dynWrapIndicatorChar); 2038​ Qt::TextDontClip | Qt::AlignRight | Qt::AlignVCenter, QString::number(realLine + 1));
2077 } 2039​ }
2040​ } else if (m_dynWrapIndicatorsOn) {
2041​ p.drawText(lnX + m_maxCharWidth / 2, y, m_lineNumberAreaWidth - m_maxCharWidth, h,
2042​ Qt::TextDontClip | Qt::AlignRight | Qt::AlignVCenter, m_dynWrapIndicatorChar);
2043​ }
2044​
2045​ lnX += m_lineNumberAreaWidth + m_separatorWidth;
2046​ if (m_updatePositionToArea) {
2047​ m_positionToArea.append(AreaPosition(lnX, LineNumbers));
2048​ }
2049​ }
2050​
2051​ // modified line system
2052​ if (m_view->config()->lineModification() && !m_doc->url().isEmpty()) {
2053​
2054​ const Kate::TextLine tl = m_doc->plainKateTextLine(realLine);
2055​ if (tl->markedAsModified()) {
2056​ p.fillRect(lnX, y, m_modAreaWidth, h, m_view->renderer()->config()->modifiedLineColor());
2057​ } else if (tl->markedAsSavedOnDisk()) {
2058​ p.fillRect(lnX, y, m_modAreaWidth, h, m_view->renderer()->config()->savedLineColor());
2059​ } else {
2060​ p.fillRect(lnX, y, m_modAreaWidth, h, m_view->renderer()->config()->iconBarColor());
2078 } 2061​ }
2079 2062​
2080 lnX += lnWidth + 2; 2063​ lnX += m_modAreaWidth; // No m_separatorWidth
2064​ if (m_updatePositionToArea) {
2065​ m_positionToArea.append(AreaPosition(lnX, None));
2066​ }
2081 } 2067​ }
2082 2068​
2083 // folding markers 2069​ // folding markers
2084 if (m_foldingMarkersOn) { 2070​ if (m_foldingMarkersOn) {
2085 // first icon border background 2071​ // first icon border background
2086 p.fillRect(lnX, y, iconPaneWidth, h, m_view->renderer()->config()->iconBarColor()); 2072​ p.fillRect(lnX, y, m_foldingAreaWidth, h, m_view->renderer()->config()->iconBarColor());
2087 2073​
2074​ const QColor foldingColor(m_view->renderer()->config()->foldingColor());
2088 // possible additional folding highlighting 2075​ // possible additional folding highlighting
2089 if ((realLine >= 0) && m_foldingRange && m_foldingRange->overlapsLine(realLine)) { 2076​ if (m_foldingRange && m_foldingRange->overlapsLine(realLine)) {
2090 p.save(); 2077​ p.save();
2091 2078​
2092 // use linear gradient as brush 2079​ // use linear gradient as brush
2093 QLinearGradient g(lnX, y, lnX + iconPaneWidth, y); 2080​ QLinearGradient g(lnX, y, lnX + m_foldingAreaWidth, y);
2094 const QColor foldingColor(m_view->renderer()->config()->foldingColor()); ​
2095 g.setColorAt(0, foldingColor); 2081​ g.setColorAt(0, foldingColor);
2096 g.setColorAt(0.3, foldingColor.lighter(110)); 2082​ g.setColorAt(0.3, foldingColor.lighter(110));
2097 g.setColorAt(1, foldingColor); 2083​ g.setColorAt(1, foldingColor);
2098 p.setBrush(g); 2084​ p.setBrush(g);
2099 p.setPen(foldingColor); 2085​ p.setPen(foldingColor);
2100 2086​
2101 p.setClipRect(lnX, y, iconPaneWidth, h); 2087​ p.setClipRect(lnX, y, m_foldingAreaWidth, h);
2102 p.setRenderHint(QPainter::Antialiasing); 2088​ p.setRenderHint(QPainter::Antialiasing);
2103 2089​
2104 const qreal r = 4.0; 2090​ const qreal r = 4.0;
2105 if (m_foldingRange->start().line() == realLine && 2091​ if (m_foldingRange->start().line() == realLine && lineLayout.viewLine() == 0) {
2106 m_viewInternal->cache()->viewLine(z).viewLine() == 0) { 2092​ p.drawRect(lnX, y, m_foldingAreaWidth, h + r);
2107 p.drawRect(lnX, y, iconPaneWidth, h + r); ​
2108 } else if (m_foldingRange->end().line() == realLine && 2093​ } else if (m_foldingRange->end().line() == realLine &&
2109 m_viewInternal->cache()->viewLine(z).viewLine() == m_viewInternal->cache()->viewLineCount(realLine) - 1) { 2094​ lineLayout.viewLine() == m_viewInternal->cache()->viewLineCount(realLine) - 1) {
2110 p.drawRect(lnX, y - r, iconPaneWidth, h + r); 2095​ p.drawRect(lnX, y - r, m_foldingAreaWidth, h + r);
2111 } else { 2096​ } else {
2112 p.drawRect(lnX, y - r, iconPaneWidth, h + 2 * r); 2097​ p.drawRect(lnX, y - r, m_foldingAreaWidth, h + 2 * r);
2113 } 2098​ }
2114 p.restore(); 2099​ p.restore();
2115 } 2100​ }
2116 2101​
2117 if ((realLine >= 0) && (m_viewInternal->cache()->viewLine(z).startCol() == 0)) { 2102​ if (lineLayout.startCol() == 0) {
2118 QVector<QPair<qint64, Kate::TextFolding::FoldingRangeFlags> > startingRanges = m_view->textFolding().foldingRangesStartingOnLine(realLine); 2103​ QVector<QPair<qint64, Kate::TextFolding::FoldingRangeFlags> > startingRanges = m_view->textFolding().foldingRangesStartingOnLine(realLine);
2119 bool anyFolded = false; 2104​ bool anyFolded = false;
2120 for (int i = 0; i < startingRanges.size(); ++i) 2105​ for (int i = 0; i < startingRanges.size(); ++i) {
2121 if (startingRanges[i].second & Kate::TextFolding::Folded) { 2106​ if (startingRanges[i].second & Kate::TextFolding::Folded) {
2122 anyFolded = true; 2107​ anyFolded = true;
2123 } 2108​ }
2109​ }
2124 2110​
2125 Kate::TextLine tl = m_doc->kateTextLine(realLine); 2111​ const Kate::TextLine tl = m_doc->kateTextLine(realLine);
2126 ​
2127 if (!startingRanges.isEmpty() || tl->markedAsFoldingStart()) { 2112​ if (!startingRanges.isEmpty() || tl->markedAsFoldingStart()) {
2128 if (anyFolded) { 2113​ if (anyFolded) {
2129 paintTriangle(p, m_view->renderer()->config()->foldingColor(), lnX, y, iconPaneWidth, h, false); 2114​ paintTriangle(p, foldingColor, lnX, y, m_foldingAreaWidth, h, false);
2130 } else { 2115​ } else {
2131 paintTriangle(p, m_view->renderer()->config()->foldingColor(), lnX, y, iconPaneWidth, h, true); 2116​ if (!lineNumberColor.isValid()) { // Try to reuse color from above
2117​ int distanceToCurrent = abs(realLine - static_cast<int>(currentLine));
2118​ if (distanceToCurrent == 0) {
2119​ lineNumberColor = m_view->renderer()->config()->currentLineNumberColor();
2120​ } else {
2121​ lineNumberColor = m_view->renderer()->config()->lineNumberColor();
2122​ }
2123​ }
2124​ paintTriangle(p, lineNumberColor, lnX, y, m_foldingAreaWidth, h, true);
2132 } 2125​ }
2133 } 2126​ }
2134 } 2127​ }
2135 2128​
2136 lnX += iconPaneWidth; 2129​ lnX += m_foldingAreaWidth;
2130​ if (m_updatePositionToArea) {
2131​ m_positionToArea.append(AreaPosition(lnX, FoldingMarkers));
2132​ }
2137 } 2133​ }
2138 2134​
2139 // modified line system 2135​ if (m_updatePositionToArea) {
2140 if (m_view->config()->lineModification() && realLine > -1 && !m_doc->url().isEmpty()) { 2136​ m_updatePositionToArea = false;
2141 // one pixel space 2137​ // Now that we know our needed space, ensure we are painted properly
2142 ++lnX; 2138​ updateGeometry();
2143 2139​ update();
2144 Kate::TextLine tl = m_doc->plainKateTextLine(realLine); 2140​ return;
2145 if (tl->markedAsModified()) { ​
2146 p.fillRect(lnX, y, 3, h, m_view->renderer()->config()->modifiedLineColor()); ​
2147 } ​
2148 if (tl->markedAsSavedOnDisk()) { ​
2149 p.fillRect(lnX, y, 3, h, m_view->renderer()->config()->savedLineColor()); ​
2150 } ​
2151 } 2141​ }
2152 } 2142​ }
2153} 2143​}
2154 2144​
2155KateIconBorder::BorderArea KateIconBorder::positionToArea(const QPoint &p) const 2145​KateIconBorder::BorderArea KateIconBorder::positionToArea(const QPoint &p) const
2156{ 2146​{
2157 // see KateIconBorder::sizeHint() for pixel spacings 2147​ for (int i = 0; i < m_positionToArea.size(); ++i) {
2158 int x = 0; 2148​ if (p.x() <= m_positionToArea.at(i).first) {
2159 if (m_iconBorderOn) { 2149​ return m_positionToArea.at(i).second;
2160 x += iconPaneWidth; ​
2161 if (p.x() <= x) { ​
2162 return IconBorder; ​
2163 } ​
2164 x += 2; ​
2165 } ​
2166 if (this->m_annotationBorderOn) { ​
2167 x += m_annotationBorderWidth; ​
2168 if (p.x() <= x) { ​
2169 return AnnotationBorder; ​
2170 } ​
2171 x += 2; ​
2172 } ​
2173 if (m_lineNumbersOn || m_dynWrapIndicators) { ​
2174 x += lineNumberWidth(); ​
2175 if (p.x() <= x) { ​
2176 return LineNumbers; ​
2177 } ​
2178 x += 2; ​
2179 } ​
2180 if (m_foldingMarkersOn) { ​
2181 x += iconPaneWidth; ​
2182 if (p.x() <= x) { ​
2183 return FoldingMarkers; ​
2184 } ​
2185 } ​
2186 if (m_view->config()->lineModification()) { ​
2187 x += 3 + 2; ​
2188 if (p.x() <= x) { ​
2189 return ModificationBorder; ​
2190 } 2150​ }
2191 } 2151​ }
2152​
2192 return None; 2153​ return None;
2193} 2154​}
2194 2155​
2195void KateIconBorder::mousePressEvent(QMouseEvent *e) 2156​void KateIconBorder::mousePressEvent(QMouseEvent *e)
2196{ 2157​{
2197 const KateTextLayout &t = m_viewInternal->yToKateTextLayout(e->y()); 2158​ const KateTextLayout &t = m_viewInternal->yToKateTextLayout(e->y());
2198 if (t.isValid()) { 2159​ if (t.isValid()) {
2199 m_lastClickedLine = t.line(); 2160​ m_lastClickedLine = t.line();
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Line(s)
2623{ 2584​{
2624 setAnnotationItemDelegate(nullptr); 2585​ setAnnotationItemDelegate(nullptr);
2625} 2586​}
2626 2587​
2627void KateIconBorder::initStyleOption(KTextEditor::StyleOptionAnnotationItem* styleOption) const 2588​void KateIconBorder::initStyleOption(KTextEditor::StyleOptionAnnotationItem* styleOption) const
2628{ 2589​{
2629 styleOption->initFrom(this); 2590​ styleOption->initFrom(this);
2630 styleOption->view = m_view; 2591​ styleOption->view = m_view;
2631 styleOption->decorationSize = QSize(iconPaneWidth, iconPaneWidth); 2592​ styleOption->decorationSize = QSize(m_iconAreaWidth, m_iconAreaWidth);
2632 styleOption->contentFontMetrics = m_view->renderer()->config()->fontMetrics(); 2593​ styleOption->contentFontMetrics = m_view->renderer()->config()->fontMetrics();
2633} 2594​}
2634 2595​
2635void KateIconBorder::setStyleOptionLineData(KTextEditor::StyleOptionAnnotationItem* styleOption, 2596​void KateIconBorder::setStyleOptionLineData(KTextEditor::StyleOptionAnnotationItem* styleOption,
2636 int y, 2597​ int y,
2637 int realLine, 2598​ int realLine,
2638 const KTextEditor::AnnotationModel *model, 2599​ const KTextEditor::AnnotationModel *model,
2639 const QString &annotationGroupIdentifier) const 2600​ const QString &annotationGroupIdentifier) const
2640{ 2601​{
2641 // calculate rendered displayed line 2602​ // calculate rendered displayed line
2642 const uint h = m_view->renderer()->lineHeight(); 2603​ const uint h = m_view->renderer()->lineHeight();
2643 const uint z = (y / h); 2604​ const uint z = (y / h);
2644 2605​
2645 KateAnnotationGroupPositionState annotationGroupPositionState(m_viewInternal, model, 2606​ KateAnnotationGroupPositionState annotationGroupPositionState(m_viewInternal, model,
2646 annotationGroupIdentifier, 2607​ annotationGroupIdentifier,
2647 z, true); 2608​ z, true);
2648 annotationGroupPositionState.nextLine(*styleOption, z, realLine); 2609​ annotationGroupPositionState.nextLine(*styleOption, z, realLine);
2649} 2610​}
2650 2611​
2651 2612​
2652QRect KateIconBorder::annotationLineRectInView(int line) const 2613​QRect KateIconBorder::annotationLineRectInView(int line) const
2653{ 2614​{
2654 int x = 0; 2615​ int x = 0;
2655 if (m_iconBorderOn) { 2616​ if (m_iconBorderOn) {
2656 x += iconPaneWidth + 2; 2617​ x += m_iconAreaWidth + 2;
2657 } 2618​ }
2658 const int y = m_view->m_viewInternal->lineToY(line); 2619​ const int y = m_view->m_viewInternal->lineToY(line);
2659 2620​
2660 return QRect(x, y, m_annotationBorderWidth, m_view->renderer()->lineHeight()); 2621​ return QRect(x, y, m_annotationAreaWidth, m_view->renderer()->lineHeight());
2661} 2622​}
2662 2623​
2663void KateIconBorder::updateAnnotationLine(int line) 2624​void KateIconBorder::updateAnnotationLine(int line)
2664{ 2625​{
2665 // TODO: why has the default value been 8, where is that magic number from? 2626​ // TODO: why has the default value been 8, where is that magic number from?
2666 int width = 8; 2627​ int width = 8;
2667 KTextEditor::AnnotationModel *model = m_view->annotationModel() ? 2628​ KTextEditor::AnnotationModel *model = m_view->annotationModel() ?
2668 m_view->annotationModel() : m_doc->annotationModel(); 2629​ m_view->annotationModel() : m_doc->annotationModel();
2669 2630​
2670 if (model) { 2631​ if (model) {
2671 KTextEditor::StyleOptionAnnotationItem styleOption; 2632​ KTextEditor::StyleOptionAnnotationItem styleOption;
2672 initStyleOption(&styleOption); 2633​ initStyleOption(&styleOption);
2673 width = m_annotationItemDelegate->sizeHint(styleOption, model, line).width(); 2634​ width = m_annotationItemDelegate->sizeHint(styleOption, model, line).width();
2674 } 2635​ }
2675 2636​
2676 if (width > m_annotationBorderWidth) { 2637​ if (width > m_annotationAreaWidth) {
2677 m_annotationBorderWidth = width; 2638​ m_annotationAreaWidth = width;
2678 updateGeometry(); 2639​ updateGeometry();
2679 2640​
2680 QTimer::singleShot(0, this, SLOT(update())); 2641​ QTimer::singleShot(0, this, SLOT(update()));
2681 } 2642​ }
2682} 2643​}
2683 2644​
2684void KateIconBorder::showAnnotationMenu(int line, const QPoint &pos) 2645​void KateIconBorder::showAnnotationMenu(int line, const QPoint &pos)
2685{ 2646​{
Show All 11 Lines
2697{ 2658​{
2698 m_annotationItemDelegate->hideTooltip(m_view); 2659​ m_annotationItemDelegate->hideTooltip(m_view);
2699} 2660​}
2700 2661​
2701void KateIconBorder::updateAnnotationBorderWidth() 2662​void KateIconBorder::updateAnnotationBorderWidth()
2702{ 2663​{
2703 calcAnnotationBorderWidth(); 2664​ calcAnnotationBorderWidth();
2704 2665​
2705 updateGeometry(); 2666​ m_updatePositionToArea = true;
2706 2667​
2707 QTimer::singleShot(0, this, SLOT(update())); 2668​ QTimer::singleShot(0, this, SLOT(update()));
2708} 2669​}
2709 2670​
2710void KateIconBorder::calcAnnotationBorderWidth() 2671​void KateIconBorder::calcAnnotationBorderWidth()
2711{ 2672​{
2712 // TODO: another magic number, not matching the one in updateAnnotationLine() 2673​ // TODO: another magic number, not matching the one in updateAnnotationLine()
2713 m_annotationBorderWidth = 6; 2674​ m_annotationAreaWidth = 6;
2714 KTextEditor::AnnotationModel *model = m_view->annotationModel() ? 2675​ KTextEditor::AnnotationModel *model = m_view->annotationModel() ?
2715 m_view->annotationModel() : m_doc->annotationModel(); 2676​ m_view->annotationModel() : m_doc->annotationModel();
2716 2677​
2717 if (model) { 2678​ if (model) {
2718 KTextEditor::StyleOptionAnnotationItem styleOption; 2679​ KTextEditor::StyleOptionAnnotationItem styleOption;
2719 initStyleOption(&styleOption); 2680​ initStyleOption(&styleOption);
2720 2681​
2721 const int lineCount = m_view->doc()->lines(); 2682​ const int lineCount = m_view->doc()->lines();
2722 if (lineCount > 0) { 2683​ if (lineCount > 0) {
2723 const int checkedLineCount = m_hasUniformAnnotationItemSizes ? 1 : lineCount; 2684​ const int checkedLineCount = m_hasUniformAnnotationItemSizes ? 1 : lineCount;
2724 for (int i = 0; i < checkedLineCount; ++i) { 2685​ for (int i = 0; i < checkedLineCount; ++i) {
2725 const int curwidth = m_annotationItemDelegate->sizeHint(styleOption, model, i).width(); 2686​ const int curwidth = m_annotationItemDelegate->sizeHint(styleOption, model, i).width();
2726 if (curwidth > m_annotationBorderWidth) { 2687​ if (curwidth > m_annotationAreaWidth) {
2727 m_annotationBorderWidth = curwidth; 2688​ m_annotationAreaWidth = curwidth;
2728 } 2689​ }
2729 } 2690​ }
2730 } 2691​ }
2731 } 2692​ }
2732} 2693​}
2733 2694​
2734void KateIconBorder::annotationModelChanged(KTextEditor::AnnotationModel *oldmodel, KTextEditor::AnnotationModel *newmodel) 2695​void KateIconBorder::annotationModelChanged(KTextEditor::AnnotationModel *oldmodel, KTextEditor::AnnotationModel *newmodel)
2735{ 2696​{
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines