3party/easy_profiler
0
0
Fork 0
mirror of https://github.com/yse/easy_profiler.git synced 2024-12-26 16:11:02 +08:00
Code Issues Projects Releases Wiki Activity
easy_profiler/profiler_gui/graphics_block_item.cpp
Sergey Yagovtsev 04a472121e #210 Safety range for GraphicsBlockItem intersection
2023-11-13 23:49:13 +03:00

1502 lines
55 KiB
C++
Raw Blame History

/************************************************************************
* file name : graphics_block_item.cpp
* ----------------- :
* creation time : 2016/09/15
* author : Victor Zarubkin
* email : v.s.zarubkin@gmail.com
* ----------------- :
* description : The file contains implementation of GraphicsBlockItem.
* ----------------- :
* license : Lightweight profiler library for c++
* : Copyright(C) 2016-2019 Sergey Yagovtsev, Victor Zarubkin
* :
* : Licensed under either of
* : * MIT license (LICENSE.MIT or http://opensource.org/licenses/MIT)
* : * Apache License, Version 2.0, (LICENSE.APACHE or http://www.apache.org/licenses/LICENSE-2.0)
* : at your option.
* :
* : The MIT License
* :
* : Permission is hereby granted, free of charge, to any person obtaining a copy
* : of this software and associated documentation files (the "Software"), to deal
* : in the Software without restriction, including without limitation the rights
* : to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* : of the Software, and to permit persons to whom the Software is furnished
* : to do so, subject to the following conditions:
* :
* : The above copyright notice and this permission notice shall be included in all
* : copies or substantial portions of the Software.
* :
* : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* : INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* : PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* : LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* : TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* : USE OR OTHER DEALINGS IN THE SOFTWARE.
* :
* : The Apache License, Version 2.0 (the "License")
* :
* : You may not use this file except in compliance with the License.
* : You may obtain a copy of the License at
* :
* : http://www.apache.org/licenses/LICENSE-2.0
* :
* : Unless required by applicable law or agreed to in writing, software
* : distributed under the License is distributed on an "AS IS" BASIS,
* : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* : See the License for the specific language governing permissions and
* : limitations under the License.
************************************************************************/
#include <QGraphicsScene>
#include <QDebug>
#include <algorithm>
#include "graphics_block_item.h"
#include "blocks_graphics_view.h"
#include "globals.h"
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
namespace {
enum BlockItemState : int8_t
{
BLOCK_ITEM_DO_PAINT_FIRST = -2,
BLOCK_ITEM_DO_NOT_PAINT = -1,
BLOCK_ITEM_UNCHANGED,
BLOCK_ITEM_DO_PAINT
};
//////////////////////////////////////////////////////////////////////////
EASY_CONSTEXPR int MIN_SYNC_SPACING = 1;
EASY_CONSTEXPR int MIN_SYNC_SIZE = 3;
EASY_CONSTEXPR int EVENT_HEIGHT = 4;
EASY_CONSTEXPR auto BORDERS_COLOR = profiler_gui::BLOCK_BORDER_COLOR;
inline QRgb selectedItemBorderColor(profiler::color_t _color) {
return ::profiler_gui::isLightColor(_color, 192) ? profiler::colors::Black : profiler::colors::RichRed;
}
EASY_FORCE_INLINE void setSelectedFont(QPainter* /*painter*/)
{
// Currently font.selected_item is similar to font.item
// so there is no need to change font at all
//painter->setFont(EASY_GLOBALS.font.selected_item);
}
EASY_FORCE_INLINE void restoreItemFont(QPainter* /*painter*/)
{
// Currently font.selected_item is similar to font.item
// so there is no need to change font at all
//painter->setFont(EASY_GLOBALS.font.item);
}
const QPen HIGHLIGHTER_PEN = ([]() -> QPen {
QPen p(profiler::colors::Black);
p.setStyle(Qt::DotLine);
p.setWidth(2);
return p;
})();
} // end of namespace <noname>.
#ifdef max
#undef max
#endif
#ifdef min
#undef min
#endif
//////////////////////////////////////////////////////////////////////////
GraphicsBlockItem::GraphicsBlockItem(uint8_t _index, const profiler::BlocksTreeRoot& _root)
: QGraphicsItem(nullptr)
, m_thread(_root)
, m_threadName(::profiler_gui::decoratedThreadName(EASY_GLOBALS.use_decorated_thread_name, _root, EASY_GLOBALS.hex_thread_id))
, m_index(_index)
{
}
GraphicsBlockItem::~GraphicsBlockItem()
{
}
void GraphicsBlockItem::validateName()
{
m_threadName = ::profiler_gui::decoratedThreadName(EASY_GLOBALS.use_decorated_thread_name, m_thread, EASY_GLOBALS.hex_thread_id);
}
const BlocksGraphicsView* GraphicsBlockItem::view() const
{
return static_cast<const BlocksGraphicsView*>(scene()->parent());
}
//////////////////////////////////////////////////////////////////////////
QRectF GraphicsBlockItem::boundingRect() const
{
return m_boundingRect;
}
//////////////////////////////////////////////////////////////////////////
struct EasyPainterInformation EASY_FINAL
{
const QRectF visibleSceneRect;
QRectF rect;
QBrush brush;
const qreal visibleBottom;
const qreal currentScale;
const qreal offset;
const qreal sceneLeft;
const qreal sceneRight;
const qreal dx;
QRgb previousColor;
QRgb textColor;
Qt::PenStyle previousPenStyle;
bool is_light;
bool selectedItemsWasPainted;
explicit EasyPainterInformation(const BlocksGraphicsView* sceneView)
: visibleSceneRect(sceneView->visibleSceneRect())
, visibleBottom(visibleSceneRect.bottom() - 1)
, currentScale(sceneView->scale())
, offset(sceneView->offset())
, sceneLeft(offset)
, sceneRight(offset + visibleSceneRect.width() / currentScale)
, dx(offset * currentScale)
, previousColor(0)
, textColor(0)
, previousPenStyle(Qt::NoPen)
, is_light(false)
, selectedItemsWasPainted(false)
{
brush.setStyle(Qt::SolidPattern);
}
EasyPainterInformation() = delete;
};
#ifdef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
void GraphicsBlockItem::paintChildren(const float _minWidth, const int _narrowSizeHalf, const uint8_t _levelsNumber,
QPainter* _painter, struct EasyPainterInformation& p, profiler_gui::EasyBlockItem& _item,
const profiler_gui::EasyBlock& _itemBlock, RightBounds& _rightBounds, uint8_t _level,
int8_t _mode)
{
if (_level >= _levelsNumber || _itemBlock.tree.children.empty())
return;
const auto top = levelY(_level);
if (top > p.visibleBottom)
return;
qreal& prevRight = _rightBounds[_level];
auto& level = m_levels[_level];
const auto next_level = (short)(_level + 1);
uint32_t neighbours = (uint32_t)_itemBlock.tree.children.size();
uint32_t last = neighbours - 1;
uint32_t neighbour = 0;
if (_mode == BLOCK_ITEM_DO_PAINT_FIRST)
{
neighbour = last = _item.max_depth_child;
neighbours = neighbour + 1;
}
for (uint32_t i = _item.children_begin + neighbour; neighbour < neighbours; ++i, ++neighbour)
{
auto& item = level[i];
if (item.left() > p.sceneRight)
break; // This is first totally invisible item. No need to check other items.
if (item.right() < p.sceneLeft)
continue; // This item is not visible
const auto& itemBlock = easyBlock(item.block);
const auto totalHeight = itemBlock.tree.depth * EASY_GLOBALS.size.graphics_row_full + EASY_GLOBALS.size.graphics_row_height;
if ((top + totalHeight) < p.visibleSceneRect.top())
continue; // This item is not visible
const auto item_width = ::std::max(item.width(), _minWidth);
auto x = item.left() * p.currentScale - p.dx;
auto w = item_width * p.currentScale;
//const auto right = x + w;
if ((x + w) <= prevRight)
{
// This item is not visible
if (!(EASY_GLOBALS.hide_narrow_children && w < EASY_GLOBALS.blocks_narrow_size))
paintChildren(_minWidth, _narrowSizeHalf, _levelsNumber, _painter, p, item, itemBlock, _rightBounds,
(uint8_t)next_level, BLOCK_ITEM_DO_PAINT_FIRST);
continue;
}
if (x < prevRight)
{
w -= prevRight - x;
x = prevRight;
}
if (EASY_GLOBALS.hide_minsize_blocks && w < EASY_GLOBALS.blocks_size_min)
continue; // Hide blocks (except top-level blocks) which width is less than 1 pixel
const auto& itemDesc = easyDescriptor(itemBlock.tree.node->id());
int h = 0;
bool do_paint_children = false;
if ((EASY_GLOBALS.hide_narrow_children && w < EASY_GLOBALS.blocks_narrow_size) || !itemBlock.expanded)
{
// Items which width is less than 20 will be painted as big rectangles which are hiding it's children
//x = item.left() * p.currentScale - p.dx;
h = totalHeight;
const auto dh = top + h - p.visibleBottom;
if (dh > 0)
h -= dh;
if (item.block == EASY_GLOBALS.selected_block)
p.selectedItemsWasPainted = true;
const bool colorChange = (p.previousColor != itemDesc.color());
if (colorChange)
{
// Set background color brush for rectangle
p.previousColor = itemDesc.color();
//p.inverseColor = 0xffffffff - p.previousColor;
p.is_light = ::profiler_gui::isLightColor(p.previousColor);
p.textColor = ::profiler_gui::textColorForFlag(p.is_light);
p.brush.setColor(QColor::fromRgba(p.previousColor));
_painter->setBrush(p.brush);
}
if (EASY_GLOBALS.highlight_blocks_with_same_id && (EASY_GLOBALS.selected_block_id == itemBlock.tree.node->id()
|| (::profiler_gui::is_max(EASY_GLOBALS.selected_block) && EASY_GLOBALS.selected_block_id == itemDesc.id())))
{
if (p.previousPenStyle != Qt::DotLine)
{
p.previousPenStyle = Qt::DotLine;
_painter->setPen(HIGHLIGHTER_PEN);
}
}
else if (EASY_GLOBALS.draw_graphics_items_borders)
{
if (p.previousPenStyle != Qt::SolidLine)// || colorChange)
{
// Restore pen for item which is wide enough to paint borders
p.previousPenStyle = Qt::SolidLine;
_painter->setPen(BORDERS_COLOR);//BORDERS_COLOR & inverseColor);
}
}
else if (p.previousPenStyle != Qt::NoPen)
{
p.previousPenStyle = Qt::NoPen;
_painter->setPen(Qt::NoPen);
}
const auto wprev = w;
decltype(w) dw = 0;
if (item.left() < p.sceneLeft)
{
// if item left border is out of screen then attach text to the left border of the screen
// to ensure text is always visible for items presenting on the screen.
w += (item.left() - p.sceneLeft) * p.currentScale;
x = p.sceneLeft * p.currentScale - p.dx - 2;
w += 2;
dw = 2;
}
if (item.right() > p.sceneRight)
{
w -= (item.right() - p.sceneRight) * p.currentScale;
w += 2;
dw += 2;
}
if (w < EASY_GLOBALS.blocks_size_min)
w = EASY_GLOBALS.blocks_size_min;
// Draw rectangle
p.rect.setRect(x, top, w, h);
_painter->drawRect(p.rect);
prevRight = p.rect.right() + EASY_GLOBALS.blocks_spacing;
//skip_children(next_level, item.children_begin);
if (wprev < EASY_GLOBALS.blocks_narrow_size)
continue;
if (dw > 1)
{
w -= dw;
x += 2;
}
}
else
{
if (item.block == EASY_GLOBALS.selected_block)
p.selectedItemsWasPainted = true;
const bool colorChange = (p.previousColor != itemDesc.color());
if (colorChange)
{
// Set background color brush for rectangle
p.previousColor = itemDesc.color();
//p.inverseColor = 0xffffffff - p.previousColor;
p.is_light = ::profiler_gui::isLightColor(p.previousColor);
p.textColor = ::profiler_gui::textColorForFlag(p.is_light);
p.brush.setColor(QColor::fromRgba(p.previousColor));
_painter->setBrush(p.brush);
}
if (EASY_GLOBALS.highlight_blocks_with_same_id && (EASY_GLOBALS.selected_block_id == itemBlock.tree.node->id()
|| (::profiler_gui::is_max(EASY_GLOBALS.selected_block) && EASY_GLOBALS.selected_block_id == itemDesc.id())))
{
if (p.previousPenStyle != Qt::DotLine)
{
p.previousPenStyle = Qt::DotLine;
_painter->setPen(HIGHLIGHTER_PEN);
}
}
else if (EASY_GLOBALS.draw_graphics_items_borders)
{
if (p.previousPenStyle != Qt::SolidLine)// || colorChange)
{
// Restore pen for item which is wide enough to paint borders
p.previousPenStyle = Qt::SolidLine;
_painter->setPen(BORDERS_COLOR);// BORDERS_COLOR & inverseColor);
}
}
else if (p.previousPenStyle != Qt::NoPen)
{
p.previousPenStyle = Qt::NoPen;
_painter->setPen(Qt::NoPen);
}
// Draw rectangle
//x = item.left() * currentScale - p.dx;
h = EASY_GLOBALS.size.graphics_row_height;
const auto dh = top + h - p.visibleBottom;
if (dh > 0)
h -= dh;
const auto wprev = w;
decltype(w) dw = 0;
if (item.left() < p.sceneLeft)
{
// if item left border is out of screen then attach text to the left border of the screen
// to ensure text is always visible for items presenting on the screen.
w += (item.left() - p.sceneLeft) * p.currentScale;
x = p.sceneLeft * p.currentScale - p.dx - 2;
w += 2;
dw = 2;
}
if (item.right() > p.sceneRight)
{
w -= (item.right() - p.sceneRight) * p.currentScale;
w += 2;
dw += 2;
}
if (w < EASY_GLOBALS.blocks_size_min)
w = EASY_GLOBALS.blocks_size_min;
p.rect.setRect(x, top, w, h);
_painter->drawRect(p.rect);
prevRight = p.rect.right() + EASY_GLOBALS.blocks_spacing;
if (wprev < EASY_GLOBALS.blocks_narrow_size)
{
paintChildren(_minWidth, _narrowSizeHalf, _levelsNumber, _painter, p, item, itemBlock, _rightBounds, next_level, wprev < _narrowSizeHalf ? BLOCK_ITEM_DO_PAINT_FIRST : BLOCK_ITEM_DO_PAINT);
continue;
}
if (dw > 1)
{
w -= dw;
x += 2;
}
do_paint_children = true;
}
// Draw text-----------------------------------
p.rect.setRect(x + 1, top, w - 1, h);
// text will be painted with inverse color
//auto textColor = inverseColor < 0x00808080 ? profiler::colors::Black : profiler::colors::White;
//if (textColor == previousColor) textColor = 0;
_painter->setPen(p.textColor);
if (item.block == EASY_GLOBALS.selected_block)
setSelectedFont(_painter);
// drawing text
auto name = easyBlockName(itemBlock.tree, itemDesc);
_painter->drawText(p.rect, Qt::AlignCenter, ::profiler_gui::toUnicode(name));
// restore previous pen color
if (p.previousPenStyle == Qt::NoPen)
_painter->setPen(Qt::NoPen);
else if (p.previousPenStyle == Qt::DotLine)
{
_painter->setPen(HIGHLIGHTER_PEN);
}
else
_painter->setPen(BORDERS_COLOR);// BORDERS_COLOR & inverseColor); // restore pen for rectangle painting
// restore font
if (item.block == EASY_GLOBALS.selected_block)
restoreItemFont(_painter);
// END Draw text~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (do_paint_children)
paintChildren(_minWidth, _narrowSizeHalf, _levelsNumber, _painter, p, item, itemBlock, _rightBounds, next_level, _mode);
}
}
#endif
void GraphicsBlockItem::paint(QPainter* _painter, const QStyleOptionGraphicsItem*, QWidget*)
{
const bool gotItems = !m_levels.empty() && !m_levels.front().empty();
const bool gotSync = !m_thread.sync.empty();
if (!gotItems && !gotSync)
{
return;
}
EasyPainterInformation p(view());
_painter->save();
_painter->setFont(EASY_GLOBALS.font.item);
// Reset indices of first visible item for each layer
const auto levelsNumber = levels();
m_rightBounds[0] = -1e100;
for (uint8_t i = 1; i < levelsNumber; ++i) {
::profiler_gui::set_max(m_levelsIndexes[i]);
m_rightBounds[i] = -1e100;
}
// Search for first visible top-level item
if (gotItems)
{
auto& level0 = m_levels.front();
auto first = ::std::lower_bound(level0.begin(), level0.end(), p.sceneLeft, [](const ::profiler_gui::EasyBlockItem& _item, qreal _value)
{
return _item.left() < _value;
});
if (first != level0.end())
{
m_levelsIndexes[0] = first - level0.begin();
if (m_levelsIndexes[0] > 0)
m_levelsIndexes[0] -= 1;
}
else
{
m_levelsIndexes[0] = static_cast<unsigned int>(level0.size() - 1);
}
}
// This is to make _painter->drawText() work properly
// (it seems there is a bug in Qt5.6 when drawText called for big coordinates,
// drawRect at the same time called for actually same coordinates
// works fine without using this additional shifting)
//const auto dx = p.offset * p.currentScale;
// Shifting coordinates to current screen offset
_painter->setTransform(QTransform::fromTranslate(0, -y()), true);
if (EASY_GLOBALS.draw_graphics_items_borders)
{
p.previousPenStyle = Qt::SolidLine;
_painter->setPen(BORDERS_COLOR);
}
else
{
_painter->setPen(Qt::NoPen);
}
const auto MIN_WIDTH = EASY_GLOBALS.enable_zero_length ? 0.f : 0.25f;
// Iterate through layers and draw visible items
if (gotItems)
{
const int narrow_size_half = EASY_GLOBALS.blocks_narrow_size >> 1;
#ifndef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
static const auto MAX_CHILD_INDEX = ::profiler_gui::numeric_max<decltype(::profiler_gui::EasyBlockItem::children_begin)>();
auto const dont_skip_children = [this, &levelsNumber](short next_level, decltype(::profiler_gui::EasyBlockItem::children_begin) children_begin, int8_t _state)
{
if (next_level < levelsNumber && children_begin != MAX_CHILD_INDEX)
{
if (m_levelsIndexes[next_level] == MAX_CHILD_INDEX)
{
// Mark first potentially visible child item on next sublevel
m_levelsIndexes[next_level] = children_begin;
}
// Mark children items that we want to draw them
m_levels[next_level][children_begin].state = _state;
}
};
#endif
//size_t iterations = 0;
#ifndef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
for (uint8_t l = 0; l < levelsNumber; ++l)
#else
for (uint8_t l = 0; l < 1; ++l)
#endif
{
auto& level = m_levels[l];
const auto next_level = (short)(l + 1);
const auto top = levelY(l);
if (top > p.visibleBottom)
break;
//qreal& prevRight = m_rightBounds[l];
qreal prevRight = -1e100;
uint32_t neighbour = 0;
for (uint32_t i = m_levelsIndexes[l], end = static_cast<uint32_t>(level.size()); i < end; ++i, ++neighbour)
{
//++iterations;
auto& item = level[i];
if (item.left() > p.sceneRight)
break; // This is first totally invisible item. No need to check other items.
#ifndef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
char state = BLOCK_ITEM_DO_PAINT;
if (item.state != BLOCK_ITEM_UNCHANGED)
{
neighbour = 0; // first block in parent's children list
state = item.state;
item.state = BLOCK_ITEM_DO_NOT_PAINT;
}
#endif
if (item.right() < p.sceneLeft)
continue; // This item is not visible
#ifndef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
if (state == BLOCK_ITEM_DO_NOT_PAINT)
{
// This item is not visible
if (neighbour < item.neighbours)
i += item.neighbours - neighbour - 1; // Skip all neighbours
continue;
}
if (state == BLOCK_ITEM_DO_PAINT_FIRST && item.children_begin == MAX_CHILD_INDEX && next_level < levelsNumber && neighbour < (item.neighbours-1))
// Paint only first child which has own children
continue; // This item has no children and would not be painted
#endif
const auto& itemBlock = easyBlock(item.block);
const auto totalHeight = itemBlock.tree.depth * EASY_GLOBALS.size.graphics_row_full + EASY_GLOBALS.size.graphics_row_height;
if ((top + totalHeight) < p.visibleSceneRect.top())
continue; // This item is not visible
const auto item_width = ::std::max(item.width(), MIN_WIDTH);
auto x = item.left() * p.currentScale - p.dx;
auto w = item_width * p.currentScale;
if ((x + w) <= prevRight)
{
// This item is not visible
#ifdef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
if (!EASY_GLOBALS.hide_narrow_children || w >= EASY_GLOBALS.blocks_narrow_size)
paintChildren(MIN_WIDTH, narrow_size_half, levelsNumber, _painter, p, item, itemBlock,
m_rightBounds, (uint8_t)next_level, BLOCK_ITEM_DO_PAINT_FIRST);
#else
if (!(EASY_GLOBALS.hide_narrow_children && w < EASY_GLOBALS.blocks_narrow_size) && l > 0)
dont_skip_children(next_level, item.children_begin, BLOCK_ITEM_DO_PAINT_FIRST);
#endif
continue;
}
if (x < prevRight)
{
w -= prevRight - x;
x = prevRight;
}
#ifndef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
if (EASY_GLOBALS.hide_minsize_blocks && w < EASY_GLOBALS.blocks_size_min && l > 0)
continue; // Hide blocks (except top-level blocks) which width is less than 1 pixel
if (state == BLOCK_ITEM_DO_PAINT_FIRST && neighbour < item.neighbours)
{
// Paint only first child which has own children
i += item.neighbours - neighbour - 1; // Skip all neighbours
}
#endif
const auto& itemDesc = easyDescriptor(itemBlock.tree.node->id());
int h = 0;
#ifdef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
bool do_paint_children = false;
#endif
if ((EASY_GLOBALS.hide_narrow_children && w < EASY_GLOBALS.blocks_narrow_size) || !itemBlock.expanded)
{
// Items which width is less than 20 will be painted as big rectangles which are hiding it's children
//x = item.left() * p.currentScale - p.dx;
h = totalHeight;
const auto dh = top + h - p.visibleBottom;
if (dh > 0)
h -= dh;
if (item.block == EASY_GLOBALS.selected_block)
p.selectedItemsWasPainted = true;
const bool colorChange = (p.previousColor != itemDesc.color());
if (colorChange)
{
// Set background color brush for rectangle
p.previousColor = itemDesc.color();
//p.inverseColor = 0xffffffff - p.previousColor;
p.is_light = ::profiler_gui::isLightColor(p.previousColor);
p.textColor = ::profiler_gui::textColorForFlag(p.is_light);
p.brush.setColor(QColor::fromRgba(p.previousColor));
_painter->setBrush(p.brush);
}
if (EASY_GLOBALS.highlight_blocks_with_same_id && (EASY_GLOBALS.selected_block_id == itemBlock.tree.node->id()
|| (::profiler_gui::is_max(EASY_GLOBALS.selected_block) && EASY_GLOBALS.selected_block_id == itemDesc.id())))
{
if (p.previousPenStyle != Qt::DotLine)
{
p.previousPenStyle = Qt::DotLine;
_painter->setPen(HIGHLIGHTER_PEN);
}
}
else if (EASY_GLOBALS.draw_graphics_items_borders)
{
if (p.previousPenStyle != Qt::SolidLine)// || colorChange)
{
// Restore pen for item which is wide enough to paint borders
p.previousPenStyle = Qt::SolidLine;
_painter->setPen(BORDERS_COLOR);//BORDERS_COLOR & inverseColor);
}
}
else if (p.previousPenStyle != Qt::NoPen)
{
p.previousPenStyle = Qt::NoPen;
_painter->setPen(Qt::NoPen);
}
const auto wprev = w;
decltype(w) dw = 0;
if (item.left() < p.sceneLeft)
{
// if item left border is out of screen then attach text to the left border of the screen
// to ensure text is always visible for items presenting on the screen.
w += (item.left() - p.sceneLeft) * p.currentScale;
x = p.sceneLeft * p.currentScale - p.dx - 2;
w += 2;
dw = 2;
}
if (item.right() > p.sceneRight)
{
w -= (item.right() - p.sceneRight) * p.currentScale;
w += 2;
dw += 2;
}
if (w < EASY_GLOBALS.blocks_size_min)
w = EASY_GLOBALS.blocks_size_min;
// Draw rectangle
p.rect.setRect(x, top, w, h);
_painter->drawRect(p.rect);
prevRight = p.rect.right() + EASY_GLOBALS.blocks_spacing;
//skip_children(next_level, item.children_begin);
if (wprev < EASY_GLOBALS.blocks_narrow_size)
continue;
if (dw > 1) {
w -= dw;
x += 2;
}
}
else
{
if (item.block == EASY_GLOBALS.selected_block)
p.selectedItemsWasPainted = true;
const bool colorChange = (p.previousColor != itemDesc.color());
if (colorChange)
{
// Set background color brush for rectangle
p.previousColor = itemDesc.color();
//p.inverseColor = 0xffffffff - p.previousColor;
p.is_light = ::profiler_gui::isLightColor(p.previousColor);
p.textColor = ::profiler_gui::textColorForFlag(p.is_light);
p.brush.setColor(QColor::fromRgba(p.previousColor));
_painter->setBrush(p.brush);
}
if (EASY_GLOBALS.highlight_blocks_with_same_id && (EASY_GLOBALS.selected_block_id == itemBlock.tree.node->id()
|| (::profiler_gui::is_max(EASY_GLOBALS.selected_block) && EASY_GLOBALS.selected_block_id == itemDesc.id())))
{
if (p.previousPenStyle != Qt::DotLine)
{
p.previousPenStyle = Qt::DotLine;
_painter->setPen(HIGHLIGHTER_PEN);
}
}
else if (EASY_GLOBALS.draw_graphics_items_borders)
{
if (p.previousPenStyle != Qt::SolidLine)// || colorChange)
{
// Restore pen for item which is wide enough to paint borders
p.previousPenStyle = Qt::SolidLine;
_painter->setPen(BORDERS_COLOR);// BORDERS_COLOR & inverseColor);
}
}
else if (p.previousPenStyle != Qt::NoPen)
{
p.previousPenStyle = Qt::NoPen;
_painter->setPen(Qt::NoPen);
}
// Draw rectangle
//x = item.left() * currentScale - p.dx;
h = EASY_GLOBALS.size.graphics_row_height;
const auto dh = top + h - p.visibleBottom;
if (dh > 0)
h -= dh;
const auto wprev = w;
decltype(w) dw = 0;
if (item.left() < p.sceneLeft)
{
// if item left border is out of screen then attach text to the left border of the screen
// to ensure text is always visible for items presenting on the screen.
w += (item.left() - p.sceneLeft) * p.currentScale;
x = p.sceneLeft * p.currentScale - p.dx - 2;
w += 2;
dw = 2;
}
if (item.right() > p.sceneRight)
{
w -= (item.right() - p.sceneRight) * p.currentScale;
w += 2;
dw += 2;
}
if (w < EASY_GLOBALS.blocks_size_min)
w = EASY_GLOBALS.blocks_size_min;
p.rect.setRect(x, top, w, h);
_painter->drawRect(p.rect);
prevRight = p.rect.right() + EASY_GLOBALS.blocks_spacing;
if (wprev < EASY_GLOBALS.blocks_narrow_size)
{
#ifndef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
dont_skip_children(next_level, item.children_begin, wprev < narrow_size_half ? BLOCK_ITEM_DO_PAINT_FIRST : BLOCK_ITEM_DO_PAINT);
#else
paintChildren(MIN_WIDTH, narrow_size_half, levelsNumber, _painter, p, item, itemBlock, m_rightBounds, next_level, wprev < narrow_size_half ? BLOCK_ITEM_DO_PAINT_FIRST : BLOCK_ITEM_DO_PAINT);
#endif
continue;
}
#ifndef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
dont_skip_children(next_level, item.children_begin, BLOCK_ITEM_DO_PAINT);
#endif
if (dw > 1) {
w -= dw;
x += 2;
}
#ifdef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
do_paint_children = true;
#endif
}
// Draw text-----------------------------------
p.rect.setRect(x + 1, top, w - 1, h);
// text will be painted with inverse color
//auto textColor = inverseColor < 0x00808080 ? profiler::colors::Black : profiler::colors::White;
//if (textColor == previousColor) textColor = 0;
_painter->setPen(p.textColor);
if (item.block == EASY_GLOBALS.selected_block)
setSelectedFont(_painter);
// drawing text
auto name = easyBlockName(itemBlock.tree, itemDesc);
_painter->drawText(p.rect, Qt::AlignCenter, ::profiler_gui::toUnicode(name));
// restore previous pen color
if (p.previousPenStyle == Qt::NoPen)
_painter->setPen(Qt::NoPen);
else if (p.previousPenStyle == Qt::DotLine)
{
_painter->setPen(HIGHLIGHTER_PEN);
}
else
_painter->setPen(BORDERS_COLOR);// BORDERS_COLOR & inverseColor); // restore pen for rectangle painting
// restore font
if (item.block == EASY_GLOBALS.selected_block)
restoreItemFont(_painter);
// END Draw text~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#ifdef EASY_GRAPHICS_ITEM_RECURSIVE_PAINT
if (do_paint_children)
paintChildren(MIN_WIDTH, narrow_size_half, levelsNumber, _painter, p, item, itemBlock, m_rightBounds, next_level, BLOCK_ITEM_DO_PAINT);
#endif
}
}
if (EASY_GLOBALS.selected_block < EASY_GLOBALS.gui_blocks.size())
{
const auto& guiblock = EASY_GLOBALS.gui_blocks[EASY_GLOBALS.selected_block];
if (guiblock.graphics_item == m_index)
{
const auto& item = m_levels[guiblock.graphics_item_level][guiblock.graphics_item_index];
if (item.left() < p.sceneRight && item.right() > p.sceneLeft)
{
const auto& itemBlock = easyBlock(item.block);
const auto item_width = ::std::max(item.width(), MIN_WIDTH);
auto top = levelY(guiblock.graphics_item_level);
auto w = ::std::max(item_width * p.currentScale, 1.0);
decltype(top) h = (!itemBlock.expanded ||
(w < EASY_GLOBALS.blocks_narrow_size && EASY_GLOBALS.hide_narrow_children))
? (itemBlock.tree.depth * EASY_GLOBALS.size.graphics_row_full + EASY_GLOBALS.size.graphics_row_height)
: EASY_GLOBALS.size.graphics_row_height;
auto dh = top + h - p.visibleBottom;
if (dh < h)
{
if (dh > 0)
h -= dh;
const auto& itemDesc = easyDescriptor(itemBlock.tree.node->id());
QPen pen(Qt::SolidLine);
pen.setJoinStyle(Qt::MiterJoin);
pen.setColor(selectedItemBorderColor(itemDesc.color()));//Qt::red);
pen.setWidth(3);
_painter->setPen(pen);
if (!p.selectedItemsWasPainted)
{
p.brush.setColor(QColor::fromRgba(itemDesc.color()));// SELECTED_ITEM_COLOR);
_painter->setBrush(p.brush);
}
else
{
_painter->setBrush(Qt::NoBrush);
}
auto x = item.left() * p.currentScale - p.dx;
decltype(w) dw = 0;
if (item.left() < p.sceneLeft)
{
// if item left border is out of screen then attach text to the left border of the screen
// to ensure text is always visible for items presenting on the screen.
w += (item.left() - p.sceneLeft) * p.currentScale;
x = p.sceneLeft * p.currentScale - p.dx - 2;
w += 2;
dw = 2;
}
if (item.right() > p.sceneRight)
{
w -= (item.right() - p.sceneRight) * p.currentScale;
w += 2;
dw += 2;
}
p.rect.setRect(x, top, w, h);
_painter->drawRect(p.rect);
if (!p.selectedItemsWasPainted && w > EASY_GLOBALS.blocks_narrow_size)
{
if (dw > 1) {
w -= dw;
x += 2;
}
// Draw text-----------------------------------
p.rect.setRect(x + 1, top, w - 1, h);
// text will be painted with inverse color
//auto textColor = 0x00ffffff - previousColor;
//if (textColor == previousColor) textColor = 0;
p.textColor = ::profiler_gui::textColorForRgb(itemDesc.color());// SELECTED_ITEM_COLOR);
_painter->setPen(p.textColor);
// drawing text
setSelectedFont(_painter);
auto name = easyBlockName(itemBlock.tree, itemDesc);
_painter->drawText(p.rect, Qt::AlignCenter, ::profiler_gui::toUnicode(name));
restoreItemFont(_painter);
// END Draw text~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
}
}
}
}
}
//printf("%u: %llu\n", m_index, iterations);
}
if (gotSync)
{
const auto sceneView = view();
auto firstSync = ::std::lower_bound(m_thread.sync.begin(), m_thread.sync.end(), p.sceneLeft, [&sceneView](::profiler::block_index_t _index, qreal _value)
{
return sceneView->time2position(easyBlocksTree(_index).node->begin()) < _value;
});
if (firstSync != m_thread.sync.end())
{
if (firstSync != m_thread.sync.begin())
--firstSync;
}
else if (!m_thread.sync.empty())
{
firstSync = m_thread.sync.begin() + m_thread.sync.size() - 1;
}
//firstSync = m_thread.sync.begin();
p.previousColor = 0;
qreal prevRight = -1e100;
const qreal top = y() + 1 - EVENT_HEIGHT;
if (top + EVENT_HEIGHT < p.visibleBottom)
{
_painter->setPen(BORDERS_COLOR);
for (auto it = firstSync, end = m_thread.sync.end(); it != end; ++it)
{
const auto& item = easyBlocksTree(*it);
auto left = sceneView->time2position(item.node->begin());
if (left > p.sceneRight)
break; // This is first totally invisible item. No need to check other items.
decltype(left) width = sceneView->time2position(item.node->end()) - left;
if (left + width < p.sceneLeft) // This item is not visible
continue;
left *= p.currentScale;
left -= p.dx;
width *= p.currentScale;
if (left + width <= prevRight) // This item is not visible
continue;
if (left < prevRight)
{
width -= prevRight - left;
left = prevRight;
}
if (width < MIN_SYNC_SIZE)
width = MIN_SYNC_SIZE;
const ::profiler::thread_id_t tid = EASY_GLOBALS.version < ::profiler_gui::V130 ? item.node->id() : item.cs->tid();
const bool self_thread = tid != 0 && EASY_GLOBALS.profiler_blocks.find(tid) != EASY_GLOBALS.profiler_blocks.end();
::profiler::color_t color = 0;
if (self_thread)
color = ::profiler::colors::Coral;
else if (item.node->id() == 0)
color = ::profiler::colors::Black;
else
color = ::profiler::colors::RedA400;
if (p.previousColor != color)
{
p.previousColor = color;
_painter->setBrush(QColor::fromRgb(color));
}
p.rect.setRect(left, top, width, EVENT_HEIGHT);
_painter->drawRect(p.rect);
prevRight = left + width + MIN_SYNC_SPACING;
}
}
}
if (EASY_GLOBALS.enable_event_markers && !m_thread.events.empty())
{
const auto sceneView = view();
auto first = ::std::lower_bound(m_thread.events.begin(), m_thread.events.end(), p.offset, [&sceneView](::profiler::block_index_t _index, qreal _value)
{
return sceneView->time2position(easyBlocksTree(_index).node->begin()) < _value;
});
if (first != m_thread.events.end())
{
if (first != m_thread.events.begin())
--first;
}
else if (!m_thread.events.empty())
{
first = m_thread.events.begin() + m_thread.events.size() - 1;
}
p.previousColor = 0;
qreal prevRight = -1e100;
const qreal top = y() + boundingRect().height() - 1;
if (top + EVENT_HEIGHT < p.visibleBottom)
{
_painter->setPen(BORDERS_COLOR);
for (auto it = first, end = m_thread.events.end(); it != end; ++it)
{
const auto& item = easyBlocksTree(*it);
auto left = sceneView->time2position(item.node->begin());
if (left > p.sceneRight)
break; // This is first totally invisible item. No need to check other items.
decltype(left) width = MIN_WIDTH;
if (left + width < p.sceneLeft) // This item is not visible
continue;
left *= p.currentScale;
left -= p.dx;
width *= p.currentScale;
if (width < 2)
width = 2;
if (left + width <= prevRight) // This item is not visible
continue;
if (left < prevRight)
{
width -= prevRight - left;
left = prevRight;
}
if (width < 2)
width = 2;
::profiler::color_t color = easyDescriptor(item.node->id()).color();
if (p.previousColor != color)
{
p.previousColor = color;
_painter->setBrush(QColor::fromRgb(color));
}
p.rect.setRect(left, top, width, EVENT_HEIGHT);
_painter->drawRect(p.rect);
prevRight = left + width + 2;
}
}
}
_painter->restore();
}
//////////////////////////////////////////////////////////////////////////
const profiler::BlocksTreeRoot& GraphicsBlockItem::root() const
{
return m_thread;
}
const QString& GraphicsBlockItem::threadName() const
{
return m_threadName;
}
//////////////////////////////////////////////////////////////////////////
QRect GraphicsBlockItem::getRect() const
{
return view()->mapFromScene(m_boundingRect).boundingRect();
}
//////////////////////////////////////////////////////////////////////////
void GraphicsBlockItem::getBlocks(qreal _left, qreal _right, ::profiler_gui::TreeBlocks& _blocks) const
{
// Search for first visible top-level item
auto& level0 = m_levels.front();
auto first = ::std::lower_bound(level0.begin(), level0.end(), _left, [](const ::profiler_gui::EasyBlockItem& _item, qreal _value)
{
return _item.left() < _value;
});
size_t itemIndex = 0;
if (first != level0.end())
{
itemIndex = static_cast<size_t>(std::distance(level0.begin(), first));
if (itemIndex > 0)
itemIndex -= 1;
}
else
{
itemIndex = level0.size() - 1;
}
// Add all visible top-level items into array of visible blocks
for (size_t i = itemIndex, end = level0.size(); i < end; ++i)
{
const auto& item = level0[i];
if (item.left() > _right)
{
// First invisible item. No need to check other items.
break;
}
if (item.right() < _left)
{
// This item is not visible yet
// This is just to be sure
continue;
}
_blocks.emplace_back(&m_thread, item.block);
}
}
//////////////////////////////////////////////////////////////////////////
const ::profiler_gui::EasyBlock* GraphicsBlockItem::intersect(const QPointF& _pos, ::profiler::block_index_t& _blockIndex) const
{
if (m_levels.empty() || m_levels.front().empty())
{
return nullptr;
}
const auto& level0 = m_levels.front();
const auto top = y();
if (top > _pos.y())
{
return nullptr;
}
const auto overlap = (EASY_GLOBALS.size.threads_row_spacing >> 1) + 2;
const auto bottom = top + m_levels.size() * EASY_GLOBALS.size.graphics_row_full + overlap;
if (bottom < _pos.y())
{
return nullptr;
}
const unsigned int levelIndex = static_cast<unsigned int>(_pos.y() - top) / EASY_GLOBALS.size.graphics_row_full;
if (levelIndex >= m_levels.size())
{
// The Y position is out of blocks range
if (EASY_GLOBALS.enable_event_markers && !m_thread.events.empty())
{
// If event indicators are enabled then try to intersect with one of event indicators
const auto& sceneView = view();
auto first = ::std::lower_bound(m_thread.events.begin(), m_thread.events.end(), _pos.x(), [&sceneView](::profiler::block_index_t _index, qreal _value)
{
return sceneView->time2position(easyBlocksTree(_index).node->begin()) < _value;
});
if (first != m_thread.events.end())
{
if (first != m_thread.events.begin())
--first;
}
else if (!m_thread.events.empty())
{
first = m_thread.events.begin() + m_thread.events.size() - 1;
}
const auto MIN_WIDTH = EASY_GLOBALS.enable_zero_length ? 0.f : 0.25f;
const auto currentScale = sceneView->scale();
const auto dw = 5. / currentScale;
for (auto it = first, end = m_thread.events.end(); it != end; ++it)
{
_blockIndex = *it;
const auto& item = easyBlock(_blockIndex);
auto left = sceneView->time2position(item.tree.node->begin());
if (left - dw > _pos.x())
break; // This is first totally invisible item. No need to check other items.
decltype(left) width = MIN_WIDTH;
if (left + width + dw < _pos.x()) // This item is not visible
continue;
return &item;
}
}
return nullptr;
}
// The Y position is inside blocks range
const auto MIN_WIDTH = EASY_GLOBALS.enable_zero_length ? 0.f : 0.25f;
const auto currentScale = view()->scale();
const auto dw = 5. / currentScale;
unsigned int i = 0;
size_t itemIndex = ::std::numeric_limits<size_t>::max();
size_t firstItem = 0, lastItem = static_cast<unsigned int>(level0.size());
while (i <= levelIndex)
{
const auto& level = m_levels[i];
size_t levelSize = level.size();
auto firstItemIterator = level.begin();
auto lastItemIterator = level.begin();
// Ensure that firstItem and lastItem are within the permissible range
if (firstItem < levelSize) {
std::advance(firstItemIterator, firstItem);
} else {
firstItemIterator = level.end();
}
if (lastItem <= levelSize) {
std::advance(lastItemIterator, lastItem);
} else {
lastItemIterator = level.end();
}
// Search for first visible item
auto first = ::std::lower_bound(firstItemIterator, lastItemIterator, _pos.x(), [](const ::profiler_gui::EasyBlockItem& _item, qreal _value)
{
return _item.left() < _value;
});
if (first != level.end())
{
itemIndex = first - level.begin();
if (itemIndex != 0)
--itemIndex;
}
else
{
itemIndex = level.size() - 1;
}
for (auto size = level.size(); itemIndex < size; ++itemIndex)
{
const auto& item = level[itemIndex];
static const auto MAX_CHILD_INDEX = ::profiler_gui::numeric_max(item.children_begin);
if (item.left() - dw > _pos.x())
{
return nullptr;
}
const auto item_width = ::std::max(item.width(), MIN_WIDTH);
if (item.left() + item_width + dw < _pos.x())
{
continue;
}
const auto w = item_width * currentScale;
const auto& guiItem = easyBlock(item.block);
if (i == levelIndex || (w < EASY_GLOBALS.blocks_narrow_size && EASY_GLOBALS.hide_narrow_children) || !guiItem.expanded)
{
_blockIndex = item.block;
return &guiItem;
}
if (item.children_begin == MAX_CHILD_INDEX)
{
if (itemIndex != 0)
{
auto j = itemIndex;
firstItem = 0;
do {
--j;
const auto& item2 = level[j];
if (item2.children_begin != MAX_CHILD_INDEX)
{
firstItem = item2.children_begin;
break;
}
} while (j != 0);
}
else
{
firstItem = 0;
}
}
else
{
firstItem = item.children_begin;
}
lastItem = m_levels[i + 1].size();
for (auto j = itemIndex + 1; j < size; ++j)
{
const auto& item2 = level[j];
if (item2.children_begin != MAX_CHILD_INDEX)
{
lastItem = item2.children_begin;
break;
}
}
break;
}
++i;
}
return nullptr;
}
const ::profiler_gui::EasyBlock* GraphicsBlockItem::intersectEvent(const QPointF& _pos) const
{
if (m_thread.sync.empty())
{
return nullptr;
}
const auto top = y() - EVENT_HEIGHT;
if (top > _pos.y())
{
return nullptr;
}
const auto bottom = top + EVENT_HEIGHT + 2;
if (bottom < _pos.y())
{
return nullptr;
}
const auto sceneView = view();
auto firstSync = ::std::lower_bound(m_thread.sync.begin(), m_thread.sync.end(), _pos.x(), [&sceneView](::profiler::block_index_t _index, qreal _value)
{
return sceneView->time2position(easyBlocksTree(_index).node->begin()) < _value;
});
if (firstSync == m_thread.sync.end())
firstSync = m_thread.sync.begin() + m_thread.sync.size() - 1;
else if (firstSync != m_thread.sync.begin())
--firstSync;
const auto dw = 4. / view()->scale();
for (auto it = firstSync, end = m_thread.sync.end(); it != end; ++it)
{
const auto& item = easyBlock(*it);
const auto left = sceneView->time2position(item.tree.node->begin()) - dw;
if (left > _pos.x())
break;
const auto right = sceneView->time2position(item.tree.node->end()) + dw;
if (right < _pos.x())
continue;
return &item;
}
return nullptr;
}
//////////////////////////////////////////////////////////////////////////
void GraphicsBlockItem::setBoundingRect(qreal x, qreal y, qreal w, qreal h)
{
m_boundingRect.setRect(x, y, w, h);
}
void GraphicsBlockItem::setBoundingRect(const QRectF& _rect)
{
m_boundingRect = _rect;
}
//////////////////////////////////////////////////////////////////////////
::profiler::thread_id_t GraphicsBlockItem::threadId() const
{
return m_thread.thread_id;
}
//////////////////////////////////////////////////////////////////////////
uint8_t GraphicsBlockItem::levels() const
{
return static_cast<uint8_t>(m_levels.size());
}
float GraphicsBlockItem::levelY(uint8_t _level) const
{
return static_cast<float>(y() + static_cast<int>(_level) * EASY_GLOBALS.size.graphics_row_full);
}
void GraphicsBlockItem::setLevels(uint8_t _levels)
{
typedef decltype(m_levelsIndexes) IndexesT;
static const auto MAX_CHILD_INDEX = ::profiler_gui::numeric_max<IndexesT::value_type>();
m_levels.resize(_levels);
m_levelsIndexes.resize(_levels, MAX_CHILD_INDEX);
m_rightBounds.resize(_levels, -1e100);
}
void GraphicsBlockItem::reserve(uint8_t _level, unsigned int _items)
{
m_levels[_level].reserve(_items);
}
//////////////////////////////////////////////////////////////////////////
const GraphicsBlockItem::Children& GraphicsBlockItem::items(uint8_t _level) const
{
return m_levels[_level];
}
const ::profiler_gui::EasyBlockItem& GraphicsBlockItem::getItem(uint8_t _level, unsigned int _index) const
{
return m_levels[_level][_index];
}
::profiler_gui::EasyBlockItem& GraphicsBlockItem::getItem(uint8_t _level, unsigned int _index)
{
return m_levels[_level][_index];
}
unsigned int GraphicsBlockItem::addItem(uint8_t _level)
{
m_levels[_level].emplace_back();
return static_cast<unsigned int>(m_levels[_level].size() - 1);
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
Reference in New Issue View Git Blame Copy Permalink