1. Introduction
This specification defines mechanisms for driving the progress of an animation based on the scroll progress of a scroll container.
1.1. Relationship to other specifications
Web Animations [WEB-ANIMATIONS-1] defines an abstract conceptual model for animations on the Web platform, with elements of the model including animations and their timelines, and associated programming interfaces.
This specification extends this model by defining a new type of animation timeline: a scroll timeline.
This specification defines both programming interfaces for interacting with these concepts, as well as CSS markup which applies these concepts to CSS Animations [CSS3-ANIMATIONS].
The behavior of the CSS markup is described in terms of the programming interfaces. User agents that do not support script may still implement the CSS markup provided it behaves as if the underlying programming interfaces were in place.
1.2. Relationship to asynchronous scrolling
Some user agents support scrolling that is asynchronous with respect to layout or script. This specification is intended to be compatible with such an architecture.
Specifically, this specification allows expressing scroll-linked effects in a way that does not require script to run each time the effect is sampled. User agents that support asynchronous scrolling are allowed (but not required) to sample such effects asynchronously as well.
1.3. Value Definitions
This specification follows the CSS property definition conventions from [CSS2] using the value definition syntax from [CSS-VALUES-3]. Value types not defined in this specification are defined in CSS Values & Units [CSS-VALUES-3]. Combination with other CSS modules may expand the definitions of these value types.
In addition to the property-specific values listed in their definitions, all properties defined in this specification also accept the CSS-wide keywords as their property value. For readability they have not been repeated explicitly.
2. Use cases
This section is non-normative
Note: Based on this curated list of use cases.
These use cases need updating. <https://github.com/w3c/csswg-drafts/issues/4354>
2.1. Scrollable picture-story show
It is sometimes desired to use an animation to tell a story where the user controls the progress of the animation by scrolling or some other gesture. This may be because the animation contains a lot of textual information which the user may wish to peruse more slowly, it may be for accessibility considerations to accommodate users who are uncomfortable with rapid animation, or it may simply be to allow the user to easily return to previous parts of the story such as a story that introduces a product where the user wishes to review previous information.
The following (simplified) example shows two balls colliding. The animation is controlled by scroll position allowing the user to easily rewind and replay the interaction.
Using the CSS markup:
@media ( prefers-reduced-motion: no-preference) { div.circle{ animation-duration : 1 s ; animation-timing-function : linear; animation-timeline : collision-timeline; } #left-circle{ animation-name : left-circle; } #right-circle{ animation-name : right-circle; } #union-circle{ animation-name : union-circle; animation-fill-mode : forwards; animation-timeline : union-timeline; } @scroll-timeline collision-timeline{ source : selector ( #container); orientation : block; scroll-offsets : 200 px , 300 px ; } @scroll-timeline union-timeline{ source : selector ( #container); orientation : block; scroll-offsets : 250 px , 300 px ; } @keyframes left-circle{ to{ transform : translate ( 300 px ) } } @keyframes right-circle{ to{ transform : translate ( 350 px ) } } @keyframes union-circle{ to{ opacity : 1 } } }
Using the programming interface, we might write this as:
if ( window. matchMedia( '(prefers-reduced-motion: no-preference)' ). matches) { const scrollableElement= document. querySelector( '#container' ); const collisionTimeline= new ScrollTimeline({ source: scrollableElement, scrollOffsets: [ CSS. px( 200 ), CSS. px( 300 )] }); const left= leftCircle. animate({ transform: 'translate(300px)' }, 1000 ); left. timeline= collisionTimeline; const right= leftCircle. animate({ transform: 'translate(350px)' }, 1000 ); right. timeline= collisionTimeline; const union= unionCircle. animate({ opacity: 1 }, { duration: 1000 , fill: "forwards" }); union. timeline= new ScrollTimeline({ source: scrollableElement, scrollOffsets: [ CSS. px( 250 ), CSS. px( 300 )] }); }
2.2. The content progress bar
Another common example of an animation that tracks scroll position is a progress bar that is used to indicate the reader’s position in a long article.
Typically, the scroll bar provides this visual indication but applications may wish to hide the scroll bar for aesthetic or useability reasons.
Using the updated animation shorthand that includes animation-timeline, this example could be written as follows:
@media ( prefers-reduced-motion: no-preference) { @scroll-timeline progress-timeline{ source : selector ( #body); scroll-offsets : 0 , 100 % ; } @keyframes progress{ to{ width : 100 % ; } } #progress{ width : 0 px ; height : 30 px ; background : red; animation : 1 s linear forwards progress progress-timeline; } }
If we use this API for this case, the example code will be as follow:
if ( window. matchMedia( '(prefers-reduced-motion: no-preference)' ). matches) { var animation= div. animate({ width: '100%' }, { duration: 1000 , fill: "forwards" }); animation. timeline= new ScrollTimeline( { scrollOffsets: [ 0 , CSS. percent( 100 )] } ); }
2.3. Combination scroll and time-base animations
2.3.1. Photo viewer
We are currently reworking this use case
3. Scroll-driven animations
3.1. Scroll timelines
3.1.1. The ScrollDirection
enumeration
enum {
ScrollDirection ,
"block" ,
"inline" ,
"horizontal" };
"vertical"
The ScrollDirection
enumeration specifies a direction of scroll of a
scrollable element.
block
-
Selects the direction along the block axis, conforming to writing mode and directionality.
inline
-
Selects the direction along the inline axis, confirming to writing mode and directionality.
horizontal
-
Selects the physical horizontal direction (ignoring writing mode and directionality).
vertical
-
Selects the physical vertical direction (ignoring writing mode and directionality).
Note: Having both logical (block/inline) and physical (vertical/horizontal) directions allows web developers to animate both logical (e.g. margin-inline-start) and physical (e.g. transform) properties with good behavior under different directionalities and writing modes.
3.1.2. The ScrollTimeline
interface
enum {
ScrollTimelineAutoKeyword };
"auto" typedef (CSSNumericValue or CSSKeywordish );
ContainerBasedOffset typedef (ContainerBasedOffset or ElementBasedOffset );
ScrollTimelineOffset dictionary {
ScrollTimelineOptions Element ?;
source ScrollDirection = "block";
orientation sequence <ScrollTimelineOffset >= []; (
scrollOffsets double or ScrollTimelineAutoKeyword )= "auto"; }; [
timeRange Exposed =Window ]interface :
ScrollTimeline AnimationTimeline {constructor (optional ScrollTimelineOptions = {});
options readonly attribute Element ?source ;readonly attribute ScrollDirection orientation ;readonly attribute FrozenArray <ScrollTimelineOffset >scrollOffsets ;readonly attribute (double or ScrollTimelineAutoKeyword )timeRange ; };
A scroll timeline is an AnimationTimeline
whose time values are
determined not by wall-clock time, but by the progress of scrolling in a scroll container.
ScrollTimeline(options)
-
Creates a new
ScrollTimeline
object using the following procedure:-
Let timeline be a new
ScrollTimeline
object. -
Let source be the result corresponding to the first matching condition from the following:
- If the
source
member of options is missing, -
The
scrollingElement
of theDocument
associated with theWindow
that is the current global object. - Otherwise,
-
The
source
member of options.
- If the
-
Set the
source
of timeline to source. -
Assign the
orientation
,scrollOffsets
andtimeRange
properties of timeline to the corresponding value from options.
-
source
, of type Element, readonly, nullable-
The scrollable element whose scrolling triggers the activation and drives the progress of the timeline.
orientation
, of type ScrollDirection, readonly-
Determines the direction of scrolling which triggers the activation and drives the progress of the timeline.
scrollOffsets
, of type FrozenArray<ScrollTimelineOffset>, readonly-
scroll timeline offsets which determine the effective scroll offsets in the direction specified by
orientation
that constitute the equally-distanced in progress intervals in which the timeline is active.The procedure to set the offset value with val as the provided value, pos as the position in
scrollOffsets
and size as thescrollOffsets
array size has the following steps:-
If val is a
DOMString
, let val be the result of rectifying the keywordish value. -
Set the offset value to be the result corresponding to the first matching condition from the following:
- If val is a
CSSKeywordValue
and matches the grammarauto
and pos equals to 0 or size - 1: -
Return val.
- If val is a
CSSNumericValue
and matches the grammar <length-percentage>: -
Return val.
- If val is an
ElementBasedOffset
: -
Return val.
- Otherwise,
-
Do not set the value and throw a
DOMException
with error nameSyntaxError
.
- If val is a
-
timeRange
, of type(double or ScrollTimelineAutoKeyword)
, readonly-
A time duration that allows mapping between a distance scrolled, and quantities specified in time units, such as an animation’s duration and start delay.
Conceptually,
timeRange
represents the number of milliseconds to map to the scroll range defined bystart
andend
. As a result, this value does not have a correspondence to wall-clock time.This value is used to compute the timeline’s effective time range, and the mapping is then defined by mapping the scroll distance from
start
toend
, to the effective time range.
We are working to remove the need for timeRange
to be declared.
The most recent work on this involved introduction of the concept of
"progress-based animations" to web animations. <https://github.com/w3c/csswg-drafts/issues/4862>
3.1.3. Scroll Timeline Offset
An effective scroll offset is a scroll position for a given scroll container and on a given scroll direction.
A scroll timeline offset is provided by authors and determines a effective scroll offset for the source
and in the direction specified by orientation
.
There are two types of scroll timeline offset: container-based offset, and element-based offset. To resolve a scroll timeline offset into an effective scroll offset, run the procedure to resolve a container-based offset or to resolve an element-based offset depending on the offset type. It is possible for a scroll timeline offset to be resolved to null.
The effective start offset is the value of first offset in effective scroll offsets array or null if the array is empty.
The effective end offset is the value of last offset in effective scroll offsets array or null if the array is empty.
<IP_ADDRESS>. Container-based Offset
A container-based offset is a scroll timeline offset that is declared only in relation with the scroll container as specified bysource
.
A container-based offset is provided in the CSSNumericValue
or CSSKeywordValue
forms.
The procedure to resolve a container-based offset given offset and a flag is first (to indicate if the offset is being inserted first into effective scroll offsets) is as follows:
-
If any of the following are true:
-
source
is null, or -
source
does not currently have a CSS layout box, or -
source
's layout box is not a scroll container.
The effective scroll offset is null and abort remaining steps.
-
-
The effective scroll offset is the scroll offset corresponding to the first matching condition from the following:
- If offset is a
CSSKeywordValue
and matchesauto
: -
The beginning of
source
's scroll range inorientation
if is first is true or the ending ofsource
's scroll range inorientation
otherwise. - If offset is a
CSSNumericValue
and matches <length-percentage>: -
The distance indicated by the value along
source
's scroll range inorientation
as expressed by absolute length, a percentage, or a calc() expression that resolves to a <length>. - Otherwise,
-
null.
- If offset is a
Note: The scroll range of an element is the range defined by its minimum and maximum scroll offsets which are determined by it scrolling box, padding box, and overflow direction.
Note: Container-based scroll offsets cannot be provided as bare numbers but
should be CSSNumericValue
. This way the full richness of CSSNumericValue
APIs can be used to provide the offset in percentages, various length units or
'calc()' expressions. For example CSS.percent(50)
, CSS.px(200)
, or CSS.vh(10)
are valid and represent 50%
, 200px
, and 10vh
.
Note: It is valid to provide a length or percentage based offset such that it is outside the source’s scroll range and thus not reachable e.g., '120%'.
<IP_ADDRESS>. Element-based Offset
An element-based offset is a scroll timeline offset that is declared
in terms of the intersection of the scroll container as specified by source
and one of its descendants as specified by target
.
An element-based offset is provided in the ElementBasedOffset
form.
enum {
Edge ,
"start" };
"end" dictionary {
ElementBasedOffset Element target ;Edge edge = "start";double threshold = 0.0; };
target
, of type Element-
The target whose intersection with
source
's scrolling box determines the concrete scroll offset. edge
, of type Edge, defaulting to"start"
-
The edge of
source
's scrolling box in the direction specified by theorientation
which the target should intersect with. threshold
, of type double, defaulting to0.0
-
A double in the range of [0.0, 1.0] that represent the percentage of the target that is expected to be visible in
source
's scrollport at the intersection offset.
The range of the threshold
member is not currently
checked anywhere. <https://github.com/w3c/csswg-drafts/issues/5203>
The procedure to resolve an element-based offset given offset is as follows:
-
If any of the following are true:
-
source
is null, or -
source
does not currently have a CSS layout box, or -
source
's layout box is not a scroll container.
The effective scroll offset is null and abort remaining steps.
-
-
Let target be offset’s
target
. -
If any of the following are true:
-
target is null, or
-
target does not currently have a CSS layout box.
The effective scroll offset is null and abort remaining steps.
-
-
If target 's nearest scroll container ancestor is not
source
abort remaining steps since the effective scroll offset is null. -
Let container box be the
source
's scrollport. -
Let target box be the result of finding the rectangular bounding box (axis-aligned in
source
’s coordinate space) of target’s transformed border box. -
If offset’s
edge
is start then let scroll offset be the scroll offset at which container box’s start edge is flush with the target box’s end edge in the axis and direction determined byorientation
. -
If offset’s
edge
is end then let scroll offset be the scroll offset at which container box’s end edge is flush with the target box’s start edge in the axis and direction determined byorientation
. -
Let threshold amount be the result of evaluating the following expression where target dimension is target box’s dimension in the axis determined by
orientation
.threshold amount =
threshold
× target dimension -
Adjust scroll offset by threshold amount as follow:
-
Clamp the value of scroll offset to be within the
source
's scroll range. -
The effective scroll offset is scroll offset
Note that here we are expecting a typical top to bottom scrolling and thus consider the entrance to coincide when target’s start edge is flushed with scrollport’s end edge and viceversa for exit.
if ( window. matchMedia( '(prefers-reduced-motion: no-preference)' ). matches) { const scrollableElement= document. querySelector( '#container' ); const image= document. querySelector( '#image' ); const timeline= new ScrollTimeline({ source: scrollableElement, scrollOffsets: [{ target: image, edge: 'end' }, { target: image, edge: 'start' }], }); const slideIn= target. animate({ transform: [ 'translateX(0)' , 'translateX(50vw)' ], opacity: [ 0 , 1 ] }, { timeline: timeline, duration: 1000 } ); }
The same logic can be done in CSS markup:
@media ( prefers-reduced-motion: no-preference) { @keyframes slide-in{ from{ transform : translateX ( 0 ); opacity : 0 ; } to{ transform : translateX ( 50 vw ); opacity : 1 ; } } @scroll-timeline image-in-scrollport{ source : selector ( #container); scroll-offsets : selector ( #image) end, selector ( #image) start; } #target{ animation-name : slide-in; animation-duration : 1 s ; animation-timeline : image-in-scrollport; } }
3.1.4. The effective time range of a ScrollTimeline
The effective time range of a ScrollTimeline
is calculated as
follows:
- If the
timeRange
has the value"auto"
, -
The effective time range is the maximum value of the target effect end of all animations directly associated with this timeline.
If any animation directly associated with the timeline has a target effect end of infinity, the effective time range is zero.
- Otherwise,
-
The effective time range is the
ScrollTimeline
'stimeRange
.
3.1.5. The effective scroll offsets of a ScrollTimeline
The effective scroll offsets are calculated by the procedure to resolve scroll timeline offsets from scrollOffsets
as follows:
-
Let effective scroll offsets be an empty list of effective scroll offsets.
-
Let first offset be true.
-
If
scrollOffsets
is empty-
Run the procedure to resolve a scroll timeline offset for auto with the is first flag set to first offset and add the resulted value into effective scroll offsets.
-
Set first offset to false.
-
Run the procedure to resolve a scroll timeline offset for auto with the is first flag set to first offset and add the resulted value into effective scroll offsets.
-
-
If
scrollOffsets
has exactly one element-
Run the procedure to resolve a scroll timeline offset for auto with the is first flag set to first offset and add the resulted value into effective scroll offsets.
-
Set first offset to false.
-
-
For each scroll offset in the list of
scrollOffsets
, perform the following steps:-
Let effective offset be the result of applying the procedure to resolve a scroll timeline offset for scroll offset with the is first flag set to first offset.
-
If effective offset is null, the effective scroll offsets is empty and abort the remaining steps.
-
Add effective offset into effective scroll offsets.
-
Set first offset to false.
-
-
Return effective scroll offsets.
3.1.6. The progress of a ScrollTimeline
The scroll timeline progress is calculated by applying the procedure
to calculate scroll timeline progress given offset as follows:
-
Let scroll offsets be the result of applying the procedure to resolve scroll timeline offsets for
scrollOffsets
. -
Let offset index correspond to the position of the last offset in scroll offsets whose value is less than or equal to offset and the value at the following position greater than offset
-
Let start offset be the offset value at position offset index in scroll offsets.
-
Let end offset be the value of next offset in scroll offsets after start offset.
-
Let size be the number of offsets in scroll offsets.
-
Let offset weight be the result of evaluating
1 / (size - 1)
. -
Let interval progress be the result of evaluating
(offset - start offset) / (end offset - start offset)
. -
Return the result of evaluating
(offset index + interval progress) × offset weight
.
Note: This procedure guarantees that given offset belongs to scroll range within first and last offsets of scroll offsets. This is because the case when offset falls outside of the scroll range is handled before calling this procedure, as part of current time calculation.
Note: The rationale behind choosing last matching offset in the array is to be consistent with findRule method for finding which CSSKeyframeRule applies in a comma separated list of overlapping keyframes.
3.1.7. The phase of a ScrollTimeline
The phase of a ScrollTimeline
is calculated as follows:
-
If any of the following are true:
-
source
is null, or -
source
does not currently have a CSS layout box, or -
source
's layout box is not a scroll container, or -
effective scroll offsets is empty.
-
-
Let current scroll offset be the current scroll offset of
source
in the direction specified byorientation
. -
The phase is the result corresponding to the first matching condition from below:
- If current scroll offset is less than effective start offset:
- If current scroll offset is greater than or equal to effective
end offset and effective end offset is less than the maximum
scroll offset of
source
inorientation
:
Note: In web animations, in general ranges are normally exclusive of their end point. But there is an exception here for the scroll timeline active range as it may in some cases be inclusive of its end. In particular if the timeline end offset is the maximum scroll offset we include it in active range because it is not possible for user to scroll passed this point and not including this value in the active range would leave to animations that would not be active at the very last scroll position.
3.1.8. The current time of a ScrollTimeline
The current time of a ScrollTimeline
is calculated as follows:
-
If any of the following are true:
-
source
is null, or -
source
does not currently have a CSS layout box, or -
source
's layout box is not a scroll container, or -
effective scroll offsets is empty.
The current time is an unresolved time value and abort remaining steps.
-
-
Let current scroll offset be the current scroll offset of
source
in the direction specified byorientation
. -
The current time is the result corresponding to the first matching condition from below:
- If current scroll offset is less than effective start offset:
-
The current time is 0.
- If current scroll offset is greater than or equal to effective end offset:
-
The current time is the effective time range.
- Otherwise,
-
-
Let progress be a result of applying calculate scroll timeline progress procedure for current scroll offset.
-
The current time is the result of evaluating the following expression:
progress × effective time range
-
target
is not a descendant of the scroll timeline source
, the timeline remains inactive.
3.2. The '@scroll-timeline' at-rule
Scroll Timelines are specified in CSS using the @scroll-timeline at-rule, defined as follows:
@scroll-timeline = @scroll-timeline <timeline-name> { <declaration-list> }
An @scroll-timeline rule has a name given by the <custom-ident> or <string> in its prelude. The two syntaxes are equivalent in functionality; the name is the value of the ident or string. As normal for <custom-ident>s and <string>s, the names are fully case-sensitive; two names are equal only if they are codepoint-by-codepoint equal. The <custom-ident> additionally excludes the none keyword.
Once specified, a scroll timeline may be associated with a CSS Animation [CSS3-ANIMATIONS] by using the animation-timeline property.
The <declaration-list> inside of @scroll-timeline rule can only contain the descriptors defined in this section.
An @scroll-timeline rule is invalid if it occurs in a stylesheet inside of a shadow tree, and must be ignored.
This will likely change in the future. <https://github.com/w3c/csswg-drafts/issues/5167>
3.2.1. Scroll Timeline descriptors
| Name: | source |
|---|---|
| For: | @scroll-timeline |
| Value: | selector( <id-selector> ) | auto | none |
| Initial: | auto |
source descriptor determines the scroll timeline’s source
.
The value of source
is the result corresponding to the first matching
condition from the following:
- If source is a 'selector()'
-
The scroll container identified by the <id-selector>.
- If source is
auto
-
The
scrollingElement
of theDocument
associated with theWindow
that is the current global object. - Otherwise (source is
none
) -
null.
Consider choosing animation target’s nearest scrollable ancestor
instead of document’s scrolling Element for auto
. <https://github.com/w3c/csswg-drafts/issues/4338>
| Name: | orientation |
|---|---|
| For: | @scroll-timeline |
| Value: | auto | block | inline | horizontal | vertical |
| Initial: | auto |
orientation descriptor determines the scroll timeline’s orientation
.
| Name: | scroll-offsets |
|---|---|
| For: | @scroll-timeline |
| Value: | [ none | <scroll-timeline-offset> ]# |
| Initial: | none |
scroll-offsets descriptor determines the scroll timeline’s scrollOffsets
.
Scroll timeline offsets in CSS are represented by the <scroll-timeline-offset> type:
<scroll-timeline-offset> = auto | <length-percentage> | <element-offset> <element-offset> = selector( <id-selector> ) [<element-offset-edge> || <number>]? <element-offset-edge> = start | end
The offset type depends on the value of <scroll-timeline-offset> per following:
- If value is "auto" or of type <length-percentage>
-
The scroll timeline offset is a container-based offset with the same value.
- If value is of type <element-offset>
-
The scroll timeline offset is an element-based offset with the following member values:
-
target
is the element identified by <id-selector>. -
edge
is the optional value of <element-offset-edge>. If not provided it defaults to "start". -
threshold
is the optional value <number>. If not provided it defaults to 0.
-
| Name: | time-range |
|---|---|
| For: | @scroll-timeline |
| Value: | auto | <time> |
| Initial: | auto |
time-range descriptor determines the scroll timeline’s timeRange
.
3.2.2. The CSSScrollTimelineRule
Interface
[Exposed =Window ]interface CSSScrollTimelineRule :CSSRule {readonly attribute CSSOMString name ;readonly attribute CSSOMString source ;readonly attribute CSSOMString orientation ;readonly attribute CSSOMString scrollOffsets ;readonly attribute CSSOMString timeRange ; };
name
, of type CSSOMString, readonly- The name associated with the @scroll-timeline rule.
source
, of type CSSOMString, readonly- The source descriptor associated with the @scroll-timeline, or "auto" if not specified.
orientation
, of type CSSOMString, readonly- The orientation descriptor associated with the @scroll-timeline, or "auto" if not specified.
scrollOffsets
, of type CSSOMString, readonly- The scroll-offsets descriptor associated with the @scroll-timeline, or "none" if not specified.
timeRange
, of type CSSOMString, readonly- The time-range descriptor associated with the @scroll-timeline, or "auto" if not specified.
-
The string
"@scroll-timeline"
followed by a SPACE (U+0020). -
The result of performing serialize an identifier on the rule’s
name
, followed by a SPACE (U+0020). -
A single LEFT CURLY BRACKET (U+007B), followed by a SPACE (U+0020).
-
If the source descriptor is missing, the empty string. Otherwise, the concatenation of the following:
-
The string
"source:"
, followed by a SPACE (U+0020). -
One of the following, depending on the value of the source descriptor:
- an identifier
-
The result of performing serialize an identifier on that identifier.
- selector(<id-selector>)
-
The result of performing serialize a selector() function.
-
A single SEMICOLON (U+003B), followed by a SPACE (U+0020).
-
-
If the orientation descriptor is missing, the empty string. Otherwise, the concatenation of the following:
-
The string
"orientation:"
, followed by a SPACE (U+0020). -
The result of performing serialize an identifier on the value of the orientation descriptor, followed by a SEMICOLON (U+003B), followed by a SPACE (U+0020).
-
-
If the start descriptor is missing, the empty string. Otherwise, the concatenation of the following:
-
The string
"start:"
, followed by a SPACE (U+0020). -
The result of performing serialize a scroll timeline offset on the rule’s start descriptor, followed by a SEMICOLON (U+003B), followed by a SPACE (U+0020).
-
-
If the end descriptor is missing, the empty string. Otherwise, the concatenation of the following:
-
The string
"end:"
, followed by a SPACE (U+0020). -
The result of performing serialize a scroll timeline offset on the rule’s end descriptor, followed by a SEMICOLON (U+003B), followed by a SPACE (U+0020).
-
-
If the time-range descriptor is missing, the empty string. Otherwise, the concatenation of the following:
-
The string
"time-range:"
, followed by a SPACE (U+0020). -
One of the following, depending on the value of the time-range descriptor:
- an identifier
-
The result of performing serialize an identifier on that identifier.
- <time>
-
The result of performing serialize a CSS component value on that value.
-
A single SEMICOLON (U+003B), followed by a SPACE (U+0020).
-
-
A single RIGHT CURLY BRACKET (U+007D).
- an identifier
- <length-percentage>
-
The result of performing serialize a CSS component value on that value.
- <element-offset>
-
The concatenation of the following:
-
The result of performing serialize a selector() function on the selector() function associated with the element offset.
-
If the offset has an associated
edge
, a single SPACE (U+0020), followed by the result of serialize an identifier on the value of "edge". Otherwise, the empty string. -
If the offset has an associated
threshold
, a single SPACE (U+0020), followed by the result of serialize a CSS component value on the value of "threshold". Otherwise, the empty string.
-
-
The string
"selector"
, followed by LEFT PARENTHESIS (U+0028). -
The result of performing serialize a selector on the selector() function’s argument.
-
A single RIGHT PARENTHESIS (U+0029).
3.3. Examples
#progress{ position : fixed; top : 0 ; width : 0 ; height : 2 px ; background-color : red; }
if ( window. matchMedia( '(prefers-reduced-motion: no-preference)' ). matches) { let progress= document. getElementById( "progress" ); let effect= new KeyframeEffect( progress, [ { width: "0vw" }, { width: "100vw" } ], { duration: 1000 , easing: "linear" , fill: "forwards" }); let timeline= new ScrollTimeline({ scrollSource: document. documentElement, orientation: "vertical" , }); let animation= new Animation( effect, timeline); animation. play(); }
@media ( prefers-reduced-motion: no-preference) { @scroll-timeline progress{ /* Assume the HTML element has id 'root' */ source:selector ( #root); orientation : vertical; } @keyframes progress{ from{ width : 0 vw ; } to{ width : 100 vw ; } } #progress{ position : fixed; top : 0 ; width : 0 ; height : 2 px ; background-color : red; /* This name is used to select both the keyframes and the scroll-timeline at-rules. */ animation-name: progress; animation-duration : 1 s ; animation-fill-mode : forwards; animation-timing-function : linear; } }
4. Avoiding cycles with layout
The ability for scrolling to drive the progress of an animation, gives rise to the possibility of layout cycles, where a change to a scroll offset causes an animation’s effect to update, which in turn causes a new change to the scroll offset.
To avoid such layout cycles, animations with a ScrollTimeline
are
sampled once per frame, after scrolling in response to input events has taken
place, but before requestAnimationFrame()
callbacks are run. If the sampling
of such an animation causes a change to a scroll offset, the animation will not
be re-sampled to reflect the new offset until the next frame.
The implication of this is that in some situations, in a given frame, the rendered scroll offset of a scroll container may not be consistent with the state of an animation driven by scrolling that scroll container. However, this will only occur in situations where the animation’s effect changes the scroll offset of that same scroll container (in other words, in situations where the animation’s author is asking for trouble). In normal situations, including - importantly - when scrolling happens in response to input events, the rendered scroll offset and the state of scroll-driven animations will be consistent in each frame.
User agents that composite frames asynchronously with respect to layout and/or script may, at their discretion, sample scroll-driven animations once per composited frame, rather than (or in addition to) once per full layout cycle. Again, if sampling such an animation causes a change to a scroll offset, the animation will not be re-sampled to reflect the new offset until the next frame.
Nothing in this section is intended to require that scrolling block on layout
or script. If a user agent normally composites frames where scrolling has
occurred but the consequences of scrolling have not been fully propagated in
layout or script (for example, scroll
event listeners have not yet
run), the user agent may likewise choose not to sample scroll-driven animations
for that composited frame. In such cases, the rendered scroll offset and the
state of a scroll-driven animation may be inconsistent in the composited frame.
Appendix A. Considerations for Security and Privacy
This appendix is informative.
There are no known security or privacy impacts of this feature.
The W3C TAG is developing a Self-Review Questionnaire: Security and Privacy for editors of specifications to informatively answer.
Per the Questions to Consider
-
Does this specification deal with personally-identifiable information?
No.
-
Does this specification deal with high-value data?
No.
-
Does this specification introduce new state for an origin that persists across browsing sessions?
No.
-
Does this specification expose persistent, cross-origin state to the web?
No.
-
Does this specification expose any other data to an origin that it doesn’t currently have access to?
No.
-
Does this specification enable new script execution/loading mechanisms?
No.
-
Does this specification allow an origin access to a user’s location?
No.
-
Does this specification allow an origin access to sensors on a user’s device?
No.
-
Does this specification allow an origin access to aspects of a user’s local computing environment?
No.
-
Does this specification allow an origin access to other devices?
No.
-
Does this specification allow an origin some measure of control over a user agent’s native UI?
No.
-
Does this specification expose temporary identifiers to the web?
No.
-
Does this specification distinguish between behavior in first-party and third-party contexts?
No.
-
How should this specification work in the context of a user agent’s "incognito" mode?
No differently. The website should not be able to determine that the user is in an "incognito" mode using scroll-linked animations.
-
Does this specification persist data to a user’s local device?
No.
-
Does this specification have a "Security Considerations" and "Privacy Considerations" section?
Yes.
-
Does this specification allow downgrading default security characteristics?
No.


Friend Finder
Answer a few basic questions.
Then find a friend with the greatest compatibility!
Start Your Survey


#include <stats.h>
Definition at line 91 of file stats.h.
◆ Stat() [1/2]
| operations_research::Stat::Stat |
( |
const std::string & |
name | ) |
|
|
inlineexplicit |
◆ Stat() [2/2]
| operations_research::Stat::Stat |
( |
const std::string & |
name, |
|
|
StatsGroup * |
group |
|
) |
| |
◆ ~Stat()
| virtual operations_research::Stat::~Stat |
( |
| ) |
|
|
inlinevirtual |
◆ Name()
| std::string operations_research::Stat::Name |
( |
| ) |
const |
|
inline |
◆ StatString()
| std::string operations_research::Stat::StatString |
( |
| ) |
const |
◆ Priority()
| virtual int operations_research::Stat::Priority |
( |
| ) |
const |
|
inlinevirtual |
◆ Sum()
| virtual double operations_research::Stat::Sum |
( |
| ) |
const |
|
inlinevirtual |
◆ ValueAsString()
| virtual std::string operations_research::Stat::ValueAsString |
( |
| ) |
const |
|
pure virtual |
◆ WorthPrinting()
| virtual bool operations_research::Stat::WorthPrinting |
( |
| ) |
const |
|
pure virtual |
◆ Reset()
| virtual void operations_research::Stat::Reset |
( |
| ) |
|
|
pure virtual |
The documentation for this class was generated from the following file:


%inherit file="base.html"/>
## Current tab for navigation
<%!
tab = "exceptions"
%>
## SEO Stuff
<%block name="title">Ultros | Exceptions%block>
<%block name="description">Look up errors that have been detected on your bot%block>
<%block name="og_title">Ultros | Exceptions%block>
<%block name="og_description">Look up errors that have been detected on your bot%block>


from .server import CanvasServer
try:
from .jupyter import JupyterCanvas, create_jupyter_canvas
HAS_JUPYTER = True
except:
HAS_JUPYTER = False
JupyterCanvas = None # type: ignore
[docs]def http_server(
file: str = None, host: str = "localhost", port: int = 5050
) -> CanvasServer:
"""Creates a new HTTP server for displaying the network, using WebSockets to
transmit data. The server will only start once its
:meth:`~server.CanvasServer.start` method is called. After the server has started,
the network can be viewed by opening a browser and navigating to the address
``http://localhost:5050/`` (change the port as necessary).
:file: (Optional) The path to the HTML file which the server should display,
relative to the current runtime directory. If unspecified, the default HTML file
will be used. When creating a custom HTML interface, use the default file as a
guide.
:type file: str
:port: (Optional) The port on which the server should start, defaulting to to 5050.
Note that the next port (by default 5051) will also be used to transmit data
through WebSockets.
:type port: int
"""
return CanvasServer(file, host, port)
[docs]def jupyter_canvas(buttons: bool = False) -> JupyterCanvas:
"""Creates a new :class:`~api.Canvas` which will dispatch and receive
events through a Jupyter widget, and which can be displayed using the IPython
``display`` function.
By default, the canvas size is (400, 250), and requires the ``ctrl``/``cmd`` to be
held down while zooming."""
if HAS_JUPYTER:
return create_jupyter_canvas(buttons=buttons)
else:
raise Exception("Jupyter is not installed")


@KomodoWorld @RaceredFree @whiteblockio @bstr156 @el33th4xor @zycrypto @syscoin @KomodoPlatform Apparently it's not technology, it's money thing as I read in discord. Someone has to pay to get it validated if I get it correct. I don't know much on the subject to be honest.


You have successfully changed your password. Please wait, you will be redirected in a second.
Open Wallet
We have detected an encrypted seed so you either have to enter the old password or your seed phrase manually in order to access your wallet address.
We haven't detected a seed phrase so you have to enter it.
or
{{ .ErrorMsg }}


Vivo S5 launch set for November 14 in China - Gizchina.com
by Ige EbimaRate this post
News/reports about the imminent arrival of the Vivo S5 smartphone have been floating around for some days now. The Chinese brand however recently quelled the prevailing rumors when it officially confirmed the device via a short video teaser.
Now, the brand has confirmed the VIVO S5 would be launching pretty soon. How soon you may ask? Well, the Vivo S5 as per a recent launch teaser will be announced at an event in Hangzhou on 14th November – the same date Xiaomi announces its Mi Note 10.
Brand ambassador Cai Xukun, who was recently caught holding the S5 in a promo video for a fashion magazine will make an appearance at the event.
The tagline of the device can roughly be translated as “Illuminate your beauty”. The Vivo S1 and S1 Pro were released as photo-centric smartphones. Based on this, we believe that the upcoming VivoS5 will also come with a great focus on the camera. Also, the “Illuminate your beauty” logan can stand for some selfie-centric modes.
Currently, there are no official specs details, though there are speculations it will feature a 64MP main camera – the same on the recently launched Vivo Nex 3, while it is expected to arrive in some fancy color hues. We expect some specs leaks or even official teasers to surface in the coming days.


Psalm 72
A psalm of Solomon.
1 Give the king your righteous decrees, God,
your righteousness to the king's son.
2 May he judge your people with righteousness
and your poor with justice.
3 May the mountains produce peace for the people;
may the hills produce righteousness.
4 May he judge the poor of the people;
may he save the children of the needy
and break in pieces the oppressor.
5 May they honor you while the sun endures,
and as long as the moon lasts throughout all generations.
6 May he come down like rain on the mown grass,
like showers that water the earth.
7 May the righteous flourish in his days,
and may there be an abundance of peace till the moon is no more.
8 May he have dominion from sea to sea,
and from the River to the ends of the earth.
9 May those who live in the wilderness bow down before him;
may his enemies lick the dust.
10 May the kings of Tarshish and of the islands render tribute;
may the kings of Sheba and Seba offer gifts.
11 Indeed, may all kings fall down before him;
may all nations serve him.
12 For he helps the needy person who cries out
and the poor person who has no other helper.
13 He has pity on the poor and needy,
and he saves the lives of needy people.
14 He redeems their lives from oppression and violence,
and their blood is precious in his sight.
15 May the king live! May the gold of Sheba be given to him.
May people always pray for him;
may God bless him all day long.
16 May there be abundance of grain in the earth on the mountaintops;
may their crops wave in the breeze like the trees of Lebanon,
and the people in the cities flourish like grass on the earth.
17 May the king's name endure forever;
may his name continue as long as the sun;
may people be blessed in him;
may all nations call him blessed.
18 May Yahweh God, the God of Israel, be blessed,
who alone does wonderful things.
19 May his glorious name be blessed forever,
and may the whole earth be filled with his glory.
Amen and Amen.
20 The prayers of David, the son of Jesse, are finished.
Book Three


Angular directives for ScrollReveal: a JavaScript library for easily animating elements as they enter/leave the viewport.
Scroll down to see it in action!
Learn more Documentation Code on Github


| deleteAllVisibleCookies |
|
|
| setTimeout |
100000 |
|
| open |
/vivo/ |
|
| assertTitle |
VIVO |
|
| clickAndWait |
link=Log in |
|
| assertTitle |
Log in to VIVO |
|
| type |
loginName |
<EMAIL_ADDRESS>|
| type |
loginPassword |
Password |
| clickAndWait |
loginForm |
|
| clickAndWait |
link=Index |
|
| clickAndWait |
link=Faculty Member |
|
| assertTitle |
Faculty Member |
|
| clickAndWait |
link=Furter, Frank |
|
| assertTitle |
Furter, Frank |
|
| click |
css=li.nonSelectedGroupTab.clickable |
|
| verifyTextPresent |
Too Much Nintendo. Child Development. 29:298-344. 2010 |
|
| verifyTextPresent |
Nintendo: Good or Bad for Kids?. New York: Putnam. 2010 |
|
| verifyTextPresent |
Nintendo O.K. for Kids. Kids in the 21st Century. Ed. Sony, Sunny. New York: Marcel Dekker. 765-876. |
|
| verifyTextPresent |
Nintendo Case Studies. Games and Child Development. 2010 |
|
| clickAndWait |
id=managePubLink |
|
| assertTitle |
VIVO |
|
| verifyTextPresent |
Manage Publications for Frank Furter |
|
| selectWindow |
null |
|
| click |
css=input.itemCheckbox |
|
| click |
xpath=(//input[@type='checkbox'])[2] |
|
| click |
xpath=(//input[@type='checkbox'])[3] |
|
| click |
xpath=(//input[@type='checkbox'])[4] |
|
| clickAndWait |
link=Return to Profile Page |
|
| assertTitle |
Furter, Frank |
|
| verifyTextNotPresent |
Too Much Nintendo. Child Development. 29:298-344. 2010 |
|
| verifyTextNotPresent |
Nintendo: Good or Bad for Kids?. New York: Putnam. 2010 |
|
| verifyTextNotPresent |
Nintendo O.K. for Kids. Kids in the 21st Century. Ed. Sony, Sunny. New York: Marcel Dekker. 765-876. |
|
| verifyTextNotPresent |
Nintendo Case Studies. Games and Child Development. 2010 |
|
| verifyTextPresent |
manage publications |
|
| clickAndWait |
id=managePubLink |
|
| assertTitle |
VIVO |
|
| verifyTextPresent |
Too Much Nintendo |
|
| verifyTextPresent |
Nintendo: Good or Bad for Kids? |
|
| verifyTextPresent |
Nintendo O.K. for Kids |
|
| verifyTextPresent |
Nintendo Case Studies |
|
| click |
xpath=(//input[@type='checkbox'])[4] |
|
| click |
css=input.itemCheckbox |
|
| clickAndWait |
link=Return to Profile Page |
|
| assertTitle |
Furter, Frank |
|
| verifyTextPresent |
Too Much Nintendo. Child Development. 29:298-344. 2010 |
|
| verifyTextNotPresent |
Nintendo: Good or Bad for Kids?. New York: Putnam. 2010 |
|
| verifyTextNotPresent |
Nintendo O.K. for Kids. Kids in the 21st Century. Ed. Sony, Sunny. New York: Marcel Dekker. 765-876. |
|
| verifyTextPresent |
Nintendo Case Studies. Games and Child Development. 2010 |
|
| verifyTextPresent |
manage publications |
|
| clickAndWait |
id=managePubLink |
|
| assertTitle |
VIVO |
|
| click |
xpath=(//input[@type='checkbox'])[2] |
|
| click |
xpath=(//input[@type='checkbox'])[3] |
|
| clickAndWait |
link=Return to Profile Page |
|
| assertTitle |
Furter, Frank |
|
| verifyTextPresent |
Too Much Nintendo. Child Development. 29:298-344. 2010 |
|
| verifyTextPresent |
Nintendo: Good or Bad for Kids?. New York: Putnam. 2010 |
|
| verifyTextPresent |
Nintendo O.K. for Kids. Kids in the 21st Century. Ed. Sony, Sunny. New York: Marcel Dekker. 765-876. |
|
| verifyTextPresent |
Nintendo Case Studies. Games and Child Development. 2010 |
|
| clickAndWait |
link=Home |
|
| clickAndWait |
link=Log out |
|
| assertTitle |
VIVO |
|


$
/mo
$
/mo
$
/mo
$
/mo
Just pick up the phone and give us a call. We'll help you customize the perfect plan for your practice.
877-311-4690No Setup Fee/ No Contract
For practices interested saving valuable staff-time with automated text, email, auto-call and postal reminders. Set and forget your reminders while reducing no shows, improving recall and bringing back dormant patients.
$
/mo
No Setup Fee/ No Contract
For dental teams wanting more granular methods for communicating with patients. Enjoy two-way texting, validation of mobile and land-line phone numbers and actionable reports.
$
/mo
No Setup Fee/ No Contract
For practices that want to grow through referrals and an enhanced online web presence. Let our PRM software and marketing services do the Legwork. Retain your existing patients with on-going monthly campaigns, encourage new referrals with our automated referral system, and encourage Google and Facebook reviews, monthly social media postings and more.
$
/mo
Setup fee may apply
For practices that want to grow through an enhanced website and online presence. Generate new leads with a Legwork mobile-first website designed to adapt to the new demand of richer mobile and tablet experiences. To accomplish this, we purposefully avoid frivolous bells and whistles in exchange for efficient, scalable design. Additionally, we infuse rich, engaging content experiences that have little to do with clinical philosophy and everything to do with building instant rapport and trust with each visitor.
*3 package levels available. Basic level - no-set up fee, Semi-Custom $1,250 set-up fee, Full-Custom $2,500 set-up fee.
$
/mo
Pricing Question
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Fugiat quas qui, consequuntur cum recusandae tempore odio exercitationem ea fugit nesciunt totam earum sunt eum maiores facilis eveniet quo, asperiores commodi.
Pricing Question
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Fugiat quas qui, consequuntur cum recusandae tempore odio exercitationem ea fugit nesciunt totam earum sunt eum maiores facilis eveniet quo, asperiores commodi.
Pricing Question
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Fugiat quas qui, consequuntur cum recusandae tempore odio exercitationem ea fugit nesciunt totam earum sunt eum maiores facilis eveniet quo, asperiores commodi.
Pricing Question
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Fugiat quas qui, consequuntur cum recusandae tempore odio exercitationem ea fugit nesciunt totam earum sunt eum maiores facilis eveniet quo, asperiores commodi.
Pricing Question
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Fugiat quas qui, consequuntur cum recusandae tempore odio exercitationem ea fugit nesciunt totam earum sunt eum maiores facilis eveniet quo, asperiores commodi.
Pricing Question
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Fugiat quas qui, consequuntur cum recusandae tempore odio exercitationem ea fugit nesciunt totam earum sunt eum maiores facilis eveniet quo, asperiores commodi.


Chiefs hold on for cover against Chargers in Mexico City
by Jim Barnes Las Vegas Review-JournalThe Kansas City Chiefs received no style points, but they did manage to cover as 6-point favorites with a 24-17 victory over the Los Angeles Chargers on Monday in Mexico City.
The outcome hurt Las Vegas sportsbooks, who were hoping to avoid parlay liability on the favorite that rolled over from Sunday, Caesars Entertainment director of trading Jeff Davis said earlier Monday. The game did stay under 53 to mitigate the damage.
Chargers and over bettors were alive into the final minute, until Chiefs defensive back Daniel Sorensen intercepted quarterback Philip Rivers in the end zone to end the game.
The Chargers covered as 3½-point underdogs in the first half when Michael Badgley hit a 49-yard field goal on the final play before halftime to cut the Chiefs’ lead to 10-9. The first-half total stayed well under 26.
Kansas City led 24-9 in the third quarter but was unable to put the game away — and nearly paid for it.
The Chiefs (7-4) held onto first place in the AFC West and now go on their bye week before hosting the second-place Raiders on Dec. 1.
The Chargers (4-7) are also on a bye after seeing their playoff hopes all but evaporate. They next play at Denver on Dec. 1.
More Betting: Follow at reviewjournal.com/betting.


This conference will be held for 1 whole day, every attendant including speakers, guests and auditors
will be invited by the organizer committee. We hope this conference could be dedicated to the
people who really love and care about this community, which includes committers, Weex users and active
community contributors, and we also hope this chance can be leveraged to discuss the possibility of implementing
a offline Weex Community Developer Group, to hold meet-ups in different cities regularly.
If you love Weex project and community as we do, hope to join this conference, please fill the registration
form below and submit your personal information that requires, and we will send you the invitation letter
if you are chosen as the selected audiance. Thanks for the understanding.
Registration


Kettlebells add great variation to your workout! Integrate this to your regular routine one per week to boost your results!
Women begin with a 6kg kettlebell and quickly progress to an 8kg kettlebell.
Men begin with a 12kg kettlebell and quickly progress to a 16kg kettlebell.
Perform this workout as a mini circuit with no more than 30 seconds rest between exercises. At the end of the circuit have a 60 seconds rest and repeat.


Collection
Statistics on national curriculum assessments at key stage 3.
Statistics from May 2010 onwards are available on GOV.UK. You can find our archived statistics on the National Archives . Note: the search function is not available on archived content so please use the filters on the left of each page.
Published: 17 October 2013


Zimbabwe's Chamisa ready for talks with President Mnangagwa
by KITSEPILE NYATHIIn Summary
- South Africa’s International Relations minister Naledi Pandor announced a major shift in her country’s approach to Zimbabwe’s crisis saying “practical solutions” were needed to end the crisis.
Zimbabwe’s main opposition leader Mr Nelson Chamisa on Tuesday said he was ready for talks with President Emmerson Mnangagwa, and urged South Africa to act as mediator.
This is after South Africa said problems in Zimbabwe were mainly political and called for an end to the crisis.
South Africa’s International Relations minister Naledi Pandor announced a major shift in her country’s approach to Zimbabwe’s crisis saying “practical solutions” were needed to end the crisis.
“The political formations in Zimbabwe remain at loggerheads and have apparent deep antipathy towards each other, which makes joint decision-making and planning extremely difficult,” Dr Pandor said.
“It seems clear that even as we support the call for an end to economic sanctions, the political dynamics that we observe are inextricably linked to the economic solutions and thus the politics and the economic as well as the social need to be confronted simultaneously.”
READY FOR MEDIATION
Related Stories
-
EU differ with AU on lifting of sanctions on Zimbabwe
-
Zimbabweans believe there is more to economic crisis
Advertisement
Zimbabwe’s opposition last year rejected President Emmerson Mnangagwa’s election victory claiming the polls were rigged.
Southern African countries, including South Africa, endorsed President Mnangagwa and at the last regional meeting held in Tanzania agreed that Western sanctions were behind the crisis that has crippled Harare’s economy.
Reacting to Dr Pandor’s statement, Mr Chamisa said the opposition will welcome South Africa to mediate in the talks between him and President Mnangagwa following Pretoria’s latest pronouncements.
“For months now, we have been asking our African brothers and sisters to look into the man-made governance crisis in Zimbabwe and help us restore the dignity of citizens. We are heartened by Minister Pandor’s correct diagnosis of the major problem in Zimbabwe as toxic politics,” he said.
“We in the MDC stand ready to welcome South Africa and Sadc’s mediation in Zimbabwe to end the suffering that has gone on for far too long, and give our people hope.”
Legislators from Mr Chamisa’s Movement for Democratic Change (MDC) party last week boycotted a parliamentary session after President Mnangagwa attended the presentation of the 2020 budget.
Last month the opposition legislators walked out after the president arrived in the House of Assembly to present his state of the nation address, saying they did not recognise his presidency.
CALL FOR TALKS
Churches recently called for talks between the ruling party and the opposition, saying the political impasse is perpetuating the economic crisis in the country.
President Mnangagwa has in the past refused to take part in direct talks with his rival saying Mr. Chamisa must first recognise his election victory.
The ruling party leader has instead opened dialogue with leaders of fringe political parties that took part in the contested presidential elections.
Zimbabwe is struggling to emerge from an economic crisis that has spanned nearly two decades and which was blamed on the policies of the late founding leader, Robert Mugabe.
Mr Mugabe, who was replaced by President Mnangagwa following a 2017 military coup, died in September this year.
DOCTORS
Meanwhile, Mr. Chamisa pleaded with South Africa to help set up a donor fund to pay doctors at public hospitals who have been on strike for almost three months.
The doctors went on strike in September demanding better pay and the government responded by firing more than 300 of them, leaving hospitals unmanned.
“There is a silent genocide in hospitals, which cannot wait for politicians to find each other,” Mr. Chamisa added.


gnome-dictionary(1) gnome-dictionary(1) NAME gnome-dictionary - Look up words on dictionaries SYNOPSIS gnome-dictionary gnome-dictionary [options] or select Dictionary from the Accessories submenu of the Applications menu. DESCRIPTION GNOME Dictionary provides dictionary definitions of words, using a dic‐ tionary source. For full documentation see the GNOME Dictionary online help. OPTIONS --look-up word Looks up the specified word using the pre-defined dictionary source. -s source or --source source Uses the specified source for looking up words. This does not affect the global settings. -l or --list-sources Lists all the sources available. -n or --no-window Using this switch with the --look-up will print the definitions found on the console without launching the GUI. --help Display help information. CONFIGURATION All the configuration is handled using GConf. AUTHOR GNOME Dictionary was originally written by Spiros Papadimitriou (<spa‐ padim+@cs.cmu.edu>), Mike Hughes<EMAIL_ADDRESS>and Bradford Hovinen (<hovinen@udel.edu>). Emmanuele Bassi<EMAIL_ADDRESS>rewrote it from scratch. This manual page was originally written by Jochen Voss <voss@mathe‐ matik.uni-kl.de>. SEE ALSO dict(1), dictd(8), http://www.dict.org/, RFC 2229 gnome-utils 2.13.4 Jan 2 2005 gnome-dictionary(1)


The Wikimaps Atlas project is an open source wiki geo data engine to create data driven maps for the web. Ever wanted a simple API that can give you a json list of all the countries in the world, or the geojson shape of a province, or the major rivers in the world? This is it.
GIDs are multipart topological albhabetic identifiers for major geographic features and landmarks. These codes can be used to uniquely reference well known geographic feature at a particular point in time on earth. GID codes are made up of the following attributes:
Time-Place-Name
GIDs are proposed to help eliminate ambiguity regarding named geographical features in computer databases, since proper names vary across languages, place and time. eg. The GID for the territory of Germany in the year 1940 would be 1940-DE
Historical and future locations can be referenced by prefixing the GID with a numerical datestamp in the format:
Year.Month.Day.HourIf the temporal identifier is omitted, the system assumes you are referring to the present.
Any place on earth can be described as being in a certain geographical region or an administrative unit. THe length of the GID codes is inversely proportional to the feature's size and importance.
Continental regions are represented using a single letter, and sub continents using two letters.
Natural geographic features like rivers, lakes, mountain ranges, seas are referenced by a five letter identifier prefixed by the continental code
Metro areas can be referenced by 3 letter IATA codes of the primary airport serving the area.
Hierarchical Administrative Subdivision Codes (HASC) are used to reference well known administrative areas.
Urban incorporated areas can be referenced by a nationally defined 3 letter code prefixed with the HASC.
Rural unincorporated areas can be referenced by a subnationally defined 4 letter code prefixed with the HASC.
The common name of the geogarphical feature can be included in the GID to reference a more specific feature that cannot be trageted with the temporal and spatial attributes. This is considered the least significant attribute and is ignored if a suitable feature match is not found.
Every WKL has associated geographic data categorized into a variety of layers. The common ones are:
Every geographic feature has associated attribute fields
All outputs are valid JSON. Shape data is available in both GeoJSON or optimized TopoJSON formats.


If none of your friends own Pokemon Mystery Dungeon, it is still possible to rescue yourself with the help of this tool.
Using this tool, you can generate an A-OK and Thank-You Mail password from an SOS Mail password, or a Thank-You Mail password from an A-OK Mail password. Note also the following.
Detailed information about mail passwords is available.


Problem Statement
There are a few minutes left before the start of a SRM. While waiting, Elly entertains herself in the following way: In front of her she has several bottles of the same capacity, containing various amount of water.
She finds two bottles: one that contains the largest amount of water and one that contains the smallest amount of water. She then pours water from the first bottle she found into the second bottle she found until they both contain the same amount of water.
After that she again looks at all the bottles, finding the most filled one and the least filled one and does this procedure again. Elly performs the above procedure exactly k times. Then the SRM starts and she switches to solving problems instead.
The initial amount of liquid in each of the bottles is provided to you in the int[] bottles. Can you calculate what is the amount of water in the least filled bottle, after executing the described procedure k times?
- She pours from a bottle containing 42 into a bottle containing 7 units of water, making the amount of water in the bottles {24.5, 13, 17, 24.5, 22}
- She pours from a bottle containing 24.5 into a bottle containing 13 units of water, making the amount of water in the bottles {18.75, 18.75, 17, 24.5, 22}
- She pours from a bottle containing 24.5 into a bottle containing 17 units of water, making the amount of water in the bottles {18.75, 18.75, 20.75, 20.75, 22}
- She pours from a bottle containing 22 into a bottle containing 18.75 units of water, making the amount of water in the bottles {20.375, 18.75, 20.75, 20.75, 20.375}
- She pours from a bottle containing 20.75 into a bottle containing 18.75 units of water, making the amount of water in the bottles {20.375, 19.75, 19.75, 20.75, 20.375}
- She pours from a bottle containing 20.75 into a bottle containing 19.75 units of water, making the amount of water in the bottles {20.375, 20.25, 19.75, 20.25, 20.375}
- She pours from a bottle containing 20.375 into a bottle containing 19.75 units of water, making the amount of water in the bottles {20.0625, 20.25, 20.0625, 20.25, 20.375}
- She pours from a bottle containing 20.375 into a bottle containing 20.0625 units of water, making the amount of water in the bottles {20.21875, 20.25, 20.0625, 20.25, 20.21875}
The lowest amount of water in any of the bottles after the transactions is 20.0625.


When adding a new storage node, you may see it as an offline node, with "No Access" issue (see the image below).
The first step to troubleshooting such case is to check the firewall settings on this node.
Additional information about the ports setup can be found in the following article
Please make sure that the ports range of 60100-60600 is open for inbound traffic. These ports are used to communicate between the storage nodes to allow an efficient self-healing behavior.
Once you verified that the ports are open, please navigate to the node -> Test & Diagnostics and click on "Run Test" button. This test will run connectivity test and it should pass if the firewall is configured correctly.
For any additional help, please contact support@noobaa.com


ActionFront User Manual
- General User Interface
- Navigating around the App
- List Views
- Add New Record Button
- Delete Current Record Button
- Print Page Button
- Action Buttons
- Simultaneous Player Inputs
- Audio Mixer
- Scales and Basing
- Scenarios
- Copy Existing Scenario
- Create New Scenario
- Edit Scenario
- Red Team / Blue Team
- Add a New Corps
- Edit Corps Details
- Add Division
- Add Infantry Brigade
- Add Cavalry Brigade
- Add Artillery Battery
- Add Other Unit Type
- Publish Your Scenario
- Scenario Review Process
- Sharing Your Scenario with Others
- Joining a Game
- Pre-Game Registration
- Study your Team Briefing
- Study your Unit Details
- Write up Initial Orders
- The Game Phases
- Ending the Game
- Playing the Game
- Game Phase I - Orders and Commands
- Order Definitions
- Reserve
- March
- Defend
- Probe
- Attack
- Support
- Special
- Order Definitions
- Game Phase II - Grand Tactical Actions
- Time Scale
- Grand Tactical Movement
- The GRID System for Grand Tactical Moves
- Record New Engagements
- Artillery Bombardments
- DisEngagements
- Checkpoint - all players have moved
- Game Phase III - Tactical Engagements
- Resolve Mulitple Tactical Engaments in Parallel
- Time Scale
- Results Tables and Dice
- Commander Actions
- Opposing Player Counter Actions
- Tactical Moves
- Small Arms Fire
- Melee
- End of Tactical Engagement
- Game Phase IV - Assessment, Reaction and Recovery
- Perform Compulsory Uncontrolled Moves
- Recovery for troops in Reserve
- Update Objective Status Information
- Victory Points Calculation
- Game Phase I - Orders and Commands
- Create and Host Your Own Game
- Create a Game from a Scenario
- The Pre-Game Checklist
- Setup the Table
- Set Objectives
- Edit Forces for Red Team / Blue Team
- Apply Pre-Game Attrition
- Assign Players to Commands in the Game
- Getting out Invites for your Game
- Pre-Game Player Registration
- Your Account Settings
- Change Your Details
- Subscribe to Newsletter
- Website / Blog Address
- Enable Forums / Social Media Sharing
- Purchase a Commission
- Privacy & Data Security Policy
- Terms and Conditions
- Closing Your Account
- Gaming Groups
- Find other Gaming Groups
- Create Your Own Gaming Group
- Add Players to Gaming Group
- Publish Newsletter to Gaming Group
- Publish Group Events to Public
- Using a SmartPhone


Jahqyad Austin
Chef, Artist, and Entrepreneur"
Caterer, Artist, and Entrepreneur
I'm 17 year old junior who attends Food and Finance High School, and Harlem School of the Arts. I've been at FFHS 2 years now, where I have the opportunity to become a “Modern chef” and build my brand Cheftobe. I've attended HSA for 4 years now (3 years as college prep) and have used my skills acquired there to build my brand Gloabalarts. Similar to my Cheftobe platform will connect artist of all kinds for inspiration and a place where my creations can be sold, such handmade keychains, necklaces, and more.
I enjoy baking, mostly because it is a way to express myself and add my artistic visions of life to food. I run a part time catering business that I want to turn into my Pâtisserie. Where I will teach the next generation and sell freshly baked goods the echo peoples favorite childhood desserts and savory dishes.
Chef, Artist, and Entrepreneur"
Scholar, Cuber, Gamer
Athlete, and Future scientist
Teacher, Organizer, Lover of Learning


Getting Started
Using ATT&CK Evaluations
Who We Are
MITRE Engenuity evaluates cybersecurity products using an open methodology based on the ATT&CK® knowledge base. Our goals are to improve organizations against known adversary behaviors by:
These evaluations are not a competitive analysis. We show the detections we observed without providing a “winner.” Because there is no singular way for analyzing, ranking, or rating the solutions, we instead show how each vendor approaches threat defense within the context of ATT&CK.
MITRE Engenuity’s evaluation methodology is publicly available, and the results are publicly released. MITRE will continue to evolve the ATT&CK Evaluation methodology and content to ensure a fair, transparent, and useful evaluation process.
User Guide
This guide helps you understand how to use the evaluation results to assess security products and select an endpoint threat detection tool. In this guide, we address using ATT&CK Evaluations to inform two of the key questions:
- Does this tool detect known threats to your organization (i.e., ATT&CK technique coverage)?
- How does the tool present the data to your analysts (i.e., Graphical User Interface)?”
Interpreting Our Results
The ATT&CK Evaluation methodology and results can assist organizations as they make critical decisions about which vendor capabilities best suit their needs. These evaluation results describe how product users could address specific ATT&CK Technique implementations under perfect circumstances with knowledge of what the adversary did and without environmental noise. Our evaluations look at each vendor’s capabilities within their own context, while doing so in a way that is consistent across all vendors who participate.
By looking at the capabilities of these products and weighing their unique constraints, organizations may be able to “down-select” products that appear to best meet their requirements. Decision makers should consider other factors that we are not accounting for when determining which tool best fits their needs as our evaluations are narrowly focused on the technical ability to defend against specific adversaries. For additional guidance on how to leverage our results to compare vendor performance, please see our Using Results to Evaluate Endpoint Detection Products guide.
As many use our results to develop their own scores, rankings, or ratings, we encourage you to consider how those analyses relate to your unique requirements. We have released a number of tools on this site to help you with your analysis. We also encourage you to use our methodologies to test the solutions in your own environment. This allows false positives, environmental noise, and system impact to be considered in a way that is tailored to your organization, as well as provide your analysts an opportunity to get hands-on with the user interfaces.
 We use an open-book and minimally sized environment to understand baseline capabilities of solutions. Operationalization of these solutions is important to consider in the context of your organization, including false positive generation.
There are no scores or winners. The goal of ATT&CK Evaluations is to show the different capabilities of each vendor.
Counting has limitations. We don’t think any single way to count is right for everyone. As we’ve described, you should consider your own needs and then consider scoring based on those.
Not all techniques are created equal. A technique detection for Credential Dumping may not have same value as a technique for Process Discovery, due to the severity of the action. The category gives you a general idea, but you should dive into the details to understand the technique and detection.
Not all procedures are created equal. Process Discovery (T1057) via Command-Line Interface (T1059) can be detected with most process monitoring. Process Discovery via API (T1106) would need API monitoring. A vendor could have a detection for one but not the other.


Previous Reputation
Have you retailed on Ebay before?
@b3.radio( form("retailebay"), '_inline -> true ) { implicit extraInfo =>
}
@helper.inputText(
form("ebayname"),
'_label -> "What is your ebay username?",
'class -> "form-control",
'_showConstraints -> false
)
@helper.select(
form("ebayscore"),
helper.options(ebayScoreList),
'_label -> "Ebay feedback score (%)",
'value -> "",
'class -> "selectpicker show-menu-arrow",
'_showConstraints -> false
)
Have you retailed on Amazon before?
@b3.radio( form("retailamazon"), '_inline -> true ) { implicit extraInfo =>
}
@helper.inputText(
form("totalamazonsales"),
'_label -> "How many transactions have you completed?",
'_showConstraints -> false
)
@helper.select(
form("amazonscore"),
helper.options(amazonList),
'_label -> "Amazon star rating",
'class -> "selectpicker show-menu-arrow",
'_showConstraints -> false
)
Do you have a Facebook account?
@b3.radio( form("retailfacebook"), '_inline -> true ) { implicit extraInfo =>
}
@helper.inputText(
form("facebookemail"),
'_label -> "Enter the email address associated to your account.",
'class -> "form-control",
'_showConstraints -> false
)


Abstract node allocator.
More...
#include <dictionary.hpp>
|
|
| node_allocator () |
| | Create a new node allocator.
|
| |
| virtual size_t | used_memory () const |
| | Get number of bytes used by nodes allocated using this allocator including size of a used index (if any). More...
|
| |
| virtual size_t | used_nodes () const |
| | Get number of used virtual nodes. More...
|
| |
| virtual uint64_t | next_id () const |
| | Get ID that will be assigned to the next newly allocated node. More...
|
| |
| virtual size_t | real_nodes () const =0 |
| | Get number of real nodes. More...
|
| |
| virtual node * | alloc (uint8_t sym, node *parent) |
| | Allocate a new node for a given transition parent – sym –> node. More...
|
| |
| virtual node * | alloc (uint8_t *phrase, uint32_t len, node *parent) |
| | Allocate a new collapsed node for transitions according to a given phrase and parent. More...
|
| |
| virtual node * | split (node *n, uint32_t at) |
| | Split a given collapsed node at a given index. More...
|
| |
| virtual void | append (node *n, uint8_t sym) |
| | Append symbol into a given collapsed node. More...
|
| |
| virtual void | append (node *n, uint8_t *phrase, uint32_t len) |
| | Append phrase to a given collapsed node. More...
|
| |
| virtual node ** | alloc_children (uint8_t count) |
| | Allocate array for storing children node pointers. More...
|
| |
| virtual void | free_children (node **children, uint8_t count) |
| | Free a given array for storing children node pointers. More...
|
| |
| node * node_allocator::alloc |
( |
uint8_t |
sym, |
|
|
node * |
parent |
|
) |
| |
|
virtual |
Allocate a new node for a given transition parent – sym –> node.
- Parameters
-
| sym | transition symbol |
| parent | parent node |
- Returns
- new node
| node * node_allocator::alloc |
( |
uint8_t * |
phrase, |
|
|
uint32_t |
len, |
|
|
node * |
parent |
|
) |
| |
|
virtual |
Allocate a new collapsed node for transitions according to a given phrase and parent.
- Parameters
-
| phrase | collapsed phrase |
| len | collapsed phrase length |
| parent | parent node |
- Returns
- new node
| node ** node_allocator::alloc_children |
( |
uint8_t |
count | ) |
|
|
virtual |
Allocate array for storing children node pointers.
- Parameters
-
- Returns
- array
| void node_allocator::append |
( |
node * |
n, |
|
|
uint8_t |
sym |
|
) |
| |
|
virtual |
Append symbol into a given collapsed node.
- Parameters
-
| n | node |
| sym | transition symbol |
| void node_allocator::append |
( |
node * |
n, |
|
|
uint8_t * |
phrase, |
|
|
uint32_t |
len |
|
) |
| |
|
virtual |
Append phrase to a given collapsed node.
- Parameters
-
| n | node |
| phrase | phrase |
| len | phrase length |
| void node_allocator::free_children |
( |
node ** |
children, |
|
|
uint8_t |
count |
|
) |
| |
|
virtual |
Free a given array for storing children node pointers.
- Parameters
-
| children | array |
| count | array width |
| virtual void alzw::node_allocator::insert |
( |
node * |
n | ) |
|
|
protectedpure virtual |
| virtual uint64_t alzw::node_allocator::next_id |
( |
| ) |
const |
|
inlinevirtual |
Get ID that will be assigned to the next newly allocated node.
- Returns
- next node ID
| virtual size_t alzw::node_allocator::real_nodes |
( |
| ) |
const |
|
pure virtual |
| virtual void alzw::node_allocator::remove |
( |
node * |
n | ) |
|
|
protectedpure virtual |
| node * node_allocator::split |
( |
node * |
n, |
|
|
uint32_t |
at |
|
) |
| |
|
virtual |
Split a given collapsed node at a given index.
- Parameters
-
| n | node to be split |
| at | zero-based split index |
- Returns
- left part
| virtual size_t alzw::node_allocator::used_memory |
( |
| ) |
const |
|
inlinevirtual |
Get number of bytes used by nodes allocated using this allocator including size of a used index (if any).
- Returns
- used memory
Reimplemented in alzw::indexed_node_allocator.
| virtual size_t alzw::node_allocator::used_nodes |
( |
| ) |
const |
|
inlinevirtual |
Get number of used virtual nodes.
- Returns
- number of virtual nodes
The documentation for this class was generated from the following files:


No es ningún estado conocido
Height: {{people.height}}
Mass: {{people.mass}}
Hair Color: {{people.hair_color}}
Skin Color: {{people.skin_color}}
Eyes Color: {{people.eye_color}}
Birthday: {{people.birth_year}}
Gender: {{people.gender}}
This button triggers a popover on click.
This link and that link have tooltips on hover.


Scheme of an X-ray diffraction experiment in transmission geometry. The focused X-ray beam can probe different spatial positions on the sample. Diffraction pattern recorded by a 2D detector positioned behind the sample and polar coordinate system for evaluation of the angular cross-correlation function C ( q 1 , q 2 , Δ ) are shown. The intensity of the diffraction pattern is coded by color.


This year's problem will involve web technologies. You'll need to implement an application that services HTTP requests. In addition, your application will need to make HTTP requests out to other applications on the web. The HTTP protocol will serve as an API to your application. An example of an HTTP conversation is given below. Your application should handle large numbers of simultaneous incoming HTTP requests as well as generate large numbers of outgoing requests.
Your solution will be submitted to the judges as a virtual box vm. Make sure you have Virtual Box set up and running before the competition.
A desktop application will be provided to you to help you develop your solution. It will require the Java runtime to run. Make sure you have Sun JRE 1.6.0_25 or later installed.
One person on your team should have a Twilio account.
Content-Type: application/x-www-form-urlencoded Content-Length: 148 Message=Hello%20World
<?xml version="1.0" encoding="UTF-8"?> <Response> Hello </Response>


Simple channel Words¶
A simple channel is a monodirectional means of communicating data, as arbitrary-sized blocks of data, between two or more different tasks and/or interrupt service routines. Simple channels form a fixed-size queue onto which data is sent on one end and data is received on the other. Any task which attempts to send data on a full simple channel, or receive data on an empty simple channel, will be suspended until either data is received from the simple channel, or data is sent to the simple channel, respectively, unless non-blocking operations are used, where then x-would-block
(declared in task
) is raised instead of blocking. Note that non-blocking simple channel routines are specifically interrupt service routine-safe, unlike other channel constructs provided by zeptoforth.
Simple channels can be created anywhere in memory; they are not dependent upon any allocation mechanism. Therefore they can be put into alloted memory in the dictionary or into allocated memory in the heap. Note that the size of a simple channel for a given element size and element count may be calculated with schan-size
.
schan
¶
The following words are in schan
:
x-schan-closed
¶
( – )
Simple channel closed exception. Raised on attempting to send to a closed simple channel or when trying to receive on an empty closed simple channel.
schan-full?
¶
( schan – flag )
Get whether a simple channel is full.
schan-empty?
¶
( schan – flag )
Get whether a simple channel is empty.
schan-size
¶
( element-bytes element-count – total-bytes )
Get the size in memory for a simple channel with a specified element size in bytes and element count.
init-schan
¶
( element-bytes element-count addr – )
Initialize a simple channel starting at the specified address with the element size and element count. The element-bytes and element-count should be the same as when they were passed to schan-size
when alloting or allocating the memory whose starting address is passed in.
close-schan
¶
( schan – )
Close a simple channel. Raise x-schan-closed
for all pending sending tasks or for all pending receiving tasks if the simple channel is empty.
reopen-schan
¶
( schan – )
Reopen a simple channel.
schan-closed?
¶
( schan – closed )
Get whether a simple channel is closed.
send-schan
¶
( addr bytes schan – )
Send message with a buffer as a payload over a simple channel. Block until another task receives the message if the simple channel is full. Note that the buffer is copied, and will be truncated if the buffer size of the simple channel is smaller than the data provided, and padded with zeros if it is larger. This is not safe to call within an interrupt service routine or a critical section.
recv-schan
¶
( addr bytes schan – recv-bytes )
Receive message into a buffer from a simple channel. Block until another task sends a message if the simple channel is empty. Note that the buffer is copied, and will be truncated if the provided buffer is smaller than the buffer size of the simple channel, and padded with zeros if it is larger; the number of bytes copied is returned. This is not safe to call within an interrupt service routine or a critical section.
peek-schan
¶
( addr bytes schan – addr peek-bytes )
Peek the oldest message into a buffer from a simple channel, without popping it from the simple channel’s queue. Block until another task sends a message if the simple channel is empty. Note that the buffer is copied, and will be truncated if the provided buffer is smaller than the buffer size of the simple channel, and padded with zeros if it is larger; the number of bytes copied is returned. This is not safe to call within an interrupt service routine or a critical section.
skip-schan
¶
( schan – )
Skip the most oldest message in a simple channel. Block until another task sends a message if the simple channel is empty. Note that no copying takes place, making this faster than receiving a message. This is not safe to call within an interrupt service routine or a critical section.
send-schan-no-block
¶
( addr bytes schan – )
Send message with a buffer as a payload over a simple channel. If the simple channel is full, or if another task or interrupt service rouine is attempting to send on the same simple channel simultaneously, x-would-block
is raised. Note that the buffer is copied, and will be truncated if the buffer size of the simple channel is smaller than the data provided, and padded with zeros if it is larger. This is safe to call within an interrupt service routine or a critical section.
recv-schan-no-block
¶
( addr bytes schan – recv-bytes )
Receive message into a buffer from a simple channel. If the simple channel is empty, or if another task or interrupt service rouine is attempting to receive on the same simple channel simultaneously, x-would-block
is raised. Note that the buffer is copied, and will be truncated if the provided buffer is smaller than the buffer size of the simple channel, and padded with zeros if it is larger; the number of bytes copied is returned. This is safe to call within an interrupt service routine or a critical section.
peek-schan-no-block
¶
( addr bytes schan – addr peek-bytes )
Peek the oldest message into a buffer from a simple channel, without popping it from the simple channel’s queue. If the simple channel is empty, or if another task or interrupt service rouine is attempting to receive on the same simple channel simultaneously, x-would-block
is raised. Note that the buffer is copied, and will be truncated if the provided buffer is smaller than the buffer size of the simple channel, and padded with zeros if it is larger; the number of bytes copied is returned. This is safe to call within an interrupt service routine or a critical section.
skip-schan-no-block
¶
( schan – )
Skip the most oldest message in a simple channel. If the simple channel is empty, or if another task or interrupt service rouine is attempting to receive on the same simple channel simultaneously, x-would-block
is raised. Note that no copying takes place, making this faster than receiving a message. This is safe to call within an interrupt service routine or a critical section.


{{template "header.html" .}}
Cluster Size
Regression
Step Size
Least Squares
Step Time
Delete all non-Bug alerts. (Dangerous!)


Page maintained by Ke-Sen Huang.
If you have additions or changes, send an e-mail.
Information here is provided with the permission of the ACM.
Note that when possible I link to the page containing the link to the actual PDF or PS of the preprint.
I prefer this as it gives some context to the paper and avoids possible copyright problems with direct linking.
Thus you may need to search on the page to find the actual document.
ACM Digital Library: Proceedings of the 2009 ACM SIGGRAPH/Eurographics Symposium on Computer Animation
Eurographics Digital Library: Proceedings of the 2009 ACM SIGGRAPH/Eurographics Symposium on Computer Animation
the ACM Digital Library (DOI) Link for the paper
the Eurographics Digital Library Link for the paper
the link of author version paper
the link of project page
Changelog
Session 1: Leveraging Motion Capture Data
- Face/Off: Live Facial Puppetry
-
Thibaut Weise,
Hao Li,
Luc Van Gool,
Mark Pauly
- Efficient and Robust Annotation of Motion Capture Data
-
Meinard Mueller,
Andreas Baak,
Hans-Peter Seidel
- Automatic Construction of a Minimum Size Motion Graph
-
Liming Zhao,
Aline Aline Normoyle,
Sanjeev Khanna,
Alla Safonova
- Simulating Balance Recovery Responses to Trips Based on Biomechanical Principles
-
Takaaki Shiratori,
Brooke Coley,
Rakie Cham,
Jessica Hodgins
- Interactive Synthesis of Human-Object Interaction
-
Sumit Jain,
C. Karen Liu
Session 2: Geometry
- Visibility Transition Planning for Real-Time Camera Control
-
Thomas Oskam,
Robert W. Sumner,
Nils Thuerey,
Markus Gross
- Space Deformation Transfer
-
Mirela Ben-Chen,
Ofir Weber,
Craig Gotsman
- Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
-
Sara C. Schvartzman,
Jorge Gascon,
Miguel A. Otaduy
- Exact volume preserving skinning with shape control
-
Damien Rohmer,
Stefanie Hahmann,
Marie-Paule Cani
Session 3: Editing in Style
- Leveraging the Talent of Hand Animators to Create Three-Dimensional Animation
-
Eakta Jain,
Yaser Sheikh,
Jessica Hodgins
- Interactive Editing of Motion Style Using Drives and Correlations
-
Michael Neff,
Yejin Kim
- Pose-Timeline for Propagating Motion Edits
-
Tomohiko Mukai,
Shigeru Kuriyama
- Style Learning and Transferring for Facial Animation Editing
-
Xiaohan Ma,
Binh H. Le,
Zhigang Deng
Session 4: Deformation, Contact, and Fracture
- A Point-based Method for Animating Elastoplastic Solids
-
Dan Gerszewski,
Haimasree Bhattacharya,
Adam Bargteil
- Statistical Simulation of Rigid Bodies
-
Shu-Wei Hsu,
John Keyser
- Anisotropic Friction for Deformable Surfaces and Solids
-
Simon Pabst,
Bernhard Thomaszewski,
Wolfgang Strasser
- Energy Stability and Fracture for Frame Rate Rigid Body Simulations
-
Jonathan Su,
Craig Schroeder,
Ronald Fedkiw
- Real-Time Deformation and Fracture in a Game Environment
-
Eric Parker,
James F. O'Brien
Session 5: Crowds
- ClearPath: Highly Parallel Collision Avoidance for Multi-Agent Simulations
-
Stephen J. Guy,
Jatin Chhugani,
Changkyu Kim, Nadathur Satish, Pradeep Dubey,
Ming Lin,
Dinesh Manocha
- Experiment-based Modeling, Simulation and Validation of Interactions between Virtual Walkers
-
Julien Pettre,
Jan Ondrej,
Anne-Helene Olivier, Armel Cretual,
Stephane Donikian
- Fitting Behaviors to Pedestrian Simulations
-
Alon Lerner,
Eitan Fitusi,
Yiorgos Chrysanthou,
Danny Cohen-Or
- SteerBug: An Interactive Framework for Specifying and Detecting Steering Behaviors
-
Mubbasir Kapadia,
Shawn Singh,
Brian Allen,
G. Reinman,
Petros Faloutsos
Session 6: Fluids
- Guiding of Smoke Animations Through Variational Coupling of Simulations at Different Resolution
-
Michael B. Nielsen,
Brian B. Christensen,
Nafees B. Zafar,
Doug Roble,
Ken Museth
- Accurate Tangential Velocities For Solid Fluid Coupling
-
Avi Robinson-Mosher,
Elliot English,
Ronald Fedkiw
- Fast and Robust Tracking of Fluid Surfaces
-
Matthias Muller-Fischer
- A Point-based Method for Animating Incompressible Flow
-
FunShing Sin,
Adam Bargteil,
Jessica Hodgins
kesen.huang@gmail.com


Create an Open Source WhatsApp clone app using Mesibo
Estimated reading time: 3 minutes- 1: Introduction
- 2: Android App
- 3: iOS App
- 4: Customizing
- 5: Hosting APIs
- 6: On-Premise Deployment
- 7: Conclusion
This multi-part series will describe the design and implementation of a commercially deployable WhatsApp like app having real-time messaging, voice and video communication. By the end of this article series, you will create fully functional Android and iOS applications which you can even publish on Google and Apple App Store under your own brand name.
For this article series, we have selected WhatsApp as a use case since it’s easy to relate. However, the technology and techniques described in this article series are equally applicable to any domain that requires real-time communication, for example, telemedicine, customer support, social apps, to name a few.
Ready? let’s get started. Remember, for all our subsequent discussion, we will refer the app as Messanger.
Messenger Features
Let’s quickly learn about some of the key features of both these apps which we are about to build and run. Both these open-source apps are fully functional real-time messaging, voice and video calling apps. Some of the key features are,
- One-on-one messaging and Group chat
- High-quality voice and video calling
- Rich messaging (text, picture, video, audio, other files)
- Encryption
- Location sharing
- Message status and typing indicators
- Online status (presence) and real-time profile update
- Push notifications
Excited? It won’t take much before you build your own Android and iOS app with all these features yourself. But if you can’t wait, you can also try them from Google Play Store OR Apple AppStore
Alright, let’s get going!
Prerequisites
Before we dive into building and running a fully featured Messenger for Android and iOS, ensure that you’ve read the followings.
It is expected that you are already familiar with the Android
or iOS
app development, and have installed the Android Studio
OR Xcode
. Familiarity with GitHub is also recommended but not mandatory.
You must run this code on a real device! Hence it is also expected that you have access to Android or iPhone to run this app.
Introduction
This tutorial is broken into multiple parts. Instead of making you wait till the end to build both the apps, we will quickly build apps first and then dwell into details later.
- In this part, we will learn about the features and key components of both the apps.
- In the next part, we will download the source code for Android App, build and run it.
- We will then download the source code for iOS App, build and run it.
- In the fourth part, we will learn about customizing both the apps.
- In the fifth and sixth part, we will learn about hosting entire platform on your own-premise.
- Finally, we will discuss contributing and requesting support if you need any help.
Key App Components & Third Party Libraries
These apps use the following Mesibo SDKs.
- Mesibo Core SDK
- Mesibo Messaging UI Module
- Mesibo Call UI Module
These apps also use the following third-party libraries/services.
- Facebook AccountKit for the Phone Verification
- Google Maps and Google Places SDKs for Geolocation integration
In a later section, we will discuss how to configure your own API keys for both these services.
Conclusion of part one
In this part, we have learned a brief about Messenger app features and key components.
In part 2, we will start building the Android app.
whatsapp clone tutorial, android chat app tutorial, ios chat app tutorial, tutorials for making whatsapp, open source chat app tutorials


Too tired to clean?  Give us a call and We'll clean it all.
SPEAK TO AN SPECIALIST NOW!!!
Our basic three room house special, includes sweeping, vaccumming, dusting, and mopping.
Make an Appointment! 300.00
Includes all the services in "Simple Clean", addition includes polishing, bathroom care.
Make an Appointment! 400.00
Includes all the services in "Super clean", addition includes kitchen services,
Make an Appointment! 500.00
WE'LL MAKE SURE YOU CAN EAT OFF YOUR FLOORS TYPE OF CLEAN!!
Make an Appointment! 700.00


#include <cstdio>
#include <cstdlib>
#include <string>
#include <iostream>
#include <sstream>
Go to the source code of this file.
◆ ode_check_write()
| void ode_check_write |
( |
const char * |
fn | ) |
|
check if a file can be written (opened in write mode)
- Parameters
-
Definition at line 5 of file ode_io.cc.
◆ ode_print_exit()
| void ode_print_exit |
( |
const char * |
msg | ) |
|
print a message and exit with failure
- Parameters
-
| [in] | msg | the message to print before exiting the program |
Definition at line 15 of file ode_io.cc.
◆ ode_write()
template<class T >
| void ode_write |
( |
char const * |
fn, |
|
|
T * |
a, |
|
|
unsigned long |
n |
|
) |
| |
write an array to a binary file
- Parameters
-
| [in] | fn | file name or path |
| [in] | a | array of values to write |
| [in] | n | size of array or number of elements to write |
Definition at line 25 of file ode_io.h.


I was born an American Citizen in Corona, California, living with a father, a mother, and two sisters. Foothill Elementary was the school I started in. When I came to elemantary, I had a decent education until I reaches 3rd grade where my mathmatics was an issue and it discouraged me to learn math. I then found myself in the 4th grade, having trouble with reading comprehension; I tried to read more and write more, but in the end my teacher and parents asked me to stop. In the end, I manage to resolve those issues when I completed 6th Grade, but the damage was kind of done.
Citrus Hills was the middle school where my philosophy, mentality, and thinking changed drastically due to the environment I was being educated in. Despite bullying being a common cause, the immature ghetto attitude adopted by the boys, the gossips developed by most of the girls, and social issues caused by both students were some factors that negatively affected both my education and my innocence. Yet, I manage to improve my studies during my time in middle school; the middle school may not be safe in a social sense, but it did provide the necessary subjects like Math and Language Arts (Literature and Writing) which are important to use students. At this time, I took interest in story writing and later game development, and it's the second interest that got me interested in coding. However, coding wasn't introduced to me until High School.
High school has kind of changed me, seeing that story writing and art are just my hobbies. Animation and Game Development were now the focus of my career. In the end Game Development became my final choice to focus, but my family insisted I take something else that related to coding and programming. My social skills were still trying to improve, but instead of bullying and gossip, I now had to deal with family issues, financal management, driving education, and college preparations. And all this was overwhelming to me, and today I still feel that sense of anxiety when dealing with college.
After graduating, I left the United States and moved to the Philippines to gain some college experience here in Baugio as a duel citizen. So far, the University of Cordilleras just reminded me of High School with a few exceptions. My education here, however, is more challenging. My social skills were kind of sent back to square-one since I had difficulties speaking Tagalog (and it still regret not getting to learn the language). Other than social issues, family issues and financial management have not left me. The ethics here left me with mixed responses; some teachers were fair, some were unfair, and some were something inbetween.


Johnson & Johnson loses vaginal mesh class action
More than 1,350 Australian women have won a long-running class action lawsuit against Johnson & Johnson (J&J) over vaginal mesh implants.
Australia's Federal Court found that J&J subsidiary Ethicon failed to warn patients and surgeons about the "risks" posed by the products.
The implants were commonly used to treat pelvic organ prolapse and incontinence after childbirth.
The case is one of a series of lawsuits J&J faces over the products.
Some patients said they had suffered chronic pain, bleeding and severe discomfort during sexual intercourse after having the mesh surgically implanted.
Judge Anna Katzmann ruled that much of the information the company provided about the products was "inaccurate" and at times made "false representations".
"The risks were known, not insignificant and on Ethicon's own admission, serious harm could ensue if they eventuated," Ms Katzmann said in her ruling.
The court will set damages next year.
In a statement, Ethicon defended its record and said it would consider an appeal.
"Ethicon believes that the company acted ethically and responsibly in the research, development and supply of these products," the company said.
Julie Davis, the original claimant in the case, welcomed the decision.
"They have treated women essentially like guinea pigs, lied about it and done nothing to help," she told reporters outside the court in Sydney.
Last year, the Australian government issued a national apology to women affected by vaginal mesh, acknowledging decades of "agony and pain".
Mounting lawsuits
The ruling is the latest bad news for J&J, which is facing billions of dollars in legal claims over other products, including opioids.
In October, the company agreed to pay nearly $117m (£90.5m) to resolve claims over pelvic mesh in 41 US states and the District of Columbia.
It is also facing lawsuits over the product in Canada and Europe.
Separately, J&J is facing thousands of lawsuits from people who claim its talc products caused cancer.
The multinational was also ordered to pay $8bn in damages to a man over claims he was not warned that an anti-psychotic drug could lead to breast growth.
Despite the lawsuits, the company booked $20.7bn in quarterly sales in its most recent results, an increase of 1.9% over the same quarter in 2018.