/*************************************************************************
Return the ListboxItem under the given window local pixel co-ordinate.
*************************************************************************/
ListboxItem* Listbox::getItemAtPoint(const Point& pt) const
{
Rect renderArea(getListRenderArea());
// point must be within the rendering area of the Listbox.
if (renderArea.isPointInRect(pt))
{
float y = renderArea.d_top - getVertScrollbar()->getScrollPosition();
// test if point is above first item
if (pt.d_y >= y)
{
for (size_t i = 0; i < getItemCount(); ++i)
{
y += d_listItems[i]->getPixelSize().d_height;
if (pt.d_y < y)
{
return d_listItems[i];
}
}
}
}
return 0;
}
void Renderer::renderMetaTile(RenderAttributes& map, const shared_ptr<MetaTile>& tile)
{
const shared_ptr<MetaIdentifier>& id = tile->getIdentifier();
int width = id->getWidth() * TILE_SIZE;
int height = id->getHeight() * TILE_SIZE;
int zoom = id->getZoom();
TileIdentifier::Format format = id->getIdentifiers()[0]->getImageFormat();
shared_ptr<ImageWriter> writer = getWriter(format, width, height);
FixedRect area;
tileToMercator(id->getX(), id->getY(), zoom, area.minX, area.minY);
tileToMercator(id->getX() + id->getWidth(),
id->getY() + id->getHeight(),
zoom, area.maxX, area.maxY);
#if OLD_CAIRO
renderLock.lock();
#endif
AssetCache cache;
CairoLayer layers[LAYER_NUM];
setupLayers(layers, writer, cache);
paintBackground(layers[0], map.getCanvasStyle());
renderArea(area, layers, width, height, map, cache);
#if OLD_CAIRO
renderLock.unlock();
#endif
tile->setData(layers[0].surface);
}
void setRenderArea(ToonzScene *scene) {
TDimension cameraRes = scene->getCurrentCamera()->getRes();
double rx = cameraRes.lx * 0.5, ry = cameraRes.ly * 0.5;
TRectD renderArea(-rx, -ry, rx, ry);
TRenderPort::setRenderArea(renderArea);
m_cameraDpi = scene->getCurrentCamera()->getDpi();
}
void FalagardMenubar::sizeToContent_impl(void)
{
Rect renderArea(getItemRenderArea());
Rect wndArea(getAbsoluteRect());
// get size of content
Size sz(getContentSize());
// calculate the full size with the frame accounted for and resize the window to this
sz.d_width += wndArea.getWidth() - renderArea.getWidth();
sz.d_height += wndArea.getHeight() - renderArea.getHeight();
setSize(Absolute,sz);
}
/************************************************************************
Resize to fit content
************************************************************************/
void ItemListBase::sizeToContent_impl(void)
{
Rect renderArea(getItemRenderArea());
Rect wndArea(getArea().asAbsolute(getParentPixelSize()));
// get size of content
Size sz(getContentSize());
// calculate the full size with the frame accounted for and resize the window to this
sz.d_width += wndArea.getWidth() - renderArea.getWidth();
sz.d_height += wndArea.getHeight() - renderArea.getHeight();
setSize(UVector2(cegui_absdim(sz.d_width), cegui_absdim(sz.d_height)));
}
/*************************************************************************
Return the TreeItem under the given window local pixel co-ordinate.
*************************************************************************/
TreeItem* Tree::getItemAtPoint(const Vector2f& pt) const
{
Rectf renderArea(getTreeRenderArea());
// point must be within the rendering area of the Tree.
if (renderArea.isPointInRect(pt))
{
float y = renderArea.top() - d_vertScrollbar->getScrollPosition();
// test if point is above first item
if (pt.d_y >= y)
return getItemFromListAtPoint(d_listItems, &y, pt);
}
return 0;
}
void FalagardPopupMenu::sizeToContent_impl(void)
{
Rect renderArea(getItemRenderArea());
Rect wndArea(getAbsoluteRect());
// get size of content
Size sz(getContentSize());
// calculate the full size with the frame accounted for and resize the window to this
sz.d_width += wndArea.getWidth() - renderArea.getWidth();
sz.d_height += wndArea.getHeight() - renderArea.getHeight();
sz.d_width /= System::getSingleton().getRenderer()->getSize().d_width;
sz.d_height /= System::getSingleton().getRenderer()->getSize().d_height;
setSize(Relative,sz);
}
void ToolRender::render(SDL_Surface *on) {
if(tool == -1) {
return;
}
if(tool == SIMULTY_CLIENT_TOOL_ZONE_COM
|| tool == SIMULTY_CLIENT_TOOL_ZONE_RES
|| tool == SIMULTY_CLIENT_TOOL_ZONE_IND
|| tool == SIMULTY_CLIENT_TOOL_BULLDOZER
|| tool == SIMULTY_CLIENT_TOOL_LAND) {
renderArea(on, mr, *camera, toolStartPos, toolEndPos);
} else if(tool == SIMULTY_CLIENT_TOOL_ROAD) {
renderTrail(on, mr, *camera, toolStartPos, toolEndPos);
}
}
void FalagardChatHistory::configureScrollbars()
{
// no scrollbars? Can't configure then!
if(!d_vertScrollbar) return;
Rect initialArea(getTextRenderArea());
//
// Set up scroll bar values
//
Rect renderArea(getTextRenderArea());
d_vertScrollbar->setDocumentSize(d_totalHeight);
d_vertScrollbar->setPageSize(renderArea.getHeight());
d_vertScrollbar->setStepSize(ceguimax(1.0f, renderArea.getHeight() / 10.0f));
d_vertScrollbar->setScrollPosition(d_vertScrollbar->getScrollPosition());
requestRedraw();
d_parentWindow->requestRedraw();
}
/*************************************************************************
display required integrated scroll bars according to current state
of the list box and update their values.
*************************************************************************/
void Listbox::configureScrollbars(void)
{
Scrollbar* vertScrollbar = getVertScrollbar();
Scrollbar* horzScrollbar = getHorzScrollbar();
float totalHeight = getTotalItemsHeight();
float widestItem = getWidestItemWidth();
//
// First show or hide the scroll bars as needed (or requested)
//
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getListRenderArea().getHeight()) || d_forceVertScroll)
{
vertScrollbar->show();
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getListRenderArea().getWidth()) || d_forceHorzScroll)
{
horzScrollbar->show();
}
else
{
horzScrollbar->hide();
}
}
else
{
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getListRenderArea().getWidth()) || d_forceHorzScroll)
{
horzScrollbar->show();
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getListRenderArea().getHeight()) || d_forceVertScroll)
{
vertScrollbar->show();
}
else
{
vertScrollbar->hide();
}
}
else
{
vertScrollbar->hide();
horzScrollbar->hide();
}
}
//
// Set up scroll bar values
//
Rect renderArea(getListRenderArea());
vertScrollbar->setDocumentSize(totalHeight);
vertScrollbar->setPageSize(renderArea.getHeight());
vertScrollbar->setStepSize(ceguimax(1.0f, renderArea.getHeight() / 10.0f));
vertScrollbar->setScrollPosition(vertScrollbar->getScrollPosition());
horzScrollbar->setDocumentSize(widestItem);
horzScrollbar->setPageSize(renderArea.getWidth());
horzScrollbar->setStepSize(ceguimax(1.0f, renderArea.getWidth() / 10.0f));
horzScrollbar->setScrollPosition(horzScrollbar->getScrollPosition());
}
/*************************************************************************
display required integrated scroll bars according to current state
of the edit box and update their values.
*************************************************************************/
void MultiLineEditbox::configureScrollbars(void)
{
float totalHeight = (float)d_lines.size() * getFont()->getLineSpacing();
float widestItem = d_widestExtent;
//
// First show or hide the scroll bars as needed (or requested)
//
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getTextRenderArea().getHeight()) || d_forceVertScroll)
{
d_vertScrollbar->show();
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getTextRenderArea().getWidth()) || d_forceHorzScroll)
{
d_horzScrollbar->show();
}
else
{
d_horzScrollbar->hide();
}
}
else
{
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getTextRenderArea().getWidth()) || d_forceHorzScroll)
{
d_horzScrollbar->show();
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getTextRenderArea().getHeight()) || d_forceVertScroll)
{
d_vertScrollbar->show();
}
else
{
d_vertScrollbar->hide();
}
}
else
{
d_vertScrollbar->hide();
d_horzScrollbar->hide();
}
}
//
// Set up scroll bar values
//
Rect renderArea(getTextRenderArea());
d_vertScrollbar->setDocumentSize(totalHeight);
d_vertScrollbar->setPageSize(renderArea.getHeight());
d_vertScrollbar->setStepSize(ceguimax(1.0f, renderArea.getHeight() / 10.0f));
d_vertScrollbar->setScrollPosition(d_vertScrollbar->getScrollPosition());
d_horzScrollbar->setDocumentSize(widestItem);
d_horzScrollbar->setPageSize(renderArea.getWidth());
d_horzScrollbar->setStepSize(ceguimax(1.0f, renderArea.getWidth() / 10.0f));
d_horzScrollbar->setScrollPosition(d_horzScrollbar->getScrollPosition());
}
QRegion QSGAbstractSoftwareRenderer::optimizeRenderList()
{
// Iterate through the renderlist from front to back
// Objective is to update the dirty status and rects.
for (auto i = m_renderableNodes.rbegin(); i != m_renderableNodes.rend(); ++i) {
auto node = *i;
if (!m_dirtyRegion.isEmpty()) {
// See if the current dirty regions apply to the current node
node->addDirtyRegion(m_dirtyRegion, true);
}
if (!m_obscuredRegion.isEmpty()) {
// Don't try to paint things that are covered by opaque objects
node->subtractDirtyRegion(m_obscuredRegion);
}
// Keep up with obscured regions
if (node->isOpaque()) {
m_obscuredRegion += node->boundingRectMin();
}
if (node->isDirty()) {
// Don't paint things outside of the rendering area
if (!m_background->rect().toRect().contains(node->boundingRectMax(), /*proper*/ true)) {
// Some part(s) of node is(are) outside of the rendering area
QRegion renderArea(m_background->rect().toRect());
QRegion outsideRegions = node->dirtyRegion().subtracted(renderArea);
if (!outsideRegions.isEmpty())
node->subtractDirtyRegion(outsideRegions);
}
// Get the dirty region's to pass to the next nodes
if (node->isOpaque()) {
// if isOpaque, subtract node's dirty rect from m_dirtyRegion
m_dirtyRegion -= node->boundingRectMin();
} else {
// if isAlpha, add node's dirty rect to m_dirtyRegion
m_dirtyRegion += node->dirtyRegion();
}
// if previousDirtyRegion has content outside of boundingRect add to m_dirtyRegion
QRegion prevDirty = node->previousDirtyRegion();
if (!prevDirty.isNull())
m_dirtyRegion += prevDirty;
}
}
if (m_obscuredRegion.contains(m_background->rect().toAlignedRect())) {
m_isOpaque = true;
} else {
m_isOpaque = false;
}
// Empty dirtyRegion (for second pass)
m_dirtyRegion = QRegion();
m_obscuredRegion = QRegion();
// Iterate through the renderlist from back to front
// Objective is to make sure all non-opaque items are painted when an item under them is dirty
for (auto j = m_renderableNodes.begin(); j != m_renderableNodes.end(); ++j) {
auto node = *j;
if (!node->isOpaque() && !m_dirtyRegion.isEmpty()) {
// Only blended nodes need to be updated
node->addDirtyRegion(m_dirtyRegion, true);
}
m_dirtyRegion += node->dirtyRegion();
}
QRegion updateRegion = m_dirtyRegion;
// Empty dirtyRegion
m_dirtyRegion = QRegion();
m_obscuredRegion = QRegion();
return updateRegion;
}
/*************************************************************************
display required integrated scroll bars according to current state
of the list box and update their values.
*************************************************************************/
void Listbox::configureScrollbars(void)
{
Scrollbar* vertScrollbar;
Scrollbar* horzScrollbar;
try
{
vertScrollbar = static_cast<Scrollbar*>(WindowManager::getSingleton().getWindow(getName() + "__auto_vscrollbar__"));
horzScrollbar = static_cast<Scrollbar*>(WindowManager::getSingleton().getWindow(getName() + "__auto_hscrollbar__"));
}
catch (UnknownObjectException)
{
// no scrollbars? Can't configure then!
return;
}
float totalHeight = getTotalItemsHeight();
float widestItem = getWidestItemWidth();
//
// First show or hide the scroll bars as needed (or requested)
//
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getListRenderArea().getHeight()) || d_forceVertScroll)
{
vertScrollbar->show();
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getListRenderArea().getWidth()) || d_forceHorzScroll)
{
horzScrollbar->show();
}
else
{
horzScrollbar->hide();
}
}
else
{
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getListRenderArea().getWidth()) || d_forceHorzScroll)
{
horzScrollbar->show();
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getListRenderArea().getHeight()) || d_forceVertScroll)
{
vertScrollbar->show();
}
else
{
vertScrollbar->hide();
}
}
else
{
vertScrollbar->hide();
horzScrollbar->hide();
}
}
//
// Set up scroll bar values
//
Rect renderArea(getListRenderArea());
vertScrollbar->setDocumentSize(totalHeight);
vertScrollbar->setPageSize(renderArea.getHeight());
vertScrollbar->setStepSize(ceguimax(1.0f, renderArea.getHeight() / 10.0f));
vertScrollbar->setScrollPosition(vertScrollbar->getScrollPosition());
horzScrollbar->setDocumentSize(widestItem);
horzScrollbar->setPageSize(renderArea.getWidth());
horzScrollbar->setStepSize(ceguimax(1.0f, renderArea.getWidth() / 10.0f));
horzScrollbar->setScrollPosition(horzScrollbar->getScrollPosition());
}
/*************************************************************************
display required integrated scroll bars according to current state
of the tree and update their values.
*************************************************************************/
void Tree::configureScrollbars(void)
{
Rectf renderArea(getTreeRenderArea());
//This is becuase CEGUI IS GAY! and fires events before the item is initialized
if(!d_vertScrollbar)
d_vertScrollbar = createVertScrollbar("__auto_vscrollbar__");
if(!d_horzScrollbar)
d_horzScrollbar = createHorzScrollbar("__auto_hscrollbar__");
float totalHeight = getTotalItemsHeight();
float widestItem = getWidestItemWidth() + 20;
//
// First show or hide the scroll bars as needed (or requested)
//
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > renderArea.getHeight()) || d_forceVertScroll)
{
d_vertScrollbar->show();
renderArea.d_max.d_x -= d_vertScrollbar->getWidth().d_offset + d_vertScrollbar->getXPosition().d_offset;
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > renderArea.getWidth()) || d_forceHorzScroll)
{
d_horzScrollbar->show();
renderArea.d_max.d_y -= d_horzScrollbar->getHeight().d_offset;
}
else
{
d_horzScrollbar->hide();
d_horzScrollbar->setScrollPosition(0);
}
}
else
{
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > renderArea.getWidth()) || d_forceHorzScroll)
{
d_horzScrollbar->show();
renderArea.d_max.d_y -= d_vertScrollbar->getHeight().d_offset;
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > renderArea.getHeight()) || d_forceVertScroll)
{
d_vertScrollbar->show();
// renderArea.d_right -= d_vertScrollbar->getAbsoluteWidth();
renderArea.d_max.d_x -= d_vertScrollbar->getWidth().d_offset;
}
else
{
d_vertScrollbar->hide();
d_vertScrollbar->setScrollPosition(0);
}
}
else
{
d_vertScrollbar->hide();
d_vertScrollbar->setScrollPosition(0);
d_horzScrollbar->hide();
d_horzScrollbar->setScrollPosition(0);
}
}
//
// Set up scroll bar values
//
float itemHeight;
if (!d_listItems.empty())
itemHeight = d_listItems[0]->getPixelSize().d_height;
else
itemHeight = 10;
d_vertScrollbar->setDocumentSize(totalHeight);
d_vertScrollbar->setPageSize(renderArea.getHeight());
d_vertScrollbar->setStepSize(ceguimax(1.0f, renderArea.getHeight() / itemHeight));
d_vertScrollbar->setScrollPosition(d_vertScrollbar->getScrollPosition());
d_horzScrollbar->setDocumentSize(widestItem + d_vertScrollbar->getWidth().d_offset);
// d_horzScrollbar->setDocumentSize(widestItem + d_vertScrollbar->getAbsoluteWidth());
d_horzScrollbar->setPageSize(renderArea.getWidth());
d_horzScrollbar->setStepSize(ceguimax(1.0f, renderArea.getWidth() / HORIZONTAL_STEP_SIZE_DIVISOR));
d_horzScrollbar->setScrollPosition(d_horzScrollbar->getScrollPosition());
}
void MovieRenderer::Imp::prepareForStart()
{
struct locals {
static void eraseUncompatibleExistingLevel(const TFilePath &fp, const TDimension &imageSize) // nothrow
{
assert(!fp.isEmpty());
if (TSystem::doesExistFileOrLevel(fp)) {
bool remove = false;
// In case the raster specifics are different from those of a currently
// existing movie, erase it
try {
TLevelReaderP lr(fp);
lr->loadInfo();
const TImageInfo *info = lr->getImageInfo();
if (!info || info->m_lx != imageSize.lx || info->m_ly != imageSize.ly)
TSystem::removeFileOrLevel(fp); // nothrow
} catch (...) {
// Same if the level could not be read/opened
TSystem::removeFileOrLevel(fp); // nothrow
}
// NOTE: The level removal procedure could still fail.
// In this case, no signaling takes place. The level readers will throw
// when the time to write on the file comes, leading to a render failure.
}
}
};
TOutputProperties *oprop = m_scene->getProperties()->getOutputProperties();
double frameRate = (double)oprop->getFrameRate();
/*-- Frame rate の stretch --*/
double stretchFactor = oprop->getRenderSettings().m_timeStretchTo / oprop->getRenderSettings().m_timeStretchFrom;
frameRate *= stretchFactor;
// Get the shrink
int shrinkX = m_renderSettings.m_shrinkX, shrinkY = m_renderSettings.m_shrinkY;
//Build the render area
TPointD cameraPos(-0.5 * m_frameSize.lx, -0.5 * m_frameSize.ly);
TDimensionD cameraRes(double(m_frameSize.lx) / shrinkX, double(m_frameSize.ly) / shrinkY);
TDimension cameraResI(cameraRes.lx, cameraRes.ly);
TRectD renderArea(cameraPos.x, cameraPos.y, cameraPos.x + cameraRes.lx, cameraPos.y + cameraRes.ly);
setRenderArea(renderArea);
if (!m_fp.isEmpty()) {
try // Construction of a LevelUpdater may throw (well, almost ANY operation on a LevelUpdater
{ // could throw). But due to backward compatibility this function is assumed to be non-throwing.
if (!m_renderSettings.m_stereoscopic) {
locals::eraseUncompatibleExistingLevel(m_fp, cameraResI);
m_levelUpdaterA.reset(new LevelUpdater(m_fp, oprop->getFileFormatProperties(m_fp.getType())));
m_levelUpdaterA->getLevelWriter()->setFrameRate(frameRate);
} else {
TFilePath leftFp = m_fp.withName(m_fp.getName() + "_l");
TFilePath rightFp = m_fp.withName(m_fp.getName() + "_r");
locals::eraseUncompatibleExistingLevel(leftFp, cameraResI);
locals::eraseUncompatibleExistingLevel(rightFp, cameraResI);
m_levelUpdaterA.reset(new LevelUpdater(leftFp, oprop->getFileFormatProperties(leftFp.getType())));
m_levelUpdaterA->getLevelWriter()->setFrameRate(frameRate);
m_levelUpdaterB.reset(new LevelUpdater(rightFp, oprop->getFileFormatProperties(rightFp.getType())));
m_levelUpdaterB->getLevelWriter()->setFrameRate(frameRate);
}
} catch (...) {
// If we get here, it's because one of the LevelUpdaters could not be created. So, let's say
// that if one could not be created, then ALL OF THEM couldn't (ie saving is not possible at all).
m_levelUpdaterA.reset();
m_levelUpdaterB.reset();
}
}
}
