49ers Announce George Kittle’s Status For This Weekend
by Chris RosvoglouThe San Francisco 49ers are about to face the toughest three-game stretch in NFL history. Fortunately for the top team in the NFC West, it should have All-Pro tight end George Kittle back this weekend.
Kittle suffered a knee injury a few weeks ago against the Arizona Cardinals. It didn’t look good at first, but the former Iowa star managed to stay in the game.
San Francisco held Kittle out for the past two games, falling short to Seattle and needing a fourth-quarter comeback to defeat Arizona.
On Sunday, the 49ers will host the Green Bay Packers with first place in the NFC at stake.
Kyle Shanahan won’t have offensive tackle Joe Staley or defensive end Dee Ford. However, the offense should have most of its play-makers available.
George Kittle, Emmanuel Sanders and Deebo Samuel are all questionable for this weekend. They were all listed as limited participants during Friday’s practice.
Jimmy Garoppolo would benefit greatly from having all his top weapons at his disposal this Sunday. Last weekend, the only reliable wide receiver on the field was Samuel, who finished with eight receptions for 134 receiving yards.
With Kittle most likely active this weekend, the 49ers should have more than enough firepower to keep up with Aaron Rodgers and the Packers.
Kickoff for this game is at 8:20 p.m. ET from Levi’s Stadium.


ConditionalCommand(onTrue: Command, onFalse: Command? = null)
Creates a new ConditionalCommand with given onTrue and onFalse Commands. onFalse can be left unspecified if you do not want it to be a no-op on the false condition.
onTrue
- the command to run when the condition function returns true
onFalse
- the command to run when the condition function returns true


I really like your name btw!
It's your birthday!!! :D
Happy birthday to you!! Yeee! Many many happy blah...
Send
That's what I was going to do.
But then I stopped.
I realised, I wanted to do something special.
Because,
You are Special :)
S O


| interval_t::interval_t |
( |
| ) |
|
|
inline |
Default constructor, constructs an off interval of no duration
| interval_t::interval_t |
( |
const millis_t |
d | ) |
|
|
inline |
Constructs an interval d ms, starting immediately
| void interval_t::advance |
( |
const int |
count | ) |
|
|
inline |
Advances the interval by count durations Use this in combination with ticks() to advance the interval when needed
- Parameters
-
| count | The number of ticks to advance by |
| millis_t interval_t::getDuration |
( |
| ) |
const |
|
inline |
- Returns
- the duration of the interval
| bool interval_t::isOff |
( |
| ) |
const |
|
inline |
- Returns
- True if this interval is off
| bool interval_t::isOn |
( |
| ) |
const |
|
inline |
- Returns
- True if this interval is on
| bool interval_t::isTime |
( |
| ) |
const |
|
inline |
- Returns
- True if this interval has had at least one tick elapse
| double interval_t::progress |
( |
| ) |
const |
|
inline |
- Returns
- The progress made towards the next tick, can be greater than 1
| void interval_t::setMillis |
( |
const millis_t |
millis | ) |
|
|
inline |
Sets the interval of this interval to the desired length in milliseconds. Does not effect the starting time
- Parameters
-
| millis | Length of duration in milliseconds |
| void interval_t::setSeconds |
( |
const millis_t |
seconds | ) |
|
|
inline |
Sets the interval of this interval to the desired length in seconds. Does not effect the starting time
- Parameters
-
| millis | Length of duration in seconds |
| int interval_t::ticks |
( |
| ) |
const |
|
inline |
- Returns
- The number of ticks, or times this interval has elapsed, since the start
| millis_t interval_t::timeRemaining |
( |
| ) |
const |
|
inline |
- Returns
- The number of milliseconds remaining until the next tick
| void interval_t::turnOff |
( |
| ) |
|
|
inline |
| void interval_t::turnOn |
( |
| ) |
|
|
inline |
Turns on the interval Can be called on a running interval to reset the start time
The documentation for this class was generated from the following file:


Dsiplay stream is cloned to make several streams, which are merged together and sent over a single WebRTC MediaTrack.
No renegotiation ever occurs. The total horizontal resolution of all streams never changes.
Resolution can be improved at the cost of higher latency.


The Cubesat Engineering Toolkit is a user-friendly application that allows
people with limited education to design and build cubesats. We provide engineering experience and
talent, allowing you to spend less resources on production of your very own small satellite.
Pricing Plans
Free!
$0
Single User
$TBD
per month
Includes some engineering analysis and modeling tools, persistent saves, and technical support.
Discounted purchases through our website.
Enterprise
$TBD
per user per month
users
Includes ALL engineering analysis and modeling tools in addition to all perks of single user version.


Hi! My name is Rebeca Mora, and I am a Software Engineering with experience in web application, Apis and Microservices. I am fluent in PHP and Symfony. I do pretty well in Typescript and Golang. I build and deliver quality software that helps businesses succeed. I always enforcing the highest legal and professional standards in everything that I do.
Integrating restaurants and services providers with a range of systems providing a platform for hospitality and dining experiences. I was responsible for designing new microservices, building out new APIs to handle ingesting and retrieving data and enabling developers to follow good software development practices (BDD, continuous integration, static code analysis).
Building clean and maintainable systems based on Microservices using Golang in an Agile environment. Also Designing clear RESTful APIs and participating in technical design
Building Lumeon’s Care Pathway Management (CPM) platform that allows healthcare providers to create digital pathways that optimize care delivery and fluidly guide patients and care teams throughout the continuum.
Working as an Analyst Programmer in the Technological Institute of Renewable Energies (ITER SA). Specifically for the Department of Computer Science and New Technologies. The main tasks were to provide support to other departments in the area of implementation of information systems and development of research projects, implementation and dissemination in the field of Information Technology.
Architecting, developing and deploying solutions that support the business, with special attention to the maintainability, scalability and performance of the solutions provided.
Establish architectural principles, select design patterns and discuss with team members on their appropriate application.
Work side-by-side with clients and colleague, teaching them the skills necessary to lead highly productive customer-driven software practices, like pair programming, continuous integration/continuous deployment and test-driven development.


原文地址：http://kkovacs.eu/businessmens-guide-to-open-source-licenses
“Is it OK to take program code under the __ license, add our own functionality, and then __?”
Here is your answer:
<table width=”100%”>
| License (in order of friendliness) |
…sell (license) it as a product? |
…provide it as software-as-a-service? |
| [BSD](http://www.freebsd.org/copyright/freebsd-license.html “BSD”) / [MIT](http://dev.jquery.com/browser/trunk/jquery/MIT-LICENSE.txt “MIT”) License |
OK |
OK |
| [Apache](http://www.apache.org/licenses/LICENSE-2.0 “Apache”) License |
OK |
OK |
| [MPL](http://www.mozilla.org/MPL/MPL-1.1.html “MPL”) (Mozilla Public License) |
If done right * |
OK |
| [LGPL](http://www.gnu.org/licenses/lgpl.txt “LGPL”) (Lesser GNU Public License) |
As a larger work ** |
OK |
| [GPL](http://www.gnu.org/licenses/gpl.txt “GPL”) (Lesser GNU Public License) (GNU Public License) |
your code must be given away for free |
OK |
| [AGPL](http://www.gnu.org/licenses/agpl.txt “AGPL”) (Lesser GNU Public License) (Affero GNU Public License) |
your code must be given away for free |
anyone has to be able to download and use freely |
</table>


{% extends "base.html" %} {% block content %} {% include 'lists_bar.html' %}
These User Account will be permanently deleted and cannot be recovered. Are you sure?


Other modules¶
In addition to invocation.py
already mentioned, and excluding modules defining individual
dialects, the following are included:
console¶
Console adapted from Python’s console found in code.py.
An earlier version of this code was subclassing code.InteractiveConsole. However, as more and more changes were introduced, dealing with code transformation and especially customized error handling, it seemed to make sense to “rewrite” every relevant part in this single module.
-
class
avantpy.console.
AvantPyInteractiveConsole
(locals=None)[source]¶ A Python console that tries to emulate the normal Python interpreter except that it support experimental code transformations. It is adapted from cPython’s
code.InteractiveConsole
and its parent.Like the normal Python interactive console, it attempts to evaluate code entered one line at a time by a user.
-
push
(line)[source]¶ Pushes a transformed line to the interpreter.
The line should not have a trailing newline; it may have internal newlines. The line is transformed and appended to a buffer. The interpreter’s run_source() method is called with the concatenated contents of the buffer as source. If this indicates that the command was executed or invalid, the buffer is reset; otherwise, the command is incomplete, and the buffer is left as it was after the line was appended. The return value is True if more input is required, False if the line was dealt with in some way (this is the same as run_source()).
-
runsource
(source, filename='<input>', symbol='single')[source]¶ Compile and run some source in the interpreter.
Arguments are as for compile_command().
One several things can happen:
1) The input is incorrect; compile_command() raised an exception (SyntaxError or OverflowError). A syntax traceback will be printed by calling the showsyntaxerror() method.
2) The input is incomplete, and more input is required; compile_command() returned None. Nothing happens.
3) The input is complete; compile_command() returned a code object. The code is executed by calling self.runcode() (which also handles run-time exceptions, except for SystemExit).
The return value is True in case 2, False in the other cases (unless an exception is raised). The return value can be used to decide whether to use sys.ps1 or sys.ps2 to prompt the next line.
-
converter¶
This module contains all the necessary functions, classes and methods to take a file written in a given dialect and convert it into Python. In doing so, it can identify some mistakes and raise some custom exceptions which can be used to inform users in a way that is less intimidating than the usual Python tracebacks.
The following can definitely be skipped unless you are interested in (most of) the gory details.
AvantPy uses Python’s tokenize
module to convert a
source into a sequence of tokens. A token might be the name
of a variable, an operator, a parenthesis, a string, etc.
AvantPy analyses these tokens, replacing some written into a different dialect until all are converted into standard Python tokens. Then, these are recombined into a string which is the source to be executed.
Python’s tokenize module includes a function, called untokenize, which can be used to combine a series of tokens into a valid program. With a normal Python program, doing something similar to:
new_source = untokenize(tokenize(source))
would be such that executing new_source
would be the same
as executing source
. However, the spacing between tokens
would not necessarily be the same for both new_source
and the original program. For example, the original program
may include a line like:
variable = function( argument )
which might be converted into:
variable =function(argument)
This could make it more difficult to compare the original code with the converted one, as it is possible to do using one of the utilises provided with AvantPy, or any “diff” program. As a result, we do not use Python’s untokenize function, and explicitly keep track of spacing between tokens.
To understand how the conversion process works, it is useful to review all possible cases, from some of the most complex, ending with the simplest ones.
nobreak
AvantPy has an additional keyword, named nobreak
in the
English dialect, which can be used in for
or while
loops instead of the standard else
, as in:
while condition:
# code
nobreak:
# code
However, nobreak
cannot be used in an if/elif/else
blocks to replace else
.
Furthermore, nobreak
cannot be used instead of else
in an assignment such as:
a = 1 if True else 2
To identify if a program includes a nobreak
keyword
mistakenly, every time we see a leading for
, while
,
if
or elif
keyword (or their equivalent in a
given dialect), we note the indentation (column where the
first character is written) and the corresponding keyword.
A list containing these keywords is called blocks_with_else
in this function.
Later, when we encounter a nobreak
keyword at a given
indentation, we check to see if the last blocks_with_else
keyword found at that same indentation was one for which
it made sense to use nobreak
or not. If it was a
loop, we simply replace nobreak
by else
. If not,
we raise a custom exception which is handled elsewhere.
repeat
In addition to the standard Python loops constructs, AvantPy support four additional idioms:
repeat forever: # while True:
pass
repeat while condition: # while condition:
pass
repeat until condition: # while not condition:
pass
repeat n: # for some_var in range(n):
pass
For this last case, n
could be an expression, possibly
spanning multiple lines.
When we encounter the equivalent to the “repeat” keyword in the selected dialect, we must make sure that it is the first keyword occurring on a logical line; if not, we raise a custom exception.
If repeat
is the first keyword on a line, we set a flag
(repeat_loop) to True, preparing to look at the next token.
a) If the next token is one of forever
, until
, while
,
or their equivalent in the target dialect
(remember that including normal Python keywords in a program written
in a different dialect is allowed)
we can proceed with the rest in a straightforward manner.
b) if that is not the case, we set a different flag (repeat_n) to True so that we can deal with the relevant for loop.
For this last case, the variable in the for loop is a dummy
variable; we must ensure that its name is chosen such that
it does not occur anywhere else in the source code.
This is accomplished using a method called
get_unique_variable_names
.
nobreak
andrepeat
A repeat
loop is essentially a for
or a while
loop. As such, it could have an else
clause which
has a clearer meaning if the keyword nobreak
is used
instead. Thus, just like we mentioned before, we also
keep track of where a leading repeat
is used.
Direct translation
If a token does not match one of the cases described above, we need to see if it is a term used in the dialect; if so, we simply translate it into standard Python.
Brackets
In Python, brackets must always come in pairs: (…), […], {…}. In the course of processing the file, if we identify brackets which are not paired correctly, an exception is raised.
Remaining tokens
Any remaining token is left as is; it is assumed to be valid Python.
-
class
avantpy.converter.
Converter
(source, dialect=None, filename=None)[source]¶ This class uses Python’s
tokenize
module to convert a source into a sequence of tokens. A token might be the name of a variable, an operator, a parenthesis, a string, etc.It processes one token at a time, identifying potential misuses, replacing some tokens written into a different dialect until all are converted into standard Python tokens. Then, these are recombined into a string which is the source to be executed.
Python’s tokenize module includes a function, called untokenize, which can be used to combine a series of tokens into a valid program. With a normal Python program, doing something similar to:
new_source = untokenize(tokenize(source))
would be such that executing
new_source
would be the same as executingsource
. However, the spacing between tokens would not necessarily be the same for bothnew_source
and the original program. For example, the original program may include a line like:variable = function( argument )
which might be converted into:
variable =function(argument)
This could make it more difficult to compare the original code with the converted one, as it is possible to do using one of the utilises provided with AvantPy, or any “diff” program. As a result, we do not use Python’s untokenize function, and explicitly keep track of spacing between tokens.
-
convert
()[source]¶ Uses Python’s tokenize module to generate tokens from a source.
It calls a function to process each token in turn, and combine the results to returned a transformed source.
-
do_close_bracket
(token)[source]¶ Determines if a closing bracket ), ], or }, matches a previously opened one, and raises an error if that is not the case.
-
do_until_forever_error
(token)[source]¶ This function is called when we see a keyword equivalent to
until
orforever
in a given dialect without them being preceeded by the keywordrepeat
. This is not allowed.
-
preserve_repeat_spacing
(token)[source]¶ We ensure spacing of original file is preserved, including space between tokens. When self.just_processed_repeat_kwd is True, it means we just saw the repeat keyword which can simply be dropped; we don’t need add the space between “repeat” and the next token.
-
process_after_repeat
(token)[source]¶ After we see the
repeat
keyword, there are four possibilities:the keyword
until
followsthe keyword
until
followsthe keyword
forever
followsit is meant to be followed by some_expression which evaluates to an integer.
-
process_nobreak
(token)[source]¶ The
nobreak
keyword is allowed to replaceelse
in awhile
orfor
loop only.
-
-
avantpy.converter.
convert
(source, dialect=None, filename=None)[source]¶ Normally used from other functions to call for a conversion of a Python source from a given dialect into Python.
-
avantpy.converter.
get_unique_variable_names
(source, repeat_kwd, all_count_names=[])[source]¶ Returns a list of possible variables names that are not found in the original source and have not been used anywhere. These variables will be used in expressions such as
for _COUNT_42 in range(n):
which will replace
repeat n:
-
avantpy.converter.
transcode
(source, from_dialect, to_dialect)[source]¶ Transforms a source (string) written in a known dialect into an equivalent version written in a different dialect. Spacing between tokens is preserved. This means that if a source is transformed from dialect xx to dialect yy, and that the result is transformed back to dialect xx, the original source should be recovered.
Returns either the transformed source as a string, or None if something prevented the transformation to be successful.
exception_handling¶
The goal of exception_handling.py is to display information about exceptions being raised in a way that is much easier to understand for beginners than normal Python tracebacks. These “friendly” tracebacks are written so that they can easily be translated into any human language.
-
avantpy.exception_handling.
extract_filename_linenumber
(exc)[source]¶ Extracting filename and linenumber where an error occurred based on information from traceback.
-
avantpy.exception_handling.
get_partial_source
(source, begin, end, marks=None, nb_digits=None)[source]¶ Extracts a few relevant lines from a source file.
If the number of lines would exceed a certain limit (currently 7) the function is called recursively to only show the a few lines at the beginning and at the end.
-
avantpy.exception_handling.
handle_IfNobreakError
(exc, source)[source]¶ Handles situation where
nobreak
was wrongly use as a replacement forelse
in an if/elif/else block.
-
avantpy.exception_handling.
handle_MismatchedBracketsError
(exc, source)[source]¶ Handles situation where a bracket of one kind ‘([{‘ is closed with a bracket of a different kind.
-
avantpy.exception_handling.
handle_MissingLeftBracketError
(exc, source)[source]¶ Handles situation where at bracket of one kind ),],} is closed without a corresponding open bracket.
-
avantpy.exception_handling.
handle_MissingRepeatColonError
(exc, source)[source]¶ Handles situation where a statement beginning with repeat does not end with a colon.
-
avantpy.exception_handling.
handle_MissingRepeatError
(exc, source)[source]¶ Handles situation where either
until
orforever
was used without being preceeded byrepeat
.
-
avantpy.exception_handling.
handle_NameError
(exc, source)[source]¶ Handles situation where a NameError is raise.
-
avantpy.exception_handling.
handle_NobreakFirstError
(exc, source)[source]¶ Handles situation where
nobreak
was wrongly use as a replacement forelse
in statements like var = x if condition else y.
-
avantpy.exception_handling.
handle_NobreakSyntaxError
(exc, source)[source]¶ Handles situation where
nobreak
is used without a matchingfor
orwhile
loop and not already raised.
-
avantpy.exception_handling.
handle_RepeatFirstError
(exc, source)[source]¶ Handles situation where
repeat
was uses wrongly as it did not appear as the first keyword of a given statement.
-
avantpy.exception_handling.
handle_TryNobreakError
(exc, source)[source]¶ Handles situation where
nobreak
was wrongly use as a replacement forelse
in an try/except/else/finally block.
-
avantpy.exception_handling.
handle_UnknownDialectError
(exc, *args)[source]¶ Handles error raised when an unknown dialect is requested
-
avantpy.exception_handling.
handle_UnknownLanguageError
(exc, *args)[source]¶ Handles error raised when an unknown language is requested
exceptions¶
Custom exceptions
-
exception
avantpy.exceptions.
AvantPySyntaxError
(msg, args)[source]¶ Base class for custom exceptions that are SyntaxErrors
-
exception
avantpy.exceptions.
IfNobreakError
(msg, args)[source]¶ Raised if
nobreak
is used instead ofelse
in anif
statement
-
exception
avantpy.exceptions.
MismatchedBracketsError
(msg, args)[source]¶ Raised if a left parenthesis ‘(‘, or square bracket ‘[‘ or curly bracket ‘{‘, is closed by a right ‘bracket’ of a different type.
In standard Python, this would be indicated as:
SyntaxError: invalid syntax
-
exception
avantpy.exceptions.
MissingLeftBracketError
(msg, args)[source]¶ Raised if a right parenthesis ‘)’, or square bracket ‘]’ or curly bracket ‘}’, is found without having a matching left bracket found previously.
In standard Python, this would be indicated as:
SyntaxError: invalid syntax
-
exception
avantpy.exceptions.
MissingRepeatColonError
(msg, args)[source]¶ Raised if a line beginning with
repeat
does not end with a colon.
-
exception
avantpy.exceptions.
MissingRepeatError
(msg, args)[source]¶ Raised if
until
orforever
is used without being preceeded byrepeat
.
-
exception
avantpy.exceptions.
NobreakFirstError
(msg, args)[source]¶ Raised if
nobreak
is used somewhere other than at the beginning of a line.
-
exception
avantpy.exceptions.
NobreakSyntaxError
(msg, args)[source]¶ Raised if
nobreak
is without a matching block.
-
exception
avantpy.exceptions.
RepeatFirstError
(msg, args)[source]¶ Raised if
repeat
is used somewhere other than at the beginning of a line.
-
exception
avantpy.exceptions.
TryNobreakError
(msg, args)[source]¶ Raised if
nobreak
is used instead ofelse
intry/except
statement
gui¶
This module provides a GUI to the conversion function.
It makes it possible to load up a source file written in a given dialect and convert it into another dialect or into Python, showing both the original source and the converted one in two different editor frames, with Python keyword, as well as their counterpart in various dialects, highlighted.
Todo
This module needs to be documented properly
-
class
avantpy.gui.
App
(master=None)[source]¶
-
class
avantpy.gui.
EditorWidget
(parent, parent_frame, other=None)[source]¶ A scrollable text editor, that can save files.
-
colorize
(event=None)[source]¶ Colorizes the Python keywords and a few builtins, as well as the corresponding version in other dialects.
-
import_hook¶
A custom importer making use of the import hook capability
-
class
avantpy.import_hook.
AvantPyLoader
(filename)[source]¶ A custom loader which will transform the source prior to its execution
-
class
avantpy.import_hook.
AvantPyMetaFinder
[source]¶ A custom finder to locate modules. The main reason for this code is to ensure that our custom loader, which does the code transformations, is used.
-
avantpy.import_hook.
import_main
(name)[source]¶ Imports the module that is to be interpreted as the main module.
avantpy is often invoked with a script meant to be run as the main module its source is transformed with the -s (or –source) option, as in:
python -m avantpy -s name
Python identifies avantpy as the main script, which is not what we want.


At the top of the dialog box is the name of the selected graph followed by the number of images in the graph and the image number currently in the foreground. The Prev and Next buttons immediately below this information step through the images, bringing each one to the foreground in turn. It is possible to either blink all the images in order or in a specified sequence. The Add to List button appends to this sequence list the image currently in the foreground. The sequence List entry box consists of a comma-separated list of image numbers and/or ranges (e.g., 1-3,5,8-10,14). A pair of radio buttons determines with the sequence list is used or all the images are blinked in order. Two checkbuttons control whether blinking is Looped--repeated indefinitely--or stopped after the last image is displayed, or blinked in Reverse order. A slidebar controls the Speed at which blinking occurs. All these controls can be modified while images are being blinked and will take effect immediately. To have a new list of frames take effect, though, one must reselect the List radio button.
When the controls are set to their desired values, press the Blink Images button to begin blinking. The button changes to Stop Blinking.
If the selected graph is changed while the dialog box is open, press the Reload Info button to update the dialog with the new information.
Blink begins when the Blink Graphs button is pressed. Blinking is always in the specified order (no reverse option) and will repeat indefinitely until the Stop Blinking button (same as the Blink Graphs button) is pressed.
As graphs normally don't initially overlap and will likely need to be repositioned, the graphs in the Blink Order list can be moved from within the dialog box. A compass labeled Shift & Align Graphs is present in the center of the dialog box. Clicking on the center of the compass aligns all the graphs in the list according to the top right corner of the first graph. Clicking on any of the arrows shifts the highlighted graphs 10 pixels in that direction. Shift-clicking an arrow shifts the graphs 1 pixel at a time. The graphs continue to move in these increments until the mouse button is released or the cursor leaves the compass arrow. (Note: if an individual graph is present several times in the Blink Order list, each instance of it in the highlighted selection will experience the shift.) Graphs can be repositioned with the compass while blinking.
If graphs are added to the POW canvas while the dialog box is open, press the Reload Info button to create a new list of Available Graphs.


Hi {{ name }}, Thanks for contacting me. Here's a copy of the message you sent:
{{ content }}
I'll get back to you soon. Regards, Danny Fischer


Blood Donor Sign Up
1. Home Address
2. Blood Type
Choose blood type
A
B
O
3. Notification
How frequently do you want to be notified by blood seekers?
Daily
Weekly
Monthly
3. Transportation
Do you have Transportation?
Yes
No
Only in emergencies
4. Countries visited before
Select countries you have visited in the last 2 month.
Amsterdam
Washington
Sydney
Beijing
Cairo
5. Time Availability
Please Indicate your time availability in the following table
Sun
Mon
Tue
Wed
Thu
Fri
Sat
6. Check for diseases
Do you have any of the following diseases:
AIDs
Yes
No
May Be
Submit


Lets overwrite the content section
Some Articles
$article[title]
Author: $article[author]
%d. %h. %Y, %H:%M:%S
First entry, lets show the whole text
$article[full]
$article[excerpt]
There are more than 3 articles?
~{$articles_n|gt|3}
There are more articles.
Some more useless demo stuff...
Counting from 10 to 0...
but take only the even ones and multiply by 5...
$i
$i * 5
Repeat some text...


Closing this ticket means trying it and seeing how it goes.
More analysis: EphemeraFolder state readability is as permissive as possible: If it's containing box has a readable state, it will treated as having readable state no matter what its own state is, and if it's containing box doesn't have a readable state, its own state will be used to determine.
However, the mechanism that powers this relies on a hack that codes "needs_qa" as a readable state. Then lots of other code relies on that readable state array.
readable state definition: https://github.com/pulibrary/figgy/blob/150e9def951fd0b1ea8f948069f5a0225fff4f4f/app/models/folder_workflow.rb#L30
Code relying on that array: * https://github.com/pulibrary/figgy/blob/28ce5082801c4e62a6cc1d2992e3aa8372f73194/app/decorators/valkyrie/resource_decorator.rb#L183-L188 * https://github.com/pulibrary/figgy/blob/6b66dc52aa4187a2a2d0d2e2fb087cefd35f3e1e/app/presenters/permission_badge.rb#L37-L40 * https://github.com/pulibrary/figgy/blob/c5f851aea6e7c65306e17fb40ec9cf74c40a0a7f/app/change_set_persisters/change_set_persister/mint_identifier.rb#L30 * https://github.com/pulibrary/figgy/blob/9ac0402b4255b356f83360c5453a6b49d0ce1602/app/models/ability.rb#L203-L218 * * https://github.com/pulibrary/figgy/blob/9ac0402b4255b356f83360c5453a6b49d0ce1602/app/models/ability.rb#L120-L123
All the ephemera folders currently say they will sync to discovery sites, regardless of the state of their containing box. Here's one example with a "shipped" box: * folder: https://figgy.princeton.edu/catalog/b43b32bd-874b-415a-8350-75e553342d42 * box: https://figgy.princeton.edu/catalog/626af16f-152f-4985-a106-70afd3d80320
I'm not sure if they actually are syncing to discovery sites. More investigation needed on that point.
It seems like we might want to change this so that the public read states are accurate, and update child state at save time the way we do with other propagations. This might necessitate a migration.
labeled
by Trey Pendragon at 2022-11-23 16:31:40.labeled
by Trey Pendragon at 2022-11-23 16:31:46.closed
by Trey Pendragon at 2022-11-23 16:36:35.referenced
by Trey Pendragon at 2022-11-23 19:09:48.merged
by Trey Pendragon at 2022-11-23 19:09:48.closed
by Trey Pendragon at 2022-11-23 19:09:49.head_ref_deleted
by Trey Pendragon at 2022-11-23 19:09:49.review_dismissed
by Trey Pendragon at 2022-11-23 19:14:45.head_ref_force_pushed
by Trey Pendragon at 2022-11-23 19:14:45.head_ref_force_pushed
by Trey Pendragon at 2022-11-23 19:34:20.ready_for_review
by Trey Pendragon at 2022-11-23 19:34:26.We're getting a CORS error, thinking that we set up CORS for the mosaic endpoint and not the COG endpoint.
Implementing this for MARC records will mean adding a harmful_content tag to Orangelight if the right metadata appears (which CAMS hasn't decided on yet), so we may be able to create a ticket in Orangelight and leave implementation to DACS.
Here's the latest wireframe. Still needs work.
labeled
by Trey Pendragon at 2022-11-23 16:02:58.labeled
by Trey Pendragon at 2022-11-23 16:03:30.labeled
by Trey Pendragon at 2022-11-23 16:03:36.unlabeled
by Trey Pendragon at 2022-11-23 20:23:00.@kelea99 will check in with Colleen.
@kelea99 will check in with Colleen.
Colleen will rescan the reel next week.
mentioned
by Kim Leaman at 2022-11-23 20:33:23.subscribed
by Kim Leaman at 2022-11-23 20:33:23.mentioned
by Kim Leaman at 2022-11-23 20:33:23.subscribed
by Kim Leaman at 2022-11-23 20:33:24.Does turning this off mean we don't get the error or does it mean it lets them through? I'm not sure we want to let them through.
@kelea99 will fix this.
Fixed! https://figgy.princeton.edu/catalog/0a61e17a-17b0-431b-bb06-0852c733ed2a
mentioned
by Kim Leaman at 2022-11-23 20:51:32.subscribed
by Kim Leaman at 2022-11-23 20:51:32.closed
by Kim Leaman at 2022-11-23 21:40:14.Coverage remained the same at 94.498% when pulling dcb8efb24901b077e03c22ec4cafae18fe802f49 on availabilityjs-continue-2696 into 017dc28a1eceb167f072c14f96687be12292a776 on main.
head_ref_force_pushed
by Francis Kayiwa at 2022-11-23 14:01:12.assigned
by Jane Sandberg at 2022-11-23 16:31:59.head_ref_force_pushed
by Robert-Anthony Lee-Faison at 2022-11-23 17:10:47.CI has been failing on this branch with:
TASK [cantaloupe : Install Cantaloupe] *****************************************
fatal: [instance]: FAILED! => {"changed": false, "msg": "Failure downloading https://github.com/medusa-project/cantaloupe/releases/download/v4.0.3/Cantaloupe-4.0.3.zip, HTTP Error 503: Egress is over the account limit."}
Is this something we should add to our mirror?
Could we have this PR ref a ticket that explains why / what rapid7 is? It can point to https://github.com/pulibrary/pul-it-handbook/pull/138
Good idea @hackartisan.
We put what we know about Rapid7 into a file in pul-it-handbook. I don't think that PR has been merged yet - it's https://github.com/pulibrary/pul-it-handbook/pull/138
mentioned
by None at 2022-11-23 17:23:15.subscribed
by None at 2022-11-23 17:23:16.head_ref_force_pushed
by Vickie Karasic at 2022-11-23 17:01:46.referenced
by Francis Kayiwa at 2022-11-23 17:35:38.merged
by Francis Kayiwa at 2022-11-23 17:35:38.closed
by Francis Kayiwa at 2022-11-23 17:35:38.head_ref_deleted
by Francis Kayiwa at 2022-11-23 17:35:39.head_ref_force_pushed
by Francis Kayiwa at 2022-11-23 20:25:32.review_requested
by Jane Sandberg at 2022-11-23 16:53:56.mentioned
by None at 2022-11-23 16:53:56.subscribed
by None at 2022-11-23 16:53:56.head_ref_force_pushed
by Francis Kayiwa at 2022-11-23 21:09:04.We noticed this is always at 5 AM and 5 PM. @acozine going to see if there's anything running on those pulfalight boxes at that time.
mentioned
by Alicia Cozine at 2022-11-23 20:58:51.subscribed
by Alicia Cozine at 2022-11-23 20:58:51.assigned
by Alicia Cozine at 2022-11-23 20:59:04.This was from geodata.mitlib.net, which has renewed its SSL cert, we can close this.
closed
by Trey Pendragon at 2022-11-23 20:26:13.referenced
by Chuck McCallum at 2022-11-23 16:05:19.merged
by Chuck McCallum at 2022-11-23 16:05:19.closed
by Chuck McCallum at 2022-11-23 16:05:19.head_ref_deleted
by Chuck McCallum at 2022-11-23 16:05:23.referenced
by Jane Sandberg at 2022-11-23 18:07:48.merged
by Jane Sandberg at 2022-11-23 18:07:48.closed
by Jane Sandberg at 2022-11-23 18:07:48.head_ref_deleted
by Jane Sandberg at 2022-11-23 18:07:49.


Test 1
Test 2
Test 3
To see tree sample run
server application
.
Column sorting in grids also requires server component.


[?do clear_text(); ?]
NEANDERTHAL BUSINESS OWNER: Whoah - you mean that stuff that comes out of the trees when they're struck by lightning?
Case Study #1: The Dos and Dont's of Artifical Fire
NEANDERTHAL ENGINEER: I've invented artificial fire!NEANDERTHAL BUSINESS OWNER: Whoah - you mean that stuff that comes out of the trees when they're struck by lightning?
NEANDERTHAL ENGINEER: Yup!
NEANDERTHAL BUSINESS OWNER: We can totally sell access to Fire As A Service!
NEANDERTHAL ENGINEER: Yeah, I guess so...just don't crowd too many in until we expand the cave capacity.
NEANDERTHAL BUSINESS OWNER: Can't we just work with what we have and crowd them in and expand at the same time?
Case Study #2: The Dos and Dont's Of Sandwich Logic (Strategic Fail!)
AKAMAI SA: The extraordinarilly complicated configuration is ready for approval. Be very thorough with the user acceptance testing...BUSINESS OWNER: Okourtestingiscompleteitsfinedeployitrightaway!!!!!!!
AKAMAI SA:
A. Ok, here goes...
B. No, we need to slow down...
...and then, the next time...
AKAMAI SA: The extraordinarilly complicated configuration is ready for approval. Be very thorough with the user acceptance testing...BUSINESS OWNER: Okourtestingiscompleteitsfinedeployitrightaway!!!!!!!
AKAMAI SA:
A. Ok, here goes...
B. No, we need to slow down...
...and then, the next time...
AKAMAI SA: The extraordinarilly complicated configuration is ready for approval. Be very thorough with the user acceptance testing...BUSINESS OWNER: Okourtestingiscompleteitsfinedeployitrightaway!!!!!!!
AKAMAI SA:
A. Ok, here goes...
B. No, we need to slow down...
...and then, the next time...
AKAMAI SA: The extraordinarilly complicated configuration is ready for approval. Be very thorough with the user acceptance testing...BUSINESS OWNER: Okourtestingiscompleteitsfinedeployitrightaway!!!!!!!
AKAMAI SA:
A. Ok, here goes...
B. No, we need to slow down...
...and eventually we had an SI.
Try again...Case Study #3: The Dos and Dont's HSTS Headers (Strategic Success!)
BUSINESS OWNER: HSTS is where it's at! Implement HSTS with 1 year TTL and enable on subdomains right now!AKAMAI SA: That change is nearly impossible to reverse if end users that experience a problem and may result in a partial DoS.
BUSINESS OWNER: Nah, it's fine.
AKAMAI SA:
A. Ok, here goes...
B. No, we need to slow down...
You're joking right? Pick the other one.
BUSINESS OWNER: Ok fine, do what you need to do but we're going to implement it on our toplevel anyway!
AKAMAI SA:
A. Sounds good - you do that.
B. No, we need to slow down...
AKAMAI SA:
A. Sounds good - you do that.
B. No, we need to slow down...
BUSINESS OWNER: We just noticed something. All of our pre-prod test sites are down. We should not have done what we did. The Akamai SAs are wise and knowledgeable and we will listen to them more in the future.
THE END
THE END


George/John,
The following schedule is based on general research and analysis of your project. The goals that you want to achieve with the implementation of the project can be broken down to the following:
As an agency with a focus on return on investment, we are dedicated to creating a robust, highly scalable application that will allow you to focus on securing clients and building a community with the confidence that users will have a consistent, immersive experience each time they visit BeKon.
To achieve the above objectives, we divide the upcoming project into 5 sections:
Our task will be to strengthen your brand online by implementing a customized development strategy with proven methods and results. Our goal is to position BeKon as the leading option amongst other applications that provide a similar service.
The focus is always the communication of values and innovation.
We achieve this through the following points:
The focus of the above strategies is on the quality, the feel and the impact of your product to communicate online in such a way that visitors and customers talk about your brand online and offline, thus growing the brand virally.
Planning is an objective of each and every activity, where we want to discover things that belong to the project. An important task in creating a software program is extracting the requirements or requirements analysis.
At this point, we will discuss abstract ideas that you expect as an end result and convert the relevant aspects into the system design.
Requirements that are created as a result of this brainstorming between Bright Ideas and Bekon will subsequently be added to Planscope, our preferred project management tool, as tasks for developers to complete. These tasks will be tracked and reviewed iteratively by BeKon and Bright Ideas.
At this point, we will discuss abstract ideas that you expect as an end result and convert the relevant aspects into the system design.
During this stage, the design functions and operations are described in detail. These functions and operations include screen layouts, business rules, process diagrams and other documentation. The output of this stage will describe the new system as a collection of modules or subsystems.
The elements created during the design stage are largely derived from the approved requirements that we create during the planning phase. For each requirement, one or more design elements will be produced.
At the end of this phase (typically 1-2 weeks), our deliverable will be a prototype that will accurately depict the functionality, flow and overall structure that should be expected when interacting with the real application. Our preferred tool to create prototypes is Invision.
Setup of backend database to be hosted in the cloud.
In this phase, we bring your idea and vision to life. We create your online presence based on the findings gained in the previous sections as well as the design.
During this phase, we perform the actual coding. We will employ a test-driven development process to ensure the validity of the code that we write as we write it as opposed to solely relying on testing afterwards. This process will severely decrease the potential for bugs that would need to be addressed post-deployment.
In addition, we will develop a number of cloud-hosted services that will allow seamless communication between the front-end client and the backend infrastructure.
Finally, we will style the applications such that a consistency of design is maintained across each platform. This is typically the longest phase of the application development process.
Our objective is to create a solid foundation by building an application that is highly scalable once demand increases and new features are added. Also, the code base will be well-documented for the purpose of optimal maintainability.
Our primary focus is to create a simple yet elegant design that provides a seamless, pleasurable experience for the end user. The catalog of features will be classified logically and easily searchable.
The application will be designed in such a way that the content will be presented logically based on the target device. To increase the readability and the perception of the side on these devices, we will optimize your new presence for all mobile devices.
An automatic adjustment to the following devices:
Responsive design assures that the application adapts to the screen upon which it is accessed.
Smartphone users have grown to expect certain functionality when viewing content on their devices. In order to remain competitive, it is imperative that these items are captured while pushing the envelope by incorporating cutting-edge features that are made available to developers for implementation in applications.
We will leverage React Native, an immensely popular JavaScript framework, and Swift, a programming language designed to create native applications for Apple iPhone, Watch, Apple TV and Macs. React Native will allow us to build one application that will run on iOS and Android platforms, respectively. As previously stated, it is imperative that we maintain integrity across platforms in terms of design. Swift will provide the hooks needed to access native APIs such as HealthKit, WatchKit and Touch ID.
While the application will be developed in such a way that it we will be able to deploy to Android and Apple devices, respectively, from one code base, I recommend that we focus intitially on developing for Apple devices (iPhone and Watch). Apple provides APIs (HealthKit and CareKit, among others) that will allow the application to work with user's shared health data.
Our development schedule will be as follows:
After the code is developed it is tested against the requirements to make sure that the product is actually solving the needs addressed and gathered during the requirements phase. During this phase, we will use TestFlight to share the application with users to conduct beta testing before we release to the public.
Once we verify that the different components of the application work together as expected, we will submit the application to the App Store. The approval process normally lasts 10-14 days, although the times may vary...
Our task will be to provide a robust system that integrates services such as Smart 911 and Checkr while also providing a level of integration with Apple Health. By using open web-standards and employing software development best practices, we will create an engaging experience that will compel users to register and become active members of the BeKon community.
In order to adhere to the proposed schedule, we estimate a budget of $50,000. Here is an itemized breakdown:
We request a $15,000 down payment to begin the Infrastructure Setup and Technical Implementation phases.
In addition, we will require a $1000 monthly retainer to maintain the existing codebase. Some examples of occurrences that would warrant maintenance include the following:
From the start of the project to our first deployment to the App Store, we estimate 10-14 weeks.
If you have any further questions, do not hesitate to reach out to me via email or phone.
Phone:<PHONE_NUMBER> / Email: dana@brightideas.nyc


Solves the individual bioenergetic balance for different aquaculture sea fish (Sea Bream and Sea Bass; Brigolin et al., 2014 <doi:10.3354/aei00093>) and shellfish (Mussel and Clam; Brigolin et al., 2009 <doi:10.1016/j.ecss.2009.01.029>; Solidoro et al., 2000 <doi:10.3354/meps199137>). Allows for spatialized model runs and population simulations.
| Version: | 1.5 |
| Depends: | R (≥ 3.1.0), matrixStats, rstudioapi, plotrix |
| Imports: | maps, maptools, ncdf4, rgdal, rgeos, sp, stats, utils, raster |
| Suggests: | MASS, knitr, rmarkdown |
| Published: | 2018-05-02 |
| Author: | Baldan D. [aut, cre], Palazzo D. [ctb], Porporato E.M.D [ctb], Brigolin D. [ctb] |
| Maintainer: | Baldan D. <damiano.baldan91 at gmail.com> |
| License: | MIT + file LICENSE |
| NeedsCompilation: | no |
| CRAN checks: | RAC results |
| Reference manual: | RAC.pdf |
| Vignettes: |
RAC |
| Package source: | RAC_1.5.tar.gz |
| Windows binaries: | r-devel: RAC_1.5.zip, r-release: RAC_1.5.zip, r-oldrel: RAC_1.5.zip |
| OS X binaries: | r-release: RAC_1.5.tgz, r-oldrel: RAC_1.5.tgz |
| Old sources: | RAC archive |
Please use the canonical form https://CRAN.R-project.org/package=RAC to link to this page.


UA-110417537-1
Home
Points table
Apps & Books
About Us
Gallery
Photos
Vedios you may like
New Item
best website authoring software
Hello friends ! welcome to the WORLD OF KNOWLEDGE
get your brain boosted by reading books and dont be just reading books alone also play games
Wait to get more games , app & books related to Mind Skills
(you can also recomend us some apps or games through our contact form)
Click Here
Sudoku
Click Here
Swordigo
Click Here
Mind Games
Click Here
Logic Master I
Click Here
ClashRoyale
Click Here
Where's my water II
Click Here
X&O
Click Here
C.A.T.S


[§339D-27] State procurement. All state and county agencies that purchase or lease any covered television shall require each prospective offeror to certify compliance with this part. Failure to provide certification shall disqualify the prospective offeror. [L 2009, c 183, pt of §6]


Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This document defines an XML timing language that makes SMIL 3.0 element and attribute timing control available to a wide range of other XML languages. This language allows SMIL timing to be integrated into a wide variety of a-temporal languages, even when several such languages are combined in a compound document. Because of its similarity with external style and positioning descriptions in the Cascading Style Sheet (CSS) language, this functionality has been termed SMIL Timesheets.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document has been produced by the SYMM Working Group as part of the W3C Synchronized Multimedia Activity. The goals of the SYMM Working Group are discussed in the SYMM Working Group Charter. The authors of this document are the SYMM Working Group members. Different parts of the document have different editors.
This document was part of the SMIL 3.0 specification as the "SMIL 3.0 External timing" module, extending SMIL timing. It was removed from the SMIL 3.0 specification at Candidate Recommandation phase in order to give it more visibility as Timesheets allows integration of timing into a wide range of other XML languages. This document did not collect enough implementation experience to advance further than Last Call Working Draft. It was published as a Working Group Note at closure of the SYMM Working Group. This document represents the state of SMIL Timesheets 1.0 as of 2012. The SYMM Working Group does not expect any further changes to this document.
Comments or report errors on this document can be sent to the public mailing<EMAIL_ADDRESS>- (public archives)
including the prefix'[Timesheets NOTE comment]'
in the subject
line.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This section is informative
This document defines an XML-based timing language that makes SMIL 3.0 element and attribute timing control available to a wide range of other XML-based languages. This language allows SMIL timing to be integrated into a wide variety of a-temporal languages, even when several such languages are combined in a compound document. Because of its similarity with external style and positioning descriptions in the Cascading Style Sheet (CSS) language, this functionality has been termed SMIL Timesheets.
SMIL Timesheets can be seen as a temporal counterpart of CSS. Whereas CSS defines the spatial layout of the document and formatting of the elements,SMIL Timesheets specify which elements are active at a certain moment and what their temporal scope is within a document. And as with CSS, SMIL Timesheets can be reused in multiple documents, which can provide a common temporal framework for multimedia presentations with different contents but identical storylines. The document can be shown in a user agent even if SMIL Timesheets are not supported, since the contents and the layout are still governed by the document itself. Of course, the temporal aspect of the document is then lost, since all the elements are active all the time.
SMIL Timesheets allows the definition of out-of-line timing in conjunction with non-SMIL languages including compound XML documents. To make authoring easier, it contains only a limited subset of SMIL functionality.
SMIL Timesheets provides a temporal dimension to existing a-temporal web documents, in the form of a external XML document. It can be used, for example, for online slide shows or photo galleries. The following [TimesheetsTutorial] provides a number of examples together with an implementation of SMIL Timesheets.
An alternative to Timesheets is XHTML+SMIL [XHTMLplusSMIL] which gives full SMIL functionality as in-line in non-SMIL XML documents. On the other hand, SMIL itself gives full SMIL functionality as in-line XML-based document.
This section explains the design rationale behind Timesheets, its intended use, and its relation to other XML-based languages.
XML-based compound documents need to define the structure of the document and its content, the styling and layout of the document, and the user interaction and internal logic. Where the structure and contents are defined by the host language (XHTML) [XHTML], the styling and layout by Stylesheets (CSS) [CSS2], vector graphics support by SVG [SVG], and the user interaction and data model by XForms [XForms]. Timeshets is a solution for providing timing control capabilities for such compound documents.
| Topic | Technology |
| Structure | Host Language (XHTML) [XHTML] |
| Layout and Styling | Stylesheets (CSS) [CSS2] |
| Vector Graphics | SVG [SVG] |
| User Interaction and data model | XForms [XForms] |
| Timing | SMIL Timesheets |
Because the intention of Timesheets is to provide timing control capabilities, they are based on the SMIL 3.0 Timing and Synchronization modules with some restrictions and additional attributes.
In addition to the SMIL 3.0 Timing and Synchronization modules, SMIL Timesheets includes the SMIL 3.0 PrefetchControl module and the SMIL 3.0 BasicAnimation module is used for controlling animations.
Moreover, SMIL Timesheets defines two new elements, not included in the SMIL 3.0 Timing and Synchronization modules:
Finally, similary to CSS, SMIL Timesheets uses CSS selectors [CSS2] for identifying the elements in the web document to which apply timing control.
Firstly, an overview of the SMIL Timesheets is given in the Overview section. After that, the normative definition of SMIL Timesheets is provided.
The normative definition starts with an introduction of the basic concepts behind SMIL Timesheets. After that, the new elements timesheet and item and use of CSS selectors are described in the SMIL Timesheet Specific Elements section. Then, the use of SMIL 3.0 Timing and Synchronization modules is discussed in the Timing and Synchronization section. After that, the Prefetch section describes how the SMIL 3.0 PrefetchControl is used. Next, Animation section covers the use of SMIL 3.0 BasicAnimation module. Finally, integration with CSS layout is discussed in the Integration with CSS Layout section.
This section is informative
The following example is a simple slide show. The SMIL Timesheet is located
in the head section. It is declared with the timesheet element, which
belongs to the smil namespace. In this example, the seq element is used for timing.
The item elements contain references
to the body of the document and additional timing information. The elements of
the document body are selected using CSS selectors. In this example, the id
selectors (i.e., "#Slide1"
, "#Slide2"
, and
"#Slide3"
) are used. Based on the timing information a new slide
is shown after five seconds.
<?xml version="1.0"?>   <title>Timesheet Example</title> <smil:timesheet> <smil:seq> <smil:item select="#Slide1" dur="5s" /> <smil:item select="#Slide2" dur="5s" /> <smil:item select="#Slide3" dur="5s" /> </siml:seq> </smil:timesheet>

Timesheets

Timesheets defines temporal dimension of documents

Timesheets uses SMIL Timing and Synchronization primitives

Timesheet is located in the head section of the document

The body elements are selected using CSS selectors

CSS Selectors

Timesheets uses CSS selectors to reference body elements

Id selector references individual elementst

Other selectors can be used to match multiple elements

For example, class selector matches all elements that belong to certain class

Animations

Timesheets includes also BasicAnimation module

Supported elements are animate, set, animateMotion, and animateColor

The animation can be defined with either values or from, to, and by attributes

The target elements are referenced with CSS selectors

This section is normative.
This section defines the four basic concepts behind Timesheets:
SMIL Timesheets use five SMIL 3.0 Timing and Synchronization modules:
The timing semantics of SMIL Timesheets is based on the semantics of the SMIL 3.0 Timing and
Synchronization module. Host document's elements are set to
"active"
and "inactive"
following the semantics of
the defined time containers. In case of an element in the document that is not
referenced by the Timsheets, the element will be visible as dictated by the
stylesheet. By default the element will remain visible all the time.
The base time, or the syncbase of a timesheet element is the
moment when the element is started by its parent. Starting an element does not
necessarily make the referenced media element visible. Rather, it sets the time
moment "0s"
, to which the element's attributes are compared.
The syncbase of the child elements of a time container is dependent on the type of the container. The children of par and excl elements have the starting time of their parent as their syncbase. The children of the seq element consider the end time of preceding child as their syncbase. This time is resolved only at the moment the preceding child ends.
This section is informative.
Figure 1 shows a simple example of the semantics of a timesheet. A parallel time container has two children, which are item elements referencing two media elements. When the par is started, it activates both its children with the current time as their syncbase. The media elements referenced by the children are not activated yet. At time moment 1s, the media element item1 is activated, according to the begin value of the referencing timesheet element. At 2s, the item2 is activated. At 3s, the duration of item1 runs out, so it is stopped and the corresponding timesheet element deactivates itself. At 4s, the parent container stops according to its duration attribute, stopping all of its active children.
Figure 1: Timeline of a Timesheets
The duration of an element is primarily defined by the dur attribute. If the element is not stopped prematurely, due to an event or scheduling of its parent, the dur attribute tells the overall duration of the element. The element will not stop until this duration has passed, and will not stay active longer than this duration. The value of the dur attribute will prevail:
If the duration is not set, the duration of an element depends on the type
of the referenced elements, or the durations of the children. The timesheet
items can reference to discrete and continuous elements in the document. The
intrisic duration of an item element referencing a
discrete media element is "0s"
. But, the default fill behaviour is
"freeze"
. Continuous media elements have their own durations,
which will be also used as the duration of the timesheet element. The default
duration of the time container depends on the duration of their children. By
default, a time container ends when the last scheduled child ends. By default
the begin attibute of a children of
a seq and a par time containers is
"0s"
. On the other hand, the begin
attribute of a children of a excl time
container is "indefinite"
.
The item target element references elements in the document host language(s). It is the mechanism SMIL Timesheets uses to select the elements in the host language that will be timed.
The item can reference a media element in the host language or a set of elements by the element's tag, id or class. If follows the syntax and processing mechanism of the CSS Selectors.
The CSS selector can match more than one element in the document host language, for example, when CSS class selector is used. When multiple matching occur, a sequence of elements that all match exactly the item element is constructed. This sequence is ordered following the host document's order and the selection mechanism will consider the elements as ordered in such list. Thus, one item element can reference multiple host language elements at the same time.
This section is informative.
In the following example, an item element contains seq time container and further another item element.
<smil:timesheet> <smil:seq> <smil:item xml:id="first" select=".Slide" dur="7s"> <smil:seq> <smil:item xml:id="second" select=".Bullet" dur="1s" /> </smil:seq> </smil:item> </smil:seq> </smil:timesheet>
The "first" item element selects one slide at a time and shows each slide for 7 seconds. Within each slide the "second" item element selects each bullet and shows it for 1 second.
Figure 1: Item Selection Process for Nested Items
The item selection process of the above example is depicted in the Figure 1. The left side of the figure shows the timesheet as a tree, while the right side presents the body of the host document also as a tree. As the figure shows, the "first" item element selects the slides by using the ".Slide" CSS class selector. The selector matches all the div elements of the host document body, since they have the class attribute set to "Slide". Thus, three slides are shown in sequential order.
The "second" item elements uses the ".Bullet" CSS class selector to select all the bullets of the presentation. However, the scope of the selection is limited by the first item element. WIthin the first slide, the CSS selector can match only the descendants of the div element "Slide1". Similarly within the second slide, the CSS selector can match only the descendants of the div element "Slide2". The same applies also to the third slide.
The begin, dur, and end attributes can contain references to DOM events [DOM2Events]. DOM events can be triggered by user interaction or by some other event in the document. Events are divided into two distinct groups: internal events and user events.
Internal events are dispatched from within the timesheets. They can be used
by other elements in the timesheet to create relations between different parts
of the timeline. The events specified are beginEvent
event, which
is dispatched when an element starts and endEvent
event, which is
dispatched when an element stops. User events are triggered by user actions.
A timesheet element is set to listen to a certain event by specifying the event's target and type by either the begin, dur, or end attributes. When specified by the begin attribute, an inactive or started but not yet activated element will be activated when it receives the specified event. The parent time containers and item elements have to be active, though.
When the element is specified to stop according to an event, the element
informs its parent that it has stopped and parent then decides what should
happen next. Of course, some other element could be waiting to be activated
according to the endEvent
event from the particular element.
As defined in the Selection
Mechanism section, when multiple elements in the host document match
multiple items, an ordered list of item elements is constructed following the
document order. In case only one element matches the list will include one
element and if there are no matches the list will be empty. SMIL Timesheets
provide a way to identify each of the elements by using the index()
function. Thus, the index()
function becomes a shortcut to each of the elements composing the ordered list
and provide index numbers for the DOMActivate
event references in
the Timesheets.
This section is informative.
The following example gives an example on how the index()
function works. The example is an image show, which consist of images and
corresponding thumbnail images. The thumbnail images can be used to select an
individual image for viewing. Only one image is shown at a time.
  <title>Timesheet Example</title> <smil:timesheet> <smil:par> <smil:excl> <smil:item select="#Image1" begin="Thumbnail1.DOMActivate" /> <smil:item select="#Image2" begin="Thumbnail2.DOMActivate" /> <smil:item select="#Image3" begin="Thumbnail3.DOMActivate" /> <smil:item select="#Image4" begin="Thumbnail4.DOMActivate" /> <smil:item select="#Image5" begin="Thumbnail5.DOMActivate" /> </smil:excl> <smil:par> <smil:item select="#Thumbnail1" /> <smil:item select="#Thumbnail2" /> <smil:item select="#Thumbnail3" /> <smil:item select="#Thumbnail4" /> <smil:item select="#Thumbnail5" /> </smil:par> </smil:par> </smil:timesheet>
 <button class="Thumbnail" xml:id="Thumbnail1">  </button> <button class="Thumbnail" xml:id="Thumbnail2">  </button> <button class="Thumbnail" xml:id="Thumbnail3">  </button> <button class="Thumbnail" xml:id="Thumbnail4">  </button> <button class="Thumbnail" xml:id="Thumbnail5">  </button>
In the above example, the body of the HTML file consists of five pictures
and five buttons, which contain thumbnails of the same images. The idea is to
show one image at a time. The image to be shown is selected by the thumbnail
buttons. Therefore, the timesheets consist of one par time
container, which contains one excl and
another par time container. Within the excl time container the item elements select the images,
while the item elements within the second
par time container select the
individual thumbnail buttons. DOMActivate
events cause the excl time container to change the
shown image according to which button was pushed.
The problem with the above example is that each time the host document is
changed, for example, by changing an image, deleting an image, or adding a new
image, the Timesheet has to be updated. Therefore, the Timesheet is not
reusable. The main problem lies in the references to the DOMActive
events, because the index numbers have to be updated everytime a modification
in the host document occurs. Thus, there is need to automatically generate the
index numbers for the DOMActivate
event references in the
Timesheets. The index()
function can be used exactly for this purpose. In the Timesheet below, the index()
function is used within the begin
attribute of item element, which selects the
images within the excl time container.
<smil:timesheet> <smil:par> <smil:excl> <smil:item select=".Image" begin="index(Thumbnail).DOMActivate" /> </smil:excl> <smil:par> <smil:item select=".Thumbnail" /> </smil:par> </smil:par> </smil:timesheet>
The index()
function
adds the index number to the Thumbnail parameter (e.g.,
Thumbnail0.DOMActivate
, Thumbnail1.DOMActivate
, etc.)
in the begin attribute. Therefore, one
".Image"
class selector can be used in the select attribute instead of
severall id selectors. The main advantage of this is that changing the order of
images, deleting images, or adding new images does not any longer require
updating the Timesheet. Thus, the Timesheets is now much more reusable.
However, the Timesheets can be written in even more compact format. As defined in the Timing and Synchronization section, when an element in the host language does not match any item in the Timesheet, the element will remain visible all the time. Since all the thumbnail images in buttons are allways shown, the second par is actually unnecessary. When it is removed, also the first par time container becomes unnecessary. Therefore, the most simple Timesheets for this use case is as follows.
<smil:timesheet> <smil:excl> <smil:item select=".Image" begin="index(Thumbnail).DOMActivate" /> </smil:excl> </smil:timesheet>
This section is normative.
This section defines the new timesheet and item elements and their attributes.
The timesheet element is located in the head section of the document. It defines a parent container for other SMIL Timesheet elements.
The timesheet element defines two attributes: src and media.
The src attribute tells the location of an external timesheet. With this attribute a common timesheet can be reused in multiple documents. The attribute must contain a valid URI.
This section is informative
The following example shows how the timing information can be provided as an external document.
--- example.xhtml ---- <?xml version="1.0"?>   <title>Timesheet Example (External Document)</title> <smil:timesheet src="./timesheet.smil" />  --- --- --- timesheet.smil --- <?xml version="1.0"?> <smil:timesheet xmlns:smil="http://www.w3.org/ns/SMIL30"> <smil:seq> <smil:item select="#Slide1" dur="5s" /> <smil:item select="#Slide2" dur="5s" /> <smil:item select="#Slide3" dur="5s" /> </smil:seq> </smil:timesheet> --- ---
This section is informative
In non-XML markup languages, the link element can be used to reference an external timesheet document. In the following example, a HTML document contains a reference to external timesheet.smil document.
<!doctype html public "-//W3C//DTD HTML 4.01//EN">   <link href="timesheet.smil" rel="timesheet" type="application/smil+xml">
The language designers of the non-XML host language language should define what the different attributes of the link element mean. For example, the HTML language should define the timesheet link type.
The media attribute is used for selecting the most suitable timesheet for the current media device. It works in the same way as the @media rule in the CSS stylesheets [CSS2]. The media attribute contains a comma separated list of CSS media types. The timesheet timing and animation information is applied to the host language document, only when the target device media type matches one of the media types defined by the media attribute. If the media attribute is not defined, the default value is "all".
This section is informative
In the following example, the media attribute contains only one CSS media type: projection. Therefore, the timing is applied to the slideshow only when the slideshow is given as a presentation, e.g., the browser is in so called full screen mode. Otherwise, the timing information is not applied, and thus all the slides are shown at the same time.
<smil:timesheet media="projection"> <smil:seq> <smil:item select="#Slide1" dur="5s" /> <smil:item select="#Slide2" dur="5s" /> <smil:item select="#Slide3" dur="5s" /> </smil:seq> </smil:timesheet>
The timesheet element contains the par, seq, and excl time containers. The semantics and restrictions are specified in the the time container attributes. In addition, it contains the item and prefetch elements. Finally, it also contains the animation elements: animate, set, animateMotion, and animateColor.
In case of having timing containers inside of item elements, their semantics are the same
The item target element references elements in the document host language(s). The item element implements the actual connection between the timesheet and the document. It can reference a media element or a set of elements by the element's tag, id or class; the syntax and processing is the same to the CSS selector [CSS2] syntax.
As indicated in the Selection Mechanism, when multiple elements of the host document match an item element an ordered list based on the host document order is constructed.
This section is informative.
The following example illustrates how the CSS class selector can be used to select more than one slides at the same time.
<smil:timesheet> <smil:seq> <smil:item select=".Slide" dur="5s"/> </smil:seq> </smil:timesheet>
The class selector ".Slide"
selects all the slides at once.
Thus, the above timesheet is equivalent to the first example.
The item element defines two attributes: select and beginInc. In addition, it uses the begin, dur, end, repeatCount, and repeatDur attributes defined in the SMIL 3.0 Timing and Synchronization module.
The select attribute links the timesheet to the document. Its value is a comma-separated list of CSS selectors [CSS2]. The attribute follows the same syntax as the CSS selectors, so that the elements can be referenced by their name, id, or class, or a more complex combination of the selectors. If the attribute targets multiple elements in the host document, item controls all of them based on the host document order.
When the selector matches more than one element, an ordered list of elements is constructed. The beginInc attribute increments the begin time of each of the elements, but the first one, by the defined value. Note that the begin time of the first element is never modified. The beginInc attribute has to be a positive integer.
This section is informative.
The following example illustrates how the beginInc can be used to increment the starting times of individual elements.
<smil:par> <smil:item select=".Bullet" beginInc="1s" /> </smil:par>
In practise, the above example could also be expressed as follows.
<smil:par> <smil:item select="#Bullet1_1" begin="0s" /> <smil:item select="#Bullet1_2" begin="1s" /> <smil:item select="#Bullet1_3" begin="2s" /> <smil:item select="#Bullet1_4" begin="3s" /> </smil:par>
The item element defines one
function: index()
.
As introduced in the Index
Functionality section, the index()
function can be used for identifying a specific element within the sorted list
resulting from multiple items matching. Thus, it can be used to automatically
generate index numbers for both internal and external events within the begin, dur, or end attributes of the item, animate, set, animateMotion, and animateColor elements.
The index()
function has the format:
index(<selector>, <indexStart>)
where:
<selector>
parameter contains the CSS
selector.<indexStart>
parameter indicates the index
start.The <selector>
parameter has to be a valid CSS selector,
while the <indexStart>
parameter has to be a positive
integer value. By default <indexStart>
is "0"
.
If there are no elements in the host document matching the CSS selector, the index() function is not
called. If there are elements in the host document matching the CSS selector,
an ordered list of the elements is constructed. In this case, when an element
from the list is activated, the index() function returns
the index of such element within the list plus the
<indexStart>
value.
The item element can contain:
However, the direct child of the item element can only have one child or none. All other children than the first one are ignored. If the item element has several descendants they have to be included within a child time container. The timing and synchronization of the child element is controlled by the item, as described in the Timing andSynchronization section. Furthermore, the parent item element limits the scope of the CSS selectors of the descendant item, prefetch, animate, set, animateMotion, and animateColor elements to match only descendant elements of the host language elements selected by the parent item element, as described in the SelectionMechanism section.
This section is normative.
This section is informative.
The SMIL Timesheets uses five SMIL 3.0 Timing and Synchronization modules:
This section gives futher details on the attributes and elements of the above mentioned modules. The reader is presumed to have read and be familiar with them.
The timing semantics of the timesheets is based on the semantics of the SMIL 3.0 Timing and Synchronization chapter, although it has been simplified a bit. This may cause the timing model not to be as powerful in expressing timing relations as SMIL's, but it should be more approachable to the authors.
The base time, or the syncbase of a timesheet element is the moment when the element is started by its parent. Starting an element does not necessarily make the referenced media element visible. Rather, it sets the time moment "0s", to which the element's attributes are compared.
The syncbase of the child elements of a time container is dependent on the type of the container. The children of par and excl elements have the starting time of their parent as their syncbase. The children of the seq element consider the end time of preceding child as their syncbase. This time is resolved only at the moment the preceding child ends.
Figure 2 shows a simple example of the semantics of a timesheet. A parallel time container has two children, which are item elements referencing two media elements. When the par is started, it activates both its children with the current time as their syncbase. The media elements referenced by the children are not activated yet. At time moment 1s, the media element item1 is activated, according to the begin value of the referencing timesheet element. At 2s, the item2 is activated. At 3s, the duration of item1 runs out, so it is stopped and the corresponding timesheet element deactivates itself. At 4s, the parent container stops according to its duration attribute, stopping all of its active children.
The duration of an element is primarily defined by the dur attribute. If the element is not stopped prematurely, due to an event or scheduling of its parent, the dur attribute tells the overall duration of the element. The element will not stop until this duration has passed, and will not stay active longer than this duration. The value of the dur attribute will prevail:
If the duration is not set, the duration of an element depends on the type
of the referenced elements, or the durations of the children. The timesheet
items can reference to discrete and continuous elements in the document.
Discrete elements don't have implicit durations, and the implicit duration of
an item element referencing a
discrete element is "indefinite"
. Continuous elements have their
own durations, which will be also used as the duration of the timesheet
element. The duration of the timecontainer depends on the durations and
activations of its children. The seq and par elements stay active until all
of their children have stopped. The implicit duration of the excl is always
"indefinite"
.
The SMIL Timesheets includes the basic timing attributes begin, dur, and end as defined in the BasicInlineTiming and EventTiming modules. In addition fill and endsync attributes are included as defined in the BasicTimeContainers and BasicExclTimeContainers modules. Also, it includes the repeatCount and repeatDur attributes as defined in the RepeatTiming module. The rest of the SMIL 3.0 Timing and Synchronization attributes are not supported. Finally, the SMIL Timesheets includes four new Timing and Synchronization attributes: first, prev, next, and last.
The begin attribute supports offset
and event values, "indefinite"
, or a semi-colon separated list of
values. All other values are not supported. The allowed values and semantics of
the begin attribute are defined in
the SMIL 3.0
Timing and Synchronization module.
The dur attribute supports the clock
values, "media"
, and "indefinite"
. The allowed values
and semantics of the dur attribute are defined in the
SMIL
3.0 Timing and Synchronization module.
The end attribute supports offset and
event values, "indefinite"
, or a semi-colon separated list of
values. All other values are not supported. The allowed values and semantics of
the end attribute are defined in the
SMIL
3.0 Timing and Synchronization module.
The fill attribute allows an author
to specify that an element should be extended beyond the active duration by
freezing the final state of the element. It is defined in the SMIL
3.0 Timing and Synchronization module. Since SMIL Timesheets does not
include transitions, the fill="transition"
value of fill attribute is not supported.
Also, since the fillDefault
attribute is not included in the SMIL
Timesheets, the fill="default"
is interpreted the same as
fill="auto"
.
The endsync attribute controls the implicit duration of time containers, as a function of their children. It is defined in the SMIL 3.0 Timing and Synchronization module.
The repeatCount attribute specifies the number of iterations of a simple duration. It is defined in the SMIL 3.0 Timing and Synchronization module.
The repeatDur attribute specifies the total duration for repeat. It is defined in the SMIL 3.0 Timing and Synchronization module.
The first attribute sets the current
active child of a time container
"inactive"
. Then, it selects the first child element and sets it
"active"
. The first attribute can only be used
for the excl time container. The allowed
value of the first attribute is a DOM event
[DOM2Events].
The prev attribute first checks,
whether the current active child is the first child. If not, it sets the
current active child of a time container "inactive"
. Then, it
selects the previous child of the time container and sets it
"active"
. The prev attribute can only be used
for the excl time container. The allowed
value of the prev attribute is a DOM event
[DOM2Events]
The next attribute first checks,
whether the current active child is the last child. If not, it sets the current
active child of a time container
"inactive"
. Then, it selects the next child of the time
container and sets it
"active"
. The next attribute can only be used
for the excl time container. The allowed
value of the next attribute is a DOM event
[DOM2Events]
The last attribute sets the current
active child of a time container
"inactive"
. Then, it selects the last child of the time
container and sets it
"active"
. The last attribute can only be used
for the excl time container. The allowed
value of the last attribute is a DOM event
[DOM2Events]
The SMIL Timesheets includes three elements par, seq, and excl as defined in the BasicTimeContainers and BasicExclTimeContainers modules.
The par element short for "parallel", defines a simple time grouping in which multiple elements can play back at the same. It is defined in the SMIL 3.0 Timing and Synchronization module.
The seq element defines a sequence of elements in which elements play one after the other. Children of a seq can never play simultaneously and play strictly in document order, except when a hyperlink traversal targets an earlier child. It is defined in the SMIL 3.0 Timing and Synchronization module.
The excl element defines a time container with semantics based upon par, but with the additional constraint that only one child element may play at any given time. If any element begins playing while another is already playing, the element that was playing is stopped. In SMIL Timesshets, it is a simplified version of the excl element defined in the SMIL 3.0 Timing and Synchronization module, since the BasicPriorityClassContainers module is not included.
There are also four additional attributes that are specified for the excl element. They are first, prev, next, and last. These are used to select a certain child of the excl element, which facilitates the creation of presentations where the user can have control of the progression of the presentation, for example, a picture show.
This section is informative.
The following example illustrates how the additional first, prev, next, and last attributes can be used in slideshow. It contains a new timesheet and four buttons, which are appended to the body part of first example.
 <smil:timesheet> <smil:excl first="first.DOMActivate" prev="prev.DOMActivate" next="next.DOMActivate" last="last.DOMActivate"> <smil:item select=".Slide" /> </smil:excl> </smil:timesheet>   ... <button xml:id="first">First slide</button> <button xml:id="prev">Previous slide</button> <button xml:id="next">Next slide</button> <button xml:id="last">Last slide</button>
The first button selects the first slide, the prev button selects the previous slide, the next button selects the next slide, and finally the last button selects the last slide.
This section is normative.
The SMIL Timesheets uses the SMIL 3.0 PrefetchControl module. The module defines one element prefetch, which has three attributes mediaSize, mediaTime, and bandwidth. The original SMIL 3.0 PrefetchControl module uses the src attribute for locating and fetching the associated media. In the SMIL Timesheets, the src attribute is replaced with the select attribute. This section gives further details on how the attributes and elements of the SMIL 3.0 PrefetchControl module are used in Timesheets.
If multiple elements in the host language match the select attribute, the behaviour is the same as with the item element. An oredered list of elements is constructed based on the host document order, so that the parent time container determines whether the prefetching of the elements is done in parallel or in sequence.
The SMIL Timesheets includes all three attributes of the SMIL 3.0 PrefetchControl module: mediaSize, mediaTime, and bandwidth.
The meadiaSize attribute defines how much of the resource to fetch as a function of the file size of the resource. It is defined in the SMIL 3.0 PrefetchControl module.
The meadiaTime attribute defines how much of the resource to fetch as a function of the duration of the resource. It is defined in the SMIL 3.0 PrefetchControl module.
The bandwidth attribute defines how much network bandwidth the user agent should use when doing the prefetch. It is defined in the SMIL 3.0 PrefetchControl module.
The SMIL Timesheets includes the prefetch element of the SMIL 3.0 PrefetchControl module.
The prefetch element gives authoring tools or savvy authors the ability to schedule retrieval of resources when they think that there is available bandwidth or time to do it. It is defined in the SMIL 3.0 PrefetchControl module. It uses the mediaSize, mediaTime, and bandwidth attributes.
This section is informative.
The following example illustrates how to use the prefetch element.
 <smil:timesheet> <smil:seq> <smil:prefetch select="#Image1" mediaSize="100%" /> <smil:par> <smil:item select="#Image1" dur="5s" /> <smil:prefetch select="#Image2" /> </smil:par> <smil:par> <smil:item select="#Image2" dur="5s" /> <smil:prefetch select="#Image3" /> </smil:par> <smil:par> <smil:item select="#Image3" dur="5s" /> <smil:prefetch select="#Image4" /> </smil:par> <smil:par> <smil:item select="#Image4" dur="5s" /> <smil:prefetch select="#Image5" /> </smil:par> <smil:item select="#Image5" dur="5s" /> </smil:seq> </smil:timesheet>

This section is normative.
The SMIL Timesheets uses the SMIL 3.0 BasicAnimation module. This section gives further details on how the attributes and elements of the SMIL 3.0 BasicAnimation module are used in Timesheets.The reader is presumed to have read the SMIL 3.0 BasicAnimation module and be familiar with it.
This section is informative.
In SMIL
3.0 BasicAnimation module, the animation target element can be referenced
either with targetElement
or XLink href
attribute.
According to the module, a host language designer should select only one of
them. In Timesheets, the href
is more natural choice. However, use
of wider selection of CSS selectors is prefered as in the item element. Therefore, the select attribute is used
instead of targetElement
and href
attributes. Because
of this choise, the XLink actuate
, show
, and
type
attributes are also not used.
An animation element can define the target element of the animation either explicitly or implicitly. An explicit definition uses the select attribute to specify the target element. The syntax for this is described below. If no explicit target is specified, that is, the animation element does not specify the select attribute, the implicit target element is the host language element or elements referenced by the parent or ancestor item element.
Timesheets uses the select attribute to specify the
target element. Therefore it does not include the targetElement
and the XLink attributes href
, actuate
,
show
, and type
attributes. The target attribute is
specified with the attributeName attribute
and optional attributeType attribute,
which specifies whether the target attribute is CSS property or XML attribute.
Animation is described either as a list of values, or
in a simplified form that describes the from, to, and by values. The calcMode attribute specifies
the interpolation mode for the animation. The cumulative and additive behavior
of repeating animations is controlled with the accumulate and additive attributes,
respectively. The origin attribute specifies the
origin of motion for the animation. The begin, dur, end, and fill attributes are used to
control the timing of animation, while repeatCount and repeatDur attributes are
used to control the repeat of animation. Finally, beginInc attribute can be
used to increment the begin time, while the index()
function can be used to automatically generate index numbers for events.
The select and beginInc attributes and the
index()
function are described in the SMIL
Timesheet Specific Elements section, while the begin, dur, end, fill, repeatCount, and repeatDur attributes are
described in the Timing and
Synchronization section. The other animation attributes are described
below.
The attributeName attribute specifies the name of the target attribute. It is defined in the SMIL 3.0 BasicAnimation module.
The attributeType attribute specifies the namespace in which the target attribute and its associated values are defined. It is defined in the SMIL 3.0 BasicAnimation module.
The values attribute contains a semicolon-separated list of one or more values. It is defined in the SMIL 3.0 BasicAnimation module.
The from attribute specifies the starting value of the animation. It is defined in the SMIL 3.0 BasicAnimation module.
The to attribute specifies the ending value of the animation. It is defined in the SMIL 3.0 BasicAnimation module.
The by attribute Specifies a relative offset value for the animation. It is defined in the SMIL 3.0 BasicAnimation module.
The calcMode attribute specifies the interpolation mode for the animation. It is defined in the SMIL 3.0 BasicAnimation module.
The accumulate attribute controls whether or not the animation is cumulative. It is defined in the SMIL 3.0 BasicAnimation module.
The additive attribute controls whether or not the animation is additive. It is defined in the SMIL 3.0 BasicAnimation module.
The origin attribute specifies the origin of motion for the animation. It is defined in the SMIL 3.0 BasicAnimation module.
The SMIL Timesheets includes all elements of the SMIL 3.0 BasicAnimation module: animate, set, animateMotion, and animateColor.
The animate element controls the animation of both CSS properties and XML element attributes. It is defined in the SMIL 3.0 BasicAnimation module. It uses the select, beginInc, from, to, by, values, calcMode, accumulate, additive, begin, dur, end, fill, repeatCount, and repeatDur attributes.
This section is informative.
The following example illustrates how the animate element can be used to animate CSS properties of elements of the host language.
<smil:timesheet> <smil:seq> <smil:item select=".Slide" dur="15s"> <smil:par> <smil:item select=".Bullet" beginInc="3s"> <smil:animate select=".Bullet" attributeType="CSS" attributeName="margin-left" values="200;0" dur="1s" /> </smil:item> </smil:par> </smil:item> </smil:seq> </smil:timesheet>
The slides are shown in sequential order, while the bullets are shown in parallel within each slide. However, each bullet starts 3 seconds after the previous one. Each bullet flies from right to left for 1 second when shown.
The set element provides a simple means of setting the value of an attribute for a specified duration. It is defined in the SMIL 3.0 BasicAnimation module. It uses the select, beginInc, to, begin, dur, end, fill, repeatCount, and repeatDur attributes.
The animateMotion element moves an element along a path. It is defined in the SMIL 3.0 BasicAnimation module. It uses the select, beginInc, from, to, by, values, calcMode, accumulate, additive, origin, begin, dur, end, fill, repeatCount, and repeatDur attributes.
The animateColor element specifies an animation of a color attribute. It is defined in the SMIL 3.0 BasicAnimation module. It uses the select, beginInc, from, to, by, values, calcMode, accumulate, additive, begin, dur, end, fill, repeatCount, and repeatDur attributes.
This section is informative.
The begin, dur, and end attributes can contain references to DOM events [DOM2Events]. DOM events can be triggered by user interaction or by some other event in the document. Events are divided into two distinct groups, internal events and user events.
This section is informative.
Internal events are dispatched from within the timesheets. They can be used
by other elements in the timesheet to create relations between different parts
of the timeline. The events specified are beginEvent
event, which
is dispatched when an element starts and endEvent
event, which is
dispatched when element stops.
This section is informative.
User events are triggered by the actions that user makes. A typical example
is that the user activates a link in the document, and thus a
DOMActivate
event is dispatched [DOM2Events].
This section is informative.
A timesheet element is set to listen to a certain event by specifying the event's target and type by either the begin, dur, or end attributes. When specified by the begin attribute, an inactive or started but not yet activated element will be activated when it receives the specified event. The parent time containers and item elements have to be active, though.
When the element is specified to stop according to an event, it does not
cause that much processing in the timesheet. The element informs its parent
that it has stopped and parent then decides what should happen next. Of course,
some other element could be waiting to be activated according to the
endEvent
event from the particular element.
This section is informative.
The index()
function can be used to automatically generate
index numbers for both internal and external events within begin, dur, or end attributes of item element.
The following example gives an example on how index()
function can
be used. The example is an image show, which consist of images and
corresponding thumbnail images, which can be used to select an individual image
for viewing. Only one image is shown at a time.
  <title>Timesheet Example</title> <smil:timesheet> <smil:par> <smil:excl> <smil:item select="#Image1" begin="Thumbnail1.DOMActivate" /> <smil:item select="#Image2" begin="Thumbnail2.DOMActivate" /> <smil:item select="#Image3" begin="Thumbnail3.DOMActivate" /> <smil:item select="#Image4" begin="Thumbnail4.DOMActivate" /> <smil:item select="#Image5" begin="Thumbnail5.DOMActivate" /> </smil:excl> <smil:par> <smil:item select="#Thumbnail1" /> <smil:item select="#Thumbnail2" /> <smil:item select="#Thumbnail3" /> <smil:item select="#Thumbnail4" /> <smil:item select="#Thumbnail5" /> </smil:par> </smil:par> </smil:timesheet>
 <button class="Thumbnail" xml:id="Thumbnail1">  </button> <button class="Thumbnail" xml:id="Thumbnail2">  </button> <button class="Thumbnail" xml:id="Thumbnail3">  </button> <button class="Thumbnail" xml:id="Thumbnail4">  </button> <button class="Thumbnail" xml:id="Thumbnail5">  </button>
In the above example, the body of the HTML file consists of five pictures
and five buttons, which contain thumbnails of the same images. The idea is to
show one image at a time. The image to be shown is selected by the thumbnail
buttons. Therefore, the timesheets consist of one par time
container, which contains one excl and
another par time container. Within the excl time container the item elements select the images,
while the item elements within the second
par time container select the
individual thumbnail buttons. DOMActivate
events cause the excl time container to change the
shown image according to which button was pushed.
The problem with the above example is that each time the position of an
image is changed, deleted, or added to the image show, the Timesheet has to be
updated. Therefore, the Timesheet is not reusable. The main problem lies in the
references to the DOMActive
events, because the index numbers have
to be updated. Thus, there is need to automatically generate index numbers for
the DOMActivate
event references in the Timesheets. The
index()
function can be used exactly for this purpose. In the
Timesheet below, index()
function is used within the begin attribute of item element, which selects the
images within the excl time container.
<smil:timesheet> <smil:par> <smil:excl> <smil:item select=".Image" begin="index(Thumbnail).DOMActivate" /> </smil:excl> <smil:par> <smil:item select=".Thumbnail" /> </smil:par> </smil:par> </smil:timesheet>
The index()
function adds the index number to the Thumbnail
parameter (e.g., Thumbnail0.DOMActivate
,
Thumbnail1.DOMActivate
, etc.) in the begin attribute. Therefore, one
".Image"
class selector can be used in the select attribute instead of
severall id selectors. The main advantage of this is that changing the order of
images, deleting images, or adding new images does not any longer require
updating the Timesheet. Thus, the Timesheets is now much more reusable.
However, there is one problem in the above example. The index numbering starts
from 0. It should be corrected to start from 1 by using the indexStart
attribute as shown in the example below.
<smil:timesheet> <smil:par> <smil:excl> <smil:item select=".Image" indexStart="1" begin="index(Thumbnail).DOMActivate" /> </smil:excl> <smil:par> <smil:item select=".Thumbnail" /> </smil:par> </smil:par> </smil:timesheet>
Now, the index numbering starts from 1, and thus the Timesheet functions properly. However, the Timesheets can be written in even more compact format. The reason is that all the thumbnail images in buttons are allways shown, and thus the second par is actually unnecessary. When it is removed, also the first par time container becomes unnecessary. Therefore, the most simple Timesheets for this use case is as follows.
<smil:timesheet> <smil:excl> <smil:item select=".Image" indexStart="1" begin="index(Thumbnail).DOMActivate" /> </smil:excl> </smil:timesheet>
This section is informative.
Since SMIL Timesheets only describes the temporal dimension of the document, it must be integrated with a host language's layout system. It can be integrated, for example, with CSS based layout by affecting the CSS properties of the timed elements. For instance, the CSS display property can be used to control, whether an element is displayed or not. The SMIL Timesheets processor sets the CSS display property to to "none", when the timed element should not be visible based on the timesheet. According to CSS specification, this causes the element to have no effect on the layout of the document, and thus the element is invisible. At the same time the original value should be stored for later use. When the media element should become visible, the original display value can be restored.
The content authors should be aware that according to the CSS specification the descendant elements of an element, which has display value set to none, are also invisible. Therefore, the content authors should check that all the parent elements of an active elements are also set active in the timesheet if they are referenced in the timesheet.
Finally, the content authors should also be aware that only visible elements can increment CSS counters. Therefore, CSS counters might not work as expected when they are used together with timesheet. One solution is to use CSS attributes instead and define their values in the document or increment the attribute values, e.g., using a scripting language.
This section is informative.
This document has been prepared by the Synchronized Multimedia Working Group
(SYMM WG) of the World Wide Web Consortium.
The SYMM WG which specified SMIL 3.0 included the following individuals:


event.on(el, event, fn);
You can listen for standard and custom (non-jQuery) JS events
This hasn't been clicked. click here to update
el
event
fn