static void justify(char *fromnum, char *tonum, TELNUM number) { register char *p1, *p2; auto char s[BUFSIZ], sx[BUFSIZ], sy[BUFSIZ]; /* AK:16-Dec-99 */ /* Hier ist noch ein Bug in normalizeNumber(), Leo! */ /* Bei Sonderrufnummern landet die komplette Nummer in number.area, */ /* wobei die letzten 2 Digits abgeschnitten sind (fehlen) */ if (!*number.msn) { strcpy(number.msn, c.dialout ? tonum : fromnum); *number.area = 0; } /* if */ p1 = numtonam(c.dialout ? CALLED : CALLING, 1); if (*number.msn) sprintf(sx, "%s%s%s", number.area, (*number.area ? "/" : ""), number.msn); else strcpy(sx, number.area); if (*number.country && strcmp(number.country, mycountry)) sprintf(s, "%s %s", number.country, sx); else sprintf(s, "%s%s", (*number.country ? "0" : ""), sx); p2 = msnsum[SUBTOTAL][c.si1][c.ihome].alias; printf("%12s %s %-21s", p2 ? p2 : fromnum, (c.dialout ? "->" : "<-"), p1 ? clip(p1, 20) : s); *s = 0; if (*tonum && getSpecial(tonum)) sprintf(s, "%s", getSpecialName(tonum)); else { if (*number.country && strcmp(number.country, mycountry)) sprintf(s, "%s", number.scountry); else if (*number.scountry && strcmp(number.country, mycountry)) sprintf(s, "%s", number.scountry); if (*number.sarea) { if (*s) strcat(s, ", "); strcat(s, number.sarea); if (c.dialout) { sprintf(sy, ",%d", c.zone); strcat(s, sy); } /* if */ } /* if */ if (!*s && *tonum) sprintf(s, "???"); } /* else */ s[COUNTRYLEN] = 0; /* clipping */ sprintf(c.country, "%-*s", COUNTRYLEN, s); } /* justify */
BOOL TapeLab::paintlabel(PMPresSpace& ps) { ps.setColor(CLR_BLACK); // righe orizzontali int i; for (i=0; i<=labelformat.flaps; i++) { if (i>0 && i<labelformat.flaps) ps.setLineType(LINETYPE_DOT); else ps.setLineType(LINETYPE_DEFAULT); ps.move(&fixpoints[labelformat.size][i*2]); ps.line(&fixpoints[labelformat.size][i*2+1]); } // righe verticali ps.move(&fixpoints[labelformat.size][0]); ps.line(&fixpoints[labelformat.size][ labelformat.flaps * 2 ]); ps.move(&fixpoints[labelformat.size][1]); ps.line(&fixpoints[labelformat.size][ ( labelformat.flaps * 2 ) + 1 ]); // esegue clip dentro a rettangolo dell'etichetta! PMRect clip(fixpoints[labelformat.size][labelformat.flaps*2],fixpoints[labelformat.size][1]); ps.intersectClipRectangle(&clip); // titolo PMPoint a; if (labelformat.title2[0] != '\0') { // ci sono 2 titoli a.y=(fixpoints[labelformat.size][2].y+fixpoints[labelformat.size][4].y)/2; a.x=fixpoints[labelformat.size][2].x+labelformat.form.titlelm; a.y=a.y+ (((fixpoints[labelformat.size][2].y-fixpoints[labelformat.size][4].y)/2)-pts2dmm(labelformat.title1font.height))/2 ; paintString(labelformat.title1,&labelformat.title1font,1000L,a,ps); a.y=fixpoints[labelformat.size][4].y; a.x=fixpoints[labelformat.size][2].x+labelformat.form.titlelm; a.y=a.y+ (((fixpoints[labelformat.size][2].y-fixpoints[labelformat.size][4].y)/2)-pts2dmm(labelformat.title2font.height))/2 ; paintString(labelformat.title2,&labelformat.title2font,1000L,a,ps); } else { // c'e' un solo titolo a.x=fixpoints[labelformat.size][2].x+labelformat.form.titlelm; a.y=(fixpoints[labelformat.size][2].y+fixpoints[labelformat.size][4].y-pts2dmm(labelformat.title1font.height)) / 2 ; paintString(labelformat.title1,&labelformat.title1font,1000L,a,ps); } // testo a.y=fixpoints[labelformat.size][4].y-pts2dmm(labelformat.text1font.height)-labelformat.form.texttm; a.x=fixpoints[labelformat.size][4].x+labelformat.form.textlm; paintString(labelformat.text1,&labelformat.text1font,labelformat.form.textvert1,a,ps); a.y=fixpoints[labelformat.size][4].y-pts2dmm(labelformat.text1font.height)-labelformat.form.texttm; a.x=(fixpoints[labelformat.size][4].x+fixpoints[labelformat.size][5].x)/2+labelformat.form.textlm; paintString(labelformat.text2,&labelformat.text2font,labelformat.form.textvert2,a,ps); if (labelformat.size != 2 && labelformat.flaps > 2) { a.y=fixpoints[labelformat.size][0].y-pts2dmm(labelformat.datefont.height)-15; // data A if (labelformat.whatinfo[0]) { a.x=fixpoints[labelformat.size][0].x+20; paintString(labelformat.date1,&labelformat.datefont,1000L,a,ps); } // data B if (labelformat.whatinfo[1]) { a.x=fixpoints[labelformat.size][1].x-queryStrWidth(labelformat.date2,&labelformat.datefont,ps)-20; paintString(labelformat.date2,&labelformat.datefont,1000L,a,ps); } // "DATE" if (labelformat.whatinfo[1] || labelformat.whatinfo[0]) { a.x=(fixpoints[labelformat.size][0].x+fixpoints[labelformat.size][1].x-queryStrWidth("DATE",&labelformat.datefont,ps))/2; paintString("DATE",&labelformat.datefont,1000L,a,ps); a.y-=pts2dmm(labelformat.sourcefont.height); // se c'era uno dei due abbassati... } // source A if (labelformat.whatinfo[4]) { a.x=fixpoints[labelformat.size][0].x+20; paintString(apchSources[labelformat.source1],&labelformat.sourcefont,1000L,a,ps); } // source B if (labelformat.whatinfo[5]) { a.x=fixpoints[labelformat.size][1].x-queryStrWidth(apchSources[labelformat.source2],&labelformat.sourcefont,ps)-20; paintString(apchSources[labelformat.source2],&labelformat.sourcefont,1000L,a,ps); } // "SOURCE" if (labelformat.whatinfo[4] || labelformat.whatinfo[5]) { a.x=(fixpoints[labelformat.size][0].x+fixpoints[labelformat.size][1].x-queryStrWidth("SOURCE",&labelformat.sourcefont,ps))/2; paintString("SOURCE",&labelformat.sourcefont,1000L,a,ps); a.y-=pts2dmm(labelformat.nrfont.height); } // NR A if (labelformat.whatinfo[2]) { a.x=fixpoints[labelformat.size][0].x+20; paintString(apchNR[labelformat.nr1],&labelformat.nrfont,1000L,a,ps); } // NR B if (labelformat.whatinfo[3]) { a.x=fixpoints[labelformat.size][1].x-queryStrWidth(apchNR[labelformat.nr2],&labelformat.nrfont,ps)-20; paintString(apchNR[labelformat.nr2],&labelformat.nrfont,1000L,a,ps); } // "NR" if (labelformat.whatinfo[2] || labelformat.whatinfo[3]) { a.x=(fixpoints[labelformat.size][0].x+fixpoints[labelformat.size][1].x-queryStrWidth("NR",&labelformat.nrfont,ps))/2; paintString("NR",&labelformat.sourcefont,1000L,a,ps); } } return TRUE; }
DrawResult ClippedImage::DrawSingleTile(gfxContext* aContext, const nsIntSize& aSize, const ImageRegion& aRegion, uint32_t aWhichFrame, SamplingFilter aSamplingFilter, const Maybe<SVGImageContext>& aSVGContext, uint32_t aFlags) { MOZ_ASSERT(!MustCreateSurface(aContext, aSize, aRegion, aFlags), "Shouldn't need to create a surface"); gfxRect clip(mClip.x, mClip.y, mClip.width, mClip.height); nsIntSize size(aSize), innerSize(aSize); bool needScale = false; if (mSVGViewportSize && !mSVGViewportSize->IsEmpty()) { innerSize = *mSVGViewportSize; needScale = true; } else if (NS_SUCCEEDED(InnerImage()->GetWidth(&innerSize.width)) && NS_SUCCEEDED(InnerImage()->GetHeight(&innerSize.height))) { needScale = true; } else { MOZ_ASSERT_UNREACHABLE( "If ShouldClip() led us to draw then we should never get here"); } if (needScale) { double scaleX = aSize.width / clip.width; double scaleY = aSize.height / clip.height; // Map the clip and size to the scale requested by the caller. clip.Scale(scaleX, scaleY); size = innerSize; size.Scale(scaleX, scaleY); } // We restrict our drawing to only the clipping region, and translate so that // the clipping region is placed at the position the caller expects. ImageRegion region(aRegion); region.MoveBy(clip.x, clip.y); region = region.Intersect(clip); gfxContextMatrixAutoSaveRestore saveMatrix(aContext); aContext->Multiply(gfxMatrix::Translation(-clip.x, -clip.y)); auto unclipViewport = [&](const SVGImageContext& aOldContext) { // Map the viewport to the inner image. Note that we don't take the aSize // parameter of imgIContainer::Draw into account, just the clipping region. // The size in pixels at which the output will ultimately be drawn is // irrelevant here since the purpose of the SVG viewport size is to // determine what *region* of the SVG document will be drawn. CSSIntSize vSize(aOldContext.GetViewportSize()); vSize.width = ceil(vSize.width * double(innerSize.width) / mClip.width); vSize.height = ceil(vSize.height * double(innerSize.height) / mClip.height); return SVGImageContext(vSize, aOldContext.GetPreserveAspectRatio()); }; return InnerImage()->Draw(aContext, size, region, aWhichFrame, aSamplingFilter, aSVGContext.map(unclipViewport), aFlags); }
void LLNetMap::draw() { static LLFrameTimer map_timer; if (mObjectImagep.isNull()) { createObjectImage(); } if (gSavedSettings.getS32( "MiniMapCenter") != MAP_CENTER_NONE) { mCurPanX = lerp(mCurPanX, mTargetPanX, LLCriticalDamp::getInterpolant(0.1f)); mCurPanY = lerp(mCurPanY, mTargetPanY, LLCriticalDamp::getInterpolant(0.1f)); } F32 rotation = 0; // Prepare a scissor region { LLGLEnable scissor(GL_SCISSOR_TEST); { gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); LLLocalClipRect clip(getLocalRect()); glMatrixMode(GL_MODELVIEW); // Draw background rectangle if(isBackgroundVisible()) { gGL.color4fv(isBackgroundOpaque() ? getBackgroundColor().mV : getTransparentColor().mV); gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0); } } // region 0,0 is in the middle S32 center_sw_left = getRect().getWidth() / 2 + llfloor(mCurPanX); S32 center_sw_bottom = getRect().getHeight() / 2 + llfloor(mCurPanY); gGL.pushMatrix(); gGL.translatef( (F32) center_sw_left, (F32) center_sw_bottom, 0.f); BOOL rotate_map = gSavedSettings.getBOOL( "MiniMapRotate" ); if (rotate_map) { // rotate subsequent draws to agent rotation rotation = atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] ); glRotatef( rotation * RAD_TO_DEG, 0.f, 0.f, 1.f); } // figure out where agent is LLColor4 this_region_color = gColors.getColor( "NetMapThisRegion" ); LLColor4 live_region_color = gColors.getColor( "NetMapLiveRegion" ); LLColor4 dead_region_color = gColors.getColor( "NetMapDeadRegion" ); for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin(); iter != LLWorld::getInstance()->getRegionList().end(); ++iter) { LLViewerRegion* regionp = *iter; S32 region_width = llround(regionp->getWidth()); // Find x and y position relative to camera's center. LLVector3 origin_agent = regionp->getOriginAgent(); LLVector3 rel_region_pos = origin_agent - gAgentCamera.getCameraPositionAgent(); F32 relative_x = (rel_region_pos.mV[0] / region_width) * mScale; F32 relative_y = (rel_region_pos.mV[1] / region_width) * mScale; // background region rectangle F32 bottom = relative_y; F32 left = relative_x; F32 top = bottom + mScale ; F32 right = left + mScale ; gGL.color4fv(regionp == gAgent.getRegion() ? this_region_color.mV : live_region_color.mV); if (!regionp->isAlive()) { gGL.color4fv(dead_region_color.mV); } // Draw using texture. gGL.getTexUnit(0)->bind(regionp->getLand().getSTexture()); gGL.begin(LLRender::QUADS); gGL.texCoord2f(0.f, 1.f); gGL.vertex2f(left, top); gGL.texCoord2f(0.f, 0.f); gGL.vertex2f(left, bottom); gGL.texCoord2f(1.f, 0.f); gGL.vertex2f(right, bottom); gGL.texCoord2f(1.f, 1.f); gGL.vertex2f(right, top); gGL.end(); // Draw water gGL.setAlphaRejectSettings(LLRender::CF_GREATER, ABOVE_WATERLINE_ALPHA / 255.f); { if (regionp->getLand().getWaterTexture()) { gGL.getTexUnit(0)->bind(regionp->getLand().getWaterTexture()); gGL.begin(LLRender::QUADS); gGL.texCoord2f(0.f, 1.f); gGL.vertex2f(left, top); gGL.texCoord2f(0.f, 0.f); gGL.vertex2f(left, bottom); gGL.texCoord2f(1.f, 0.f); gGL.vertex2f(right, bottom); gGL.texCoord2f(1.f, 1.f); gGL.vertex2f(right, top); gGL.end(); } } gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); } // Redraw object layer periodically if (mUpdateNow || (map_timer.getElapsedTimeF32() > 0.5f)) { mUpdateNow = FALSE; // Locate the centre of the object layer, accounting for panning LLVector3 new_center = globalPosToView(gAgentCamera.getCameraPositionGlobal(), rotate_map); new_center.mV[0] -= mCurPanX; new_center.mV[1] -= mCurPanY; new_center.mV[2] = 0.f; mObjectImageCenterGlobal = viewPosToGlobal(llround(new_center.mV[0]), llround(new_center.mV[1]), rotate_map); // Create the base texture. U8 *default_texture = mObjectRawImagep->getData(); memset( default_texture, 0, mObjectImagep->getWidth() * mObjectImagep->getHeight() * mObjectImagep->getComponents() ); // Draw buildings gObjectList.renderObjectsForMap(*this); mObjectImagep->setSubImage(mObjectRawImagep, 0, 0, mObjectImagep->getWidth(), mObjectImagep->getHeight()); map_timer.reset(); } LLVector3 map_center_agent = gAgent.getPosAgentFromGlobal(mObjectImageCenterGlobal); map_center_agent -= gAgentCamera.getCameraPositionAgent(); gGL.getTexUnit(0)->bind(mObjectImagep); F32 image_half_width = 0.5f*mObjectMapPixels; F32 image_half_height = 0.5f*mObjectMapPixels; gGL.begin(LLRender::QUADS); gGL.texCoord2f(0.f, 1.f); gGL.vertex2f(map_center_agent.mV[VX] - image_half_width, image_half_height + map_center_agent.mV[VY]); gGL.texCoord2f(0.f, 0.f); gGL.vertex2f(map_center_agent.mV[VX] - image_half_width, map_center_agent.mV[VY] - image_half_height); gGL.texCoord2f(1.f, 0.f); gGL.vertex2f(image_half_width + map_center_agent.mV[VX], map_center_agent.mV[VY] - image_half_height); gGL.texCoord2f(1.f, 1.f); gGL.vertex2f(image_half_width + map_center_agent.mV[VX], image_half_height + map_center_agent.mV[VY]); gGL.end(); gGL.popMatrix(); LLVector3d pos_global; LLVector3 pos_map; // Mouse pointer in local coordinates S32 local_mouse_x; S32 local_mouse_y; LLUI::getCursorPositionLocal(this, &local_mouse_x, &local_mouse_y); mClosestAgentToCursor.setNull(); F32 closest_dist = F32_MAX; F32 min_pick_dist = mDotRadius * MIN_PICK_SCALE; // Draw avatars // LLColor4 mapcolor = gAvatarMapColor; static const LLCachedControl<LLColor4> standard_color(gColors,"MapAvatar",LLColor4(0.f,1.f,0.f,1.f)); static const LLCachedControl<LLColor4> friend_color_stored("AscentFriendColor",LLColor4(1.f,1.f,0.f,1.f)); static const LLCachedControl<LLColor4> em_color("AscentEstateOwnerColor",LLColor4(1.f,0.6f,1.f,1.f)); static const LLCachedControl<LLColor4> linden_color("AscentLindenColor",LLColor4(0.f,0.f,1.f,1.f)); static const LLCachedControl<LLColor4> muted_color("AscentMutedColor",LLColor4(0.7f,0.7f,0.7f,1.f)); // Draw avatars // [RLVa:KB] - Version: 1.23.4 | Alternate: Snowglobe-1.2.4 | Checked: 2009-07-08 (RLVa-1.0.0e) | Modified: RLVa-0.2.0b LLColor4 friend_color = (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) ? friend_color_stored : standard_color; // [/RLVa:KB] std::vector<LLUUID> avatar_ids; std::vector<LLVector3d> positions; LLWorld::getInstance()->getAvatars(&avatar_ids, &positions); for(U32 i=0; i<avatar_ids.size(); i++) { LLColor4 avColor = standard_color; // TODO: it'd be very cool to draw these in sorted order from lowest Z to highest. // just be careful to sort the avatar IDs along with the positions. -MG pos_map = globalPosToView(positions[i], rotate_map); if (positions[i].mdV[VZ] == 0.f) { pos_map.mV[VZ] = 16000.f; } std::string avName; gCacheName->getFullName(avatar_ids[i], avName); if(LLMuteList::getInstance()->isMuted(avatar_ids[i])) { avColor = muted_color; } LLViewerRegion* avatar_region = LLWorld::getInstance()->getRegionFromPosGlobal(positions[i]); LLUUID estate_owner = avatar_region? avatar_region->getOwner() : LLUUID::null; //Lindens are always more Linden than your friend, make that take precedence if(LLMuteList::getInstance()->isLinden(avName)) { avColor = linden_color; } else if(LLFloaterMap::getInstance()->getRadar()->isSpecial(avatar_ids[i])) { avColor = linden_color; } //check if they are an estate owner at their current position else if(estate_owner.notNull() && avatar_ids[i] == estate_owner) { avColor = em_color; } //without these dots, SL would suck. else if(is_agent_friend(avatar_ids[i])) { avColor = friend_color; } else { // MOYMOD Minimap custom av colors. boost::unordered_map<const LLUUID,LLColor4>::const_iterator it = mm_MarkerColors.find(avatar_ids[i]); if(it != mm_MarkerColors.end()) { avColor = it->second; } } LLWorldMapView::drawAvatar( pos_map.mV[VX], pos_map.mV[VY], avColor, pos_map.mV[VZ], mDotRadius); F32 dist_to_cursor = dist_vec(LLVector2(pos_map.mV[VX], pos_map.mV[VY]), LLVector2(local_mouse_x,local_mouse_y)); if(dist_to_cursor < min_pick_dist && dist_to_cursor < closest_dist) { closest_dist = dist_to_cursor; mClosestAgentToCursor = avatar_ids[i]; mClosestAgentPosition = positions[i]; } } // Draw dot for autopilot target if (gAgent.getAutoPilot()) { drawTracking(gAgent.getAutoPilotTargetGlobal(), rotate_map, gTrackColor); } else { LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus(); if ( LLTracker::TRACKING_AVATAR == tracking_status ) { drawTracking(LLAvatarTracker::instance().getGlobalPos(), rotate_map, gTrackColor); } else if ( LLTracker::TRACKING_LANDMARK == tracking_status || LLTracker::TRACKING_LOCATION == tracking_status ) { drawTracking(LLTracker::getTrackedPositionGlobal(), rotate_map, gTrackColor); } } // Draw dot for self avatar position pos_global = gAgent.getPositionGlobal(); pos_map = globalPosToView(pos_global, rotate_map); LLUIImagePtr you = LLWorldMapView::sAvatarYouLargeImage; S32 dot_width = llround(mDotRadius * 2.f); you->draw( llround(pos_map.mV[VX] - mDotRadius), llround(pos_map.mV[VY] - mDotRadius), dot_width, dot_width); // Draw frustum F32 meters_to_pixels = mScale/ LLWorld::getInstance()->getRegionWidthInMeters(); F32 horiz_fov = LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect(); F32 far_clip_meters = LLViewerCamera::getInstance()->getFar(); F32 far_clip_pixels = far_clip_meters * meters_to_pixels; F32 half_width_meters = far_clip_meters * tan( horiz_fov / 2 ); F32 half_width_pixels = half_width_meters * meters_to_pixels; F32 ctr_x = (F32)center_sw_left; F32 ctr_y = (F32)center_sw_bottom; gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); if (rotate_map) { gGL.color4fv(gColors.getColor("NetMapFrustum").mV); gGL.begin( LLRender::TRIANGLES ); gGL.vertex2f( ctr_x, ctr_y ); gGL.vertex2f( ctr_x - half_width_pixels, ctr_y + far_clip_pixels ); gGL.vertex2f( ctr_x + half_width_pixels, ctr_y + far_clip_pixels ); gGL.end(); } else { gGL.color4fv(gColors.getColor("NetMapFrustumRotating").mV); // If we don't rotate the map, we have to rotate the frustum. gGL.pushMatrix(); gGL.translatef( ctr_x, ctr_y, 0 ); glRotatef( atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] ) * RAD_TO_DEG, 0.f, 0.f, -1.f); gGL.begin( LLRender::TRIANGLES ); gGL.vertex2f( 0, 0 ); gGL.vertex2f( -half_width_pixels, far_clip_pixels ); gGL.vertex2f( half_width_pixels, far_clip_pixels ); gGL.end(); gGL.popMatrix(); } } // Rotation of 0 means that North is up setDirectionPos( getChild<LLTextBox>("e_label"), rotation); setDirectionPos( getChild<LLTextBox>("n_label"), rotation + F_PI_BY_TWO); setDirectionPos( getChild<LLTextBox>("w_label"), rotation + F_PI); setDirectionPos( getChild<LLTextBox>("s_label"), rotation + F_PI + F_PI_BY_TWO); setDirectionPos( getChild<LLTextBox>("ne_label"), rotation + F_PI_BY_TWO / 2); setDirectionPos( getChild<LLTextBox>("nw_label"), rotation + F_PI_BY_TWO + F_PI_BY_TWO / 2); setDirectionPos( getChild<LLTextBox>("sw_label"), rotation + F_PI + F_PI_BY_TWO / 2); setDirectionPos( getChild<LLTextBox>("se_label"), rotation + F_PI + F_PI_BY_TWO + F_PI_BY_TWO / 2); LLView::draw(); LLFloaterMap::getInstance()->getRadar()->updateRadarInfo(); }
void Shape::drawClipped(ShadowBuffer& sb, Point min, Point max, float scale) { clip(min, max, scale); scanLineFill(sb, clippedPoints); //drawBorder(sb, borderColor); }
Decimal & Decimal::multiply(const Decimal & other) { int low1, high1, low2, high2, lowt, hight; clip(low1, high1); other.clip(low2, high2); lowt = low1+low2-zeroDigit; if (lowt < 0) lowt = 0; hight = high1 + high2 - zeroDigit; if (hight >= maxDigits) hight = maxDigits-1; else if (hight < 0) { if (hight < -1) { setZero(); return *this; } hight = 0; } unsigned temp[maxDigits*2]; _clear(temp); // memset(temp+low1+low2, 0, (high1+high2-low1-low2+2)*sizeof(unsigned)); // only need to clear part of the target we're adding to. //More: could copy across 1st time round - might be worth it. const byte * digits1 = digits; const byte * digits2 = other.digits; for (int i = low1; i <= high1; i++) { byte next = digits1[i]; if (next) { for (int j=low2; j <= high2; j++) temp[i+j] += next * digits2[j]; } } //Now copy the results, taking care of the carries unsigned carry = 0; int j; for (j = low1+low2 - zeroDigit; j < lowt; j++) { unsigned next = temp[j+zeroDigit]+carry; //Round the least significant digit if (j+1 == lowt) next += 5; carry = next / 10; } for (j = lowt; j <= hight; j++) { div_t next = div(temp[j+zeroDigit]+carry, 10); digits[j] = next.rem; carry = next.quot; } while ((hight < maxDigits-1) && (carry != 0)) { digits[++hight] = carry % 10; carry = carry / 10; } lsb = lowt; msb = hight; negative ^= other.negative; return *this; }
// out_map was initialized to 0 already int segment1(image *in_image, image *out_map, int min_dist_th) { int n_bands = in_image->num_of_bands; int n_lines = in_image->num_of_lines; int n_cols = in_image->num_of_samples; int n_seg = 0; // number of segments, first segment is named 1, second 2, and so on float pel_dist, min_dist; // measurement of the distance between two pixels imgpel **map = (imgpel **) dim2 (n_lines, n_cols, sizeof(imgpel)); for(int y=0; y<n_lines; y++) { for(int x=0; x<n_cols; x++) { if(map[y][x] == 0) // non-segmented pixel, check its eight neighbors for a potential merge; if no merge, start a new segment { min_dist = (float) LARGE_FLOAT; for(int j=y-1; j<=y+1; j++) { for(int i=x-1; i<=x+1; i++) { if(j>=0 && j<n_lines && i>=0 && i<n_cols && (j!=y || i!=x) && (map[j][i]>0)) { pel_dist = 0; for(int k=0; k<n_bands; k++) pel_dist += ((in_image->IMG[k][y][x] - in_image->IMG[k][j][i]) * (in_image->IMG[k][y][x] - in_image->IMG[k][j][i])); if(pel_dist < min_dist) { min_dist = pel_dist; map[y][x] = map[j][i]; } } } } if (min_dist > min_dist_th * n_bands) { n_seg += 1; map[y][x] = (imgpel) n_seg; } } } } for(int y=0; y<n_lines; y++) { for(int x=0; x<n_cols; x++) { int boundary_flag = 0; for(int j=y-1; j<=y+1; j++) { for(int i=x-1; i<=x+1; i++) { int jj = clip(0, n_lines-1, j); int ii = clip(0, n_cols-1, i); if(map[jj][ii] != map[y][x]) boundary_flag = 1; } } for(int k=0; k<n_bands; k++) out_map->IMG[k][y][x] = ((boundary_flag==1) ? 0xFFFF : in_image->IMG[k][y][x]); } } free2((char **)map); return n_seg; }
/* * sprite_get_image() * Receives an animation and the desired frame number. * Returns an image. */ image_t *sprite_get_image(const animation_t *anim, int frame_id) { frame_id = clip(frame_id, 0, anim->frame_count-1); return anim->frame_data[ anim->data[frame_id] ]; }
void TextPrinter::paintPage(QPainter *painter, QTextDocument *document, int pagenum) { QRectF rect; double onepoint = painter->device()->logicalDpiY() / 72.0; // header if (headersize_ > 0) { rect = headerRect(painter->device()); if (headerrule_ > 0.0) { painter->save(); // allow space between rule and header painter->translate(0, onepoint + (headerrule_ * onepoint / 2.0)); painter->setPen(QPen(Qt::black, headerrule_ * onepoint)); painter->drawLine(rect.bottomLeft(), rect.bottomRight()); painter->restore(); } // replace page variables QString header = headertext_; header.replace("&page;", QString::number(pagenum)); if (dateformat_.isEmpty()) { header.replace("&date;", QDate::currentDate().toString()); } else { header.replace("&date;", QDate::currentDate().toString(dateformat_)); } painter->save(); painter->translate(rect.left(), rect.top()); QRectF clip(0, 0, rect.width(), rect.height()); QTextDocument doc; doc.setUseDesignMetrics(true); doc.setHtml(header); doc.documentLayout()->setPaintDevice(painter->device()); doc.setPageSize(rect.size()); // align text to bottom double newtop = clip.bottom() - doc.size().height(); clip.setHeight(doc.size().height()); painter->translate(0, newtop); doc.drawContents(painter, clip); painter->restore(); } // footer if (footersize_ > 0) { rect = footerRect(painter->device()); if (footerrule_ > 0.0) { painter->save(); // allow space between rule and footer painter->translate(0, -onepoint + (-footerrule_ * onepoint / 2.0)); painter->setPen(QPen(Qt::black, footerrule_ * onepoint)); painter->drawLine(rect.topLeft(), rect.topRight()); painter->restore(); } // replace page variables QString footer = footertext_; footer.replace("&page;", QString::number(pagenum)); if (dateformat_.isEmpty()) { footer.replace("&date;", QDate::currentDate().toString()); } else { footer.replace("&date;", QDate::currentDate().toString(dateformat_)); } painter->save(); painter->translate(rect.left(), rect.top()); QRectF clip(0, 0, rect.width(), rect.height()); QTextDocument doc; doc.setUseDesignMetrics(true); doc.setHtml(footer); doc.documentLayout()->setPaintDevice(painter->device()); doc.setPageSize(rect.size()); doc.drawContents(painter, clip); painter->restore(); } // content painter->save(); rect = contentRect(painter->device()); painter->translate(rect.left(), rect.top() - (pagenum-1) * rect.height()); QRectF clip(0, (pagenum-1) * rect.height(), rect.width(), rect.height()); document->drawContents(painter, clip); painter->restore(); }
inline StringBuffer & trimRight() { return clip(); }
static int FinalAlphaValue(int alpha) { alpha = MAX_ALPHA - alpha; return clip(alpha, 0, MAX_ALPHA); }
//////////////////////////////////////////////////////////////////////////////// // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device // (as opposed to canvas) coordinates bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt, int32_t elementsGenID, GrReducedClip::InitialState initialState, const GrReducedClip::ElementList& elements, const SkIRect& clipSpaceIBounds, const SkIPoint& clipSpaceToStencilOffset) { SkASSERT(rt); GrStencilAttachment* stencilAttachment = fDrawTarget->cmmAccess().resourceProvider()->attachStencilAttachment(rt); if (nullptr == stencilAttachment) { return false; } if (stencilAttachment->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) { stencilAttachment->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset); // Set the matrix so that rendered clip elements are transformed from clip to stencil space. SkVector translate = { SkIntToScalar(clipSpaceToStencilOffset.fX), SkIntToScalar(clipSpaceToStencilOffset.fY) }; SkMatrix viewMatrix; viewMatrix.setTranslate(translate); // We set the current clip to the bounds so that our recursive draws are scissored to them. SkIRect stencilSpaceIBounds(clipSpaceIBounds); stencilSpaceIBounds.offset(clipSpaceToStencilOffset); GrClip clip(stencilSpaceIBounds); int clipBit = stencilAttachment->bits(); SkASSERT((clipBit <= 16) && "Ganesh only handles 16b or smaller stencil buffers"); clipBit = (1 << (clipBit-1)); fDrawTarget->cmmAccess().clearStencilClip(stencilSpaceIBounds, GrReducedClip::kAllIn_InitialState == initialState, rt); // walk through each clip element and perform its set op // with the existing clip. for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) { const Element* element = iter.get(); GrPipelineBuilder pipelineBuilder; pipelineBuilder.setClip(clip); pipelineBuilder.setRenderTarget(rt); pipelineBuilder.setDisableColorXPFactory(); // if the target is MSAA then we want MSAA enabled when the clip is soft if (rt->isStencilBufferMultisampled()) { pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, element->isAA()); } bool fillInverted = false; // enabled at bottom of loop fClipMode = kIgnoreClip_StencilClipMode; // This will be used to determine whether the clip shape can be rendered into the // stencil with arbitrary stencil settings. GrPathRenderer::StencilSupport stencilSupport; GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle); SkRegion::Op op = element->getOp(); GrPathRenderer* pr = nullptr; SkPath clipPath; if (Element::kRect_Type == element->getType()) { stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport; fillInverted = false; } else { element->asPath(&clipPath); fillInverted = clipPath.isInverseFillType(); if (fillInverted) { clipPath.toggleInverseFillType(); } pr = this->getContext()->getPathRenderer(fDrawTarget, &pipelineBuilder, viewMatrix, clipPath, stroke, false, GrPathRendererChain::kStencilOnly_DrawType, &stencilSupport); if (nullptr == pr) { return false; } } int passes; GrStencilSettings stencilSettings[GrStencilSettings::kMaxStencilClipPasses]; bool canRenderDirectToStencil = GrPathRenderer::kNoRestriction_StencilSupport == stencilSupport; bool canDrawDirectToClip; // Given the renderer, the element, // fill rule, and set operation can // we render the element directly to // stencil bit used for clipping. canDrawDirectToClip = GrStencilSettings::GetClipPasses(op, canRenderDirectToStencil, clipBit, fillInverted, &passes, stencilSettings); // draw the element to the client stencil bits if necessary if (!canDrawDirectToClip) { GR_STATIC_CONST_SAME_STENCIL(gDrawToStencil, kIncClamp_StencilOp, kIncClamp_StencilOp, kAlways_StencilFunc, 0xffff, 0x0000, 0xffff); if (Element::kRect_Type == element->getType()) { *pipelineBuilder.stencil() = gDrawToStencil; // We need this AGP until everything is in GrBatch fDrawTarget->drawNonAARect(pipelineBuilder, GrColor_WHITE, viewMatrix, element->getRect()); } else { if (!clipPath.isEmpty()) { if (canRenderDirectToStencil) { *pipelineBuilder.stencil() = gDrawToStencil; GrPathRenderer::DrawPathArgs args; args.fTarget = fDrawTarget; args.fResourceProvider = this->getContext()->resourceProvider(); args.fPipelineBuilder = &pipelineBuilder; args.fColor = GrColor_WHITE; args.fViewMatrix = &viewMatrix; args.fPath = &clipPath; args.fStroke = &stroke; args.fAntiAlias = false; pr->drawPath(args); } else { GrPathRenderer::StencilPathArgs args; args.fTarget = fDrawTarget; args.fResourceProvider = this->getContext()->resourceProvider(); args.fPipelineBuilder = &pipelineBuilder; args.fViewMatrix = &viewMatrix; args.fPath = &clipPath; args.fStroke = &stroke; pr->stencilPath(args); } } } } // now we modify the clip bit by rendering either the clip // element directly or a bounding rect of the entire clip. fClipMode = kModifyClip_StencilClipMode; for (int p = 0; p < passes; ++p) { *pipelineBuilder.stencil() = stencilSettings[p]; if (canDrawDirectToClip) { if (Element::kRect_Type == element->getType()) { // We need this AGP until everything is in GrBatch fDrawTarget->drawNonAARect(pipelineBuilder, GrColor_WHITE, viewMatrix, element->getRect()); } else { GrPathRenderer::DrawPathArgs args; args.fTarget = fDrawTarget; args.fResourceProvider = this->getContext()->resourceProvider(); args.fPipelineBuilder = &pipelineBuilder; args.fColor = GrColor_WHITE; args.fViewMatrix = &viewMatrix; args.fPath = &clipPath; args.fStroke = &stroke; args.fAntiAlias = false; pr->drawPath(args); } } else { // The view matrix is setup to do clip space -> stencil space translation, so // draw rect in clip space. fDrawTarget->drawNonAARect(pipelineBuilder, GrColor_WHITE, viewMatrix, SkRect::Make(clipSpaceIBounds)); } } } } fClipMode = kRespectClip_StencilClipMode; return true; }
GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID, GrReducedClip::InitialState initialState, const GrReducedClip::ElementList& elements, const SkVector& clipToMaskOffset, const SkIRect& clipSpaceIBounds) { GrResourceProvider* resourceProvider = fDrawTarget->cmmAccess().resourceProvider(); GrUniqueKey key; GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key); if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) { return texture; } SkAutoTUnref<GrTexture> texture(this->createCachedMask( clipSpaceIBounds.width(), clipSpaceIBounds.height(), key, true)); // There's no texture in the cache. Let's try to allocate it then. if (!texture) { return nullptr; } // Set the matrix so that rendered clip elements are transformed to mask space from clip // space. SkMatrix translate; translate.setTranslate(clipToMaskOffset); // The texture may be larger than necessary, this rect represents the part of the texture // we populate with a rasterization of the clip. SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height()); // The scratch texture that we are drawing into can be substantially larger than the mask. Only // clear the part that we care about. fDrawTarget->clear(&maskSpaceIBounds, GrReducedClip::kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000, true, texture->asRenderTarget()); // When we use the stencil in the below loop it is important to have this clip installed. // The second pass that zeros the stencil buffer renders the rect maskSpaceIBounds so the first // pass must not set values outside of this bounds or stencil values outside the rect won't be // cleared. GrClip clip(maskSpaceIBounds); SkAutoTUnref<GrTexture> temp; // walk through each clip element and perform its set op for (GrReducedClip::ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) { const Element* element = iter.get(); SkRegion::Op op = element->getOp(); bool invert = element->isInverseFilled(); if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) { GrPipelineBuilder pipelineBuilder; pipelineBuilder.setClip(clip); GrPathRenderer* pr = nullptr; bool useTemp = !this->canStencilAndDrawElement(&pipelineBuilder, texture, &pr, element); GrTexture* dst; // This is the bounds of the clip element in the space of the alpha-mask. The temporary // mask buffer can be substantially larger than the actually clip stack element. We // touch the minimum number of pixels necessary and use decal mode to combine it with // the accumulator. SkIRect maskSpaceElementIBounds; if (useTemp) { if (invert) { maskSpaceElementIBounds = maskSpaceIBounds; } else { SkRect elementBounds = element->getBounds(); elementBounds.offset(clipToMaskOffset); elementBounds.roundOut(&maskSpaceElementIBounds); } if (!temp) { temp.reset(this->createTempMask(maskSpaceIBounds.fRight, maskSpaceIBounds.fBottom)); if (!temp) { texture->resourcePriv().removeUniqueKey(); return nullptr; } } dst = temp; // clear the temp target and set blend to replace fDrawTarget->clear(&maskSpaceElementIBounds, invert ? 0xffffffff : 0x00000000, true, dst->asRenderTarget()); set_coverage_drawing_xpf(SkRegion::kReplace_Op, invert, &pipelineBuilder); } else { // draw directly into the result with the stencil set to make the pixels affected // by the clip shape be non-zero. dst = texture; GR_STATIC_CONST_SAME_STENCIL(kStencilInElement, kReplace_StencilOp, kReplace_StencilOp, kAlways_StencilFunc, 0xffff, 0xffff, 0xffff); pipelineBuilder.setStencil(kStencilInElement); set_coverage_drawing_xpf(op, invert, &pipelineBuilder); } if (!this->drawElement(&pipelineBuilder, translate, dst, element, pr)) { texture->resourcePriv().removeUniqueKey(); return nullptr; } if (useTemp) { GrPipelineBuilder backgroundPipelineBuilder; backgroundPipelineBuilder.setRenderTarget(texture->asRenderTarget()); // Now draw into the accumulator using the real operation and the temp buffer as a // texture this->mergeMask(&backgroundPipelineBuilder, texture, temp, op, maskSpaceIBounds, maskSpaceElementIBounds); } else { GrPipelineBuilder backgroundPipelineBuilder; backgroundPipelineBuilder.setRenderTarget(texture->asRenderTarget()); set_coverage_drawing_xpf(op, !invert, &backgroundPipelineBuilder); // Draw to the exterior pixels (those with a zero stencil value). GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement, kZero_StencilOp, kZero_StencilOp, kEqual_StencilFunc, 0xffff, 0x0000, 0xffff); backgroundPipelineBuilder.setStencil(kDrawOutsideElement); // The color passed in here does not matter since the coverageSetOpXP won't read it. fDrawTarget->drawNonAARect(backgroundPipelineBuilder, GrColor_WHITE, translate, clipSpaceIBounds); } } else { GrPipelineBuilder pipelineBuilder; // all the remaining ops can just be directly draw into the accumulation buffer set_coverage_drawing_xpf(op, false, &pipelineBuilder); // The color passed in here does not matter since the coverageSetOpXP won't read it. this->drawElement(&pipelineBuilder, translate, texture, element); } } return texture.detach(); }
DLLEXPORT void STDCALL FPDF_FFLDraw(FPDF_FORMHANDLE hHandle, FPDF_BITMAP bitmap, FPDF_PAGE page, int start_x, int start_y, int size_x, int size_y, int rotate, int flags) { if (!hHandle) return; UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page); if (!pPage) return; #ifndef PDF_ENABLE_XFA CPDF_RenderOptions options; if (flags & FPDF_LCD_TEXT) options.m_Flags |= RENDER_CLEARTYPE; else options.m_Flags &= ~RENDER_CLEARTYPE; // Grayscale output if (flags & FPDF_GRAYSCALE) { options.m_ColorMode = RENDER_COLOR_GRAY; options.m_ForeColor = 0; options.m_BackColor = 0xffffff; } options.m_AddFlags = flags >> 8; options.m_pOCContext = new CPDF_OCContext(pPage->m_pDocument); #else // PDF_ENABLE_XFA CPDFXFA_Document* pDocument = pPage->GetDocument(); if (!pDocument) return; CPDF_Document* pPDFDoc = pDocument->GetPDFDoc(); if (!pPDFDoc) return; CPDFDoc_Environment* pEnv = (CPDFDoc_Environment*)hHandle; CPDFSDK_Document* pFXDoc = pEnv->GetSDKDocument(); if (!pFXDoc) return; #endif // PDF_ENABLE_XFA CFX_Matrix matrix; pPage->GetDisplayMatrix(matrix, start_x, start_y, size_x, size_y, rotate); FX_RECT clip(start_x, start_y, start_x + size_x, start_y + size_y); #ifdef _SKIA_SUPPORT_ std::unique_ptr<CFX_SkiaDevice> pDevice(new CFX_SkiaDevice); #else std::unique_ptr<CFX_FxgeDevice> pDevice(new CFX_FxgeDevice); #endif pDevice->Attach((CFX_DIBitmap*)bitmap); pDevice->SaveState(); pDevice->SetClip_Rect(clip); #ifndef PDF_ENABLE_XFA if (CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, pPage)) pPageView->PageView_OnDraw(pDevice.get(), &matrix, &options); #else // PDF_ENABLE_XFA CPDF_RenderOptions options; if (flags & FPDF_LCD_TEXT) options.m_Flags |= RENDER_CLEARTYPE; else options.m_Flags &= ~RENDER_CLEARTYPE; // Grayscale output if (flags & FPDF_GRAYSCALE) { options.m_ColorMode = RENDER_COLOR_GRAY; options.m_ForeColor = 0; options.m_BackColor = 0xffffff; } options.m_AddFlags = flags >> 8; options.m_pOCContext = new CPDF_OCContext(pPDFDoc); if (CPDFSDK_PageView* pPageView = pFXDoc->GetPageView(pPage)) pPageView->PageView_OnDraw(pDevice.get(), &matrix, &options, clip); #endif // PDF_ENABLE_XFA pDevice->RestoreState(); delete options.m_pOCContext; #ifdef PDF_ENABLE_XFA options.m_pOCContext = NULL; #endif // PDF_ENABLE_XFA }
void TextArea::Draw(unsigned short x, unsigned short y) { /** Don't come back recursively */ if (InternalFlags&TA_BITEMYTAIL) { return; } int tx=x+XPos; int ty=y+YPos; Region clip( tx, ty, Width, Height ); Video *video = core->GetVideoDriver(); if (Flags&IE_GUI_TEXTAREA_SPEAKER) { if (AnimPicture) { video->BlitSprite(AnimPicture, tx,ty, true, &clip); clip.x+=AnimPicture->Width; clip.w-=AnimPicture->Width; } } //this might look better in GlobalTimer //or you might want to change the animated button to work like this if (Flags &IE_GUI_TEXTAREA_SMOOTHSCROLL) { unsigned long thisTime; GetTime( thisTime); if (thisTime>starttime) { starttime = thisTime+ticks; smooth--; while (smooth<=0) { smooth+=ftext->maxHeight; if (startrow<rows) { startrow++; } } /** Forcing redraw of whole screen before drawing text*/ Owner->Invalidate(); InternalFlags |= TA_BITEMYTAIL; Owner->DrawWindow(); InternalFlags &= ~TA_BITEMYTAIL; } } if (!Changed && !(Owner->Flags&WF_FLOAT) ) { return; } Changed = false; if (XPos == 65535) { return; } size_t linesize = lines.size(); if (linesize == 0) { return; } //smooth vertical scrolling up if (Flags & IE_GUI_TEXTAREA_SMOOTHSCROLL) { clip.y+=smooth; clip.h-=smooth; } //if textarea is 'selectable' it actually means, it is a listbox //in this case the selected value equals the line number //if it is 'not selectable' it can still have selectable lines //but then it is like the dialog window in the main game screen: //the selected value is encoded into the line if (!(Flags & IE_GUI_TEXTAREA_SELECTABLE) ) { char* Buffer = (char *) malloc( 1 ); Buffer[0] = 0; int len = 0; int lastlen = 0; for (size_t i = 0; i < linesize; i++) { if (strnicmp( "[s=", lines[i], 3 ) == 0) { int tlen; unsigned long idx, acolor, bcolor; char* rest; idx = strtoul( lines[i] + 3, &rest, 0 ); if (*rest != ',') goto notmatched; acolor = strtoul( rest + 1, &rest, 16 ); if (*rest != ',') goto notmatched; bcolor = strtoul( rest + 1, &rest, 16 ); if (*rest != ']') goto notmatched; tlen = (int)(strstr( rest + 1, "[/s]" ) - rest - 1); if (tlen < 0) goto notmatched; len += tlen + 23; Buffer = (char *) realloc( Buffer, len + 2 ); if (seltext == (int) i) { sprintf( Buffer + lastlen, "[color=%6.6lX]%.*s[/color]", acolor, tlen, rest + 1 ); } else { sprintf( Buffer + lastlen, "[color=%6.6lX]%.*s[/color]", bcolor, tlen, rest + 1 ); } } else { notmatched: len += ( int ) strlen( lines[i] ) + 1; Buffer = (char *) realloc( Buffer, len + 2 ); memcpy( &Buffer[lastlen], lines[i], len - lastlen ); } lastlen = len; if (i != linesize - 1) { Buffer[lastlen - 1] = '\n'; Buffer[lastlen] = 0; } } video->SetClipRect( &clip ); int pos; if (startrow==CurLine) { pos = CurPos; } else { pos = -1; } ftext->PrintFromLine( startrow, clip, ( unsigned char * ) Buffer, palette, IE_FONT_ALIGN_LEFT, finit, Cursor, pos ); free( Buffer ); video->SetClipRect( NULL ); //streaming text if (linesize>50) { //the buffer is filled enough return; } if (core->GetAudioDrv()->IsSpeaking() ) { //the narrator is still talking return; } if (RunEventHandler( TextAreaOutOfText )) { return; } if (linesize==lines.size()) { ResetEventHandler( TextAreaOutOfText ); return; } AppendText("\n",-1); return; } // normal scrolling textarea int rc = 0; int sr = startrow; unsigned int i; int yl; for (i = 0; i < linesize; i++) { if (rc + lrows[i] <= sr) { rc += lrows[i]; continue; } sr -= rc; Palette* pal = NULL; if (seltext == (int) i) pal = selected; else if (Value == i) pal = lineselpal; else pal = palette; ftext->PrintFromLine( sr, clip, ( unsigned char * ) lines[i], pal, IE_FONT_ALIGN_LEFT, finit, NULL ); yl = ftext->size[1].h*(lrows[i]-sr); clip.y+=yl; clip.h-=yl; break; } for (i++; i < linesize; i++) { Palette* pal = NULL; if (seltext == (int) i) pal = selected; else if (Value == i) pal = lineselpal; else pal = palette; ftext->Print( clip, ( unsigned char * ) lines[i], pal, IE_FONT_ALIGN_LEFT, true ); yl = ftext->size[1].h*lrows[i]; clip.y+=yl; clip.h-=yl; } }
/* Update and possibly display the tip */ void tipDisplay() { SDWORD newMX, newMY; SDWORD currTime; SDWORD fw, topGap; switch (tipState) { case TIP_WAIT: /* See if the tip has to be shown */ newMX = mouseX(); newMY = mouseY(); currTime = wzGetTicks(); if (newMX == mx && newMY == my && (currTime - startTime > TIP_PAUSE)) { /* Activate the tip */ tipState = TIP_ACTIVE; /* Calculate the size of the tip box */ topGap = TIP_VGAP; iV_SetFont(FontID); lineHeight = iV_GetTextLineSize(); fw = 0; for (int n = 0; n < pTip.size(); ++n) { fw = std::max<int>(fw, iV_GetTextWidth(pTip[n].toUtf8().constData())); } tw = fw + TIP_HGAP * 2; th = topGap * 2 + lineHeight * pTip.size() + iV_GetTextBelowBase(); /* Position the tip box */ tx = clip(wx + ww / 2, 0, screenWidth - tw - 1); ty = std::max(wy + wh + TIP_VGAP, 0); if (ty + th >= (int)screenHeight) { /* Position the tip above the button */ ty = wy - th - TIP_VGAP; } /* Position the text */ fx = tx + TIP_HGAP; fy = ty + (th - lineHeight * pTip.size()) / 2 - iV_GetTextAboveBase(); /* Note the time */ startTime = wzGetTicks(); } else if (newMX != mx || newMY != my || mousePressed(MOUSE_LMB)) { mx = newMX; my = newMY; startTime = currTime; } break; case TIP_ACTIVE: /* Draw the tool tip */ pie_BoxFill(tx, ty, tx + tw, ty + th, WZCOL_FORM_TIP_BACKGROUND); iV_Line(tx + 1, ty + th - 2, tx + 1, ty + 1, WZCOL_FORM_DARK); iV_Line(tx + 2, ty + 1, tx + tw - 2, ty + 1, WZCOL_FORM_DARK); iV_Line(tx, ty + th, tx + tw, ty + th, WZCOL_FORM_DARK); iV_Line(tx + tw, ty + th - 1, tx + tw, ty, WZCOL_FORM_DARK); iV_Box(tx, ty, tx + tw - 1, ty + th - 1, WZCOL_FORM_LIGHT); iV_SetFont(FontID); iV_SetTextColour(TipColour); for (int n = 0; n < pTip.size(); ++n) { iV_DrawText(pTip[n].toUtf8().constData(), fx, fy + lineHeight * n); } break; default: break; } }
Decimal & Decimal::divide(const Decimal & other) { //NB: Round towards zero int lo1, hi1, lo2, hi2; clip(lo1, hi1); other.clip(lo2, hi2); int nd1 = hi1+1-lo1; int nd2 = hi2+1-lo2; int hi = (hi1-hi2)+zeroDigit; // how many digits will there be in the result int iters = hi+1; if (hi < 0) { setZero(); return *this; } if (hi2 < lo2) { //Division by zero defined to return 0 instead of throw an exception setZero(); return *this; } lsb = 0; msb = hi >= maxDigits ? maxDigits-1 : hi; const byte spare = 3; byte temp[maxDigits*2 + 3]; unsigned numeratorDigits = (hi + 1) + nd2; memset(temp, 0, numeratorDigits+spare); // ensure two zero in msb, and below lsb. Also 2 zeros for looking 2 bytes ahead.. byte * numerator = temp+spare; if (numeratorDigits > (unsigned)nd1) memcpy(numerator + numeratorDigits - 1 - nd1, digits+lo1, nd1); else memcpy(numerator, digits + hi1 + 1 - (numeratorDigits-1), numeratorDigits-1); unsigned divisor01 = other.digits[hi2] * 10; if (hi2 != lo2) divisor01 += other.digits[hi2-1]; //MORE: Terminate early for exact divide.. const byte * divisor = other.digits + lo2; for (int iter = iters; iter--; ) { //The following guess for q is never too small, may be 1 too large byte * curNumerator = numerator + iter; unsigned numerator012 = curNumerator[nd2] * 100 + curNumerator[nd2-1] * 10 + curNumerator[nd2-2]; unsigned q = numerator012 / divisor01; if (q == 10) q--; if (q) { unsigned carry = 0; for (int i = 0; i < nd2; i++) { int next = 90 + curNumerator[i] - divisor[i] * q - carry; div_t values = div(next, 10); carry = 9 - values.quot; curNumerator[i] = values.rem; } carry -= curNumerator[nd2]; if (carry) { q--; assertex(carry==1); carry = 0; for (int i = 0; i < nd2; i++) { byte next = curNumerator[i] + divisor[i] + carry; carry = 0; if (next >= 10) { next -= 10; carry = 1; } curNumerator[i] = next; } assertex(carry); } } if (iter < maxDigits) digits[iter] = q; } //MORE: This should really calculate the next digit, and conditionally round the least significant digit. if (true) { //The following guess for q is never too small, may be 1 too large byte * curNumerator = numerator-1; unsigned numerator012 = curNumerator[nd2] * 100 + curNumerator[nd2-1] * 10 + curNumerator[nd2-2]; unsigned q = numerator012 / divisor01; if (q == 5) { unsigned carry = 0; for (int i = 0; i < nd2; i++) { int next = 90 + curNumerator[i] - divisor[i] * q - carry; carry = 9 - next / 10; } carry -= curNumerator[nd2]; if (carry) q--; } if (q >= 5) { for (unsigned roundDigit=0; roundDigit < iters; roundDigit++) { unsigned next = digits[roundDigit]+1; if (next == 10) next = 0; digits[roundDigit] = next; if (next != 0) break; } } } negative ^= other.negative; return *this; }
static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, game_state *state, int dir, game_ui *ui, float animtime, float flashtime) { int i, x, y, ts = TILE_SIZE, isflash = 0, force = 0; if (flashtime > 0) { int frame = (int)(flashtime / FLASH_FRAME); isflash = (frame % 2) == 0; debug(("game_redraw: flashtime = %f", flashtime)); } if (!ds->started) { int x0 = TODRAW(0)-1, y0 = TODRAW(0)-1; int x1 = TODRAW(state->w+2), y1 = TODRAW(state->h+2); draw_rect(dr, 0, 0, TILE_SIZE * (state->w+3), TILE_SIZE * (state->h+3), COL_BACKGROUND); /* clockwise around the outline starting at pt behind (1,1). */ draw_line(dr, x0+ts, y0+ts, x0+ts, y0, COL_HIGHLIGHT); draw_line(dr, x0+ts, y0, x1-ts, y0, COL_HIGHLIGHT); draw_line(dr, x1-ts, y0, x1-ts, y0+ts, COL_LOWLIGHT); draw_line(dr, x1-ts, y0+ts, x1, y0+ts, COL_HIGHLIGHT); draw_line(dr, x1, y0+ts, x1, y1-ts, COL_LOWLIGHT); draw_line(dr, x1, y1-ts, x1-ts, y1-ts, COL_LOWLIGHT); draw_line(dr, x1-ts, y1-ts, x1-ts, y1, COL_LOWLIGHT); draw_line(dr, x1-ts, y1, x0+ts, y1, COL_LOWLIGHT); draw_line(dr, x0+ts, y1, x0+ts, y1-ts, COL_HIGHLIGHT); draw_line(dr, x0+ts, y1-ts, x0, y1-ts, COL_LOWLIGHT); draw_line(dr, x0, y1-ts, x0, y0+ts, COL_HIGHLIGHT); draw_line(dr, x0, y0+ts, x0+ts, y0+ts, COL_HIGHLIGHT); /* phew... */ draw_update(dr, 0, 0, TILE_SIZE * (state->w+3), TILE_SIZE * (state->h+3)); force = 1; ds->started = 1; } if (isflash != ds->isflash) force = 1; /* draw the arena */ for (x = 0; x < state->w; x++) { for (y = 0; y < state->h; y++) { draw_arena_tile(dr, state, ds, ui, x, y, force, isflash); } } /* draw the lasers */ ds->flash_laserno = LASER_EMPTY; if (ui->flash_laser == 1) ds->flash_laserno = ui->flash_laserno; else if (ui->flash_laser == 2 && animtime > 0) ds->flash_laserno = ui->flash_laserno; for (i = 0; i < 2*(state->w+state->h); i++) { draw_laser_tile(dr, state, ds, ui, i, force); } /* draw the 'finish' button */ if (CAN_REVEAL(state)) { int outline = (ui->cur_visible && ui->cur_x == 0 && ui->cur_y == 0) ? COL_CURSOR : COL_BALL; clip(dr, TODRAW(0), TODRAW(0), TILE_SIZE-1, TILE_SIZE-1); draw_circle(dr, TODRAW(0) + ds->crad, TODRAW(0) + ds->crad, ds->crad, outline, outline); draw_circle(dr, TODRAW(0) + ds->crad, TODRAW(0) + ds->crad, ds->crad-2, COL_BUTTON, COL_BUTTON); unclip(dr); } else { draw_rect(dr, TODRAW(0), TODRAW(0), TILE_SIZE-1, TILE_SIZE-1, COL_BACKGROUND); } draw_update(dr, TODRAW(0), TODRAW(0), TILE_SIZE, TILE_SIZE); ds->reveal = state->reveal; ds->isflash = isflash; { char buf[256]; if (ds->reveal) { if (state->nwrong == 0 && state->nmissed == 0 && state->nright >= state->minballs) sprintf(buf, _("CORRECT!")); else sprintf(buf, _("%d wrong and %d missed balls."), state->nwrong, state->nmissed); } else if (state->justwrong) { sprintf(buf, _("Wrong! Guess again.")); } else { if (state->nguesses > state->maxballs) sprintf(buf, _("%d too many balls marked."), state->nguesses - state->maxballs); else if (state->nguesses <= state->maxballs && state->nguesses >= state->minballs) sprintf(buf, _("Click button to verify guesses.")); else if (state->maxballs == state->minballs) sprintf(buf, _("Balls marked: %d / %d"), state->nguesses, state->minballs); else sprintf(buf, _("Balls marked: %d / %d-%d."), state->nguesses, state->minballs, state->maxballs); } if (ui->errors) { if (ui->errors == 1) strcpy(buf + strlen(buf), _(" (1 error)")); else sprintf(buf + strlen(buf), _(" (%d errors)"), ui->errors); } status_bar(dr, buf); } }
static GLuint createPreintegrationTable(const uint8_t* Table) { LBLOG(eq::LOG_CUSTOM) << "Calculating preintegration table" << std::endl; double rInt[256]; rInt[0] = 0.; double gInt[256]; gInt[0] = 0.; double bInt[256]; bInt[0] = 0.; double aInt[256]; aInt[0] = 0.; // Creating SAT (Summed Area Tables) from averaged neighbouring RGBA values for (int i = 1; i < 256; i++) { // average Alpha from two neighbouring TF values const double tauc = (Table[(i - 1) * 4 + 3] + Table[i * 4 + 3]) / 2. / 255.; // SAT of average RGBs from two neighbouring TF values // multiplied with Alpha rInt[i] = rInt[i - 1] + (Table[(i - 1) * 4 + 0] + Table[i * 4 + 0]) / 2. * tauc; gInt[i] = gInt[i - 1] + (Table[(i - 1) * 4 + 1] + Table[i * 4 + 1]) / 2. * tauc; bInt[i] = bInt[i - 1] + (Table[(i - 1) * 4 + 2] + Table[i * 4 + 2]) / 2. * tauc; // SAT of average Alpha values aInt[i] = aInt[i - 1] + tauc; } std::vector<GLubyte> lookupImg(256 * 256 * 4, 255); // Preint Texture int lookupindex = 0; for (int sb = 0; sb < 256; sb++) { for (int sf = 0; sf < 256; sf++) { int smin, smax; if (sb < sf) { smin = sb; smax = sf; } else { smin = sf; smax = sb; } double rcol, gcol, bcol, acol; if (smax != smin) { const double factor = 1. / (double)(smax - smin); rcol = (rInt[smax] - rInt[smin]) * factor; gcol = (gInt[smax] - gInt[smin]) * factor; bcol = (bInt[smax] - bInt[smin]) * factor; acol = exp(-(aInt[smax] - aInt[smin]) * factor) * 255.; } else { const int index = smin * 4; const double factor = 1. / 255.; rcol = Table[index + 0] * Table[index + 3] * factor; gcol = Table[index + 1] * Table[index + 3] * factor; bcol = Table[index + 2] * Table[index + 3] * factor; acol = exp(-Table[index + 3] * factor) * 256.; } lookupImg[lookupindex++] = clip(static_cast<int>(rcol), 0, 255); lookupImg[lookupindex++] = clip(static_cast<int>(gcol), 0, 255); lookupImg[lookupindex++] = clip(static_cast<int>(bcol), 0, 255); lookupImg[lookupindex++] = clip(static_cast<int>(acol), 0, 255); } } GLuint preintName = 0; glGenTextures(1, &preintName); glBindTexture(GL_TEXTURE_2D, preintName); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, &lookupImg[0]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); return preintName; }
void writeFrames(const Kinect::FrameSource::IntrinsicParameters& ip,const Kinect::FrameBuffer& color,const Kinect::MeshBuffer& mesh,const char* lwoFileName) { /* Create the texture file name: */ std::string textureFileName(lwoFileName,Misc::getExtension(lwoFileName)); textureFileName.append("-color.png"); /* Write the color frame as a texture image: */ { Images::RGBImage texImage(color.getSize(0),color.getSize(1)); Images::RGBImage::Color* tiPtr=texImage.modifyPixels(); const unsigned char* cfPtr=reinterpret_cast<const unsigned char*>(color.getBuffer()); for(int y=0;y<color.getSize(1);++y) for(int x=0;x<color.getSize(0);++x,++tiPtr,cfPtr+=3) *tiPtr=Images::RGBImage::Color(cfPtr); Images::writeImageFile(texImage,textureFileName.c_str()); } /* Open the LWO file: */ IO::FilePtr lwoFile=IO::openFile(lwoFileName,IO::File::WriteOnly); lwoFile->setEndianness(Misc::BigEndian); /* Create the LWO file structure via the FORM chunk: */ { IFFChunkWriter form(lwoFile,"FORM"); form.write<char>("LWO2",4); /* Create the TAGS chunk: */ { IFFChunkWriter tags(&form,"TAGS"); tags.writeString("ColorImage"); tags.writeChunk(); } /* Create the LAYR chunk: */ { IFFChunkWriter layr(&form,"LAYR"); layr.write<Misc::UInt16>(0U); layr.write<Misc::UInt16>(0x0U); for(int i=0;i<3;++i) layr.write<Misc::Float32>(0.0f); layr.writeString("DepthImage"); layr.writeChunk(); } /* Create an index map for all vertices to omit unused vertices: */ unsigned int* indices=new unsigned int[mesh.numVertices]; for(unsigned int i=0;i<mesh.numVertices;++i) indices[i]=~0x0U; unsigned int numUsedVertices=0; /* Create the PNTS, BBOX and VMAP chunks in one go: */ { typedef Kinect::FrameSource::IntrinsicParameters::PTransform PTransform; typedef PTransform::Point Point; typedef Geometry::Box<Point::Scalar,3> Box; IFFChunkWriter bbox(&form,"BBOX"); IFFChunkWriter pnts(&form,"PNTS"); IFFChunkWriter vmap(&form,"VMAP"); /* Write the VMAP header: */ vmap.write<char>("TXUV",4); vmap.write<Misc::UInt16>(2U); vmap.writeString("ColorImageUV"); /* Process all triangle vertices: */ Box pBox=Box::empty; const Kinect::MeshBuffer::Vertex* vertices=mesh.getVertices(); const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices(); for(unsigned int i=0;i<mesh.numTriangles*3;++i,++tiPtr) { /* Check if the triangle vertex doesn't already have an index: */ if(indices[*tiPtr]==~0x0U) { /* Assign an index to the triangle vertex: */ indices[*tiPtr]=numUsedVertices; /* Transform the mesh vertex to camera space using the depth projection matrix: */ Point dp(vertices[*tiPtr].position.getXyzw()); Point cp=ip.depthProjection.transform(dp); /* Transform the depth-space point to texture space using the color projection matrix: */ Point tp=ip.colorProjection.transform(dp); /* Add the point to the bounding box: */ pBox.addPoint(cp); /* Store the point and its texture coordinates: */ pnts.writePoint(cp); vmap.writeVarIndex(numUsedVertices); for(int i=0;i<2;++i) vmap.write<Misc::Float32>(tp[i]); ++numUsedVertices; } } /* Write the bounding box: */ bbox.writeBox(pBox); /* Write the BBOX, PNTS, and VMAP chunks: */ bbox.writeChunk(); pnts.writeChunk(); vmap.writeChunk(); } /* Create the POLS chunk: */ { IFFChunkWriter pols(&form,"POLS"); pols.write<char>("FACE",4); const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices(); for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex,tiPtr+=3) { pols.write<Misc::UInt16>(3U); for(int i=0;i<3;++i) pols.writeVarIndex(indices[tiPtr[2-i]]); } pols.writeChunk(); } /* Delete the vertex index map: */ delete[] indices; /* Create the PTAG chunk: */ { IFFChunkWriter ptag(&form,"PTAG"); ptag.write<char>("SURF",4); for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex) { ptag.writeVarIndex(triangleIndex); ptag.write<Misc::UInt16>(0U); } ptag.writeChunk(); } /* Create the CLIP chunk: */ { IFFChunkWriter clip(&form,"CLIP"); clip.write<Misc::UInt32>(1U); /* Create the STIL chunk: */ { IFFChunkWriter stil(&clip,"STIL",true); stil.writeString(textureFileName.c_str()); stil.writeChunk(); } clip.writeChunk(); } /* Create the SURF chunk: */ { IFFChunkWriter surf(&form,"SURF"); surf.writeString("ColorImage"); surf.writeString(""); /* Create the SIDE subchunk: */ { IFFChunkWriter side(&surf,"SIDE",true); side.write<Misc::UInt16>(3U); side.writeChunk(); } /* Create the SMAN subchunk: */ { IFFChunkWriter sman(&surf,"SMAN",true); sman.write<Misc::Float32>(Math::rad(90.0f)); sman.writeChunk(); } /* Create the COLR subchunk: */ { IFFChunkWriter colr(&surf,"COLR",true); colr.writeColor(1.0f,1.0f,1.0f); colr.writeVarIndex(0U); colr.writeChunk(); } /* Create the DIFF subchunk: */ { IFFChunkWriter diff(&surf,"DIFF",true); diff.write<Misc::Float32>(1.0f); diff.writeVarIndex(0U); diff.writeChunk(); } /* Create the LUMI subchunk: */ { IFFChunkWriter lumi(&surf,"LUMI",true); lumi.write<Misc::Float32>(0.0f); lumi.writeVarIndex(0U); lumi.writeChunk(); } /* Create the BLOK subchunk: */ { IFFChunkWriter blok(&surf,"BLOK",true); /* Create the IMAP subchunk: */ { IFFChunkWriter imap(&blok,"IMAP",true); imap.writeString("1"); /* Create the CHAN subchunk: */ { IFFChunkWriter chan(&imap,"CHAN",true); chan.write<char>("COLR",4); chan.writeChunk(); } imap.writeChunk(); } /* Create the PROJ subchunk: */ { IFFChunkWriter proj(&blok,"PROJ",true); proj.write<Misc::UInt16>(5U); proj.writeChunk(); } /* Create the IMAG subchunk: */ { IFFChunkWriter imag(&blok,"IMAG",true); imag.writeVarIndex(1U); imag.writeChunk(); } /* Create the VMAP subchunk: */ { IFFChunkWriter vmap(&blok,"VMAP",true); vmap.writeString("ColorImageUV"); vmap.writeChunk(); } blok.writeChunk(); } /* Write the SURF chunk: */ surf.writeChunk(); } /* Write the FORM chunk: */ form.writeChunk(); } }
void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to) const { if (to < 0) to = run.length(); QPainter *p = ctx->platformContext(); if (ctx->textDrawingMode() & cTextFill) { if (ctx->fillGradient()) { QBrush brush(*ctx->fillGradient()->platformGradient()); brush.setTransform(ctx->fillGradient()->gradientSpaceTransform()); p->setPen(QPen(brush, 0)); } else if (ctx->fillPattern()) { TransformationMatrix affine; p->setPen(QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0)); } else p->setPen(QColor(ctx->fillColor())); } if (ctx->textDrawingMode() & cTextStroke) { if (ctx->strokeGradient()) { QBrush brush(*ctx->strokeGradient()->platformGradient()); brush.setTransform(ctx->strokeGradient()->gradientSpaceTransform()); p->setPen(QPen(brush, ctx->strokeThickness())); } else if (ctx->strokePattern()) { TransformationMatrix affine; p->setPen(QPen(QBrush(ctx->strokePattern()->createPlatformPattern(affine)), ctx->strokeThickness())); } else p->setPen(QPen(QColor(ctx->strokeColor()), ctx->strokeThickness())); } const QString string = fixSpacing(qstring(run)); // text shadow IntSize shadowSize; int shadowBlur; Color shadowColor; bool hasShadow = ctx->textDrawingMode() == cTextFill && ctx->getShadow(shadowSize, shadowBlur, shadowColor); if (from > 0 || to < run.length()) { QTextLayout layout(string, font()); QTextLine line = setupLayout(&layout, run); float x1 = line.cursorToX(from); float x2 = line.cursorToX(to); if (x2 < x1) qSwap(x1, x2); QFontMetrics fm(font()); int ascent = fm.ascent(); QRectF clip(point.x() + x1, point.y() - ascent, x2 - x1, fm.height()); if (hasShadow) { // TODO: when blur support is added, the clip will need to account // for the blur radius qreal dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0; if (shadowSize.width() > 0) dx2 = shadowSize.width(); else dx1 = -shadowSize.width(); if (shadowSize.height() > 0) dy2 = shadowSize.height(); else dy1 = -shadowSize.height(); // expand the clip rect to include the text shadow as well clip.adjust(dx1, dx2, dy1, dy2); } p->save(); p->setClipRect(clip.toRect()); QPointF pt(point.x(), point.y() - ascent); if (hasShadow) { p->save(); p->setPen(QColor(shadowColor)); p->translate(shadowSize.width(), shadowSize.height()); line.draw(p, pt); p->restore(); } line.draw(p, pt); p->restore(); return; } p->setFont(font()); QPointF pt(point.x(), point.y()); int flags = run.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight; if (hasShadow) { // TODO: text shadow blur support p->save(); p->setPen(QColor(shadowColor)); p->translate(shadowSize.width(), shadowSize.height()); p->drawText(pt, string, flags, run.padding()); p->restore(); } if (ctx->textDrawingMode() & cTextStroke) { QPainterPath path; path.addText(pt, font(), string); p->strokePath(path, p->pen()); } if (ctx->textDrawingMode() & cTextFill) p->drawText(pt, string, flags, run.padding()); }
void GraphicsContext::clip(const IntRect& rect) { clip(FloatRect(rect)); }
static void async_targets_selection_received( GtkWidget *WXUNUSED(widget), GtkSelectionData *selection_data, guint32 WXUNUSED(time), wxClipboardGtk *clipboard ) { if ( !clipboard ) // Assert? return; if (!clipboard->m_sink) return; wxClipboardEvent *event = new wxClipboardEvent(wxEVT_CLIPBOARD_CHANGED); event->SetEventObject( clipboard ); int selection_data_length = 0; if (selection_data) selection_data_length = gtk_selection_data_get_length(selection_data); if (selection_data_length <= 0) { clipboard->m_sink->QueueEvent( event ); clipboard->m_sink.Release(); return; } // make sure we got the data in the correct form GdkAtom type = gtk_selection_data_get_data_type(selection_data); if ( type != GDK_SELECTION_TYPE_ATOM ) { if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 ) { wxLogTrace( TRACE_CLIPBOARD, wxT("got unsupported clipboard target") ); clipboard->m_sink->QueueEvent( event ); clipboard->m_sink.Release(); return; } } // it's not really a format, of course, but we can reuse its GetId() method // to format this atom as string wxDataFormat clip(gtk_selection_data_get_selection(selection_data)); wxLogTrace( TRACE_CLIPBOARD, wxT("Received available formats for clipboard %s"), clip.GetId().c_str() ); // the atoms we received, holding a list of targets (= formats) const GdkAtom* const atoms = (GdkAtom*)gtk_selection_data_get_data(selection_data); for (size_t i = 0; i < selection_data_length / sizeof(GdkAtom); i++) { const wxDataFormat format(atoms[i]); wxLogTrace(TRACE_CLIPBOARD, wxT("\t%s"), format.GetId().c_str()); event->AddFormat( format ); } clipboard->m_sink->QueueEvent( event ); clipboard->m_sink.Release(); }
void PlatformGraphicsContextRecording::canvasClip(const Path& path) { clip(path); }
void GraphicsContext::canvasClip(const Path& path) { clip(path); }
void LLScrollableContainerView::draw() { if (mAutoScrolling) { // add acceleration to autoscroll mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), MAX_AUTO_SCROLL_RATE); } else { // reset to minimum mAutoScrollRate = MIN_AUTO_SCROLL_RATE; } // clear this flag to be set on next call to handleDragAndDrop mAutoScrolling = FALSE; // auto-focus when scrollbar active // this allows us to capture user intent (i.e. stop automatically scrolling the view/etc) if (!gFocusMgr.childHasKeyboardFocus(this) && (mScrollbar[VERTICAL]->hasMouseCapture() || mScrollbar[HORIZONTAL]->hasMouseCapture())) { focusFirstItem(); } // Draw background if( mIsOpaque ) { gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); gGL.color4fv( mBackgroundColor.mV ); gl_rect_2d( mInnerRect ); } // Draw mScrolledViews and update scroll bars. // get a scissor region ready, and draw the scrolling view. The // scissor region ensures that we don't draw outside of the bounds // of the rectangle. if( mScrolledView ) { updateScroll(); // Draw the scrolled area. { S32 visible_width = 0; S32 visible_height = 0; BOOL show_v_scrollbar = FALSE; BOOL show_h_scrollbar = FALSE; calcVisibleSize( mScrolledView->getRect(), &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar ); LLLocalClipRect clip(LLRect(mInnerRect.mLeft, mInnerRect.mBottom + (show_h_scrollbar ? SCROLLBAR_SIZE : 0) + visible_height, visible_width, mInnerRect.mBottom + (show_h_scrollbar ? SCROLLBAR_SIZE : 0) )); drawChild(mScrolledView); } } // Highlight border if a child of this container has keyboard focus if( mBorder->getVisible() ) { mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus(this) ); } // Draw all children except mScrolledView // Note: scrollbars have been adjusted by above drawing code for (child_list_const_reverse_iter_t child_iter = getChildList()->rbegin(); child_iter != getChildList()->rend(); ++child_iter) { LLView *viewp = *child_iter; if( sDebugRects ) { sDepth++; } if( (viewp != mScrolledView) && viewp->getVisible() ) { drawChild(viewp); } if( sDebugRects ) { sDepth--; } } if (sDebugRects) { drawDebugRect(); } } // end draw
virtual void drawInContext(PlatformGraphicsContext* context) { if (!m_owner) return; CGContextSaveGState(context); CGRect layerBounds = bounds(); if (m_owner->contentsOrientation() == WebCore::GraphicsLayer::CompositingCoordinatesTopDown) { CGContextScaleCTM(context, 1, -1); CGContextTranslateCTM(context, 0, -layerBounds.size.height); } if (m_owner->client()) { GraphicsContext graphicsContext(context); // It's important to get the clip from the context, because it may be significantly // smaller than the layer bounds (e.g. tiled layers) CGRect clipBounds = CGContextGetClipBoundingBox(context); IntRect clip(enclosingIntRect(clipBounds)); m_owner->paintGraphicsLayerContents(graphicsContext, clip); } #ifndef NDEBUG else { ASSERT_NOT_REACHED(); // FIXME: ideally we'd avoid calling -setNeedsDisplay on a layer that is a plain color, // so CA never makes backing store for it (which is what -setNeedsDisplay will do above). CGContextSetRGBFillColor(context, 0.0f, 1.0f, 0.0f, 1.0f); CGContextFillRect(context, layerBounds); } #endif if (m_owner->showRepaintCounter()) { String text = String::format("%d", m_owner->incrementRepaintCount());; CGContextSaveGState(context); CGContextSetRGBFillColor(context, 1.0f, 0.0f, 0.0f, 0.8f); CGRect aBounds = layerBounds; aBounds.size.width = 10 + 12 * text.length(); aBounds.size.height = 25; CGContextFillRect(context, aBounds); FontDescription desc; NONCLIENTMETRICS metrics; metrics.cbSize = sizeof(metrics); SystemParametersInfo(SPI_GETNONCLIENTMETRICS, metrics.cbSize, &metrics, 0); FontFamily family; family.setFamily(metrics.lfSmCaptionFont.lfFaceName); desc.setFamily(family); desc.setComputedSize(22); Font font = Font(desc, 0, 0); font.update(0); GraphicsContext cg(context); cg.setFillColor(Color::black, DeviceColorSpace); cg.drawText(font, TextRun(text), IntPoint(aBounds.origin.x + 3, aBounds.origin.y + 20)); CGContextRestoreGState(context); } CGContextRestoreGState(context); }
void update(objectmachine_t *obj, player_t **team, int team_size, brick_list_t *brick_list, item_list_t *item_list, object_list_t *object_list) { objectdecorator_t *dec = (objectdecorator_t*)obj; objectmachine_t *decorated_machine = dec->decorated_machine; object_t *object = obj->get_object_instance(obj); player_t *player = enemy_get_observed_player(object); objectdecorator_lockcamera_t *me = (objectdecorator_lockcamera_t*)obj; actor_t *act = object->actor, *ta; float rx, ry, rw, rh; int x1, x2, y1, y2; int i; /* configuring the rectangle */ get_rectangle_coordinates(me, &x1, &y1, &x2, &y2); update_rectangle_coordinates(me, x1, y1, x2, y2); /* my rectangle, in world coordinates */ rx = act->position.x + x1; ry = act->position.y + y1; rw = x2 - x1; rh = y2 - y1; /* only the observed player can enter this area */ for(i=0; i<team_size; i++) { ta = team[i]->actor; if(team[i] != player) { /* hey, you can't enter here! */ float border = 30.0f; if(ta->position.x > rx - border && ta->position.x < rx) { ta->position.x = rx - border; ta->speed.x = 0.0f; } if(ta->position.x > rx + rw && ta->position.x < rx + rw + border) { ta->position.x = rx + rw + border; ta->speed.x = 0.0f; } } else { /* test if the player has got inside my rectangle */ float a[4], b[4]; a[0] = ta->position.x; a[1] = ta->position.y; a[2] = ta->position.x + 1; a[3] = ta->position.y + 1; b[0] = rx; b[1] = ry; b[2] = rx + rw; b[3] = ry + rh; if(bounding_box(a, b)) { /* welcome, player! You have been locked. BWHAHAHA!!! */ me->has_locked_somebody = TRUE; team[i]->in_locked_area = TRUE; level_lock_camera(rx, ry, rx+rw, ry+rh); } } } /* cage */ if(me->has_locked_somebody) { ta = player->actor; if(ta->position.x < rx) { ta->position.x = rx; ta->speed.x = max(0.0f, ta->speed.x); player->at_some_border = TRUE; } if(ta->position.x > rx + rw) { ta->position.x = rx + rw; ta->speed.x = min(0.0f, ta->speed.x); player->at_some_border = TRUE; } ta->position.y = clip(ta->position.y, ry, ry + rh); } decorated_machine->update(decorated_machine, team, team_size, brick_list, item_list, object_list); }
void line_search(int n, float *x, float *grad, float *direction, sf_gradient gradient, sf_optim opt, float *threshold, int *flag, int cpuid, int type) /*< line search (Wolfe condition) >*/ { int i, j; float m1, m2, m3, fcost, alpha1=0., alpha2=0.; float *xk; xk=sf_floatalloc(n); copy(n, x, xk); dot_product(n, grad, direction, &m1); m2=m1*opt->c2; m1=m1*opt->c1; for(i=0; i<opt->nls; i++){ opt->ils += 1; for(j=0; j<n; j++) x[j] =xk[j] + opt->alpha*direction[j]; /* seislet regularization */ if(seislet){ seislet_lop(true, false, n, n, ss, x); soft_thresholding(ss, n, pclip); seislet_lop(false, false, n, n, ss, x); } /* model constraints */ if(type==1){ clip(x, n, threshold[0], threshold[1]); }else if(type==2){ clip(x, n/2, threshold[0], threshold[1]); clip(x+n/2, n/2, threshold[2], threshold[3]); } gradient(x, &fcost, grad); opt->igrad += 1; dot_product(n, grad, direction, &m3); if(cpuid==0){ sf_warning("line search i=%d",i+1); sf_warning("alpha1=%f alpha2=%f alpha=%f",alpha1, alpha2, opt->alpha); sf_warning("fcost=%f fk=%f fk+c1*alpha*m1=%f m3=%f c2*m1=%f ",fcost, opt->fk, opt->fk+opt->alpha*m1, m3, m2); } //if(counter1==4 && i==0) return; /* Wolfe condition */ if(fcost <= opt->fk + opt->alpha*m1 && m3 >= m2){ opt->fk=fcost; *flag=0; break; }else if (fcost > opt->fk + opt->alpha*m1){ alpha2=opt->alpha; opt->alpha=0.5*(alpha1+alpha2); }else{ alpha1=opt->alpha; if(alpha2 == 0.) opt->alpha *= opt->factor; else opt->alpha = 0.5*(alpha1+alpha2); } if(cpuid==0){ sf_warning("After adjustment, alpha1=%f alpha2=%f alpha=%f",alpha1, alpha2, opt->alpha); } } // end of line search if(i==opt->nls){ if(fcost <= opt->fk) *flag=1; else *flag=2; } free(xk); }
static void showpartner() { register int i, k; register char *p, *p1; auto int firsttime[2][2]; memset(firsttime, 0, sizeof(firsttime)); for (k = 0; k < 2; k++) { if (((k == 0) && showincoming) || ((k == 1) && showoutgoing)) { for (i = 0; i < knowns; i++) if (partner[k][i].ncalls) { if (k) { if (!firsttime[k][0]) { printf("\nAngerufene (dialout) calls Charge Duration Computed\n"); strich('-', 71); firsttime[k][0] = 1; } /* if */ printf("%-25s %5d %12s %s %12s\n", clip(onlynumbers ? partner[k][i].num : known[i]->who, 25), partner[k][i].ncalls, printRate(partner[k][i].pay), timestr(partner[k][i].duration), printRate(partner[k][i].compute)); } else { if (!firsttime[k][0]) { printf("\nAnrufer (dialin) calls Duration\n"); strich('-', 41); firsttime[k][0] = 1; } /* if */ printf("%-25s %5d %s\n", clip(onlynumbers ? partner[k][i].num : known[i]->who, 25), partner[k][i].ncalls, timestr(partner[k][i].duration)); } /* else */ } /* if */ printf("\n"); for (i = 0; i < nunknown[k]; i++) if (unknown[k][i].ncalls) { p = beautify(unknown[k][i].num); if (k) { if (!firsttime[k][1]) { printf("\nunbekannte Angerufene (dialout) von calls Charge Duration Computed\n"); strich('-', 95); firsttime[k][1] = 1; } /* if */ p1 = msnsum[SUBTOTAL][unknown[k][i].si1][unknown[k][i].ihome].alias; printf("%-16s <- %-12s %5d %12s %s %12s\n", p, clip(p1 ? p1 : "", 16), unknown[k][i].ncalls, printRate(unknown[k][i].pay), timestr(unknown[k][i].duration), printRate(unknown[k][i].compute)); } else { if (!firsttime[k][1]) { printf("\nunbekannte Anrufer (dialin) an Rufnummer calls Duration\n"); strich('-', 64); firsttime[k][1] = 1; } /* if */ printf("%-16s -> %-12s %5d %s\n", p, msnsum[SUBTOTAL][unknown[k][i].si1][unknown[k][i].ihome].alias, unknown[k][i].ncalls, timestr(unknown[k][i].duration)); } /* else */ } /* if */ } /* if */ } /* for */ } /* showpartner */