void QniteXYArtist::processData() {
if (qMin(xValues().size(), yValues().size()) < 1) {
return;
}
// get bounds
qreal xLower = axes()->axisX()->lowerBound();
qreal xUpper = axes()->axisX()->upperBound();
qreal yLower = axes()->axisY()->lowerBound();
qreal yUpper = axes()->axisY()->upperBound();
// TODO: this should be improved. clipping should be done only when bounds
// changes and tranforsm should always be performed
QMap<int, qreal> xClipped;
QMap<int, qreal> yClipped;
// clip non visible data
if (clipper() != nullptr) {
clipper()->clip(m_xValues, m_yValues, xLower, xUpper, yLower, yUpper,
xClipped, yClipped);
} else {
xClipped = m_xValues;
yClipped = m_yValues;
}
// map to display
m_xMapped = xMapper()->mapTo(xLower, xUpper, 0, width(), xClipped);
m_yMapped = yMapper()->mapTo(yLower, yUpper, 0, height(), yClipped, true);
// TODO: this is ugly and inefficient. move into a pipelino or something
// similar move to the output area
m_xProcessed = m_xMapped.values();
m_yProcessed = m_yMapped.values();
}
QwtArray<QwtDoubleInterval> QwtClipper::clipCircle(
const QwtDoubleRect &clipRect,
const QwtDoublePoint ¢er, double radius)
{
QwtCircleClipper clipper(clipRect);
return clipper.clipCircle(center, radius);
}
void Gfx::bltNoMaskNoScale(const Common::Rect& r, byte *data, Graphics::Surface *surf, byte transparentColor) {
Common::Point dp;
Common::Rect q(r);
Common::Rect clipper(surf->w, surf->h);
q.clip(clipper);
if (!q.isValidRect()) return;
dp.x = q.left;
dp.y = q.top;
q.translate(-r.left, -r.top);
byte *s = data + q.left + q.top * r.width();
byte *d = (byte *)surf->getBasePtr(dp.x, dp.y);
uint sPitch = r.width() - q.width();
uint dPitch = surf->w - q.width();
for (uint16 i = q.top; i < q.bottom; i++) {
for (uint16 j = q.left; j < q.right; j++) {
if (*s != transparentColor)
*d = *s;
s++;
d++;
}
s += sPitch;
d += dPitch;
}
}
//--------------------------------------------
// --
//--------------------------------------------
void GeneralViewer::RenderStackWnd()
{
ImGui::SetNextWindowPos(ImVec2(405, 150));
if (ImGui::Begin("Stack", nullptr, ImVec2(150, 318), 1.0f, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings))
{
u16 sp = mCpu.GetRegSP();
if (sp != 0)
{
float lineHeight = ImGui::GetTextLineHeight();
int lineTotalCount = (mCpu.GetSPStartAddr() - sp) >> 1;
ImGui::BeginChild("##stack_scrolling", ImVec2(0, 0));
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
ImGuiListClipper clipper(lineTotalCount, lineHeight);
int addr = sp;
for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
{
ImGui::Text("%0*X", 4, mMmu.ReadU16(addr));
addr += 2;
}
clipper.End();
ImGui::PopStyleVar(2);
ImGui::EndChild();
}
bool SkMaskFilter::filterPath(const SkPath& devPath, const SkMatrix& matrix,
const SkRegion& clip, SkBounder* bounder,
SkBlitter* blitter)
{
SkMask srcM, dstM;
if (!SkDraw::DrawToMask(devPath, &clip.getBounds(), this, &matrix, &srcM,
SkMask::kComputeBoundsAndRenderImage_CreateMode))
{
return false;
}
SkAutoMaskImage autoSrc(&srcM, false);
if (!this->filterMask(&dstM, srcM, matrix, NULL))
return false;
SkAutoMaskImage autoDst(&dstM, false);
SkRegion::Cliperator clipper(clip, dstM.fBounds);
if (!clipper.done() && (bounder == NULL || bounder->doIRect(dstM.fBounds)))
{
const SkIRect& cr = clipper.rect();
do {
blitter->blitMask(dstM, cr);
clipper.next();
} while (!clipper.done());
}
return true;
}
// ----------------------------------------------------------------------------
// Creates a Clipper object in device memory for use in clipping operations
// ----------------------------------------------------------------------------
CClipGeometry::Clipper * CClipGroup::clipper()
{
if (!m_handle)
{
VOX_CUDA_CHECK(cudaMalloc((void**)&m_handle, sizeof(Data)));
std::vector<CClipGeometry::Clipper*> clippers;
BOOST_FOREACH (auto & child, m_primGroup->children())
if (child->isVisible())
{
auto elem = CClipGeometry::create(child);
clippers.push_back(elem->clipper());
m_children.push_back(elem);
}
m_buffer.write(clippers);
Data data;
data.clipper.func = RenderKernel::getCClipGroupFunc();
memcpy(&data.children, &m_buffer, sizeof(m_buffer));
VOX_CUDA_CHECK(cudaMemcpy(m_handle, &data, sizeof(Data), cudaMemcpyHostToDevice));
}
void widget::bg_restore(SDL_Rect const &rect) const
{
clip_rect_setter clipper(video().getSurface(), &clip_rect_, clip_);
for(std::vector< surface_restorer >::const_iterator i = restorer_.begin(),
i_end = restorer_.end(); i != i_end; ++i)
i->restore(rect);
}
void ClipPoints(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simdvector prims[], uint32_t primMask, simdscalari primId, simdscalari viewportIdx)
{
SWR_CONTEXT *pContext = pDC->pContext;
AR_BEGIN(FEClipPoints, pDC->drawId);
Clipper<1> clipper(workerId, pDC);
clipper.ExecuteStage(pa, prims, primMask, primId, viewportIdx);
AR_END(FEClipPoints, 1);
}
bool SkMaskFilterBase::filterPath(const SkPath& devPath, const SkMatrix& matrix,
const SkRasterClip& clip, SkBlitter* blitter,
SkStrokeRec::InitStyle style) const {
SkRect rects[2];
int rectCount = 0;
if (SkStrokeRec::kFill_InitStyle == style) {
rectCount = countNestedRects(devPath, rects);
}
if (rectCount > 0) {
NinePatch patch;
switch (this->filterRectsToNine(rects, rectCount, matrix, clip.getBounds(), &patch)) {
case kFalse_FilterReturn:
SkASSERT(nullptr == patch.fMask.fImage);
return false;
case kTrue_FilterReturn:
draw_nine(patch.fMask, patch.fOuterRect, patch.fCenter, 1 == rectCount, clip,
blitter);
return true;
case kUnimplemented_FilterReturn:
SkASSERT(nullptr == patch.fMask.fImage);
// fall through
break;
}
}
SkMask srcM, dstM;
if (!SkDraw::DrawToMask(devPath, &clip.getBounds(), this, &matrix, &srcM,
SkMask::kComputeBoundsAndRenderImage_CreateMode,
style)) {
return false;
}
SkAutoMaskFreeImage autoSrc(srcM.fImage);
if (!this->filterMask(&dstM, srcM, matrix, nullptr)) {
return false;
}
SkAutoMaskFreeImage autoDst(dstM.fImage);
// if we get here, we need to (possibly) resolve the clip and blitter
SkAAClipBlitterWrapper wrapper(clip, blitter);
blitter = wrapper.getBlitter();
SkRegion::Cliperator clipper(wrapper.getRgn(), dstM.fBounds);
if (!clipper.done()) {
const SkIRect& cr = clipper.rect();
do {
blitter->blitMask(dstM, cr);
clipper.next();
} while (!clipper.done());
}
return true;
}
void SkScan::FillPath(const SkPath& path, const SkRegion& origClip,
SkBlitter* blitter) {
if (origClip.isEmpty()) {
return;
}
// Our edges are fixed-point, and don't like the bounds of the clip to
// exceed that. Here we trim the clip just so we don't overflow later on
const SkRegion* clipPtr = &origClip;
SkRegion finiteClip;
if (clip_to_limit(origClip, &finiteClip)) {
if (finiteClip.isEmpty()) {
return;
}
clipPtr = &finiteClip;
}
// don't reference "origClip" any more, just use clipPtr
SkRect bounds = path.getBounds();
bool irPreClipped = false;
if (!SkRectPriv::MakeLargeS32().contains(bounds)) {
if (!bounds.intersect(SkRectPriv::MakeLargeS32())) {
bounds.setEmpty();
}
irPreClipped = true;
}
SkIRect ir = conservative_round_to_int(bounds);
if (ir.isEmpty()) {
if (path.isInverseFillType()) {
blitter->blitRegion(*clipPtr);
}
return;
}
SkScanClipper clipper(blitter, clipPtr, ir, path.isInverseFillType(), irPreClipped);
blitter = clipper.getBlitter();
if (blitter) {
// we have to keep our calls to blitter in sorted order, so we
// must blit the above section first, then the middle, then the bottom.
if (path.isInverseFillType()) {
sk_blit_above(blitter, ir, *clipPtr);
}
SkASSERT(clipper.getClipRect() == nullptr ||
*clipper.getClipRect() == clipPtr->getBounds());
sk_fill_path(path, clipPtr->getBounds(), blitter, ir.fTop, ir.fBottom,
0, clipper.getClipRect() == nullptr);
if (path.isInverseFillType()) {
sk_blit_below(blitter, ir, *clipPtr);
}
} else {
// what does it mean to not have a blitter if path.isInverseFillType???
}
}
void widget::bg_restore(SDL_Rect const &rect) const
{
util::scoped_ptr<clip_rect_setter> clipper(NULL);
if (clip_)
clipper.assign(new clip_rect_setter(video().getSurface(), clip_rect_));
for(std::vector< surface_restorer >::const_iterator i = restorer_.begin(),
i_end = restorer_.end(); i != i_end; ++i)
i->restore(rect);
}
static void
glw_renderer_clip_tesselate(glw_renderer_t *gr, glw_root_t *root,
glw_rctx_t *rc, glw_renderer_cache_t *grc)
{
int i;
uint16_t *ip = gr->gr_indices;
const float *a = gr->gr_vertices;
PMtx pmtx;
root->gr_vtmp_size = 0;
memcpy(grc->grc_mtx, rc->rc_mtx, sizeof(Mtx));
grc->grc_active_clippers = root->gr_active_clippers;
for(i = 0; i < NUM_CLIPPLANES; i++)
if((1 << i) & root->gr_active_clippers)
memcpy(&grc->grc_clip[i], &root->gr_clip[i], sizeof(Vec4));
glw_pmtx_mul_prepare(pmtx, rc->rc_mtx);
for(i = 0; i < gr->gr_num_triangles; i++) {
int v1 = *ip++;
int v2 = *ip++;
int v3 = *ip++;
Vec3 V1, V2, V3;
glw_pmtx_mul_vec3(V1, pmtx, glw_vec3_get(a + v1*9));
glw_pmtx_mul_vec3(V2, pmtx, glw_vec3_get(a + v2*9));
glw_pmtx_mul_vec3(V3, pmtx, glw_vec3_get(a + v3*9));
clipper(root, grc,
V1, V2, V3,
glw_vec4_get(a + v1 * 9 + 5),
glw_vec4_get(a + v2 * 9 + 5),
glw_vec4_get(a + v3 * 9 + 5),
glw_vec2_get(a + v1 * 9 + 3),
glw_vec2_get(a + v2 * 9 + 3),
glw_vec2_get(a + v3 * 9 + 3),
0);
}
int size = root->gr_vtmp_size * sizeof(float) * VERTEX_SIZE;
if(root->gr_vtmp_size != grc->grc_num_vertices) {
grc->grc_num_vertices = root->gr_vtmp_size;
free(grc->grc_vertices);
grc->grc_vertices = size ? malloc(size) : NULL;
}
if(size)
memcpy(grc->grc_vertices, root->gr_vtmp_buffer, size);
}
void SVGResources::layoutDifferentRootIfNeeded(const RenderSVGRoot* svgRoot)
{
if (clipper() && svgRoot != SVGRenderSupport::findTreeRootObject(*clipper()))
clipper()->layoutIfNeeded();
if (masker() && svgRoot != SVGRenderSupport::findTreeRootObject(*masker()))
masker()->layoutIfNeeded();
if (filter() && svgRoot != SVGRenderSupport::findTreeRootObject(*filter()))
filter()->layoutIfNeeded();
if (markerStart() && svgRoot != SVGRenderSupport::findTreeRootObject(*markerStart()))
markerStart()->layoutIfNeeded();
if (markerMid() && svgRoot != SVGRenderSupport::findTreeRootObject(*markerMid()))
markerMid()->layoutIfNeeded();
if (markerEnd() && svgRoot != SVGRenderSupport::findTreeRootObject(*markerEnd()))
markerEnd()->layoutIfNeeded();
}
void wxControl::MacRedrawControl()
{
if ( (ControlHandle) m_macControl && MacGetRootWindow() && m_macControlIsShown )
{
wxClientDC dc(this) ;
wxMacPortSetter helper(&dc) ;
wxMacWindowClipper clipper(this) ;
wxDC::MacSetupBackgroundForCurrentPort( MacGetBackgroundBrush() ) ;
UMADrawControl( (ControlHandle) m_macControl ) ;
}
}
std::vector<PolygonsPart> Polygons::splitIntoParts(bool unionAll) const
{
std::vector<PolygonsPart> ret;
ClipperLib::Clipper clipper(clipper_init);
ClipperLib::PolyTree resultPolyTree;
clipper.AddPaths(polygons, ClipperLib::ptSubject, true);
if (unionAll)
clipper.Execute(ClipperLib::ctUnion, resultPolyTree, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
else
clipper.Execute(ClipperLib::ctUnion, resultPolyTree);
splitIntoParts_processPolyTreeNode(&resultPolyTree, ret);
return ret;
}
void widget::draw()
{
if (hidden() || !dirty())
return;
bg_restore();
clip_rect_setter clipper(video().getSurface(), &clip_rect_, clip_);
draw_contents();
update_rect(rect_);
set_dirty(false);
}
void widget::bg_restore() const
{
clip_rect_setter clipper(video().getSurface(), &clip_rect_, clip_);
if (needs_restore_) {
for(std::vector< surface_restorer >::const_iterator i = restorer_.begin(),
i_end = restorer_.end(); i != i_end; ++i)
i->restore();
needs_restore_ = false;
} else {
//this function should be able to be relied upon to update the rectangle,
//so do that even if we don't restore
update_rect(rect_);
}
}
void wxControl::OnPaint(wxPaintEvent& event)
{
if ( (ControlHandle) m_macControl )
{
wxPaintDC dc(this) ;
wxMacPortSetter helper(&dc) ;
wxMacWindowClipper clipper(this) ;
wxDC::MacSetupBackgroundForCurrentPort( MacGetBackgroundBrush() ) ;
UMADrawControl( (ControlHandle) m_macControl ) ;
}
else
{
event.Skip() ;
}
}
void widget::draw()
{
if (hidden() ) //|| !dirty()) // KP: always assume dirty with openGL rendering
return;
bg_restore();
util::scoped_ptr<clip_rect_setter> clipper(NULL);
if (clip_)
clipper.assign(new clip_rect_setter(/*video().getSurface(),*/ clip_rect_));
draw_contents();
// update_rect(rect_);
// set_dirty(false);
}
static void draw_nine(const SkMask& mask, const SkIRect& outerR, const SkIPoint& center,
bool fillCenter, const SkRasterClip& clip, SkBlitter* blitter) {
// if we get here, we need to (possibly) resolve the clip and blitter
SkAAClipBlitterWrapper wrapper(clip, blitter);
blitter = wrapper.getBlitter();
SkRegion::Cliperator clipper(wrapper.getRgn(), outerR);
if (!clipper.done()) {
const SkIRect& cr = clipper.rect();
do {
draw_nine_clipped(mask, outerR, center, fillCenter, cr, blitter);
clipper.next();
} while (!clipper.done());
}
}
void widget::draw()
{
if (hidden() || !dirty())
return;
bg_restore();
util::scoped_ptr<clip_rect_setter> clipper(NULL);
if (clip_)
clipper.assign(new clip_rect_setter(video().getSurface(), clip_rect_));
draw_contents();
update_rect(rect_);
set_dirty(false);
}
void Gfx::bltMaskNoScale(const Common::Rect& r, byte *data, Graphics::Surface *surf, uint16 z, byte transparentColor) {
if (!_backgroundInfo->hasMask() || (z == LAYER_FOREGROUND)) {
// use optimized path
bltNoMaskNoScale(r, data, surf, transparentColor);
return;
}
Common::Point dp;
Common::Rect q(r);
Common::Rect clipper(surf->w, surf->h);
q.clip(clipper);
if (!q.isValidRect()) return;
dp.x = q.left;
dp.y = q.top;
q.translate(-r.left, -r.top);
byte *s = data + q.left + q.top * r.width();
byte *d = (byte *)surf->getBasePtr(dp.x, dp.y);
uint sPitch = r.width() - q.width();
uint dPitch = surf->w - q.width();
for (uint16 i = 0; i < q.height(); i++) {
for (uint16 j = 0; j < q.width(); j++) {
if (*s != transparentColor) {
if (_backgroundInfo->hasMask()) {
byte v = _backgroundInfo->_mask->getValue(dp.x + j, dp.y + i);
if (z >= v) *d = *s;
} else {
*d = *s;
}
}
s++;
d++;
}
s += sPitch;
d += dPitch;
}
}
PartsView Polygons::splitIntoPartsView(bool unionAll)
{
Polygons reordered;
PartsView partsView(*this);
ClipperLib::Clipper clipper(clipper_init);
ClipperLib::PolyTree resultPolyTree;
clipper.AddPaths(polygons, ClipperLib::ptSubject, true);
if (unionAll)
clipper.Execute(ClipperLib::ctUnion, resultPolyTree, ClipperLib::pftNonZero, ClipperLib::pftNonZero);
else
clipper.Execute(ClipperLib::ctUnion, resultPolyTree);
splitIntoPartsView_processPolyTreeNode(partsView, reordered, &resultPolyTree);
(*this) = reordered;
return partsView;
}
void menu::draw()
{
if(hidden()) {
return;
}
/* if(!dirty())
{
for(std::set<int>::const_iterator i = invalid_.begin(); i != invalid_.end(); ++i) {
if(*i == -1) {
SDL_Rect heading_rect = inner_location();
heading_rect.h = heading_height();
bg_restore(heading_rect);
style_->draw_row(*this,0,heading_rect,HEADING_ROW);
//update_rect(heading_rect);
} else if(*i >= 0 && *i < int(item_pos_.size())) {
const unsigned int pos = item_pos_[*i];
const SDL_Rect& rect = get_item_rect(*i);
bg_restore(rect);
style_->draw_row(*this,pos,rect,
(!out_ && pos == selected_) ? SELECTED_ROW : NORMAL_ROW);
//update_rect(rect);
}
}
invalid_.clear();
return;
}
*/
invalid_.clear();
bg_restore();
util::scoped_ptr<clip_rect_setter> clipper(NULL);
if(clip_rect())
clipper.assign(new clip_rect_setter(/*video().getSurface(),*/ *clip_rect()));
draw_contents();
// update_rect(location());
set_dirty(false);
}
void wxStdRenderer::DrawStatusField(wxDC& dc,
const wxRect& rect,
const wxString& label,
int flags,
int style)
{
wxRect rectIn;
if ( style == wxSB_RAISED )
DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn);
else if ( style != wxSB_FLAT )
DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn);
rectIn.Deflate(GetStatusBarFieldMargins());
wxDCClipper clipper(dc, rectIn);
DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL);
}
void AudioRenderer::Render(wxDC &dc, wxPoint origin, int start, int length, AudioRenderingStyle style)
{
assert(start >= 0);
if (!provider) return;
if (!renderer) return;
if (length <= 0) return;
// One past last absolute pixel strip to render
int end = start + length;
// One past last X coordinate to render on
int lastx = origin.x + length;
// Figure out which range of bitmaps are required
int firstbitmap = start / cache_bitmap_width;
// And the offset in it to start its use at
int firstbitmapoffset = start % cache_bitmap_width;
// The last bitmap required
int lastbitmap = std::min<int>(end / cache_bitmap_width, NumBlocks(provider->GetDecodedSamples()) - 1);
// Set a clipping region so that the first and last bitmaps don't draw
// outside the requested range
wxDCClipper clipper(dc, wxRect(origin, wxSize(length, pixel_height)));
origin.x -= firstbitmapoffset;
for (int i = firstbitmap; i <= lastbitmap; ++i)
{
dc.DrawBitmap(*GetCachedBitmap(i, style), origin);
origin.x += cache_bitmap_width;
}
// Now render blank audio from origin to end
if (origin.x < lastx)
renderer->RenderBlank(dc, wxRect(origin.x-1, origin.y, lastx-origin.x+1, pixel_height), style);
if (needs_age)
{
bitmaps[style].Age(cache_bitmap_maxsize);
renderer->AgeCache(cache_renderer_maxsize);
needs_age = false;
}
}
void SkScan::FillTriangle(const SkPoint pts[], const SkRasterClip& clip,
SkBlitter* blitter) {
if (clip.isEmpty()) {
return;
}
SkRect r;
r.set(pts, 3);
// If r is too large (larger than can easily fit in SkFixed) then we need perform geometric
// clipping. This is a bit of work, so we just call the general FillPath() to handle it.
// Use FixedMax/2 as the limit so we can subtract two edges and still store that in Fixed.
const SkScalar limit = SK_MaxS16 >> 1;
if (!SkRect::MakeLTRB(-limit, -limit, limit, limit).contains(r)) {
SkPath path;
path.addPoly(pts, 3, false);
FillPath(path, clip, blitter);
return;
}
SkIRect ir = conservative_round_to_int(r);
if (ir.isEmpty() || !SkIRect::Intersects(ir, clip.getBounds())) {
return;
}
SkAAClipBlitterWrapper wrap;
const SkRegion* clipRgn;
if (clip.isBW()) {
clipRgn = &clip.bwRgn();
} else {
wrap.init(clip, blitter);
clipRgn = &wrap.getRgn();
blitter = wrap.getBlitter();
}
SkScanClipper clipper(blitter, clipRgn, ir);
blitter = clipper.getBlitter();
if (blitter) {
sk_fill_triangle(pts, clipper.getClipRect(), blitter, ir);
}
}
void NetList::Draw(const char *title, bool *p_open, Board *board) {
// TODO: export / fix dimensions & behaviour
int width = 400;
int height = 640;
ImGui::SetNextWindowSize(ImVec2(width, height));
ImGui::Begin("Net List");
ImGui::Columns(1, "part_infos");
ImGui::Separator();
ImGui::Text("Name");
ImGui::NextColumn();
ImGui::Separator();
if (board) {
auto nets = board->Nets();
ImGuiListClipper clipper(nets.size(), ImGui::GetTextLineHeight());
static int selected = -1;
string net_name = "";
for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++) {
net_name = nets[i]->name;
if (ImGui::Selectable(
net_name.c_str(), selected == i, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowDoubleClick)) {
selected = i;
if (ImGui::IsMouseDoubleClicked(0)) {
cbNetSelected_(net_name.c_str());
}
}
ImGui::NextColumn();
}
clipper.End();
}
ImGui::Columns(1);
ImGui::Separator();
ImGui::End();
}
void CPFRotatingText::renderRotatingText()
{
Font* font = d_window->getFont();
// can't render text without a font :)
if( font==NULL){
return;
}
// get destination area for the text.
Rect absarea(getTextRenderArea());
Rect clipper(absarea);
float textHeight = font->getFormattedLineCount(d_window->getText(), absarea, (TextFormatting)d_horzFormatting) * font->getLineSpacing();
Scrollbar* vertScrollbar = getVertScrollbar();
Scrollbar* horzScrollbar = getHorzScrollbar();
// calculate X offset
static float xOffset = horzScrollbar->getPageSize();
if( xOffset<-(horzScrollbar->getDocumentSize()+horzScrollbar->getPageSize()) ){
xOffset = horzScrollbar->getPageSize();
}
static boost::system_time previous_time = boost::get_system_time();
boost::system_time time = boost::get_system_time();
boost::system_time::time_duration_type time_step = (time-previous_time);
xOffset -= (static_cast<float>(time_step.total_milliseconds())*d_textSpeed);
previous_time = time;
absarea.offset(Point(xOffset, 0));
// see if we may need to adjust horizontal position
if( horzScrollbar->isVisible() ){
switch(d_horzFormatting)
{
case LeftAligned:
case WordWrapLeftAligned:
case Justified:
case WordWrapJustified:
absarea.offset(Point(-horzScrollbar->getScrollPosition(), 0));
break;
case Centred:
case WordWrapCentred:
absarea.setWidth(horzScrollbar->getDocumentSize());
absarea.offset(Point(-horzScrollbar->getScrollPosition(), 0));
break;
case RightAligned:
case WordWrapRightAligned:
absarea.offset(Point(horzScrollbar->getScrollPosition(), 0));
break;
}
}
// adjust y positioning according to formatting option
switch(d_vertFormatting)
{
case TopAligned:
absarea.d_top -= vertScrollbar->getScrollPosition();
break;
case VertCentred:
// if scroll bar is in use, act like TopAligned
if( vertScrollbar->isVisible() ){
absarea.d_top -= vertScrollbar->getScrollPosition();
}
// no scroll bar, so centre text instead.
else{
absarea.d_top += PixelAligned((absarea.getHeight() - textHeight) * 0.5f);
}
break;
case BottomAligned:
absarea.d_top = absarea.d_bottom - textHeight;
absarea.d_top += vertScrollbar->getScrollPosition();
break;
}
// offset the font little down so that it's centered within its own spacing
absarea.d_top += (font->getLineSpacing() - font->getFontHeight()) * 0.5f;
// calculate final colours
ColourRect final_cols(d_textCols);
final_cols.modulateAlpha(d_window->getEffectiveAlpha());
// cache the text for rendering.
d_window->getRenderCache().cacheText(d_window->getText(), font, (TextFormatting)d_horzFormatting, absarea, 0, final_cols, &clipper);
}
int msHatchPolygon(imageObj *img, shapeObj *poly, double spacing, double width, double *pattern, int patternlength, double angle, colorObj *color)
{
assert(MS_RENDERER_PLUGIN(img->format));
msComputeBounds(poly);
/* amount we should expand the bounding box by */
double exp = width * 0.7072;
/* width and height of the bounding box we will be creating the hatch in */
int pw=(int)(poly->bounds.maxx-poly->bounds.minx+exp*2)+1;
int ph=(int)(poly->bounds.maxy-poly->bounds.miny+exp*2)+1;
/* position of the top-left corner of the bounding box */
double ox = poly->bounds.minx - exp;
double oy = poly->bounds.miny - exp;
//create a rectangular hatch of size pw,ph starting at 0,0
//the created hatch is of the size of the shape's bounding box
mapserver::path_storage hatch = createHatch(ox,oy,
img->refpt.x,img->refpt.y,pw,ph,angle,spacing);
if(hatch.total_vertices()<=0) return MS_SUCCESS;
//translate the hatch so it overlaps the current shape
hatch.transform(mapserver::trans_affine_translation(ox,oy));
polygon_adaptor polygons(poly);
if(patternlength>1) {
//dash the hatch and render it clipped by the shape
mapserver::conv_dash<mapserver::path_storage > dash(hatch);
mapserver::conv_stroke<mapserver::conv_dash<mapserver::path_storage> > stroke(dash);
for (int i=0; i<patternlength; i+=2) {
if (i < patternlength-1) {
dash.add_dash(pattern[i], pattern[i+1]);
}
}
stroke.width(width);
stroke.line_cap(mapserver::butt_cap);
mapserver::conv_clipper<polygon_adaptor,mapserver::conv_stroke<mapserver::conv_dash<mapserver::path_storage> > > clipper(polygons,stroke, mapserver::clipper_and);
renderPolygonHatches(img,clipper,color);
} else {
//render the hatch clipped by the shape
mapserver::conv_stroke <mapserver::path_storage > stroke(hatch);
stroke.width(width);
stroke.line_cap(mapserver::butt_cap);
mapserver::conv_clipper<polygon_adaptor,mapserver::conv_stroke<mapserver::path_storage> > clipper(polygons,stroke, mapserver::clipper_and);
renderPolygonHatches(img,clipper,color);
}
//assert(prevCmd == mapserver::path_cmd_line_to);
//delete lines;
return MS_SUCCESS;
}