/* virtual */ void JPMiniGame::Render() const
{
for (int i = 0; i < blocksNum; ++i)
{
Rect texRect = normalizeTexCoords(blockRect(blocks[i]));
Rect scrRectOrigin = blockRect(i);
int indent;
if (blocks[i] == i) // правильно поставленные идут без отступа
{
indent = 0;
}
else if (blocks[i] == selectedBlock) // выделенные с небольшим оступом
{
indent = 2;
}
else // у всех остальных отступ большой
{
indent = 5;
}
scrRectOrigin.left += indent;
scrRectOrigin.top += indent;
scrRectOrigin.right -= indent;
scrRectOrigin.bottom -= indent;
::Render(scrRectOrigin, cTextureId, texRect);
}
}
bool QgsRasterIterator::readNextRasterPart( int bandNumber,
int& nCols, int& nRows,
void** rasterData,
int& topLeftCol, int& topLeftRow )
{
//get partinfo
QMap<int, RasterPartInfo>::iterator partIt = mRasterPartInfos.find( bandNumber );
if ( partIt == mRasterPartInfos.end() )
{
return false;
}
RasterPartInfo& pInfo = partIt.value();
//remove last data block
// TODO: data are released somewhere else (check)
//free( pInfo.data );
pInfo.data = 0;
delete pInfo.prj;
pInfo.prj = 0;
//already at end
if ( pInfo.currentCol == pInfo.nCols && pInfo.currentRow == pInfo.nRows )
{
return false;
}
//read data block
nCols = qMin( mMaximumTileWidth, pInfo.nCols - pInfo.currentCol );
nRows = qMin( mMaximumTileHeight, pInfo.nRows - pInfo.currentRow );
//get subrectangle
QgsRectangle viewPortExtent = mExtent;
double xmin = viewPortExtent.xMinimum() + pInfo.currentCol / ( double )pInfo.nCols * viewPortExtent.width();
double xmax = viewPortExtent.xMinimum() + ( pInfo.currentCol + nCols ) / ( double )pInfo.nCols * viewPortExtent.width();
double ymin = viewPortExtent.yMaximum() - ( pInfo.currentRow + nRows ) / ( double )pInfo.nRows * viewPortExtent.height();
double ymax = viewPortExtent.yMaximum() - pInfo.currentRow / ( double )pInfo.nRows * viewPortExtent.height();
QgsRectangle blockRect( xmin, ymin, xmax, ymax );
pInfo.data = mInput->block( bandNumber, blockRect, nCols, nRows );
*rasterData = pInfo.data;
topLeftCol = pInfo.currentCol;
topLeftRow = pInfo.currentRow;
pInfo.currentCol += nCols;
if ( pInfo.currentCol == pInfo.nCols && pInfo.currentRow + nRows == pInfo.nRows ) //end of raster
{
pInfo.currentRow = pInfo.nRows;
}
else if ( pInfo.currentCol == pInfo.nCols ) //start new row
{
pInfo.currentCol = 0;
pInfo.currentRow += nRows;
}
return true;
}
RoomDataStores MysteryDungeonMaker::RoomData()
{
RoomDataStores roomData;
for (size_t i = 0; i < dungeonSize->DungeonRowNum(); i++)
{
for (size_t j = 0; j < dungeonSize->DungeonColumnNum(); j++)
{
if (sections[i][j].HasRoom())
{
auto rect = sections[i][j].GetRoom();
BlockRect blockRect(rect.y1, rect.x1, rect.y2, rect.x2);
roomData.Add(blockRect);
}
}
}
return roomData;
}
LayoutUnit RenderFlowThread::offsetFromLogicalTopOfFirstRegion(const RenderBlock* currentBlock) const
{
// First check if we cached the offset for the block if it's an ancestor containing block of the box
// being currently laid out.
LayoutUnit offset;
if (cachedOffsetFromLogicalTopOfFirstRegion(currentBlock, offset))
return offset;
// If it's the current box being laid out, use the layout state.
const RenderBox* currentBoxDescendant = currentStatePusherRenderBox();
if (currentBlock == currentBoxDescendant) {
LayoutState* layoutState = view()->layoutState();
ASSERT(layoutState->renderer() == currentBlock);
ASSERT(layoutState && layoutState->isPaginated());
LayoutSize offsetDelta = layoutState->layoutOffset() - layoutState->pageOffset();
return currentBoxDescendant->isHorizontalWritingMode() ? offsetDelta.height() : offsetDelta.width();
}
// As a last resort, take the slow path.
LayoutRect blockRect(0, 0, currentBlock->width(), currentBlock->height());
while (currentBlock && !currentBlock->isRenderFlowThread()) {
RenderBlock* containerBlock = currentBlock->containingBlock();
ASSERT(containerBlock);
if (!containerBlock)
return 0;
LayoutPoint currentBlockLocation = currentBlock->location();
if (containerBlock->style()->writingMode() != currentBlock->style()->writingMode()) {
// We have to put the block rect in container coordinates
// and we have to take into account both the container and current block flipping modes
if (containerBlock->style()->isFlippedBlocksWritingMode()) {
if (containerBlock->isHorizontalWritingMode())
blockRect.setY(currentBlock->height() - blockRect.maxY());
else
blockRect.setX(currentBlock->width() - blockRect.maxX());
}
currentBlock->flipForWritingMode(blockRect);
}
blockRect.moveBy(currentBlockLocation);
currentBlock = containerBlock;
}
return currentBlock->isHorizontalWritingMode() ? blockRect.y() : blockRect.x();
}
void findNextBlockPlacement(Size square,std::vector<Size> blocks,std::vector<std::vector<Rect> >* blockPlacements,std::vector<Rect> currentPlacement)
{
Point startPoint = PointDefault;
for(int i=0;i<currentPlacement.size();i++)
{
Rect placement = currentPlacement[i];
if((placement.x+placement.width)%square.width > startPoint.x)
startPoint.x = placement.x+placement.width;
if(placement.y+placement.height > startPoint.y)
startPoint.y = placement.y+placement.height;
}
int currentX = 0;
for(int i=0;i<currentPlacement.size();i++)
{
Rect placement = currentPlacement[i];
if(placement.y+placement.height == startPoint.y && placement.x+placement.width > currentX)
currentX = placement.x+placement.width;
}
if(square.width == currentX && square.height == startPoint.y)
{
blockPlacements->push_back(currentPlacement);
return;
}
for(int i=0;i<blocks.size();i++)
{
Size blockSize = blocks[i];
if(startPoint.x+blockSize.width <= square.width && startPoint.y+blockSize.height <= square.height)
{
Rect blockRect(startPoint.x,startPoint.y,blockSize.width,blockSize.height);
currentPlacement.push_back(blockRect);
findNextBlockPlacement(square,blocks,blockPlacements,currentPlacement);
currentPlacement.pop_back();
}
}
}
void TextContent::updateTextConstraints()
{
// 1. actual content stretch
double prevXScale = 1.0;
double prevYScale = 1.0;
/* if (m_textRect.width() > 0 && m_textRect.height() > 0) {
QRect cRect = contentRect();
prevXScale = (qreal)cRect.width() / (qreal)m_textRect.width();
prevYScale = (qreal)cRect.height() / (qreal)m_textRect.height();
}*/
// 2. LAYOUT TEXT. find out Block rects and Document rect
int minCharSide = 0;
m_blockRects.clear();
m_textRect = QRect(0, 0, 0, 0);
for (QTextBlock tb = m_text->begin(); tb.isValid(); tb = tb.next()) {
if (!tb.isVisible())
continue;
// 2.1.A. calc the Block size uniting Fragments bounding rects
QRect blockRect(0, 0, 0, 0);
for (QTextBlock::iterator tbIt = tb.begin(); !(tbIt.atEnd()); ++tbIt) {
QTextFragment frag = tbIt.fragment();
if (!frag.isValid())
continue;
QString text = frag.text();
if (text.trimmed().isEmpty())
continue;
QFontMetrics metrics(frag.charFormat().font());
if (!minCharSide || metrics.height() > minCharSide)
minCharSide = metrics.height();
// TODO: implement superscript / subscript (it's in charFormat's alignment)
// it must be implemented in paint too
QRect textRect = metrics.boundingRect(text);
if (textRect.left() > 9999)
continue;
if (textRect.top() < blockRect.top())
blockRect.setTop(textRect.top());
if (textRect.bottom() > blockRect.bottom())
blockRect.setBottom(textRect.bottom());
int textWidth = metrics.width(text);
blockRect.setWidth(blockRect.width() + textWidth);
}
// 2.1.B. calc the Block size of blank lines
if (tb.begin() == tb.end()) {
QFontMetrics metrics(tb.charFormat().font());
int textHeight = metrics.height();
blockRect.setWidth(1);
blockRect.setHeight(textHeight);
}
// 2.2. add the Block's margins
QTextBlockFormat tbFormat = tb.blockFormat();
blockRect.adjust(-tbFormat.leftMargin(), -tbFormat.topMargin(), tbFormat.rightMargin(), tbFormat.bottomMargin());
// 2.3. store the original block rect
m_blockRects.append(blockRect);
// 2.4. enlarge the Document rect (uniting the Block rect)
blockRect.translate(0, m_textRect.bottom() - blockRect.top() + 1);
if (blockRect.left() < m_textRect.left())
m_textRect.setLeft(blockRect.left());
if (blockRect.right() > m_textRect.right())
m_textRect.setRight(blockRect.right());
if (blockRect.top() < m_textRect.top())
m_textRect.setTop(blockRect.top());
if (blockRect.bottom() > m_textRect.bottom())
m_textRect.setBottom(blockRect.bottom());
}
m_textRect.adjust(-m_textMargin, -m_textMargin, m_textMargin, m_textMargin);
// 3. use shape-based rendering
if (hasShape()) {
#if 1
// more precise, but too close to the path
m_shapeRect = m_shapePath.boundingRect().toRect();
#else
// faster, but less precise (as it uses the controls points to determine
// the path rect, instead of the path itself)
m_shapeRect = m_shapePath.controlPointRect().toRect();
#endif
minCharSide = qBound(10, minCharSide, 500);
m_shapeRect.adjust(-minCharSide, -minCharSide, minCharSide, minCharSide);
// FIXME: layout, save layouting and calc the exact size!
//int w = m_shapeRect.width();
//int h = m_shapeRect.height();
//resizeContents(QRect(-w / 2, -h / 2, w, h));
resizeContents(m_shapeRect);
// moveBy(m_shapeRect.left(), m_shapeRect.top());
// m_shapePath.translate(-m_shapeRect.left(), -m_shapeRect.top());
//setPos(m_shapeRect.center());
return;
}
// 4. resize content keeping stretch
int w = (int)(prevXScale * (qreal)m_textRect.width());
int h = (int)(prevYScale * (qreal)m_textRect.height());
resizeContents(QRect(-w / 2, -h / 2, w, h));
}
bool QgsRasterIterator::readNextRasterPart( int bandNumber,
int &nCols, int &nRows,
QgsRasterBlock **block,
int &topLeftCol, int &topLeftRow )
{
QgsDebugMsgLevel( "Entered", 4 );
*block = nullptr;
//get partinfo
QMap<int, RasterPartInfo>::iterator partIt = mRasterPartInfos.find( bandNumber );
if ( partIt == mRasterPartInfos.end() )
{
return false;
}
RasterPartInfo &pInfo = partIt.value();
// If we started with zero cols or zero rows, just return (avoids divide by zero below)
if ( 0 == pInfo.nCols || 0 == pInfo.nRows )
{
return false;
}
//remove last data block
delete pInfo.prj;
pInfo.prj = nullptr;
//already at end
if ( pInfo.currentCol == pInfo.nCols && pInfo.currentRow == pInfo.nRows )
{
return false;
}
//read data block
nCols = std::min( mMaximumTileWidth, pInfo.nCols - pInfo.currentCol );
nRows = std::min( mMaximumTileHeight, pInfo.nRows - pInfo.currentRow );
QgsDebugMsgLevel( QString( "nCols = %1 nRows = %2" ).arg( nCols ).arg( nRows ), 4 );
//get subrectangle
QgsRectangle viewPortExtent = mExtent;
double xmin = viewPortExtent.xMinimum() + pInfo.currentCol / static_cast< double >( pInfo.nCols ) * viewPortExtent.width();
double xmax = pInfo.currentCol + nCols == pInfo.nCols ? viewPortExtent.xMaximum() : // avoid extra FP math if not necessary
viewPortExtent.xMinimum() + ( pInfo.currentCol + nCols ) / static_cast< double >( pInfo.nCols ) * viewPortExtent.width();
double ymin = pInfo.currentRow + nRows == pInfo.nRows ? viewPortExtent.yMinimum() : // avoid extra FP math if not necessary
viewPortExtent.yMaximum() - ( pInfo.currentRow + nRows ) / static_cast< double >( pInfo.nRows ) * viewPortExtent.height();
double ymax = viewPortExtent.yMaximum() - pInfo.currentRow / static_cast< double >( pInfo.nRows ) * viewPortExtent.height();
QgsRectangle blockRect( xmin, ymin, xmax, ymax );
*block = mInput->block( bandNumber, blockRect, nCols, nRows, mFeedback );
topLeftCol = pInfo.currentCol;
topLeftRow = pInfo.currentRow;
pInfo.currentCol += nCols;
if ( pInfo.currentCol == pInfo.nCols && pInfo.currentRow + nRows == pInfo.nRows ) //end of raster
{
pInfo.currentRow = pInfo.nRows;
}
else if ( pInfo.currentCol == pInfo.nCols ) //start new row
{
pInfo.currentCol = 0;
pInfo.currentRow += nRows;
}
return true;
}
QRect lineRect( int line ) const {
const CodeEditor* editor = stacker->editor();
const TextDocument* document = editor ? editor->textDocument() : 0;
return document ? blockRect( document->findBlockByNumber( line ) ) : QRect();
}