See: Description
| Class | Description |
|---|---|
| AbstractDecryptAction |
Abstract base class for actions that perform SAML decryption.
|
| AbstractEncryptAction |
Abstract base class for actions that perform simple unicast SAML encryption to a single
decrypting party.
|
| AbstractResponseShellAction<MessageType extends StatusResponseType> |
Abstract action that creates an empty object derived from
StatusResponseType ,
and sets it as the message returned by InOutOperationContext.getOutboundMessageContext() . |
| AddChannelBindingsToAssertions | |
| AddGeneratedKeyToAssertions | |
| AddNameIDToSubjects | |
| AddNameIDToSubjects.NameIDPolicyLookupFunction |
Lookup function that returns the
NameIDPolicy from an AuthnRequest message returned
from a lookup function, by default the inbound message. |
| AddNameIDToSubjects.RequesterIdFromIssuerFunction |
Lookup function that returns
RequestAbstractType.getIssuer()
from a request message returned from a lookup function, by default the inbound message. |
| AddOneTimeUseConditionToAssertions | |
| AddProxyRestrictionToAssertions |
Action adds an
ProxyRestriction to every Assertion contained in a SAML 2
response, with the audiences and count obtained from a lookup function. |
| AddStatusResponseShell |
Action that creates an empty object derived from
StatusResponseType ,
and sets it as the message returned by InOutOperationContext.getOutboundMessageContext() . |
| AddStatusToResponse |
Action that sets
Status content in a Response obtained from
a lookup strategy, typically from the outbound message context. |
| AddStatusToResponse.StatusCodeMappingFunction |
A default method to map event IDs to SAML 2 StatusCode URIs based on
EventContext . |
| AddSubjectConfirmationToSubjects |
Action that builds
SubjectConfirmation and adds it to the Subject of all the assertions
found in a Response . |
| ChainingSAML2NameIDGenerator |
Subclass incorporating SAML 2 interface.
|
| CopyNameIDFromRequest | |
| DecryptAssertions |
Action to decrypt an
EncryptedAssertion element and replace it with the decrypted
Assertion in situ. |
| DecryptAttributes |
Action to decrypt an
EncryptedAttribute element and replace it with the decrypted
Attribute in situ. |
| DecryptNameIDs |
Action to decrypt an
EncryptedID element and replace it with the decrypted NameID
in situ. |
| EncryptAssertions |
Action that encrypts all assertions in a
Response message obtained from a lookup
strategy, by default the outbound message context. |
| EncryptAttributes |
Action that encrypts all attributes in a
Response message obtained from a lookup strategy,
by default the outbound message context. |
| EncryptNameIDs |
Action that encrypts all
NameID s in a message obtained from a lookup strategy,
by default the outbound message context. |
| PopulateECPContext |
Action to create and populate an
ECPContext based on the request and, when encryption is in use,
generating a session key. |
| ResolveArtifact |
Action that resolves a SAML 2.0 artifact inside an
ArtifactResolve request located
via a lookup strategy, by default from the inbound message context, and maps it to the
corresponding message. |
Copyright © 1999–2016 Shibboleth Consortium. All rights reserved.


--- layout: default title: Sectors description: CCI AG sectors ---
Most of CCI’s services are tailored for banks, financial service providers, hedge funds and other financial institutions. This sector above and beyond depends on reliable information. Our human and cyber intelligence capabilities can serve financial institutions in many areas such as collecting information, fraud detection and investigation, risk assessment, compliance, asset tracing and recovery, market analysis, trend projection.
Tags: bank, private banking, hedge fund, financial institution, pension fund, brokerage
Fraud detection and investigation is part of the everyday business of insurance companies everywhere in the world and our company is here to help. When working for our clients CCI applies legal and ethical intelligence methods, thus the data we acquire can be used to support our clients in legal cases.
Tags: insurance, fraud
Energy companies have to apply special techniques and maintain a professional system to protect their infrastructure and to secure the supply chain and transport system. Beyond the physical protection of the assets it is vital to detect potential threats and make preventive measures. This is where CCI steps in: combining human and cyber intelligence methods, we are able to provide energy companies with an early warning system that traces the signs of potential attacks.
Tags: energy, security
Litigation cases are growing more and more complex. A piece of sensitive information can be decisive in court cases. Our task is to find this piece of information. Beside our intelligence professionals, our legal experts are familiar with the different legal systems and judicial practices. Thus the information or evidence we gather and the methods we apply fully comply with the special legal and ethical requirements. With CCI’s support law firms can achieve better success rate in court cases.
Tags: law firm, litigation
Multinational business organizations are leading and deepening the globalization of the world economy. As a consequence these corporations are increasingly exposed to different types of risk. Our services like vendor and partner due diligence, internal leakage detection or competitor analysis can help eliminate these risks and fine-tune the business strategy that leads to success in the market.
Tags: leakage, competitor analysis, competitive intelligence, cross-border transaction, business strategy
The valuation of land plots or any properties is a complex and difficult process. It is not enough to do market research or analyse the market potential. Knowing the seller and the history of the asset, revealing the otherwise hidden information that affect the business potential are sometimes more important. CCI has a vast experience in property investment projects and our experts are able to provide our clients with a 360 degree picture of the target investment.
Tags: property, land, investment


public class BaseLight extends GameComponent
| Constructor and Description |
|---|
BaseLight(Vector3f colour,
float intensity)
As there isn't a convenience class of yet, Vector3f is used in order
to determine the colour of the light.
|
| Modifier and Type | Method and Description |
|---|---|
void |
addToEngine(CoreEngine engine)
Convenience method that is overidden from it's parent class.
|
Vector3f |
getColour() |
float |
getIntensity() |
Shader |
getShader() |
void |
setColour(Vector3f colour)
As there isn't a convenience class of yet, Vector3f is used in order
to determine the colour of the light.
|
void |
setIntensity(float intensity)
Recommended to keep between greater than 0.0f and smaller than 1.0f
to avoid any weird behavior.
|
void |
setShader(Shader shader) |
getTransform, input, render, setParent, update
public BaseLight(Vector3f colour, float intensity)
Vector3f(float x, float y, float z)
, the values are represented for the.
BaseLight's colour like so: Colour(RBG) float x = R float y = G float z = B
Example:
BaseLight(new Vector3f(1, 1, 1), 1.0f)
Returns a BaseLight that is white with an intensity of 1.0f
BaseLight(new Vector3f(1, 0, 0), 0.5f)
Returns a BaseLight that is red with an intensity of 0.5f
colour
- The desired colour for the Base Light(RPG).intensity
- The intensity of the light.public void addToEngine(CoreEngine engine)
addToEngine
in class GameComponent
engine
- The Core Engine in order to add the light(Not Rendering Engine!).public float getIntensity()
public void setIntensity(float intensity)
intensity
- The intensity of the Base Light.public Vector3f getColour()
public void setColour(Vector3f colour)
Vector3f(float x, float y, float z)
, the values are represented for the
BaseLight's colour like so: Colour(RBG) float x = R float y = G float z = B
Example:
BaseLight(new Vector3f(1, 1, 1), 1.0f)
Returns a BaseLight that is white with an intensity of 1.0f
BaseLight(new Vector3f(1, 0, 0), 0.5f)
Returns a BaseLight that is red with an intensity of 0.5f
colour
- The desired colour for the Base Light(RPG).public void setShader(Shader shader)
shader
- Set's the Base Light's shader.public Shader getShader()


Dear {{ person.first_name }}
FINAL REPORT - PART 5 - {{ app.location }} – {{ app.title }} – {% include "application-applicant.html" %}
The draft report on the above mentioned proposal was released for public comment by the Department of Biodiversity, Conservation and Attractions (the department) for a period of 14 days from {{ app.publish_final_report|date:"d M Y" }} to {{ app.publish_final_expiry|date:"d M Y" }}. The department has considered the submissions made in relation to the draft report and has made any changes considered appropriate.
The final report has now been prepared and forwarded to the Minister for Environment; Disability Services for determination. The final report is now available at {{ EXTERNAL_URL }}/public/application/{{ app.id }}/final/
If you have any queries regarding this matter, please email<EMAIL_ADDRESS>In all correspondence please quote reference number WO-{{ app.id }}.
{% include "signature.html" %}


Recording
- How to record sessions
- Composed recording
- Individual stream recording
- Audio-only and video-only recordings
- Automatic stop of recordings
- Custom recording layouts
- Local recording in the browser
OpenVidu Server can be configured to record sessions. Two types of recordings are available:
-
COMPOSED: every publisher stream is composed in the same video file in a grid layout. You can use the default layout, that will evenly distribute each stream in the available space, or you can use your own custom layout.
-
INDIVIDUAL: every publisher stream is recorded in its own file, generating a ZIP file containing all videos along with a text file for synchronization data.
How to record sessions
To start OpenVidu Server properly configured to allow session recording it is necessary to:
1. Have Docker CE installed in the host machine
OpenVidu recording module may use a Docker image that needs to be downloaded from the cloud. The process is 100% automatic, but you will need Docker CE installed in your server. If you enable OpenVidu recording service but there's no Docker installed, OpenVidu Server will fail to init, throwing the following exception:
Exception connecting to Docker daemon: you need Docker installed in this machine to enable OpenVidu recorder service
OpenVidu AWS deployment already includes the Docker image for recording service and is always launched with recording module enabled. You don't need to install anything or wait during the first execution if you use this type of deployment for OpenVidu Server. You can go straight to step 3
2. Launch OpenVidu Server with new properties
For OpenVidu Server JAR
java -jar \
-Dopenvidu.recording=true \
-Dopenvidu.recording.path=/PATH/TO/VIDEO/FILES \
openvidu-server.jar
openvidu.recording
: if true OpenVidu recording service is enabled and sessions can be configured to be recorded. During the first execution of openvidu-server.jar, a Docker image (openvidu/openvidu-recording) will be downloaded.openvidu.recording.path
: where to store the recorded video files on the host machine. OpenVidu Server must have write access to this path
There are other environment variables related to recordings configuration that may be set. To see the full list, visit OpenVidu Server configuration parameters
For OpenVidu Server Docker image (development environment)
docker run -p 4443:4443 --rm \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /PATH/TO/VIDEO/FILES:/PATH/TO/VIDEO/FILES \
-e openvidu.recording=true \
-e openvidu.recording.path=/PATH/TO/VIDEO/FILES \
openvidu/openvidu-server-kms:2.12.0
openvidu.recording
: same as in OpenVidu Server JARopenvidu.recording.path
: same as in OpenVidu Server JAR
It is also necessary to mount 2 volumes:
-v /var/run/docker.sock:/var/run/docker.sock
: gives openvidu-server container access to the local Docker daemon-v /PATH/TO/VIDEO/FILES:/PATH/TO/VIDEO/FILES
: gives access to the recorded video files through the container
IMPORTANT!
/PATH/TO/VIDEO/FILES
must be the same in propertyopenvidu.recording.path=/PATH/TO/VIDEO/FILES
and in both sides of flag-v /PATH/TO/VIDEO/FILES:/PATH/TO/VIDEO/FILES
3. Configure your Sessions to be recorded
Recording can be configured in two ways:
-
ALWAYS: the session will be automatically recorded from the moment the first participant starts publishing.
-
MANUAL: you will have to tell openvidu-server when to start the recording of the session.
In both cases you can stop the recording manually, and every recording will always be automatically stopped if last user leaves the session and certain timeout elapses (see Automatic stop of recordings).
You can use REST API or any of the server SDKs (openvidu-java-client, openvidu-node-client) to manage your recorded sessions.
-
Initialize your sessions with this POST method: POST /api/sessions
You may configure default values for recordings started for this session by sending params such asdefaultOutputMode
ordefaultRecordingLayout
. This way you can pre-configure recordings that will be automatically started (for sessions with{"recordingMode": "ALWAYS"}
). For these sessions configured withALWAYS
recording mode, no more steps are needed. -
If you have configured your session with
"recordingMode": "MANUAL"
-
Start the recording with this POST method: POST /api/recordings/start
You can pass parameters to override default recording configuration values set in step 1 and to further configure it with other available options -
Stop the recording with this POST method: POST /api/recordings/stop
-
Composed recording
Every publisher stream is composed in the same video file in a grid layout. This is the default recording mode, and it will generate as output an MP4 file.
You can use the default layout, that will evenly distribute each stream in the available space, or you can use your own custom layout.
To use the default layout:
When starting the recording of a session with method POST /api/recordings/start pass parameters{"outputMode: "COMPOSED", "recordingLayout": "BEST_FIT"}
For example, for a session with two publishers the video file will look like this when using output mode COMPOSED
and recording layout BEST_FIT
Notes on COMPOSED recordings
- If a COMPOSED recording is configured to record video (that is, not being an audio-only recording), this type of grid recording can be a pretty heavy consuming process. A maximum number of 4 publishers is recommended, and starting more than 2 recordings of this type at the same time can overload server CPUs. For these reasons, it is desirable to launch OpenVidu Server in a host with significant CPU power if COMPOSED video recordings are expected. In comparison, INDIVIDUAL stream recording (and COMPOSED audio-only recording) can be 4x up to 10x more efficient
- You can configure the resolution of the MP4 file for COMPOSED recordings by using
resolution
property when starting the recording- A thumbnail got from the middle of the video will be generated for COMPOSED recordings that have video. They will be stored next to the MP4 file and named [RECORDING_ID].jpg
Individual stream recording
Every publisher stream is recorded in its own file. The final result is a ZIP file containing one WEBM file for each published stream during the recording (named after each stream identifier), along with a text file with synchronization information.
When starting the recording of a session with method POST /api/recordings/start pass parameter {"outputMode:"INDIVIDUAL"}
For example, for a session with 2 publishers the final content of the ZIP file could be:
MyRecording.zip
+-- MyRecording.json
+-- tzk08sgffcqqwpor_CAMERA_DFDAE.webm
+-- ugkmpnz4bn6yewbi_CAMERA_PAHHB.webm
And the content of the JSON synchronization file might be:
{
"createdAt":<PHONE_NUMBER>287,
"id": "zfgmthb8jl9uellk",
"name": "MyRecording",
"sessionId": "zfgmthb8jl9uellk",
"files": [
{
"connectionId": "ugkmpnz4bn6yewbi",
"streamId": "ugkmpnz4bn6yewbi_CAMERA_PAHHB",
"size": 4006190,
"clientData": "",
"serverData": "UserA",
"hasAudio": true,
"hasVideo": true,
"typeOfVideo": "SCREEN",
"startTimeOffset": 95,
"endTimeOffset": 56445
},
{
"connectionId": "tzk08sgffcqqwpor",
"streamId": "tzk08sgffcqqwpor_CAMERA_DFDAE",
"size": 2404760,
"clientData": "",
"serverData": "UserB",
"hasAudio": false,
"hasVideo": true,
"typeOfVideo": "CAMERA",
"startTimeOffset": 148,
"endTimeOffset": 56398
}
]
}
These are the properties in the JSON file
- createdAt: time when the recording was started in UTC milliseconds
- id: unique identifier of the recording
- name: custom name of the recording. You can set this parameter when starting the recording, and the final ZIP file will be named after it
- sessionId: unique identifier of the session that was recorded
- files: array containing one JSON object for each one of the WEBM videos inside the ZIP file
- connectionId: unique identifier of the connection that published the stream
- streamId: unique identifier of the recorded stream
- size: size in bytes of this particular recorded file
- clientData: data associated to the connection that published the stream, in the client side. You can use this field to identify the user that published this particular recorded stream
- serverData: data associated to the connection that published the stream, in the server side. You can use this field to identify the user that published this particular recorded stream
- hasAudio: whether this recorded stream has an audio track or not
- hasVideo: whether this recorded stream has a video track or not
- typeOfVideo: type of video ("CAMERA" or "SCREEN"). Only defined if
hasVideo
is true- startTimeOffset: the offset in milliseconds for when this particular stream started being recorded, from the
createdAt
property of the root element- endTimeOffset: the offset in milliseconds for when this particular stream stopped being recorded, from the
createdAt
property of the root element
Audio-only and video-only recordings
By default recordings will be generated with both audio and video, but you can configure them to record audio-only or video-only files.
When starting the recording of a session with method POST /api/recordings/start simply pass parameters hasAudio
or hasVideo
with the desired values.
Notes on audio/video only recordings
- Recordings configured to not record neither audio nor video will fail to start, returning a status error of 422
- COMPOSED video-only recordings will generate an MP4 file. COMPOSED audio-only recordings will generate a WEBM file. INDIVIDUAL recordings will always generate a ZIP file containing one WEBM file for each recorded stream
- Streams published during a video-only recording that are audio-only won't be recorded: they won't be included in the grid layout for COMPOSED recordings and won't generate a WEBM file in INDIVIDUAL recordings. Same for audio-only recordings with video-only streams
- Recordings started automatically (with recording mode
ALWAYS
) will record both audio and video
Automatic stop of recordings
Any started recording will automatically be stopped when any of the following situations occur and certain timeout elapses. This timeout is by default 120 seconds, but you can configure it with system property openvidu.recording.autostop-timeout
. The automatic recording stop timout will start:
-
For any recorded session, if last user disconnects from the session
-
For sessions with recording mode
MANUAL
, if the recording is started and no user is publishing a stream
The only condition to abort the timeout is to have any user publishing a stream to the session within the timeout.
Sessions will always remain opened and the recording active during the timeout. If it elapses and no stream is being published to the session, the recording will be stopped. If in addition there's no user connected to the session, the session will also be automatically closed.
You can always manually stop any recording at any time:
Custom recording layouts
You can create your own layouts for the session recording process. They are implemented with HTML/CSS/JS files, just as your OpenVidu application client-side.
1. Create your layout with HTML/CSS/JS files
Put them in a path accessible to openvidu-server. There must be an index.html
file as entrypoint for your custom layout:
-
WHAT SHOULD YOUR JS CODE DO: by making use of
openvidu-browser.js
library, you need to connect a recorder participant to the session. This means:1) Your layout must connect to the session using a token like this:
'wss://' + location.hostname + ':4443?sessionId=' + SESSION_ID + '&secret=' + SECRET + '&recorder=true';
Being
SESSION_ID
andSECRET
two parameters that will be url-encoded under idssessionId
andsecret
respectively. So, for example:var url = new URL(window.location.href); var SESSION_ID = url.searchParams.get("sessionId"); var SECRET = url.searchParams.get("secret"); var TOKEN = 'wss://' + location.hostname + ':4443?sessionId=' + SESSION_ID + '&secret=' + SECRET + '&recorder=true'; var session = OV.initSession(); session.connect(TOKEN);
2) You will need to subscribe to, at least, one event:
streamCreated
of Session object. That way you can subscribe your recorder to every stream when any user starts publishing (by default, the video element will be automatically removed on everystreamDestroyed
event). To sum up, this would be the simplest code you need to properly start your recorder participant:var OV = new OpenVidu(); var url = new URL(window.location.href); var SESSION_ID = url.searchParams.get("sessionId"); var SECRET = url.searchParams.get("secret"); var TOKEN = 'wss://' + location.hostname + ':4443?sessionId=' + SESSION_ID + '&secret=' + SECRET + '&recorder=true'; var session = OV.initSession(); session.on("streamCreated", (event) => { session.subscribe(event.stream, 'html-id-where-insert-video'); }); session.connect(TOKEN);
- HOW TO IDENTIFY YOUR USERS: you can identify them by making use of property
Stream.connection.data
of the Stream object retrieved in Session event "streamCreated". That way you may know which particular user should be displayed in which particular HTML element of your layout. For example:session.on("streamCreated", (event) => { var stream = event.stream; if (stream.connection.data === 'userBigVideo') { session.subscribe(stream, 'big-video-div'); } else if (stream.connection.data === 'userSmallVideo') { session.subscribe(stream, 'small-video-div'); } });
2. Add new properties when launching openvidu-server
You can configure where should OpenVidu Server look for your custom layout in the system.
Default path is /opt/openvidu/custom-layout
, but you can configure it with system property openvidu.recording.custom-layout
. OpenVidu Server must have read access to that path, where you must have stored the index.html
file of your layout.
java -jar \
-Dopenvidu.recording=true \
-Dopenvidu.recording.path=/PATH/TO/VIDEO/FILES \
-Dopenvidu.recording.custom-layout: /PATH/TO/INDEX/CUSTOM/LAYOUT \
openvidu-server.jar
openvidu/openvidu-server-kms Docker container (development environment)
docker run -p 4443:4443 --rm \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /PATH/TO/VIDEO/FILES:/PATH/TO/VIDEO/FILES \
-v /PATH/TO/INDEX/CUSTOM/LAYOUT:/PATH/TO/INDEX/CUSTOM/LAYOUT \
-e MY_UID=$(id -u $USER) \
-e openvidu.recording=true \
-e openvidu.recording.path=/PATH/TO/VIDEO/FILES \
-e openvidu.recording.custom-layout=/PATH/TO/INDEX/CUSTOM/LAYOUT \
openvidu/openvidu-server-kms:2.12.0
WARNING: remember to add the
-v
option mounting the path defined withopenvidu.recording.custom-layout
You must store your custom layouts in the server under default path /opt/openvidu/custom-layout
3. Configure your recordings to use your custom layout
When starting the recording of a session with method POST /api/recordings/start pass parameters{"outputMode": "COMPOSED", "recordingLayout": "CUSTOM"}
Configuring multiple custom layouts
You can implement as many custom recording layouts as you want. Simply store each one of them (each one with its own index.html
entrypoint file) in a subfolder under path defined with system property openvidu.recording.custom-layout
(default value /opt/openvidu/custom-layout
). Then, when configuring your sessions as stated above in point 3, just add a new parameter:
When starting the recording of a session with method POST /api/recordings/start pass parameters{"outputMode": "COMPOSED", "recordingLayout": "CUSTOM", "customLayout": "RELATIVE/PATH/TO/INDEX"}
In the snippets above, string RELATIVE/PATH/TO/INDEX
is the path from openvidu-server configuration property openvidu.recording.custom-layout
to the specific index.html
you want to use for a particular recording. So, if you have the following folder tree structure in your OpenVidu Server host:
/opt
+-- /openvidu
| +-- /my_custom_layouts
| +-- index.html
| +-- /layout1
| +-- index.html
| +-- /layout2
| +-- index.html
/etc
...
You should start openvidu-server with property openvidu.recording.custom-layout=/opt/openvidu/my_custom_layouts
and you can use any of the 3 index.html
files for recording any of your sessions. To use the outer layout in a recording, just configure in recording properties recordingLayout
to CUSTOM
. To use any of the inner layouts, also configure customLayout
to layout1
or layout2
.
Using an external custom layout
OpenVidu allows you to configure a recording to use a custom layout deployed outside OpenVidu host. This is useful if, for whatever reason, you have your layout being served in a different server. To achieve this, you just have to configure the complete URL where your layout is served in property customLayout
:
When starting the recording of a session with method POST /api/recordings/start pass parameters{"outputMode": "COMPOSED", "recordingLayout": "CUSTOM", "customLayout": "https://USER:PASS@my.domain.com:8888/path?myParam=123"}
As you can see, this URL may have credentials and any query parameter or token you may need in your custom layout.
For example, in the snippets above the layout files would be protected by Basic Auth with "USER" ans "PASS" as username and password, and you could access value123
in your layout JS code just by callingnew URL(window.location.href).searchParams.get("myParam");
Debugging your custom layouts
To debug your custom layout, you just need to store it in the path declared with property openvidu.recording.custom-layout
, as explained in section Add new properties when launching openvidu-server.
Then, by using your OpenVidu application, start a session and as many publishers as you expect to be recorded in your custom layout. Finally you just have to connect to your layout through Chrome by entering url:
https://OPENVIDUAPP:SECRET
@OPENVIDU_IP
:4443/layouts/custom/index.html?sessionId=SESSION_ID
&secret=SECRET
Being:
SECRET
: parameteropenvidu.secret
configured when launching openvidu-serverOPENVIDU_IP
: the IP where openvidu-server is accessible in your development machine. You will be probably using openvidu-server-kms docker container in your development environment, so this parameter islocalhost
if you are in Mac or Linux, and the docker IP of the container if you are in Windows (see this FAQ)SESSION_ID
: the session ID you have initialized for the debugging process. Here's a little tip: you can initialize the session in openvidu-server (REST API, openvidu-java-client, openvidu-node-client) configuring parametercustomSessionId
to fix this session ID and avoid having to change it every time you restart your session.
By connecting with Chrome to the above URL you will see the exact result obtained when recording a session with your custom layout. You can now start changing the HTML/CSS/JS files of your layout until you are happy with the outcome
Sample custom layout
This is literally the simplest HTML for a custom recording layout. Use it as a template for building more complex ones (you will need latest openvidu-browser-VERSION.min.js
file to be in the same folder. Be sure to use the same version number as your openvidu-server!)

Local recording in the browser
OpenVidu Browser offers an extremely simple API to record Streams directly in the client's browser. Check it out here.


User Accounts
Add User
Id
Name
E-Mail Address
Created
Last Login
Id
Name
<EMAIL_ADDRESS>Created
Last login


Plato on Github
Report Home
compiled\ember-views\lib\views\view.js
Maintainability
75.51
Lines of code
1526
Difficulty
49.57
Estimated Errors
4.46
Function weight
By Complexity
By SLOC
// Ember.assert, Ember.deprecate, Ember.warn, Ember.TEMPLATES, // jQuery, Ember.lookup, // Ember.ContainerView circular dependency // Ember.ENV 'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } var _emberMetalCore = require('ember-metal/core'); var _emberMetalCore2 = _interopRequireDefault(_emberMetalCore); var _emberMetalError = require('ember-metal/error'); var _emberMetalError2 = _interopRequireDefault(_emberMetalError); var _emberMetalProperty_get = require('ember-metal/property_get'); var _emberMetalRun_loop = require('ember-metal/run_loop'); var _emberMetalRun_loop2 = _interopRequireDefault(_emberMetalRun_loop); var _emberMetalObserver = require('ember-metal/observer'); var _emberMetalUtils = require('ember-metal/utils'); var _emberMetalComputed = require('ember-metal/computed'); var _emberMetalMixin = require('ember-metal/mixin'); var _emberViewsSystemJquery = require('ember-views/system/jquery'); var _emberViewsSystemJquery2 = _interopRequireDefault(_emberViewsSystemJquery); require('ember-views/system/ext'); // for the side effect of extending Ember.run.queues var _emberViewsViewsCore_view = require('ember-views/views/core_view'); var _emberViewsViewsCore_view2 = _interopRequireDefault(_emberViewsViewsCore_view); var _emberViewsMixinsView_context_support = require('ember-views/mixins/view_context_support'); var _emberViewsMixinsView_context_support2 = _interopRequireDefault(_emberViewsMixinsView_context_support); var _emberViewsMixinsView_child_views_support = require('ember-views/mixins/view_child_views_support'); var _emberViewsMixinsView_child_views_support2 = _interopRequireDefault(_emberViewsMixinsView_child_views_support); var _emberViewsMixinsView_state_support = require('ember-views/mixins/view_state_support'); var _emberViewsMixinsView_state_support2 = _interopRequireDefault(_emberViewsMixinsView_state_support); var _emberViewsMixinsTemplate_rendering_support = require('ember-views/mixins/template_rendering_support'); var _emberViewsMixinsTemplate_rendering_support2 = _interopRequireDefault(_emberViewsMixinsTemplate_rendering_support); var _emberViewsMixinsClass_names_support = require('ember-views/mixins/class_names_support'); var _emberViewsMixinsClass_names_support2 = _interopRequireDefault(_emberViewsMixinsClass_names_support); var _emberViewsMixinsLegacy_view_support = require('ember-views/mixins/legacy_view_support'); var _emberViewsMixinsLegacy_view_support2 = _interopRequireDefault(_emberViewsMixinsLegacy_view_support); var _emberViewsMixinsInstrumentation_support = require('ember-views/mixins/instrumentation_support'); var _emberViewsMixinsInstrumentation_support2 = _interopRequireDefault(_emberViewsMixinsInstrumentation_support); var _emberViewsMixinsAria_role_support = require('ember-views/mixins/aria_role_support'); var _emberViewsMixinsAria_role_support2 = _interopRequireDefault(_emberViewsMixinsAria_role_support); var _emberViewsMixinsVisibility_support = require('ember-views/mixins/visibility_support'); var _emberViewsMixinsVisibility_support2 = _interopRequireDefault(_emberViewsMixinsVisibility_support); var _emberViewsCompatAttrsProxy = require('ember-views/compat/attrs-proxy'); var _emberViewsCompatAttrsProxy2 = _interopRequireDefault(_emberViewsCompatAttrsProxy); function K() { return this; } /** @module ember @submodule ember-views */ _emberMetalCore2['default'].warn('The VIEW_PRESERVES_CONTEXT flag has been removed and the functionality can no longer be disabled.', _emberMetalCore2['default'].ENV.VIEW_PRESERVES_CONTEXT !== false); /** Global hash of shared templates. This will automatically be populated by the build tools so that you can store your Handlebars templates in separate files that get loaded into JavaScript at buildtime. @property TEMPLATES @for Ember @type Object @private */ _emberMetalCore2['default'].TEMPLATES = {}; /** `Ember.View` is the class in Ember responsible for encapsulating templates of HTML content, combining templates with data to render as sections of a page's DOM, and registering and responding to user-initiated events. ## HTML Tag The default HTML tag name used for a view's DOM representation is `div`. This can be customized by setting the `tagName` property. The following view class: ```javascript ParagraphView = Ember.View.extend({ tagName: 'em' }); ``` Would result in instances with the following HTML: ```html <em id="ember1" class="ember-view"></em> ``` ## HTML `class` Attribute The HTML `class` attribute of a view's tag can be set by providing a `classNames` property that is set to an array of strings: ```javascript MyView = Ember.View.extend({ classNames: ['my-class', 'my-other-class'] }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view my-class my-other-class"></div> ``` `class` attribute values can also be set by providing a `classNameBindings` property set to an array of properties names for the view. The return value of these properties will be added as part of the value for the view's `class` attribute. These properties can be computed properties: ```javascript MyView = Ember.View.extend({ classNameBindings: ['propertyA', 'propertyB'], propertyA: 'from-a', propertyB: Ember.computed(function() { if (someLogic) { return 'from-b'; } }) }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view from-a from-b"></div> ``` If the value of a class name binding returns a boolean the property name itself will be used as the class name if the property is true. The class name will not be added if the value is `false` or `undefined`. ```javascript MyView = Ember.View.extend({ classNameBindings: ['hovered'], hovered: true }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view hovered"></div> ``` When using boolean class name bindings you can supply a string value other than the property name for use as the `class` HTML attribute by appending the preferred value after a ":" character when defining the binding: ```javascript MyView = Ember.View.extend({ classNameBindings: ['awesome:so-very-cool'], awesome: true }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view so-very-cool"></div> ``` Boolean value class name bindings whose property names are in a camelCase-style format will be converted to a dasherized format: ```javascript MyView = Ember.View.extend({ classNameBindings: ['isUrgent'], isUrgent: true }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view is-urgent"></div> ``` Class name bindings can also refer to object values that are found by traversing a path relative to the view itself: ```javascript MyView = Ember.View.extend({ classNameBindings: ['messages.empty'] messages: Ember.Object.create({ empty: true }) }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view empty"></div> ``` If you want to add a class name for a property which evaluates to true and and a different class name if it evaluates to false, you can pass a binding like this: ```javascript // Applies 'enabled' class when isEnabled is true and 'disabled' when isEnabled is false Ember.View.extend({ classNameBindings: ['isEnabled:enabled:disabled'] isEnabled: true }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view enabled"></div> ``` When isEnabled is `false`, the resulting HTML representation looks like this: ```html <div id="ember1" class="ember-view disabled"></div> ``` This syntax offers the convenience to add a class if a property is `false`: ```javascript // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false Ember.View.extend({ classNameBindings: ['isEnabled::disabled'] isEnabled: true }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view"></div> ``` When the `isEnabled` property on the view is set to `false`, it will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view disabled"></div> ``` Updates to the the value of a class name binding will result in automatic update of the HTML `class` attribute in the view's rendered HTML representation. If the value becomes `false` or `undefined` the class name will be removed. Both `classNames` and `classNameBindings` are concatenated properties. See [Ember.Object](/api/classes/Ember.Object.html) documentation for more information about concatenated properties. ## HTML Attributes The HTML attribute section of a view's tag can be set by providing an `attributeBindings` property set to an array of property names on the view. The return value of these properties will be used as the value of the view's HTML associated attribute: ```javascript AnchorView = Ember.View.extend({ tagName: 'a', attributeBindings: ['href'], href: 'http://google.com' }); ``` Will result in view instances with an HTML representation of: ```html <a id="ember1" class="ember-view" href="http://google.com"></a> ``` One property can be mapped on to another by placing a ":" between the source property and the destination property: ```javascript AnchorView = Ember.View.extend({ tagName: 'a', attributeBindings: ['url:href'], url: 'http://google.com' }); ``` Will result in view instances with an HTML representation of: ```html <a id="ember1" class="ember-view" href="http://google.com"></a> ``` Namespaced attributes (e.g. `xlink:href`) are supported, but have to be mapped, since `:` is not a valid character for properties in Javascript: ```javascript UseView = Ember.View.extend({ tagName: 'use', attributeBindings: ['xlinkHref:xlink:href'], xlinkHref: '#triangle' }); ``` Will result in view instances with an HTML representation of: ```html <use xlink:href="#triangle"></use> ``` If the return value of an `attributeBindings` monitored property is a boolean the property will follow HTML's pattern of repeating the attribute's name as its value: ```javascript MyTextInput = Ember.View.extend({ tagName: 'input', attributeBindings: ['disabled'], disabled: true }); ``` Will result in view instances with an HTML representation of: ```html <input id="ember1" class="ember-view" disabled="disabled" /> ``` `attributeBindings` can refer to computed properties: ```javascript MyTextInput = Ember.View.extend({ tagName: 'input', attributeBindings: ['disabled'], disabled: Ember.computed(function() { if (someLogic) { return true; } else { return false; } }) }); ``` Updates to the the property of an attribute binding will result in automatic update of the HTML attribute in the view's rendered HTML representation. `attributeBindings` is a concatenated property. See [Ember.Object](/api/classes/Ember.Object.html) documentation for more information about concatenated properties. ## Templates The HTML contents of a view's rendered representation are determined by its template. Templates can be any function that accepts an optional context parameter and returns a string of HTML that will be inserted within the view's tag. Most typically in Ember this function will be a compiled `Ember.Handlebars` template. ```javascript AView = Ember.View.extend({ template: Ember.Handlebars.compile('I am the template') }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view">I am the template</div> ``` Within an Ember application is more common to define a Handlebars templates as part of a page: ```html <script type='text/x-handlebars' data-template-name='some-template'> Hello </script> ``` And associate it by name using a view's `templateName` property: ```javascript AView = Ember.View.extend({ templateName: 'some-template' }); ``` If you have nested routes, your Handlebars template will look like this: ```html <script type='text/x-handlebars' data-template-name='posts/new'> <h1>New Post</h1> </script> ``` And `templateName` property: ```javascript AView = Ember.View.extend({ templateName: 'posts/new' }); ``` Using a value for `templateName` that does not have a Handlebars template with a matching `data-template-name` attribute will throw an error. For views classes that may have a template later defined (e.g. as the block portion of a `{{view}}` Handlebars helper call in another template or in a subclass), you can provide a `defaultTemplate` property set to compiled template function. If a template is not later provided for the view instance the `defaultTemplate` value will be used: ```javascript AView = Ember.View.extend({ defaultTemplate: Ember.Handlebars.compile('I was the default'), template: null, templateName: null }); ``` Will result in instances with an HTML representation of: ```html <div id="ember1" class="ember-view">I was the default</div> ``` If a `template` or `templateName` is provided it will take precedence over `defaultTemplate`: ```javascript AView = Ember.View.extend({ defaultTemplate: Ember.Handlebars.compile('I was the default') }); aView = AView.create({ template: Ember.Handlebars.compile('I was the template, not default') }); ``` Will result in the following HTML representation when rendered: ```html <div id="ember1" class="ember-view">I was the template, not default</div> ``` ## View Context The default context of the compiled template is the view's controller: ```javascript AView = Ember.View.extend({ template: Ember.Handlebars.compile('Hello {{excitedGreeting}}') }); aController = Ember.Object.create({ firstName: 'Barry', excitedGreeting: Ember.computed('content.firstName', function() { return this.get('content.firstName') + '!!!'; }) }); aView = AView.create({ controller: aController }); ``` Will result in an HTML representation of: ```html <div id="ember1" class="ember-view">Hello Barry!!!</div> ``` A context can also be explicitly supplied through the view's `context` property. If the view has neither `context` nor `controller` properties, the `parentView`'s context will be used. ## Layouts Views can have a secondary template that wraps their main template. Like primary templates, layouts can be any function that accepts an optional context parameter and returns a string of HTML that will be inserted inside view's tag. Views whose HTML element is self closing (e.g. `<input />`) cannot have a layout and this property will be ignored. Most typically in Ember a layout will be a compiled `Ember.Handlebars` template. A view's layout can be set directly with the `layout` property or reference an existing Handlebars template by name with the `layoutName` property. A template used as a layout must contain a single use of the Handlebars `{{yield}}` helper. The HTML contents of a view's rendered `template` will be inserted at this location: ```javascript AViewWithLayout = Ember.View.extend({ layout: Ember.Handlebars.compile("<div class='my-decorative-class'>{{yield}}</div>"), template: Ember.Handlebars.compile("I got wrapped") }); ``` Will result in view instances with an HTML representation of: ```html <div id="ember1" class="ember-view"> <div class="my-decorative-class"> I got wrapped </div> </div> ``` See [Ember.Handlebars.helpers.yield](/api/classes/Ember.Handlebars.helpers.html#method_yield) for more information. ## Responding to Browser Events Views can respond to user-initiated events in one of three ways: method implementation, through an event manager, and through `{{action}}` helper use in their template or layout. ### Method Implementation Views can respond to user-initiated events by implementing a method that matches the event name. A `jQuery.Event` object will be passed as the argument to this method. ```javascript AView = Ember.View.extend({ click: function(event) { // will be called when when an instance's // rendered element is clicked } }); ``` ### Event Managers Views can define an object as their `eventManager` property. This object can then implement methods that match the desired event names. Matching events that occur on the view's rendered HTML or the rendered HTML of any of its DOM descendants will trigger this method. A `jQuery.Event` object will be passed as the first argument to the method and an `Ember.View` object as the second. The `Ember.View` will be the view whose rendered HTML was interacted with. This may be the view with the `eventManager` property or one of its descendant views. ```javascript AView = Ember.View.extend({ eventManager: Ember.Object.create({ doubleClick: function(event, view) { // will be called when when an instance's // rendered element or any rendering // of this view's descendant // elements is clicked } }) }); ``` An event defined for an event manager takes precedence over events of the same name handled through methods on the view. ```javascript AView = Ember.View.extend({ mouseEnter: function(event) { // will never trigger. }, eventManager: Ember.Object.create({ mouseEnter: function(event, view) { // takes precedence over AView#mouseEnter } }) }); ``` Similarly a view's event manager will take precedence for events of any views rendered as a descendant. A method name that matches an event name will not be called if the view instance was rendered inside the HTML representation of a view that has an `eventManager` property defined that handles events of the name. Events not handled by the event manager will still trigger method calls on the descendant. ```javascript var App = Ember.Application.create(); App.OuterView = Ember.View.extend({ template: Ember.Handlebars.compile("outer {{#view 'inner'}}inner{{/view}} outer"), eventManager: Ember.Object.create({ mouseEnter: function(event, view) { // view might be instance of either // OuterView or InnerView depending on // where on the page the user interaction occurred } }) }); App.InnerView = Ember.View.extend({ click: function(event) { // will be called if rendered inside // an OuterView because OuterView's // eventManager doesn't handle click events }, mouseEnter: function(event) { // will never be called if rendered inside // an OuterView. } }); ``` ### Handlebars `{{action}}` Helper See [Handlebars.helpers.action](/api/classes/Ember.Handlebars.helpers.html#method_action). ### Event Names All of the event handling approaches described above respond to the same set of events. The names of the built-in events are listed below. (The hash of built-in events exists in `Ember.EventDispatcher`.) Additional, custom events can be registered by using `Ember.Application.customEvents`. Touch events: * `touchStart` * `touchMove` * `touchEnd` * `touchCancel` Keyboard events * `keyDown` * `keyUp` * `keyPress` Mouse events * `mouseDown` * `mouseUp` * `contextMenu` * `click` * `doubleClick` * `mouseMove` * `focusIn` * `focusOut` * `mouseEnter` * `mouseLeave` Form events: * `submit` * `change` * `focusIn` * `focusOut` * `input` HTML5 drag and drop events: * `dragStart` * `drag` * `dragEnter` * `dragLeave` * `dragOver` * `dragEnd` * `drop` ## Handlebars `{{view}}` Helper Other `Ember.View` instances can be included as part of a view's template by using the `{{view}}` Handlebars helper. See [Ember.Handlebars.helpers.view](/api/classes/Ember.Handlebars.helpers.html#method_view) for additional information. @class View @namespace Ember @extends Ember.CoreView @deprecated See http://emberjs.com/deprecations/v1.x/#toc_ember-view @uses Ember.ViewContextSupport @uses Ember.ViewChildViewsSupport @uses Ember.TemplateRenderingSupport @uses Ember.ClassNamesSupport @uses Ember.AttributeBindingsSupport @uses Ember.LegacyViewSupport @uses Ember.InstrumentationSupport @uses Ember.VisibilitySupport @uses Ember.AriaRoleSupport @public */ // jscs:disable validateIndentation var View = _emberViewsViewsCore_view2['default'].extend(_emberViewsMixinsView_context_support2['default'], _emberViewsMixinsView_child_views_support2['default'], _emberViewsMixinsView_state_support2['default'], _emberViewsMixinsTemplate_rendering_support2['default'], _emberViewsMixinsClass_names_support2['default'], _emberViewsMixinsLegacy_view_support2['default'], _emberViewsMixinsInstrumentation_support2['default'], _emberViewsMixinsVisibility_support2['default'], _emberViewsCompatAttrsProxy2['default'], _emberViewsMixinsAria_role_support2['default'], { concatenatedProperties: ['attributeBindings'], /** @property isView @type Boolean @default true @static @private */ isView: true, // .......................................................... // TEMPLATE SUPPORT // /** The name of the template to lookup if no template is provided. By default `Ember.View` will lookup a template with this name in `Ember.TEMPLATES` (a shared global object). @property templateName @type String @default null @private */ templateName: null, /** The name of the layout to lookup if no layout is provided. By default `Ember.View` will lookup a template with this name in `Ember.TEMPLATES` (a shared global object). @property layoutName @type String @default null @private */ layoutName: null, /** The template used to render the view. This should be a function that accepts an optional context parameter and returns a string of HTML that will be inserted into the DOM relative to its parent view. In general, you should set the `templateName` property instead of setting the template yourself. @property template @type Function @private */ template: (0, _emberMetalComputed.computed)('templateName', { get: function get() { var templateName = (0, _emberMetalProperty_get.get)(this, 'templateName'); var template = this.templateForName(templateName, 'template'); _emberMetalCore2['default'].assert('You specified the templateName ' + templateName + ' for ' + this + ', but it did not exist.', !templateName || !!template); return template || (0, _emberMetalProperty_get.get)(this, 'defaultTemplate'); }, set: function set(key, value) { if (value !== undefined) { return value; } return (0, _emberMetalProperty_get.get)(this, key); } }), /** A view may contain a layout. A layout is a regular template but supersedes the `template` property during rendering. It is the responsibility of the layout template to retrieve the `template` property from the view (or alternatively, call `Handlebars.helpers.yield`, `{{yield}}`) to render it in the correct location. This is useful for a view that has a shared wrapper, but which delegates the rendering of the contents of the wrapper to the `template` property on a subclass. @property layout @type Function @private */ layout: (0, _emberMetalComputed.computed)('layoutName', { get: function get(key) { var layoutName = (0, _emberMetalProperty_get.get)(this, 'layoutName'); var layout = this.templateForName(layoutName, 'layout'); _emberMetalCore2['default'].assert('You specified the layoutName ' + layoutName + ' for ' + this + ', but it did not exist.', !layoutName || !!layout); return layout || (0, _emberMetalProperty_get.get)(this, 'defaultLayout'); }, set: function set(key, value) { return value; } }), templateForName: function templateForName(name, type) { if (!name) { return; } _emberMetalCore2['default'].assert('templateNames are not allowed to contain periods: ' + name, name.indexOf('.') === -1); if (!this.container) { throw new _emberMetalError2['default']('Container was not found when looking up a views template. ' + 'This is most likely due to manually instantiating an Ember.View. ' + 'See: http://git.io/EKPpnA'); } return this.container.lookup('template:' + name); }, /** If a value that affects template rendering changes, the view should be re-rendered to reflect the new value. @method _contextDidChange @private @private */ _contextDidChange: (0, _emberMetalMixin.observer)('context', function () { this.rerender(); }), /** Return the nearest ancestor that is an instance of the provided class or mixin. @method nearestOfType @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself), or an instance of Ember.Mixin. @return Ember.View @private */ nearestOfType: function nearestOfType(klass) { var view = (0, _emberMetalProperty_get.get)(this, 'parentView'); var isOfType = klass instanceof _emberMetalMixin.Mixin ? function (view) { return klass.detect(view); } : function (view) { return klass.detect(view.constructor); }; while (view) { if (isOfType(view)) { return view; } view = (0, _emberMetalProperty_get.get)(view, 'parentView'); } }, /** Return the nearest ancestor that has a given property. @method nearestWithProperty @param {String} property A property name @return Ember.View @private */ nearestWithProperty: function nearestWithProperty(property) { var view = (0, _emberMetalProperty_get.get)(this, 'parentView'); while (view) { if (property in view) { return view; } view = (0, _emberMetalProperty_get.get)(view, 'parentView'); } }, /** Renders the view again. This will work regardless of whether the view is already in the DOM or not. If the view is in the DOM, the rendering process will be deferred to give bindings a chance to synchronize. If children were added during the rendering process using `appendChild`, `rerender` will remove them, because they will be added again if needed by the next `render`. In general, if the display of your view changes, you should modify the DOM element directly instead of manually calling `rerender`, which can be slow. @method rerender @public */ rerender: function rerender() { return this.currentState.rerender(this); }, /* * @private * * @method _rerender */ _rerender: function _rerender() { if (this.isDestroying || this.isDestroyed) { return; } this._renderer.renderTree(this, this.parentView); }, /** Given a property name, returns a dasherized version of that property name if the property evaluates to a non-falsy value. For example, if the view has property `isUrgent` that evaluates to true, passing `isUrgent` to this method will return `"is-urgent"`. @method _classStringForProperty @param property @private */ _classStringForProperty: function _classStringForProperty(parsedPath) { return View._classStringForValue(parsedPath.path, parsedPath.stream.value(), parsedPath.className, parsedPath.falsyClassName); }, // .......................................................... // ELEMENT SUPPORT // /** Returns the current DOM element for the view. @property element @type DOMElement @public */ element: null, /** Returns a jQuery object for this view's element. If you pass in a selector string, this method will return a jQuery object, using the current element as its buffer. For example, calling `view.$('li')` will return a jQuery object containing all of the `li` elements inside the DOM element of this view. @method $ @param {String} [selector] a jQuery-compatible selector string @return {jQuery} the jQuery object for the DOM node @public */ $: function $(sel) { _emberMetalCore2['default'].assert('You cannot access this.$() on a component with `tagName: \'\'` specified.', this.tagName !== ''); return this.currentState.$(this, sel); }, forEachChildView: function forEachChildView(callback) { var childViews = this.childViews; if (!childViews) { return this; } var len = childViews.length; var view, idx; for (idx = 0; idx < len; idx++) { view = childViews[idx]; callback(view); } return this; }, /** Appends the view's element to the specified parent element. If the view does not have an HTML representation yet, `createElement()` will be called automatically. Note that this method just schedules the view to be appended; the DOM element will not be appended to the given element until all bindings have finished synchronizing. This is not typically a function that you will need to call directly when building your application. You might consider using `Ember.ContainerView` instead. If you do need to use `appendTo`, be sure that the target element you are providing is associated with an `Ember.Application` and does not have an ancestor element that is associated with an Ember view. @method appendTo @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object @return {Ember.View} receiver @private */ appendTo: function appendTo(selector) { var target = (0, _emberViewsSystemJquery2['default'])(selector); _emberMetalCore2['default'].assert('You tried to append to (' + selector + ') but that isn\'t in the DOM', target.length > 0); _emberMetalCore2['default'].assert('You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.', !target.is('.ember-view') && !target.parents().is('.ember-view')); this.renderer.appendTo(this, target[0]); return this; }, /** @private Creates a new DOM element, renders the view into it, then returns the element. By default, the element created and rendered into will be a `BODY` element, since this is the default context that views are rendered into when being inserted directly into the DOM. ```js var element = view.renderToElement(); element.tagName; // => "BODY" ``` You can override the kind of element rendered into and returned by specifying an optional tag name as the first argument. ```js var element = view.renderToElement('table'); element.tagName; // => "TABLE" ``` This method is useful if you want to render the view into an element that is not in the document's body. Instead, a new `body` element, detached from the DOM is returned. FastBoot uses this to serialize the rendered view into a string for transmission over the network. ```js app.visit('/').then(function(instance) { var element; Ember.run(function() { element = renderToElement(instance); }); res.send(serialize(element)); }); ``` @method renderToElement @param {String} tagName The tag of the element to create and render into. Defaults to "body". @return {HTMLBodyElement} element @private */ renderToElement: function renderToElement(tagName) { tagName = tagName || 'body'; var element = this.renderer._dom.createElement(tagName); this.renderer.appendTo(this, element); return element; }, /** Replaces the content of the specified parent element with this view's element. If the view does not have an HTML representation yet, the element will be generated automatically. Note that this method just schedules the view to be appended; the DOM element will not be appended to the given element until all bindings have finished synchronizing @method replaceIn @param {String|DOMElement|jQuery} target A selector, element, HTML string, or jQuery object @return {Ember.View} received @private */ replaceIn: function replaceIn(selector) { var target = (0, _emberViewsSystemJquery2['default'])(selector); _emberMetalCore2['default'].assert('You tried to replace in (' + selector + ') but that isn\'t in the DOM', target.length > 0); _emberMetalCore2['default'].assert('You cannot replace an existing Ember.View. Consider using Ember.ContainerView instead.', !target.is('.ember-view') && !target.parents().is('.ember-view')); this.renderer.replaceIn(this, target[0]); return this; }, /** Appends the view's element to the document body. If the view does not have an HTML representation yet the element will be generated automatically. If your application uses the `rootElement` property, you must append the view within that element. Rendering views outside of the `rootElement` is not supported. Note that this method just schedules the view to be appended; the DOM element will not be appended to the document body until all bindings have finished synchronizing. @method append @return {Ember.View} receiver @private */ append: function append() { return this.appendTo(document.body); }, /** Removes the view's element from the element to which it is attached. @method remove @return {Ember.View} receiver @private */ remove: function remove() { // What we should really do here is wait until the end of the run loop // to determine if the element has been re-appended to a different // element. // In the interim, we will just re-render if that happens. It is more // important than elements get garbage collected. if (!this.removedFromDOM) { this.destroyElement(); } // Set flag to avoid future renders this._willInsert = false; }, /** The HTML `id` of the view's element in the DOM. You can provide this value yourself but it must be unique (just as in HTML): ```handlebars {{my-component elementId="a-really-cool-id"}} ``` If not manually set a default value will be provided by the framework. Once rendered an element's `elementId` is considered immutable and you should never change it. If you need to compute a dynamic value for the `elementId`, you should do this when the component or element is being instantiated: ```javascript export default Ember.Component.extend({ setElementId: Ember.on('init', function() { var index = this.get('index'); this.set('elementId', 'component-id' + index); }) }); ``` @property elementId @type String @public */ elementId: null, /** Attempts to discover the element in the parent element. The default implementation looks for an element with an ID of `elementId` (or the view's guid if `elementId` is null). You can override this method to provide your own form of lookup. For example, if you want to discover your element using a CSS class name instead of an ID. @method findElementInParentElement @param {DOMElement} parentElement The parent's DOM element @return {DOMElement} The discovered element @private */ findElementInParentElement: function findElementInParentElement(parentElem) { var id = '#' + this.elementId; return (0, _emberViewsSystemJquery2['default'])(id)[0] || (0, _emberViewsSystemJquery2['default'])(id, parentElem)[0]; }, /** Creates a DOM representation of the view and all of its child views by recursively calling the `render()` method. Once the element is created, it sets the `element` property of the view to the rendered element. After the element has been inserted into the DOM, `didInsertElement` will be called on this view and all of its child views. @method createElement @return {Ember.View} receiver @private */ createElement: function createElement() { if (this.element) { return this; } this.renderer.createElement(this); return this; }, /** Called when a view is going to insert an element into the DOM. @event willInsertElement @public */ willInsertElement: K, /** Called when the element of the view has been inserted into the DOM or after the view was re-rendered. Override this function to do any set up that requires an element in the document body. When a view has children, didInsertElement will be called on the child view(s) first, bubbling upwards through the hierarchy. @event didInsertElement @public */ didInsertElement: K, /** Called when the view is about to rerender, but before anything has been torn down. This is a good opportunity to tear down any manual observers you have installed based on the DOM state @event willClearRender @public */ willClearRender: K, /** Destroys any existing element along with the element for any child views as well. If the view does not currently have a element, then this method will do nothing. If you implement `willDestroyElement()` on your view, then this method will be invoked on your view before your element is destroyed to give you a chance to clean up any event handlers, etc. If you write a `willDestroyElement()` handler, you can assume that your `didInsertElement()` handler was called earlier for the same element. You should not call or override this method yourself, but you may want to implement the above callbacks. @method destroyElement @return {Ember.View} receiver @private */ destroyElement: function destroyElement() { return this.currentState.destroyElement(this); }, /** Called when the element of the view is going to be destroyed. Override this function to do any teardown that requires an element, like removing event listeners. Please note: any property changes made during this event will have no effect on object observers. @event willDestroyElement @public */ willDestroyElement: K, /** Called when the parentView property has changed. @event parentViewDidChange @private */ parentViewDidChange: K, // .......................................................... // STANDARD RENDER PROPERTIES // /** Tag name for the view's outer element. The tag name is only used when an element is first created. If you change the `tagName` for an element, you must destroy and recreate the view element. By default, the render buffer will use a `<div>` tag for views. @property tagName @type String @default null @public */ // We leave this null by default so we can tell the difference between // the default case and a user-specified tag. tagName: null, /* Used to specify a default tagName that can be overridden when extending or invoking from a template. @property _defaultTagName @private */ /** Normally, Ember's component model is "write-only". The component takes a bunch of attributes that it got passed in, and uses them to render its template. One nice thing about this model is that if you try to set a value to the same thing as last time, Ember (through HTMLBars) will avoid doing any work on the DOM. This is not just a performance optimization. If an attribute has not changed, it is important not to clobber the element's "hidden state". For example, if you set an input's `value` to the same value as before, it will clobber selection state and cursor position. In other words, setting an attribute is not **always** idempotent. This method provides a way to read an element's attribute and also update the last value Ember knows about at the same time. This makes setting an attribute idempotent. In particular, what this means is that if you get an `<input>` element's `value` attribute and then re-render the template with the same value, it will avoid clobbering the cursor and selection position. Since most attribute sets are idempotent in the browser, you typically can get away with reading attributes using jQuery, but the most reliable way to do so is through this method. @method readDOMAttr @param {String} name the name of the attribute @return String @public */ readDOMAttr: function readDOMAttr(name) { var attr = this._renderNode.childNodes.filter(function (node) { return node.attrName === name; })[0]; if (!attr) { return null; } return attr.getContent(); }, // ....................................................... // CORE DISPLAY METHODS // /** Setup a view, but do not finish waking it up. * configure `childViews` * register the view with the global views hash, which is used for event dispatch @method init @private */ init: function init() { if (!this.elementId) { this.elementId = (0, _emberMetalUtils.guidFor)(this); } this.scheduledRevalidation = false; this._super.apply(this, arguments); if (!this._viewRegistry) { this._viewRegistry = View.views; } }, __defineNonEnumerable: function __defineNonEnumerable(property) { this[property.name] = property.descriptor.value; }, revalidate: function revalidate() { this.renderer.revalidateTopLevelView(this); this.scheduledRevalidation = false; }, scheduleRevalidate: function scheduleRevalidate(node, label, manualRerender) { if (node && !this._dispatching && node.guid in this.env.renderedNodes) { if (manualRerender) { _emberMetalCore2['default'].deprecate('You manually rerendered ' + label + ' (a parent component) from a child component during the rendering process. This rarely worked in Ember 1.x and will be removed in Ember 2.0'); } else { _emberMetalCore2['default'].deprecate('You modified ' + label + ' twice in a single render. This was unreliable in Ember 1.x and will be removed in Ember 2.0'); } _emberMetalRun_loop2['default'].scheduleOnce('render', this, this.revalidate); return; } _emberMetalCore2['default'].deprecate('A property of ' + this + ' was modified inside the ' + this._dispatching + ' hook. You should never change properties on components, services or models during ' + this._dispatching + ' because it causes significant performance degradation.', !this._dispatching); if (!this.scheduledRevalidation || this._dispatching) { this.scheduledRevalidation = true; _emberMetalRun_loop2['default'].scheduleOnce('render', this, this.revalidate); } }, appendAttr: function appendAttr(node, buffer) { return this.currentState.appendAttr(this, node, buffer); }, templateRenderer: null, /** Removes the view from its `parentView`, if one is found. Otherwise does nothing. @method removeFromParent @return {Ember.View} receiver @private */ removeFromParent: function removeFromParent() { var parent = this.parentView; // Remove DOM element from parent this.remove(); if (parent) { parent.removeChild(this); } return this; }, /** You must call `destroy` on a view to destroy the view (and all of its child views). This will remove the view from any parent node, then make sure that the DOM element managed by the view can be released by the memory manager. @method destroy @private */ destroy: function destroy() { // get parentView before calling super because it'll be destroyed var parentView = this.parentView; var viewName = this.viewName; if (!this._super.apply(this, arguments)) { return; } // remove from non-virtual parent view if viewName was specified if (viewName && parentView) { parentView.set(viewName, null); } // Destroy HTMLbars template if (this.lastResult) { this.lastResult.destroy(); } return this; }, // ....................................................... // EVENT HANDLING // /** Handle events from `Ember.EventDispatcher` @method handleEvent @param eventName {String} @param evt {Event} @private */ handleEvent: function handleEvent(eventName, evt) { return this.currentState.handleEvent(this, eventName, evt); }, /** Registers the view in the view registry, keyed on the view's `elementId`. This is used by the EventDispatcher to locate the view in response to events. This method should only be called once the view has been inserted into the DOM. @method _register @private */ _register: function _register() { _emberMetalCore2['default'].assert('Attempted to register a view with an id already in use: ' + this.elementId, !this._viewRegistry[this.elementId]); this._viewRegistry[this.elementId] = this; }, /** Removes the view from the view registry. This should be called when the view is removed from DOM. @method _unregister @private */ _unregister: function _unregister() { delete this._viewRegistry[this.elementId]; }, registerObserver: function registerObserver(root, path, target, observer) { if (!observer && 'function' === typeof target) { observer = target; target = null; } if (!root || typeof root !== 'object') { return; } var scheduledObserver = this._wrapAsScheduled(observer); (0, _emberMetalObserver.addObserver)(root, path, target, scheduledObserver); this.one('willClearRender', function () { (0, _emberMetalObserver.removeObserver)(root, path, target, scheduledObserver); }); }, _wrapAsScheduled: function _wrapAsScheduled(fn) { var view = this; var stateCheckedFn = function stateCheckedFn() { view.currentState.invokeObserver(this, fn); }; var scheduledFn = function scheduledFn() { _emberMetalRun_loop2['default'].scheduleOnce('render', this, stateCheckedFn); }; return scheduledFn; } }); // jscs:enable validateIndentation /* Describe how the specified actions should behave in the various states that a view can exist in. Possible states: * preRender: when a view is first instantiated, and after its element was destroyed, it is in the preRender state * inBuffer: once a view has been rendered, but before it has been inserted into the DOM, it is in the inBuffer state * hasElement: the DOM representation of the view is created, and is ready to be inserted * inDOM: once a view has been inserted into the DOM it is in the inDOM state. A view spends the vast majority of its existence in this state. * destroyed: once a view has been destroyed (using the destroy method), it is in this state. No further actions can be invoked on a destroyed view. */ // in the destroyed state, everything is illegal // before rendering has begun, all legal manipulations are noops. // inside the buffer, legal manipulations are done on the buffer // once the view has been inserted into the DOM, legal manipulations // are done on the DOM element. /** Global views hash @property views @static @type Object @private */ View.views = {}; // If someone overrides the child views computed property when // defining their class, we want to be able to process the user's // supplied childViews and then restore the original computed property // at view initialization time. This happens in Ember.ContainerView's init // method. View.childViewsProperty = _emberViewsMixinsView_child_views_support.childViewsProperty; var DeprecatedView = View.extend({ init: function init() { this._super.apply(this, arguments); _emberMetalCore2['default'].deprecate('Ember.View is deprecated. Consult the Deprecations Guide for a migration strategy.', !!_emberMetalCore2['default'].ENV._ENABLE_LEGACY_VIEW_SUPPORT, { url: 'http://emberjs.com/deprecations/v1.x/#toc_ember-view' }); } }); exports['default'] = View; exports.ViewContextSupport = _emberViewsMixinsView_context_support2['default']; exports.ViewChildViewsSupport = _emberViewsMixinsView_child_views_support2['default']; exports.ViewStateSupport = _emberViewsMixinsView_state_support2['default']; exports.TemplateRenderingSupport = _emberViewsMixinsTemplate_rendering_support2['default']; exports.ClassNamesSupport = _emberViewsMixinsClass_names_support2['default']; exports.DeprecatedView = DeprecatedView;


Mandor Mountains [at27], mountain, in Mandoria, wilderness
Last updated Turn #129
Mandor Mountains [at27], mountain, in Mandoria, wilderness
------------------------------------------------------------------------
12: grimlock [h6t], refugee, with one riding horse, arrived from the
12: south.
14: grimlock [h6t], refugee, with one riding horse, went north.
16: Pack of wolves [il9s], wolves, number: 4, arrived from the east.
16: Pandora [d9i], refugee, arrived from the west.
20: Pandora [d9i], refugee, went east.
Routes leaving Mandor Mountains:
North, forest, to Great Forest [as27], 8 days
East, plain, to Plain of Tears [at28], 7 days
South, mountain, to Mandor Mountains [au27], 10 days
West, mountain, to Mandor Mountains [at26], 10 days
Seen here:
Pack of wolves [il9s], wolves, number: 4


Jack Sparrow
Refresh
Available
Busy
Away
Sign Out
Lorem ipsum dolor sadgagds sdsad s Lorem ipsum dolor sadgagds sdsad s
5.42pm from Karin
Lorem ipsumLorem ipsumLorem
5.42pm from Karin


© 2017-2018 SIL International
This Tifinagh keyboard was developed to input characters for Tifinagh scripts. You can use this keyboard with any Tifinagh Unicode font. This keyboard follows the Moroccan Tamazight Tifinagh keyboard specification plus additional keys needed for Tamajaq.
For typing in the Tawallammat Tamajaq language, we highly recommend the Tagmukay font at http://software.sil.org/tagmukay. This font has the required characters and bi-consonant ligatures for Tawallammat.


virus plants plant aphid aphids viral host viruses protein transmitted transmission interactions vector {border-style infected non-persistently px;} #ffffff;} CMV insect mosaic manipulation vectors effects phenotype gene virally-induced changes increased infection resistance transmission. â€˜retainâ€™ However, RNA deterâ€™ phenotypes settling susceptibility thaliana â€˜attract feeding genes induction insects persicae spread CMV-infected development host-vector increase non-persistent phloem px; unpublished {font-family (Donnelly Mauck Myzus VOCs Virus Westwood effect expression font-size hosts induces proteins responses showed silencing specific tobacco virus-induced (Fig. (Westwood Virol. compounds double; emission enhance epidemic epidermal increases influence inhibit inoculum plants, signalling suppression work Donnelly Plant Section Ziebell acquisition benefit bind border-color border-width cucumber data; evidence factor induced inoculation means particles processes production results signaling significant solid; stylet suggested {font-style {font-weight (), (Tungadi Appl. Arabidopsis Ecol. Gen. Res. Sci. VOC ability acid article benthamiana blend bold cells confined courier; cues defence em; epidemiological extended factors following funded growth i.e., improved insights interaction local model modelling modify molecular new organic persistent plantâ€™s population potato promote pt;} quality recent reproduction resulting suppress susceptible thaliana, volatile


Class WebRtcSession
Represents a WebRTC session with a remote peer.
Inheritance
System.Object
WebRtcSession
Implements
System.IDisposable
Inherited Members
System.Object.Equals(System.Object)
System.Object.Equals(System.Object, System.Object)
System.Object.GetHashCode()
System.Object.GetType()
System.Object.MemberwiseClone()
System.Object.ReferenceEquals(System.Object, System.Object)
System.Object.ToString()
Assembly: SIPSorcery.dll
Syntax
public class WebRtcSession : RTPSession, IDisposable
Constructors
|
Improve this Doc
View Source
WebRtcSession(AddressFamily, String, List<IPAddress>, IPEndPoint)
Declaration
public WebRtcSession(AddressFamily addrFamily, string dtlsFingerprint, List<IPAddress> offerAddresses, IPEndPoint turnServerEndPoint)
Parameters
| Type |
Name |
Description |
| System.Net.Sockets.AddressFamily |
addrFamily |
|
| System.String |
dtlsFingerprint |
The fingerprint of our DTLS certificate (we always act as the DTLS server).
It gets placed in the SDP offer sent to the remote party.
|
| System.Collections.Generic.List<System.Net.IPAddress> |
offerAddresses |
Optional. A list of the IP addresses used as local ICE candidates.
If null then all local IP addresses get used.
|
| System.Net.IPEndPoint |
turnServerEndPoint |
Optional. A parameter that can be used include a TURN
server in this session's ICE candidate gathering.
|
Fields
|
Improve this Doc
View Source
IceConnectionState
Declaration
public IceConnectionStatesEnum IceConnectionState
Field Value
|
Improve this Doc
View Source
IceNegotiationStartedAt
Declaration
public DateTime IceNegotiationStartedAt
Field Value
| Type |
Description |
| System.DateTime |
|
|
Improve this Doc
View Source
LocalIceCandidates
Declaration
public List<IceCandidate> LocalIceCandidates
Field Value
| Type |
Description |
| System.Collections.Generic.List<IceCandidate> |
|
|
Improve this Doc
View Source
LocalIcePassword
Declaration
public string LocalIcePassword
Field Value
| Type |
Description |
| System.String |
|
|
Improve this Doc
View Source
LocalIceUser
Declaration
public string LocalIceUser
Field Value
| Type |
Description |
| System.String |
|
|
Improve this Doc
View Source
LocalSdpSessionID
Declaration
public string LocalSdpSessionID
Field Value
| Type |
Description |
| System.String |
|
|
Improve this Doc
View Source
RemoteIcePassword
Declaration
public string RemoteIcePassword
Field Value
| Type |
Description |
| System.String |
|
|
Improve this Doc
View Source
RemoteIceUser
Declaration
public string RemoteIceUser
Field Value
| Type |
Description |
| System.String |
|
|
Improve this Doc
View Source
SdpSessionID
Declaration
public string SdpSessionID
Field Value
| Type |
Description |
| System.String |
|
Properties
|
Improve this Doc
View Source
IsConnected
Declaration
public bool IsConnected { get; }
Property Value
| Type |
Description |
| System.Boolean |
|
|
Improve this Doc
View Source
IsDtlsNegotiationComplete
Declaration
public bool IsDtlsNegotiationComplete { get; }
Property Value
| Type |
Description |
| System.Boolean |
|
|
Improve this Doc
View Source
RemoteEndPoint
The raison d'etre for the ICE checks. This represents the end point
that we were able to connect to for the WebRTC session.
Declaration
public IPEndPoint RemoteEndPoint { get; }
Property Value
| Type |
Description |
| System.Net.IPEndPoint |
|
|
Improve this Doc
View Source
RemoteIceCandidates
Declaration
public List<IceCandidate> RemoteIceCandidates { get; }
Property Value
| Type |
Description |
| System.Collections.Generic.List<IceCandidate> |
|
|
Improve this Doc
View Source
SessionID
Declaration
public string SessionID { get; }
Property Value
| Type |
Description |
| System.String |
|
Methods
|
Improve this Doc
View Source
AppendRemoteIceCandidate(IceCandidate)
Adds an ICE candidate to the list of remote party candidates.
Declaration
public void AppendRemoteIceCandidate(IceCandidate remoteIceCandidate)
Parameters
| Type |
Name |
Description |
| IceCandidate |
remoteIceCandidate |
The remote party candidate to add.
|
|
Improve this Doc
View Source
Close(String)
Close the session including the underlying RTP session and channels.
Declaration
public void Close(string reason)
Parameters
| Type |
Name |
Description |
| System.String |
reason |
An optional descriptive reason for the closure.
|
|
Improve this Doc
View Source
createAnswer()
Creates an answer to an SDP offer from a remote peer.
Declaration
public Task<SDP> createAnswer()
Returns
| Type |
Description |
| System.Threading.Tasks.Task<SDP> |
|
|
Improve this Doc
View Source
createOffer(RTCOfferOptions)
Generates the SDP for an offer that can be made to a remote peer.
Declaration
public override Task<SDP> createOffer(RTCOfferOptions options)
Parameters
Returns
| Type |
Description |
| System.Threading.Tasks.Task<SDP> |
|
Overrides
|
Improve this Doc
View Source
Send a media sample to the remote party.
Declaration
public void SendMedia(SDPMediaTypesEnum mediaType, uint sampleTimestamp, byte[] sample)
Parameters
| Type |
Name |
Description |
| SDPMediaTypesEnum |
mediaType |
Whether the sample is audio or video.
|
| System.UInt32 |
sampleTimestamp |
The RTP timestamp for the sample.
|
| System.Byte[] |
sample |
The sample payload.
|
|
Improve this Doc
View Source
setLocalDescription(RTCSessionDescription)
Declaration
public override void setLocalDescription(RTCSessionDescription sessionDescription)
Parameters
Overrides
|
Improve this Doc
View Source
setRemoteDescription(RTCSessionDescription)
Updates the session after receiving the remote SDP.
At this point check that the codecs match. We currently only support:
- Audio: PCMU,
- Video: VP8.
If they are not available there's no point carrying on.
Declaration
public override void setRemoteDescription(RTCSessionDescription sessionDescription)
Parameters
| Type |
Name |
Description |
| RTCSessionDescription |
sessionDescription |
The answer/offer SDP from the remote party.
|
Overrides
Events
|
Improve this Doc
View Source
OnClose
Declaration
public event Action<string> OnClose
Event Type
| Type |
Description |
| System.Action<System.String> |
|
Implements
System.IDisposable


Provide a short and comprehensive geographic description of the sampling site(s) or location(s) where these data were collected. For example, “Teshekpuk Lake, Alaska”.
Bounding Box Coordinates
Enter two lat,lng coordinates to specify a geographic bounding box or only one lat,lng pair for a single point.


{% extends "base.mail.html" %}
{% load i18n %}
{% block content %}
{% blocktrans with amount=amount|floatformat:2 donor_name=donor_name site=site link=link %}
Hello,
You just received a EUR {{ amount }} donation from {{ donor_name }}!
Quickly thank your supporter by posting a personal message on your fundraise action wall.
Cheers,
1%Club
{% endblocktrans %}
{% endblock %}


titaness package¶
Submodules¶
titaness.celery module¶
titaness.celery_setup module¶
titaness.routers module¶
titaness.settings module¶
Django settings for titaness project.
Generated by ‘django-admin startproject’ using Django 2.2.
For more information on this file, see https://docs.djangoproject.com/en/2.2/topics/settings/
For the full list of settings and their values, see https://docs.djangoproject.com/en/2.2/ref/settings/
titaness.urls module¶
titaness URL Configuration
- The urlpatterns list routes URLs to views. For more information please see:
Examples: Function views
Add an import: from my_app import views
Add a URL to urlpatterns: path(‘’, views.home, name=’home’)
- Class-based views
Add an import: from other_app.views import Home
Add a URL to urlpatterns: path(‘’, Home.as_view(), name=’home’)
- Including another URLconf
Import the include() function: from django.urls import include, path
Add a URL to urlpatterns: path(‘blog/’, include(‘blog.urls’))
titaness.wsgi module¶
WSGI config for titaness project.
It exposes the WSGI callable as a module-level variable named application
.
For more information on this file, see https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/


It's well known that this thief was raising Arizona with strong ties to the Coppola family, and is a fan of national treasures. Don't be moonstruck by his dashing good looks, he's willing to face-off with any opposition.
He has an affinity for bread even when it's stale, it's been said there's no roll he'd turn down. His many personalities have allowed him to con air travel around the globe.
We have compiled hundreds of photos of the thief for recognition. With all this data, we can train a model to capture the thief before they get too far.
We've matched the thief across other thieves using state of the art training. We can even recognize our thief next to Chad Kroeger!
The model is trained with a front-facing CNN to featurize and capture the culprit.


Car
It's ok, definitly a car!

It's ok, definitly a car!


Methods with mutator-like name are expected to have
side effects
. The convention is that you include parentheses if the method has side effects.
* Refer to Programming in Scala, 5.3 Operators are methods


| loglin {stats} | R Documentation |
loglin
is used to fit log-linear models to multidimensional
contingency tables by Iterative Proportional Fitting.
loglin(table, margin, start = rep(1, length(table)), fit = FALSE, eps = 0.1, iter = 20, param = FALSE, print = TRUE)
table |
a contingency table to be fit, typically the output from
|
margin |
a list of vectors with the marginal totals to be fit. (Hierarchical) log-linear models can be specified in terms of these
marginal totals which give the ‘maximal’ factor subsets contained
in the model. For example, in a three-factor model,
The names of factors (i.e., |
start |
a starting estimate for the fitted table. This optional
argument is important for incomplete tables with structural zeros
in |
fit |
a logical indicating whether the fitted values should be returned. |
eps |
maximum deviation allowed between observed and fitted margins. |
iter |
maximum number of iterations. |
param |
a logical indicating whether the parameter values should be returned. |
print |
a logical. If |
The Iterative Proportional Fitting algorithm as presented in
Haberman (1972) is used for fitting the model. At most iter
iterations are performed, convergence is taken to occur when the
maximum deviation between observed and fitted margins is less than
eps
. All internal computations are done in double precision;
there is no limit on the number of factors (the dimension of the
table) in the model.
Assuming that there are no structural zeros, both the Likelihood
Ratio Test and Pearson test statistics have an asymptotic chi-squared
distribution with df
degrees of freedom.
Note that the IPF steps are applied to the factors in the order given
in margin
. Hence if the model is decomposable and the order
given in margin
is a running intersection property ordering
then IPF will converge in one iteration.
Package MASS contains loglm
, a front-end to
loglin
which allows the log-linear model to be specified and
fitted in a formula-based manner similar to that of other fitting
functions such as lm
or glm
.
A list with the following components.
lrt |
the Likelihood Ratio Test statistic. |
pearson |
the Pearson test statistic (X-squared). |
df |
the degrees of freedom for the fitted model. There is no adjustment for structural zeros. |
margin |
list of the margins that were fit. Basically the same
as the input |
fit |
An array like |
param |
A list containing the estimated parameters of the
model. The ‘standard’ constraints of zero marginal sums
(e.g., zero row and column sums for a two factor parameter) are
employed. Only returned if |
Kurt Hornik
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.
Haberman, S. J. (1972) Log-linear fit for contingency tables—Algorithm AS51. Applied Statistics, 21, 218–225.
Agresti, A. (1990) Categorical data analysis. New York: Wiley.
loglm
in package MASS for a
user-friendly wrapper.
glm
for another way to fit log-linear models.
## Model of joint independence of sex from hair and eye color. fm <- loglin(HairEyeColor, list(c(1, 2), c(1, 3), c(2, 3))) fm 1 - pchisq(fm$lrt, fm$df) ## Model with no three-factor interactions fits well.


Gold plates seized from passenger at Tiruchi international airport
The ‘C’ shaped gold plates of 24 carat purity weighed 349 g and was valued at ₹13.28 lakh
by R RajaramOfficers of the Customs Air Intelligence Unit seized gold plates concealed in a coffee grinder by an incoming passenger at the Tiruchi international airport in the early hours on Sunday.
Lokithas, 24, of Pudukottai district arrived here from Sharjah by an Air India Express flight IX 614 when the Air Intelligence Unit officers detected a couple of gold plates while they were checking the coffee grinder.
The ‘C’ shaped gold plates of 24 carat purity weighed 349 g and was valued at ₹13.28 lakh. The passenger was detained and the smuggled gold was seized. Further investigation is on, said Customs sources.


Explore news content, curated to match your pace of life with TheNewFocus
News bulletins - what you need to know, when you need to know. Just click and browse. It's that simple.
Cut through the clutter of endless news updates & discover what matters, when it matters. Read with a new focus.


Add Customer
Please add product
Suspend Sale
Type Reference Note
Print Order
Stisla
Order
C: Walk-in Client
R:
U: admin
T:
Tax (5 or 5%)
Print Bill
Stisla
Bill
C: Walk-in Client
R:
U: admin
T:
| #1 Minion Hi (TOY01) | |
| (1 x 15.00) | 15.00 |
| Total Items | 1 (1) |
| Total | 15.00 |
| Order Tax | 0.75 |
| Grand Total | 15.75 |
| Rounding | 0.00 |
| Total Payable | 15.75 |
| Merchant Copy |
Payment
| Total Items | 1 (1) | Total Payable | 15.75 (0.00) |
| Total Paying | 15.75 | Balance | 0.00 |
Visa
Discount (5 or 5%)
Register Details
(Opened at: )
| Cash in hand: | 500.00 |
| Cash Sales: | 94.50 (94.50) |
| Cheque Sales: | 0.00 (0.00) |
| Gift Card Sales: | 0.00 (0.00) |
| Credit Card Sales: | 0.00 (0.00) |
| Stripe: | 0.00 (0.00) |
| Others: | 0.00 (0.00) |
| Total Sales: | 94.50 (94.50) |
| Expenses: | 0.00 |
| Total Cash: | 594.50 |
Today's Sale
Cash Sales: |
0.00 (0.00) |
Cheque Sales: |
0.00 (0.00) |
Credit Card Sales: |
0.00 (0.00) |
Gift Card Sales: |
0.00 (0.00) |
Stripe: |
0.00 (0.00) |
Others: |
0.00 (0.00) |
Total Sales: |
0.00 (0.00) |


- main(String...) - Static method in class net.co.java.server.Server
-
- main(String[]) - Static method in class net.co.java.tools.AttributeTest
-
- main(String[]) - Static method in class net.co.java.tools.InsertItems
-
- map - Variable in class net.co.java.entity.Location
-
- Map - Enum in net.co.java.server
-
The Map enum contains all Maps for the current Server
Map can be accessed by name (Map.CentralPlain) or id (1002).
- MAttack - Variable in class net.co.java.item.ItemPrototype.EquipmentPrototype
-
- maxAtk - Variable in class net.co.java.item.ItemPrototype.EquipmentPrototype
-
- maxDura - Variable in class net.co.java.item.ItemPrototype
-
- maxLevel() - Method in class net.co.java.skill.Skill
-
- MDef - Variable in class net.co.java.item.ItemPrototype.EquipmentPrototype
-
- MessagePacket - Class in net.co.java.packets
-
This packet is used to send messages to other players and to instruct
the client on what errors to display on login.
- MessagePacket(String, String, String) - Constructor for class net.co.java.packets.MessagePacket
-
Construct a new Message packet with the from, to and message
values already set, and the aRGB, type and chatID set to default
values
- MessagePacket(IncomingPacket) - Constructor for class net.co.java.packets.MessagePacket
-
Construct a new Message packet based on a IncomingPacket
- MessagePacket.MessageType - Enum in net.co.java.packets
-
An enumeration of various Message Types for the MessagePackets
- minAtk - Variable in class net.co.java.item.ItemPrototype.EquipmentPrototype
-
- Mock - Class in net.co.java.model
-
The Mock model is a model using mock data and is mainly for
developing and testing purposes.
- Mock() - Constructor for class net.co.java.model.Mock
-
- mode - Variable in enum net.co.java.packets.InteractPacket.Mode
-
- mode - Variable in enum net.co.java.packets.UpdatePacket.Mode
-
- Model - Interface in net.co.java.model
-
Administrators of this private server should be able to use a database of their own preference,
for instance using MySQL, PostgreSQL, SQLLite, using Java serialization or static mock data.
- Monster - Class in net.co.java.entity
-
- Monster(Location, long, String, int, int, int) - Constructor for class net.co.java.entity.Monster
-


According to one famous study, hiring managers only take an average of six seconds to decide whether to keep or trash your resume. Is it true? We were all very curious about the answer so we created this campaign website.
We got inspired from this game.
I was the main designer of this project, I discussed with the business team and made wireframes to make sure we were all on the same page. Then I made mockups to ensure the look and feel. After we all agreed, we passed it to our developer to make it playable. And finally we launched the game and started to collect data.
With over 9,000 participants and counting, I created an Infographic to show the game results. The Infographic not only tells participants about the game result but also teaches them how to do to improve the resume.
The Director of Marketing on this project told me that this project was a big success because this is what is known as evergreen content, which means it will continue to bring traffic to our website long after the project has ended. This game also got a lot of attention on social media. Search for "6 second challenge” on Google and you will find plenty of links to this game!


TIFF CHANGE INFORMATION
This document describes the changes made to the software between the
previous and current versions (see above).
If you don't find something listed here, then it was not done in this
timeframe, or it was not considered important enough to be mentioned.
The following information is located here:
CHANGES IN THE SOFTWARE CONFIGURATION:
- configure: added test for libc6 for linux targets. Bug reported by
Stanislav Brabec
- configure: fixed bugs in sed scripts
(applied sed script s:/@:s;@:;s:/s;;:;: to configure).
fix submitted by Stanislav Brabec
- tools/iptcutil was not in files list, and wasn't being
added to tar archive. Updated Makefile.in.
- Added 3.5 docs to html/Makefile.in.
Thanks to Stanislav Brabec
- Fixed tools/tiffcmp so that stopondiff testing works.
Patch care of Joseph Orost .
- Added fax3sm_winnt.c to distribution list in Makefile.in.
- Added libtiff/libtiff.def to TIFFILES distribution list.
CHANGES IN LIBTIFF:
- tif_fax3.c: Fixed serious bug introduced during the uint16->uint32
conversion for the run arrays.
- Set td_sampleformat default to SAMPLEFORMAT_UINT instead of
SAMPLEFORMAT_VOID in TIFFDefaultDirectory() in tif_dir.c.
- Added "GetDefaulted" support for TIFFTAG_SAMPLEFORMAT in tif_aux.c.
- Patched tif_fax3.c so that dsp->runs is allocated a bit bigger
to avoid overruns encountered with frle_bug.tif.
- Modified tif_unix.c to support 2-4GB seeks if USE_64BIT_API is
set to 1, and added default (off) setting in tiffconf.h. This
should eventually be set by the configure script somehow.
The original work on all these 2-4GB changes was done by
Peter Smith (psmith@creo.com).
- Modified tif_win32.c to support 2-4GB seeks.
- tentatively changed toff_t to be unsigned instead of signed to
facilitate support for 2-4GB files.
- Updated a variety of files to use toff_t. Fixed some mixups
between toff_t and tsize_t.
- Set tif_rawdatasize to zero when freeing raw data buffer in
TIFFWriteDirectory().
- Enabled "REWRITE_HACK" in tif_write.c by default.
- Fix bug in tif_write.c when switching between reading one directory
and writing to another.
- Made TIFFWriteCheck() public, and added TIFFCreateDirectory()
- Added TIFFmemory(3t) functions to libtiff.def.
- Added libtiff/libtiff.def to TIFFILES distribution list.
CHANGES IN THE TOOLS:
- fax2ps: Fixed mixup of width and height in bounding box statement
as per submission by Nalin Dahyabhai .
- fax2ps: Modified printruns to take uint32 instead of uint16.
Patch courtesy of Bernt Herd
- Largely reimplemented contrib/addtiffo to avoid temp files,
updating the TIFF file in place. Fixed a few other bugs to.
- Altered descriptions in tools to reflect "by default" lzw not supported
CHANGES IN THE LZW COMPRESSION KIT
- created mangle-src.sh -- sed scripts to munge src into LZW enabled format. Thanks to Stanislav Brabec
- created Makefile
- merged tif_dir.c with current source.
- Created lzw compression kit, as a new CVS module (libtiff-lzw-compression-kit).
- Updated index.html to note lzw compression kit.
TIFF home page.
Last updated $Date: 2016-09-25 20:05:45 $.


Vip Section is not Available!
Oops! No Internet Connection
Settings
About
Feedback
Vip Section is not Available!
WinMax Predicts..
1.0001
Feedback
Send
Thanks For the Feedback
Please Complete the form