Ultimate Guitar provides a platform, including a website available at www.ultimate-guitar.com and related mobile applications, which makes available various services, including music-related tools and content (the “Service”). “Ultimate Guitar,” or “we” or “us” refers to Ultimate Guitar USA LLC and the Ultimate Guitar Corporate Family in this Privacy Policy. The Ultimate Guitar Corporate Family means Ultimate Guitar’s subsidiaries, parent companies, joint ventures and other corporate entities under common ownership and/or any of their agents, consultants, employees, officers and directors.
We at Ultimate Guitar respect the privacy concerns of the users of this Service and have created this privacy policy to explain (1) what information we gather from you when you visit our Service, (2) how we may use such information, (3) your choices concerning how we may use such information and (4) the security measures we take to protect such information. Some information is collected on this Service automatically through our technology; other information is collected only when you choose to give it to us (e.g., when you set up an account, register for a contest or sign up for a specific online transaction).
When you visit this Service, certain non-personally identifying information is recorded automatically by the standard operation of our Internet servers. Information such as the type of browser being used, its operating system, and your computer's Internet Protocol ("IP") address (a number that your Internet service provider assigns to your computer whenever you surf the Internet) is gathered in order to facilitate our online operations and to assure an efficient online experience for you. If you access our Service from a mobile or other device, we may collect information for that device (including operating system, browser, type of device) is gathered in order to facilitate our mobile operations and to assure an efficient mobile experience for you. We may use or share this information for security purposes, to generate group statistics about our user community, or as required by law.
If you access our Service on a social network like Facebook, Ultimate Guitar receives certain information about you from the social network automatically. The information we receive depends on the Service, the social network, and your privacy settings and your friends’ privacy settings on that social network.
For example, Ultimate Guitar may collect and store some or all of the following information provided by the social network:
If you access our Service from a social network, you should also read that social network’s Terms of Service and Privacy Policy.
Among the purposes for which we may use such generally non-personally identifying information is for identification purposes in the event of an emergency threatening life or property, or where proper legal process allows using such information. For instance, we may use your IP address or other automatically recorded information, in cooperation with your Internet provider, to attempt to identify you if it is necessary to contact you or to bring legal action against you because you are violating the Terms of Service for use for this Service, may be causing injury to or interference (intentionally or unintentionally) with our company's rights or property, or may be adversely affecting other users of this Service or anyone else who could be harmed by your activities.
We may request personally identifying information from you in a variety of contexts. For example, you may provide such data to us if you: (1) complete an online registration form (e.g., registering for an account, various sign-up forms for receiving email newsletters, registering for special offers, entering a contest/sweepstakes or responding to a survey); (2) fill out an order form to request information; (3) register to participate in message boards and chat rooms (if any) and other community features; or (4) purchase any products or services from us or another Ultimate Guitar business. Additionally, when you ask for help from our Customer Support team, we will collect and store the contact information you give them (generally, your name and e-mail address), information about your activity on our Services, and your user name. We will also store the communications you have with the Customer Service team and any information in those communications in order to provide support.
In such cases, the personally identifying information we request may include your name, email address, mailing address and zip code, phone number, and, where appropriate, a valid credit card number with expiration date (collectively, "Personal Information").  Of course, you never have to answer any of the questions we ask you (nor choose to view or listen to any multimedia content or otherwise interact with our Service), but refusal to do so may limit the products or services we can offer or provide to you.
When you provide Personal Information to us, we may use that data to create a "My Profile" page for you, which will be held in a database using reasonable security measures to protect the data from unauthorized access. Others outside Ultimate-Guitar.com will not be allowed to see the data on your My Profile Page except with your consent (see below). If you register to set up an account, you will be able to access your My Profile page at any time in order to update your individual Personal Information listed therein (see below under "How Can You Correct or Review Your Personal Information?" for more details).
Within Ultimate Guitar
When you purchase products or services from Ultimate Guitar we will use your Personal Information to fulfill your order and for customer service. Many online customers are particularly concerned about their credit card information, which we will share only as required by companies involved in your transaction (e.g., fulfillment, billing, mailing, storage or delivery services). We will not share your credit card information with any other Ultimate Guitar company or third party unless that company needs the number for the fulfillment or delivery of your order. We do not rent, sell or share credit card information with promotional partners or other third parties.
Your Personal Information may be stored on the Ultimate Guitar cloud in order to provide interoperability of the Services among your devices.
Ultimate Guitar keeps track of the websites and pages you visit within the Service, what features and content you use and how frequently. This information may be used by Ultimate Guitar to maintain and improve the content, design, usability, and quality of the Service; to improve your user experience; to generate and provide statistics regarding use of the Service; to deliver customized content and advertising within the Service to users whose behavior indicates that they are interested in a particular subject area, and to develop new products and services.
We may have links to third party-operated sites that sell or license certain music, videos, or other goods mentioned, provided, or promoted on Ultimate Guitar. Unless a Service is within the Ultimate Guitar domain (as generally indicated by a web address beginning with www.Ultimate-Guitar.com), it is not operated or controlled by Ultimate Guitar, and any transactions that you may enter into with such sites will be subject to the privacy and security practices of the merchant with which you are transacting. Ultimate Guitar and Ultimate Guitar are not responsible for the privacy and security practices of sites not in our immediate control.
We may use your Personal Information and other non-personally identifying information we collect to update you about our products or services or to contact you about exciting offers of new products or services that we believe may be of interest to you. You always have the option to receive fewer or no communications in the future from us by opting out. You may opt out by following the instructions included in the specific communication you no longer wish to receive or by sending an email to<EMAIL_ADDRESS>and explaining how you would like to modify your preferences.
With Other Ultimate Guitar-Related Companies
When you give Personal Information to Ultimate Guitar, we may share that data (together with non-personally identifying information you may provide) with other Ultimate Guitar related companies. As a result of this sharing, you may receive communications from other Ultimate Guitar related companies that include offers of products or services tailored to your interests. These communications might include, for example, emails or mailed literature about new products or services, promotions, discounts, sales, openings of new facilities or websites or other similar information.
You have the option to receive fewer or no communications in the future from other Ultimate Guitar-related companies that we may provide your information to by following the instructions included in the specific communication you no longer wish to receive, or by sending an email to<EMAIL_ADDRESS>and explaining how you would like to modify your preferences.
Finally, without any specific approval from you, we may develop general aggregate data (i.e., data that cannot be used to identify specific individuals) about our user community that is partly based on information about you and your transactions with Ultimate Guitar. For example, hypothetically, you might be one of 1,000,000 customers between the ages of 25 and 35. We may share such aggregate statistics with other Ultimate Guitar-related companies without your consent.
Contest Sponsors
When you give Personal Information to Ultimate Guitar in connection with a contest, we may share that data (together with non-personally identifying information you may provide) with the sponsor or sponsors of such contest. By entering a contest, you are allowing such sponsor or sponsors to use such Personal Information and to contact you in connection with the contest and in accordance with their own privacy policies.
Outside Ultimate Guitar
When you give Personal Information to Ultimate Guitar, we may ask you to allow us to share that data (together with non-personally identifying information you may provide) with our promotional partners and third-party advertisers. In such instances, our general practice is to ask you to "opt-in" to share such data and information on, for example, a specific promotion, registration page or sweepstakes. However, in some instances, we may ask you to "opt-out" from sharing such data and information with a given promotional partner or third party advertiser in connection with a specific promotion, registration page or sweepstakes. If you prefer, you may give us blanket permission to share your Personal Information with all of our promotional partners and third-party advertisers. Conversely, you may also choose not to allow us to share your Personal Information with any other companies outside Ultimate Guitar.
If you consent to share your Personal Information with our promotional partners and third-party advertisers, you are allowing such parties to use such Personal Information and to contact you in accordance with their own privacy policies. You have the option to change your mind and to stop us from further sharing your Personal Information with our promotional partners and third-party advertisers by contacting<EMAIL_ADDRESS>and explaining how you would like to modify your preferences. We will not retrieve any Personal Information shared with our promotional partners and third-party advertisers prior to your decision to opt-out. If you wish to limit or discontinue receiving further communications from a promotional partner or third-party advertiser, please contact that company directly in the manner indicated in its own communications with you.
Without any specific approval from you, Ultimate Guitar may develop general aggregate data (i.e., data that cannot be used to identify specific individuals) about you that is partly based on information about you and your transactions us. We may share such aggregate statistics with promotional partners and third-party advertisers without your consent.
Finally, we may use your Personal Information in connection with third-party advertisers who serve ads to you while visiting an Ultimate Guitar Service. These third-party advertisers may use your Personal Information (not including any personally identifying information you may provide) in order to generate advertisements about goods and services that may be of interest to you. If you would like to know more about this practice and to obtain information about how third-party advertisers use your Personal Information to select advertisements please click here.
Service Providers
We may employ third party companies to provide customer support, perform Website-related services (e.g., without limitation, maintenance services, database management, web analytics and improvement of the Website's features) or to assist us in analyzing how our Service is used. These third parties may have access to your personal information to the extent required to perform these tasks on our behalf and are obligated not to disclose or use it for any other purpose.
For Legal Enforcement Purposes
We reserve the right to disclose your Personal Information, including credit card information, as required by law or in special cases when we have reason to believe that disclosing this information is necessary to identify, contact or bring legal action against you if you are violating the Terms of Service for this Service or may be causing injury to or interference (intentionally or unintentionally) with our company's rights or property, other users of this Service or anyone else who could be harmed by your activities. Additionally, Ultimate Guitar cooperates with government and law enforcement officials and private parties to enforce and comply with the law. We will disclose any information about you to government or law enforcement officials or private parties as we, in our sole discretion, believe necessary or appropriate to respond to claims and legal process (including but not limited to subpoenas), to protect the property and rights of Ultimate Guitar or a third party, to protect the safety of the public or any person, or to prevent or stop activity we may consider to be, or to pose a risk of being, an illegal, unethical or legally actionable activity.
As an Asset of Ultimate Guitar
We thank you for entrusting us with your Personal Information, and also should inform you that for business purposes, the information that you provide and that we collect through your usage of the service is also an asset of Ultimate Guitar and will become part of our normal business records. If Ultimate Guitar or a substantial part of our business is sold or otherwise transferred to a third party, such as a legal successor in interest, your Personal Information may be transferred to that third party.
You can access, review, update and correct Personal Information you have provided us by clicking on the My Profile tab at the top of this page. If you prefer, you can also contact us by sending an email to<EMAIL_ADDRESS>and explaining how you would like to modify your preferences.
Ultimate Guitar cares about the security of your Personal Information. We follow generally accepted industry security standards to safeguard and help prevent unauthorized access, maintain data security and correctly use such Personal Information. When you provide credit card information, we use secure socket layer (SSL) encryption for that data.
Despite many advances in information security technology and procedures, however, no commercially deployed method of information transfer over the Internet or electronic data storage is known to be 100% secure. As a result, while we do strive to use modern and commercially reasonable means to protect your Personal Information, we cannot guarantee the absolute security of that information during its transmission or its storage in our systems.
We are a general audience Service that does not knowingly collect data or accept registrations from children under 13 years of age. Currently, we do not collect any age-specific data on our Service. If, in the future, we decide to collect any age-specific data on our Service, we will, at a minimum, take reasonable steps to ensure that any users who may be under 13 years of age (and who attempt to complete the registration process on our Service) are directed to another Service within the Ultimate Guitar family which specifically complies with the requirements of the Children's Online Privacy Protection Act, or COPPA.
IMPORTANT: When you use our Services, your data may be sent to the United States and possibly other countries.
As part of our international operations, we may transfer data to the Ultimate Guitar Corporate Family from time to time for our legitimate business purposes. We may store information about users and visitors to our Service on servers located in the United States, and we may also store this information on servers and equipment in other countries. Personal Information collected within Switzerland and the European Economic Area (“EEA”) may be transferred to, and stored at, a destination outside of Switzerland and the EEA. The Personal Information we hold may also be processed by employees operating outside of Switzerland and the EEA who work for us or the Ultimate Guitar Corporate Family or for one of our vendors. This staff may be engaged in, among other things, (i) the processing of transactions and your payment details and (ii) the provision of support services. When we transfer your Personal Information internationally we will take reasonable steps to ensure that your personal information is treated securely, lawfully and in the manner we describe here. Please note that laws vary from jurisdiction to jurisdiction, and so the privacy laws applicable to the places where your Personal Information is transferred to or stored, used or processed in, may be different from the privacy laws applicable to the place where you are resident.
A "cookie" is a small text file that an Internet Service can place on your computer's hard drive for record-keeping purposes. Cookies make using this Service easier by, among other things, saving your passwords and preferences for you, keeping track of your shopping cart when you visit an online store or other similar purposes, and to help identify you whenever you return to our Service, so you do not need to reenter your identification information. Most Internet browsers are initially set up to accept cookies. However, you can reset your browser to refuse all cookies or to alert you when a cookie is being sent (note: you may need to consult your browser's "Help" area for instructions on how to do that). If you choose to disable your cookies setting or refuse to accept a cookie, some parts of this Service will not function properly or may perform considerably slower. For example, without cookies, you will not be able to set personalized preferences or you may have difficulty downloading tablatures, watching videos or utilizing the Community Forums. Some of our web pages may contain electronic images (called "Clear GIFs", "Single-Pixel GIFs", or "Web Beacons") that allow us to count page views or to access cookies. In general, any electronic image viewed as part of a web page, including an ad banner, can act as a Clear GIF. Typically, though, Clear GIFs are very small (1-by-1 pixel size) files. They are often invisible on a web page, but their presence can be detected within many Internet browsers by setting your browser to view web page "sources". Clear GIFs are so small in order not to use valuable space on the computer screen that is better used to display helpful content. We may also include Clear GIFs in our email products in order to determine information about the opening and reading of such emails. In addition, some advertising networks that serve ads on our web Service may occasionally use Clear GIFs within banner advertisements. Clear GIFs set by Ultimate Guitar generally are not used to collect, gather, monitor, or share personal information about our users, though they can be used in conjunction with cookies to record particular actions. We use Clear GIFs primarily to compile aggregated, anonymous statistics about web Service or email product usage.
Some of the advertisements and other services that appear on our web Service(s) are delivered to you by Internet advertising companies. These companies utilize certain technologies including cookies to deliver advertisements and marketing messages and to collect anonymous information about your visit to our sites and other web sites. If you would like more information about this practice or to opt out of having this information used by companies that are part of the Network Advertising Initiative to provide targeted ads, please visit http://www.networkadvertising.org.
If you visit a message board, chat room or utilize an instant messaging service on this Service, if any, you are solely responsible for the content of messages you post there. You should be aware that when you voluntarily disclose Personal Information (for example, your name, street address, email address, or telephone number) on message boards, chat rooms or instant messaging services, that information can be read, collected and used by other users of these services and may result in unsolicited messages, both commercial and otherwise. You agree that by participating in such online public forums, you will not use such forums for any purpose that is unlawful or prohibited by the Ultimate Guitar community guidelines that may be in effect from time to time in connection with such service. We reserve the right to terminate your access to this Service or to take other protective steps if you violate those terms.
We do not endorse and are not responsible for the content or practices of web sites operated by companies outside of Ultimate Guitar that may be linked to this Service. You should not assume that their privacy policies or practices are the same as those followed by our company or by other Ultimate Guitar companies. Visitors to any such web sites should refer to their respective privacy policies and practices.
If you have any questions or complaints about our Privacy Policy, you can contact our customer service department at<EMAIL_ADDRESS>When we receive such inquiries about our Privacy Policy, we will use the Personal Information (such as your email address) only to respond to your question or comment. However, if your question raises one or more issues that affect our promotional partners, we may also share your question with them in order to provide a response.
We reserve the right to modify, alter or otherwise update this Privacy Policy at any time, so we encourage you to review this Privacy Policy from time to time. When we make changes that we consider material in our privacy practices, we will notify you in this space. We may also attempt to notify you of any such material changes to our privacy practices via email or by placing a notice on our home page.
By using this Service, you consent to the collection and use of your Personal Information by Ultimate Guitar in accordance with this Privacy Policy.


{% extends "layout.html" %} {% block body %} {% if session.logged_in %}
{{ pool.address }}, {{ pool.city }} {{ pool.zip_code}}
{{ pool.neighborhood }}
Sorry, there are no pools listed.


Project
"PFIZER01 - PFIZER EMPLOYEE SERVICE CENTER" >** PFIZER01 - PFIZER EMPLOYEE SERVICE CENTER **
Client


#include <visitor.hpp>
Public Member Functions | |
| virtual void | visit (QtArgCmdLineContext &)=0 |
| Process with visitor. |
Visitors are usefull for handling "non-standard" situations with argument's values.
For example if you want to have argument with two ore more (list) of values. Here visitors are very suitable. But for this task you have to derive subclass from QtArg or whatever derived from this one.
Look at the example:
class MyArg; // Exception while processing argument with two values. class MyArgException : public QtArgBaseException { public: explicit MyArgException( const QString & desc ) : QtArgBaseException( desc ) { } }; // class MyArgException // Visitor for argument with two values. class MyVisitor : public QtArgVisitorIface { public: MyVisitor() : m_arg( 0 ) { } // Set parent argument. void setArg( MyArg * arg ) { m_arg = arg; } // Process with visitor. void visit( QtArgCmdLineContext & context ) { if( !m_arg ) throw MyArgException( QLatin1String( "Argument wasn't defined." ) ); if( !context.atEnd() ) m_arg->setSecondValue( context.next() ); else throw MyArgException( QLatin1String( "There is no second value " "for the MyArg argument." ) ); } private: // Parent argument. MyArg * m_arg; }; // class MyVisitor // Argument with two values. class MyArg : public QtArg { public: MyArg() : QtArg( QLatin1Char( 'a' ), QLatin1String( "arg" ), QLatin1String( "This is our argument with two required values" ), true, true ) { m_visitor.setArg( this ); setVisitor( &m_visitor ); } // Set second value. void setSecondValue( const QVariant & val ) { m_secondValue = val; } // Second value. const QVariant & secondValue() const { return m_secondValue; } private: // Visitor. MyVisitor m_visitor; // Second value. QVariant m_secondValue; }; // class MyArg
In this example argument [-a, --arg] require two values. It's mean if after [--agr] argument will only one value than exception MyArgException will thrown.
For example: [-a value1 value2] is correct, when [-a value1] is incorrect.
| virtual void QtArgVisitorIface::visit | ( | QtArgCmdLineContext & | ) | [pure virtual] |
Process with visitor.
In this method visitor should process with command line context in that way that developer need.
Use QtArgCmdLineContext::next() method to get next string in the command line. But first of all you need to check if there is strings available in the command line with QtArgCmdLineContext::atEnd() method.
Command line context passed as argument to this method.


---
layout: post
title: Origins of Days and Oracle's DATE
date: '2006-10-11T11:09:00.000-05:00'
author: Don Seiler
tags:
- date
- history
- oracle
modified_time: '2010-11-19T22:48:48.605-06:00'
blogger_id: tag:blogger.com,1999:blog-7032512792942232766.post-9155264115814722795
blogger_orig_url: http://www.seiler.us/2006/10/origins-of-days-and-oracle-date.html
---
I recently had a bit of a problem with an Oracle DATE value. En route to finding out more about it, HJR linked to an earlier article he wrote. Very fun stuff.


intervention obesity physical children study school activity {border-style overweight px;} #ffffff;} childhood schools body project data family years activities Health design POIBA education prevalence variables based intervention. main year Salut booster diet disadvantaged families skinfold Barcelona food health healthy information pupils schoolchildren time Agència Pública consists eating preventive px; related {font-family BMI activity, aged fat font-size increase interventions level prevention questionnaires sample sessions triceps use POIBA-How Project SES Study carried classroom determinants developed double; group habits hours immigrant multilevel obesity. participate primary programme public screen size taken Barcelona. Childhood Data European Rev [], according age aims border-color border-width collab: collected focuses implemented indicator measurement model possible practice school-based social solid; tests thickness used weight {font-style {font-weight (POIBA Additionally, Group Obes achieve adapted addressed adult analysis bold calculated children. composed courier; designed duration effects em; factors fitness following independent intervention, mass measured measurements multicomponent neighbourhoods obese old). population pt;} randomly rate school. session setting sleep study, study.


This is the adorable penguin Chilli, Coming from the coldest rock in the Atlantic Ocean. He wages war on others for his precious soup.
Meet Vector, a dasterdly little raccoon that causes more trouble than he's worth. With the help of his quick witt and some really good luck, he trys to take the world's soup.


Seeing this when logging in is usually a sign the servers are down right now.
You can usually tell servers are offline with an explicit message along the lines of 'we are working to resolve the issue', alongside a specific piece of cute Pokémon Go art work.
If you see this, chances are you'll have to return in a little while to play.
If you want to be sure that the servers are currently down, there's also a few days of knowing outside of the game too; the game's official Twitter account will report on any significant outages, while a fan-run Pokémon Go server status website uses crowdsourced feedback to determine whether the server is experiencing major issues.
There are also other error messages that you might see. When logging in, you might be told you have 'Failed to get game data from the server' or 'Failed to log in'. This likely means that while the server isn't down completely, it is currently busy, so tap the Retry button and give it another go.
If you see this, then the server might still be up - just busy.
Meanwhile, mid-game a red band can appear at the top of the screen with a message such as 'GPS signal not found', 'Internet connection not found' and 'Error'. These suggest the issue is client side - so your phone is causing a possible issue - and so it's worth checking the strength of your phone's connection and moving location to see if that resolves the issue. Servers might also have some impact in these cases too, and waiting a moment usually helps clear these issues up.
It's also worth noting that though connecting to Wi-Fi can provide a stronger signal when playing, if you are walking past shops, pubs and other places you have access to, the constant logging in and out of different hotspots may cause some confusion for the app, so it could be worth relying on phone data only if you are on the move.
A common issue is the app will freeze when you throw a Pokéball at creature. In the period when the creature entering the ball for the first time, the ball shaking and before the 'Gotcha' message appears, the app can stop responding, even enough the loading icon will rotate in the corner and some on-screen graphics will continue to move.
Check your journal after the app crashes to see if you caught the creature after all.
First, wait a few seconds to see if the app will respond. If it doesn't progress to the 'Gotcha!' phrase, then the app has likely frozen.
However, not all is lost. If you quit the game and reload it (make sure it's properly closed, and not just minimised) then check your journal (tap the Trainer icon in the lower level corner, then the Journal button underneath the XP bar) you'll see a list of recent activities, from PokéStop interactions to Pokémon captured. Here you'll be able to see whether the creature you just captured is indeed yours or not; in our experience there's about a 50/50 chance it picks up on the capture after a crash, so it's worth a check to see if it made it through!


--- layout: default title: Export your deals meta_description: Export your car deals to json current: home ---


Host defense mechanisms triggered by microbial lipoproteins through toll-like receptors.
Abstract
The generation of cell-mediated immunity against many infectious pathogens involves the production of interleukin-12 (IL-12), a key signal of the innate immune system. Yet, for many pathogens, the molecules that induce IL-12 production by macrophages and the mechanisms by which they do so remain undefined. Here it is shown that microbial lipoproteins are potent stimulators of IL-12 production by human macrophages, and that induction is mediated by Toll-like receptors (TLRs). Several lipoproteins stimulated TLR-dependent transcription of inducible nitric oxide synthase and the production of nitric oxide, a powerful microbicidal pathway. Activation of TLRs by microbial lipoproteins may initiate innate defense mechanisms against infectious pathogens.


Wacky Cake
This cake recipe is one of my parlor tricks.  It uses very basic ingredients that you probably already have in your kitchen, and you will surprise all your guests, vegan or not. I've had lots of people tell me it was the best chocolate cake they've ever had. It's moist and light. You'll love it.
I first learned about this recipe from my mother. She was hunting around in her old recipes for vegan ones and found this gem, a callback to her college years. She learned it from her mother, who learned it from her mother, all the way back. Turtles all the way down. It is believed that this cake evolved during World War II when milk and eggs were being rationed.
The quantities of ingredients listed below is for a 9" x 13" pan. You can cut everything in half for an 8" round pan.
Dry Ingredients
- 3 Cups of Flour
- 2 Cups of Sugar
- 1/2 Cup of Cocoa
- 2 Teaspoon of Baking Soda
- 1 Teaspoon of Salt
Wet Ingredients
- 2 Tablespoon of Vinegar
- 2/3 Cup of Vegetable Oil
- 2 Teaspoon of Vanilla
- 2 Cup of Cold Water
Instructions
- Sift all of the dry ingredients together into the pan that you will be baking the cake in.
- Make three wells in the sifted ingredients and then pour the vinegar, oil, and vanilla into the wells.
- Pour the water over the entire thing and whisk well.
- Bake at 350 degrees for about 30 minutes… until a toothpick comes out clean.


[1]
everything else is absolutely terrible and if the hotel internet was open.
[2]
everything else is absolutely terrible and if the receipt at me after i 'd paid.


| Package | Description |
|---|---|
| sg.edu.cs2103aug2015_w13_2j | |
| sg.edu.cs2103aug2015_w13_2j.commands |
| Modifier and Type | Method and Description |
|---|---|
java.util.HashMap<java.lang.String,CommandHandler> |
LogicInterface.getCommandHandlers()
Retrieves the
HashMap of reserved keyword strings to their
respective CommandHandler objects. |
java.util.HashMap<java.lang.String,CommandHandler> |
Logic.getCommandHandlers() |
| Modifier and Type | Method and Description |
|---|---|
void |
LogicInterface.registerCommandHandler(CommandHandler handler)
Registers the provided
CommandHandler object with this
LogicInterface component. |
void |
Logic.registerCommandHandler(CommandHandler handler) |
| Modifier and Type | Class and Description |
|---|---|
class |
AddHandler
|
class |
DeleteHandler
CommandHandler which handles deleting one or more Task
objects from the master list of Task objects. |
class |
EditHandler
CommandHandler which handles editing the details of a Task
object in the master list of Task objects. |
class |
FilterHandler
CommandHandler which handles filtering Task objects to obtain
a subset of Task objects with specific properties. |
class |
HelpHandler
CommandHandler which handles showing the FunDUE Help Page to the
user. |
class |
LoadHandler
CommandHandler which handles showing a file picker dialog to change
the FunDUE Data File. |
class |
MarkCompletedHandler
Marks a Task indicated by the user as "Completed" or "Uncompleted".
|
class |
MarkImportantHandler
Toggles a Task specified by the user as "Important" or "Unimportant".
|
class |
PopHandler
Pops or removes a filter already specified by the user.
|
class |
RedoHandler
Redoes a command previously undone using the "Undo" command by the user.
|
class |
SearchHandler
CommandHandler which handles searching for Task objects
containing one or more specified search terms. |
class |
UndoHandler
Undoes a command made by the user.
|


'use strict';
exports.__esModule = true;
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _core = require('../core');
var core = _interopRequireWildcard(_core);
var _InteractionData = require('./InteractionData');
var _InteractionData2 = _interopRequireDefault(_InteractionData);
var _InteractionEvent = require('./InteractionEvent');
var _InteractionEvent2 = _interopRequireDefault(_InteractionEvent);
var _InteractionTrackingData = require('./InteractionTrackingData');
var _InteractionTrackingData2 = _interopRequireDefault(_InteractionTrackingData);
var _eventemitter = require('eventemitter3');
var _eventemitter2 = _interopRequireDefault(_eventemitter);
var _interactiveTarget = require('./interactiveTarget');
var _interactiveTarget2 = _interopRequireDefault(_interactiveTarget);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
// Mix interactiveTarget into core.DisplayObject.prototype, after deprecation has been handled
core.utils.mixins.delayMixin(core.DisplayObject.prototype, _interactiveTarget2.default);
var MOUSE_POINTER_ID = 'MOUSE';
// helpers for hitTest() - only used inside hitTest()
var hitTestEvent = {
target: null,
data: {
global: null
}
};
/**
* The interaction manager deals with mouse, touch and pointer events. Any DisplayObject can be interactive
* if its interactive parameter is set to true
* This manager also supports multitouch.
*
* An instance of this class is automatically created by default, and can be found at renderer.plugins.interaction
*
* @class
* @extends EventEmitter
* @memberof PIXI.interaction
*/
var InteractionManager = function (_EventEmitter) {
_inherits(InteractionManager, _EventEmitter);
/**
* @param {PIXI.CanvasRenderer|PIXI.WebGLRenderer} renderer - A reference to the current renderer
* @param {object} [options] - The options for the manager.
* @param {boolean} [options.autoPreventDefault=true] - Should the manager automatically prevent default browser actions.
* @param {number} [options.interactionFrequency=10] - Frequency increases the interaction events will be checked.
*/
function InteractionManager(renderer, options) {
_classCallCheck(this, InteractionManager);
var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
options = options || {};
/**
* The renderer this interaction manager works for.
*
* @member {PIXI.SystemRenderer}
*/
_this.renderer = renderer;
/**
* Should default browser actions automatically be prevented.
* Does not apply to pointer events for backwards compatibility
* preventDefault on pointer events stops mouse events from firing
* Thus, for every pointer event, there will always be either a mouse of touch event alongside it.
*
* @member {boolean}
* @default true
*/
_this.autoPreventDefault = options.autoPreventDefault !== undefined ? options.autoPreventDefault : true;
/**
* Frequency in milliseconds that the mousemove, moveover & mouseout interaction events will be checked.
*
* @member {number}
* @default 10
*/
_this.interactionFrequency = options.interactionFrequency || 10;
/**
* The mouse data
*
* @member {PIXI.interaction.InteractionData}
*/
_this.mouse = new _InteractionData2.default();
_this.mouse.identifier = MOUSE_POINTER_ID;
// setting the mouse to start off far off screen will mean that mouse over does
// not get called before we even move the mouse.
_this.mouse.global.set(-999999);
/**
* Actively tracked InteractionData
*
* @private
* @member {Object.<number,PIXI.interation.InteractionData>}
*/
_this.activeInteractionData = {};
_this.activeInteractionData[MOUSE_POINTER_ID] = _this.mouse;
/**
* Pool of unused InteractionData
*
* @private
* @member {PIXI.interation.InteractionData[]}
*/
_this.interactionDataPool = [];
/**
* An event data object to handle all the event tracking/dispatching
*
* @member {object}
*/
_this.eventData = new _InteractionEvent2.default();
/**
* The DOM element to bind to.
*
* @private
* @member {HTMLElement}
*/
_this.interactionDOMElement = null;
/**
* This property determines if mousemove and touchmove events are fired only when the cursor
* is over the object.
* Setting to true will make things work more in line with how the DOM verison works.
* Setting to false can make things easier for things like dragging
* It is currently set to false as this is how PixiJS used to work. This will be set to true in
* future versions of pixi.
*
* @member {boolean}
* @default false
*/
_this.moveWhenInside = false;
/**
* Have events been attached to the dom element?
*
* @private
* @member {boolean}
*/
_this.eventsAdded = false;
/**
* Is the mouse hovering over the renderer?
*
* @private
* @member {boolean}
*/
_this.mouseOverRenderer = false;
/**
* Does the device support touch events
* https://www.w3.org/TR/touch-events/
*
* @readonly
* @member {boolean}
*/
_this.supportsTouchEvents = 'ontouchstart' in window;
/**
* Does the device support pointer events
* https://www.w3.org/Submission/pointer-events/
*
* @readonly
* @member {boolean}
*/
_this.supportsPointerEvents = !!window.PointerEvent;
// this will make it so that you don't have to call bind all the time
/**
* @private
* @member {Function}
*/
_this.onPointerUp = _this.onPointerUp.bind(_this);
_this.processPointerUp = _this.processPointerUp.bind(_this);
/**
* @private
* @member {Function}
*/
_this.onPointerCancel = _this.onPointerCancel.bind(_this);
_this.processPointerCancel = _this.processPointerCancel.bind(_this);
/**
* @private
* @member {Function}
*/
_this.onPointerDown = _this.onPointerDown.bind(_this);
_this.processPointerDown = _this.processPointerDown.bind(_this);
/**
* @private
* @member {Function}
*/
_this.onPointerMove = _this.onPointerMove.bind(_this);
_this.processPointerMove = _this.processPointerMove.bind(_this);
/**
* @private
* @member {Function}
*/
_this.onPointerOut = _this.onPointerOut.bind(_this);
_this.processPointerOverOut = _this.processPointerOverOut.bind(_this);
/**
* @private
* @member {Function}
*/
_this.onPointerOver = _this.onPointerOver.bind(_this);
/**
* Dictionary of how different cursor modes are handled. Strings are handled as CSS cursor
* values, objects are handled as dictionaries of CSS values for interactionDOMElement,
* and functions are called instead of changing the CSS.
* Default CSS cursor values are provided for 'default' and 'pointer' modes.
* @member {Object.<string, (string|Function|Object.<string, string>)>}
*/
_this.cursorStyles = {
default: 'inherit',
pointer: 'pointer'
};
/**
* The mode of the cursor that is being used.
* The value of this is a key from the cursorStyles dictionary.
*
* @member {string}
*/
_this.currentCursorMode = null;
/**
* Internal cached let.
*
* @private
* @member {string}
*/
_this.cursor = null;
/**
* Internal cached let.
*
* @private
* @member {PIXI.Point}
*/
_this._tempPoint = new core.Point();
/**
* The current resolution / device pixel ratio.
*
* @member {number}
* @default 1
*/
_this.resolution = 1;
_this.setTargetElement(_this.renderer.view, _this.renderer.resolution);
/**
* Fired when a pointer device button (usually a mouse left-button) is pressed on the display
* object.
*
* @event PIXI.interaction.InteractionManager#mousedown
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is pressed
* on the display object.
*
* @event PIXI.interaction.InteractionManager#rightdown
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button (usually a mouse left-button) is released over the display
* object.
*
* @event PIXI.interaction.InteractionManager#mouseup
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is released
* over the display object.
*
* @event PIXI.interaction.InteractionManager#rightup
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button (usually a mouse left-button) is pressed and released on
* the display object.
*
* @event PIXI.interaction.InteractionManager#click
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is pressed
* and released on the display object.
*
* @event PIXI.interaction.InteractionManager#rightclick
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button (usually a mouse left-button) is released outside the
* display object that initially registered a
* [mousedown]{@link PIXI.interaction.InteractionManager#event:mousedown}.
*
* @event PIXI.interaction.InteractionManager#mouseupoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is released
* outside the display object that initially registered a
* [rightdown]{@link PIXI.interaction.InteractionManager#event:rightdown}.
*
* @event PIXI.interaction.InteractionManager#rightupoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device (usually a mouse) is moved while over the display object
*
* @event PIXI.interaction.InteractionManager#mousemove
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device (usually a mouse) is moved onto the display object
*
* @event PIXI.interaction.InteractionManager#mouseover
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device (usually a mouse) is moved off the display object
*
* @event PIXI.interaction.InteractionManager#mouseout
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is pressed on the display object.
*
* @event PIXI.interaction.InteractionManager#pointerdown
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is released over the display object.
*
* @event PIXI.interaction.InteractionManager#pointerup
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when the operating system cancels a pointer event
*
* @event PIXI.interaction.InteractionManager#pointercancel
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is pressed and released on the display object.
*
* @event PIXI.interaction.InteractionManager#pointertap
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is released outside the display object that initially
* registered a [pointerdown]{@link PIXI.interaction.InteractionManager#event:pointerdown}.
*
* @event PIXI.interaction.InteractionManager#pointerupoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device is moved while over the display object
*
* @event PIXI.interaction.InteractionManager#pointermove
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device is moved onto the display object
*
* @event PIXI.interaction.InteractionManager#pointerover
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device is moved off the display object
*
* @event PIXI.interaction.InteractionManager#pointerout
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is placed on the display object.
*
* @event PIXI.interaction.InteractionManager#touchstart
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is removed from the display object.
*
* @event PIXI.interaction.InteractionManager#touchend
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when the operating system cancels a touch
*
* @event PIXI.interaction.InteractionManager#touchcancel
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is placed and removed from the display object.
*
* @event PIXI.interaction.InteractionManager#tap
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is removed outside of the display object that initially
* registered a [touchstart]{@link PIXI.interaction.InteractionManager#event:touchstart}.
*
* @event PIXI.interaction.InteractionManager#touchendoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is moved along the display object.
*
* @event PIXI.interaction.InteractionManager#touchmove
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button (usually a mouse left-button) is pressed on the display.
* object. DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#mousedown
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is pressed
* on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#rightdown
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button (usually a mouse left-button) is released over the display
* object. DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#mouseup
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is released
* over the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#rightup
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button (usually a mouse left-button) is pressed and released on
* the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#click
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is pressed
* and released on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#rightclick
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button (usually a mouse left-button) is released outside the
* display object that initially registered a
* [mousedown]{@link PIXI.DisplayObject#event:mousedown}.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#mouseupoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device secondary button (usually a mouse right-button) is released
* outside the display object that initially registered a
* [rightdown]{@link PIXI.DisplayObject#event:rightdown}.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#rightupoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device (usually a mouse) is moved while over the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#mousemove
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device (usually a mouse) is moved onto the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#mouseover
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device (usually a mouse) is moved off the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#mouseout
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is pressed on the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointerdown
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is released over the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointerup
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when the operating system cancels a pointer event.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointercancel
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is pressed and released on the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointertap
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device button is released outside the display object that initially
* registered a [pointerdown]{@link PIXI.DisplayObject#event:pointerdown}.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointerupoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device is moved while over the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointermove
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device is moved onto the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointerover
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a pointer device is moved off the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#pointerout
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is placed on the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#touchstart
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is removed from the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#touchend
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when the operating system cancels a touch.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#touchcancel
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is placed and removed from the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#tap
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is removed outside of the display object that initially
* registered a [touchstart]{@link PIXI.DisplayObject#event:touchstart}.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#touchendoutside
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
/**
* Fired when a touch point is moved along the display object.
* DisplayObject's `interactive` property must be set to `true` to fire event.
*
* @event PIXI.DisplayObject#touchmove
* @param {PIXI.interaction.InteractionEvent} event - Interaction event
*/
return _this;
}
/**
* Hit tests a point against the display tree, returning the first interactive object that is hit.
*
* @param {PIXI.Point} globalPoint - A point to hit test with, in global space.
* @param {PIXI.Container} [root] - The root display object to start from. If omitted, defaults
* to the last rendered root of the associated renderer.
* @return {PIXI.DisplayObject} The hit display object, if any.
*/
InteractionManager.prototype.hitTest = function hitTest(globalPoint, root) {
// clear the target for our hit test
hitTestEvent.target = null;
// assign the global point
hitTestEvent.data.global = globalPoint;
// ensure safety of the root
if (!root) {
root = this.renderer._lastObjectRendered;
}
// run the hit test
this.processInteractive(hitTestEvent, root, null, true);
// return our found object - it'll be null if we didn't hit anything
return hitTestEvent.target;
};
/**
* Sets the DOM element which will receive mouse/touch events. This is useful for when you have
* other DOM elements on top of the renderers Canvas element. With this you'll be bale to deletegate
* another DOM element to receive those events.
*
* @param {HTMLCanvasElement} element - the DOM element which will receive mouse and touch events.
* @param {number} [resolution=1] - The resolution / device pixel ratio of the new element (relative to the canvas).
*/
InteractionManager.prototype.setTargetElement = function setTargetElement(element) {
var resolution = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
this.removeEvents();
this.interactionDOMElement = element;
this.resolution = resolution;
this.addEvents();
};
/**
* Registers all the DOM events
*
* @private
*/
InteractionManager.prototype.addEvents = function addEvents() {
if (!this.interactionDOMElement) {
return;
}
core.ticker.shared.add(this.update, this, core.UPDATE_PRIORITY.INTERACTION);
if (window.navigator.msPointerEnabled) {
this.interactionDOMElement.style['-ms-content-zooming'] = 'none';
this.interactionDOMElement.style['-ms-touch-action'] = 'none';
} else if (this.supportsPointerEvents) {
this.interactionDOMElement.style['touch-action'] = 'none';
}
/**
* These events are added first, so that if pointer events are normalised, they are fired
* in the same order as non-normalised events. ie. pointer event 1st, mouse / touch 2nd
*/
if (this.supportsPointerEvents) {
window.document.addEventListener('pointermove', this.onPointerMove, true);
this.interactionDOMElement.addEventListener('pointerdown', this.onPointerDown, true);
// pointerout is fired in addition to pointerup (for touch events) and pointercancel
// we already handle those, so for the purposes of what we do in onPointerOut, we only
// care about the pointerleave event
this.interactionDOMElement.addEventListener('pointerleave', this.onPointerOut, true);
this.interactionDOMElement.addEventListener('pointerover', this.onPointerOver, true);
window.addEventListener('pointercancel', this.onPointerCancel, true);
window.addEventListener('pointerup', this.onPointerUp, true);
} else {
window.document.addEventListener('mousemove', this.onPointerMove, true);
this.interactionDOMElement.addEventListener('mousedown', this.onPointerDown, true);
this.interactionDOMElement.addEventListener('mouseout', this.onPointerOut, true);
this.interactionDOMElement.addEventListener('mouseover', this.onPointerOver, true);
window.addEventListener('mouseup', this.onPointerUp, true);
}
// always look directly for touch events so that we can provide original data
// In a future version we should change this to being just a fallback and rely solely on
// PointerEvents whenever available
if (this.supportsTouchEvents) {
this.interactionDOMElement.addEventListener('touchstart', this.onPointerDown, true);
this.interactionDOMElement.addEventListener('touchcancel', this.onPointerCancel, true);
this.interactionDOMElement.addEventListener('touchend', this.onPointerUp, true);
this.interactionDOMElement.addEventListener('touchmove', this.onPointerMove, true);
}
this.eventsAdded = true;
};
/**
* Removes all the DOM events that were previously registered
*
* @private
*/
InteractionManager.prototype.removeEvents = function removeEvents() {
if (!this.interactionDOMElement) {
return;
}
core.ticker.shared.remove(this.update, this);
if (window.navigator.msPointerEnabled) {
this.interactionDOMElement.style['-ms-content-zooming'] = '';
this.interactionDOMElement.style['-ms-touch-action'] = '';
} else if (this.supportsPointerEvents) {
this.interactionDOMElement.style['touch-action'] = '';
}
if (this.supportsPointerEvents) {
window.document.removeEventListener('pointermove', this.onPointerMove, true);
this.interactionDOMElement.removeEventListener('pointerdown', this.onPointerDown, true);
this.interactionDOMElement.removeEventListener('pointerleave', this.onPointerOut, true);
this.interactionDOMElement.removeEventListener('pointerover', this.onPointerOver, true);
window.removeEventListener('pointercancel', this.onPointerCancel, true);
window.removeEventListener('pointerup', this.onPointerUp, true);
} else {
window.document.removeEventListener('mousemove', this.onPointerMove, true);
this.interactionDOMElement.removeEventListener('mousedown', this.onPointerDown, true);
this.interactionDOMElement.removeEventListener('mouseout', this.onPointerOut, true);
this.interactionDOMElement.removeEventListener('mouseover', this.onPointerOver, true);
window.removeEventListener('mouseup', this.onPointerUp, true);
}
if (this.supportsTouchEvents) {
this.interactionDOMElement.removeEventListener('touchstart', this.onPointerDown, true);
this.interactionDOMElement.removeEventListener('touchcancel', this.onPointerCancel, true);
this.interactionDOMElement.removeEventListener('touchend', this.onPointerUp, true);
this.interactionDOMElement.removeEventListener('touchmove', this.onPointerMove, true);
}
this.interactionDOMElement = null;
this.eventsAdded = false;
};
/**
* Updates the state of interactive objects.
* Invoked by a throttled ticker update from {@link PIXI.ticker.shared}.
*
* @param {number} deltaTime - time delta since last tick
*/
InteractionManager.prototype.update = function update(deltaTime) {
this._deltaTime += deltaTime;
if (this._deltaTime < this.interactionFrequency) {
return;
}
this._deltaTime = 0;
if (!this.interactionDOMElement) {
return;
}
// if the user move the mouse this check has already been done using the mouse move!
if (this.didMove) {
this.didMove = false;
return;
}
this.cursor = null;
// Resets the flag as set by a stopPropagation call. This flag is usually reset by a user interaction of any kind,
// but there was a scenario of a display object moving under a static mouse cursor.
// In this case, mouseover and mouseevents would not pass the flag test in dispatchEvent function
for (var k in this.activeInteractionData) {
// eslint-disable-next-line no-prototype-builtins
if (this.activeInteractionData.hasOwnProperty(k)) {
var interactionData = this.activeInteractionData[k];
if (interactionData.originalEvent && interactionData.pointerType !== 'touch') {
var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, interactionData.originalEvent, interactionData);
this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerOverOut, true);
}
}
}
this.setCursorMode(this.cursor);
// TODO
};
/**
* Sets the current cursor mode, handling any callbacks or CSS style changes.
*
* @param {string} mode - cursor mode, a key from the cursorStyles dictionary
*/
InteractionManager.prototype.setCursorMode = function setCursorMode(mode) {
mode = mode || 'default';
// if the mode didn't actually change, bail early
if (this.currentCursorMode === mode) {
return;
}
this.currentCursorMode = mode;
var style = this.cursorStyles[mode];
// only do things if there is a cursor style for it
if (style) {
switch (typeof style === 'undefined' ? 'undefined' : _typeof(style)) {
case 'string':
// string styles are handled as cursor CSS
this.interactionDOMElement.style.cursor = style;
break;
case 'function':
// functions are just called, and passed the cursor mode
style(mode);
break;
case 'object':
// if it is an object, assume that it is a dictionary of CSS styles,
// apply it to the interactionDOMElement
Object.assign(this.interactionDOMElement.style, style);
break;
}
} else if (typeof mode === 'string' && !Object.prototype.hasOwnProperty.call(this.cursorStyles, mode)) {
// if it mode is a string (not a Symbol) and cursorStyles doesn't have any entry
// for the mode, then assume that the dev wants it to be CSS for the cursor.
this.interactionDOMElement.style.cursor = mode;
}
};
/**
* Dispatches an event on the display object that was interacted with
*
* @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - the display object in question
* @param {string} eventString - the name of the event (e.g, mousedown)
* @param {object} eventData - the event data object
* @private
*/
InteractionManager.prototype.dispatchEvent = function dispatchEvent(displayObject, eventString, eventData) {
if (!eventData.stopped) {
eventData.currentTarget = displayObject;
eventData.type = eventString;
displayObject.emit(eventString, eventData);
if (displayObject[eventString]) {
displayObject[eventString](eventData);
}
}
};
/**
* Maps x and y coords from a DOM object and maps them correctly to the PixiJS view. The
* resulting value is stored in the point. This takes into account the fact that the DOM
* element could be scaled and positioned anywhere on the screen.
*
* @param {PIXI.Point} point - the point that the result will be stored in
* @param {number} x - the x coord of the position to map
* @param {number} y - the y coord of the position to map
*/
InteractionManager.prototype.mapPositionToPoint = function mapPositionToPoint(point, x, y) {
var rect = void 0;
// IE 11 fix
if (!this.interactionDOMElement.parentElement) {
rect = { x: 0, y: 0, width: 0, height: 0 };
} else {
rect = this.interactionDOMElement.getBoundingClientRect();
}
var resolutionMultiplier = navigator.isCocoonJS ? this.resolution : 1.0 / this.resolution;
point.x = (x - rect.left) * (this.interactionDOMElement.width / rect.width) * resolutionMultiplier;
point.y = (y - rect.top) * (this.interactionDOMElement.height / rect.height) * resolutionMultiplier;
};
/**
* This function is provides a neat way of crawling through the scene graph and running a
* specified function on all interactive objects it finds. It will also take care of hit
* testing the interactive objects and passes the hit across in the function.
*
* @private
* @param {PIXI.interaction.InteractionEvent} interactionEvent - event containing the point that
* is tested for collision
* @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - the displayObject
* that will be hit test (recursively crawls its children)
* @param {Function} [func] - the function that will be called on each interactive object. The
* interactionEvent, displayObject and hit will be passed to the function
* @param {boolean} [hitTest] - this indicates if the objects inside should be hit test against the point
* @param {boolean} [interactive] - Whether the displayObject is interactive
* @return {boolean} returns true if the displayObject hit the point
*/
InteractionManager.prototype.processInteractive = function processInteractive(interactionEvent, displayObject, func, hitTest, interactive) {
if (!displayObject || !displayObject.visible) {
return false;
}
var point = interactionEvent.data.global;
// Took a little while to rework this function correctly! But now it is done and nice and optimised. ^_^
//
// This function will now loop through all objects and then only hit test the objects it HAS
// to, not all of them. MUCH faster..
// An object will be hit test if the following is true:
//
// 1: It is interactive.
// 2: It belongs to a parent that is interactive AND one of the parents children have not already been hit.
//
// As another little optimisation once an interactive object has been hit we can carry on
// through the scenegraph, but we know that there will be no more hits! So we can avoid extra hit tests
// A final optimisation is that an object is not hit test directly if a child has already been hit.
interactive = displayObject.interactive || interactive;
var hit = false;
var interactiveParent = interactive;
// if the displayobject has a hitArea, then it does not need to hitTest children.
if (displayObject.hitArea) {
interactiveParent = false;
}
// it has a mask! Then lets hit test that before continuing
else if (hitTest && displayObject._mask) {
if (!displayObject._mask.containsPoint(point)) {
hitTest = false;
}
}
// ** FREE TIP **! If an object is not interactive or has no buttons in it
// (such as a game scene!) set interactiveChildren to false for that displayObject.
// This will allow PixiJS to completely ignore and bypass checking the displayObjects children.
if (displayObject.interactiveChildren && displayObject.children) {
var children = displayObject.children;
for (var i = children.length - 1; i >= 0; i--) {
var child = children[i];
// time to get recursive.. if this function will return if something is hit..
var childHit = this.processInteractive(interactionEvent, child, func, hitTest, interactiveParent);
if (childHit) {
// its a good idea to check if a child has lost its parent.
// this means it has been removed whilst looping so its best
if (!child.parent) {
continue;
}
// we no longer need to hit test any more objects in this container as we we
// now know the parent has been hit
interactiveParent = false;
// If the child is interactive , that means that the object hit was actually
// interactive and not just the child of an interactive object.
// This means we no longer need to hit test anything else. We still need to run
// through all objects, but we don't need to perform any hit tests.
if (childHit) {
if (interactionEvent.target) {
hitTest = false;
}
hit = true;
}
}
}
}
// no point running this if the item is not interactive or does not have an interactive parent.
if (interactive) {
// if we are hit testing (as in we have no hit any objects yet)
// We also don't need to worry about hit testing if once of the displayObjects children
// has already been hit - but only if it was interactive, otherwise we need to keep
// looking for an interactive child, just in case we hit one
if (hitTest && !interactionEvent.target) {
if (displayObject.hitArea) {
displayObject.worldTransform.applyInverse(point, this._tempPoint);
if (displayObject.hitArea.contains(this._tempPoint.x, this._tempPoint.y)) {
hit = true;
}
} else if (displayObject.containsPoint) {
if (displayObject.containsPoint(point)) {
hit = true;
}
}
}
if (displayObject.interactive) {
if (hit && !interactionEvent.target) {
interactionEvent.target = displayObject;
}
if (func) {
func(interactionEvent, displayObject, !!hit);
}
}
}
return hit;
};
/**
* Is called when the pointer button is pressed down on the renderer element
*
* @private
* @param {PointerEvent} originalEvent - The DOM event of a pointer button being pressed down
*/
InteractionManager.prototype.onPointerDown = function onPointerDown(originalEvent) {
// if we support touch events, then only use those for touch events, not pointer events
if (this.supportsTouchEvents && originalEvent.pointerType === 'touch') return;
var events = this.normalizeToPointerData(originalEvent);
/**
* No need to prevent default on natural pointer events, as there are no side effects
* Normalized events, however, may have the double mousedown/touchstart issue on the native android browser,
* so still need to be prevented.
*/
// Guaranteed that there will be at least one event in events, and all events must have the same pointer type
if (this.autoPreventDefault && events[0].isNormalized) {
originalEvent.preventDefault();
}
var eventLen = events.length;
for (var i = 0; i < eventLen; i++) {
var event = events[i];
var interactionData = this.getInteractionDataForPointerId(event);
var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
interactionEvent.data.originalEvent = originalEvent;
this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerDown, true);
this.emit('pointerdown', interactionEvent);
if (event.pointerType === 'touch') {
this.emit('touchstart', interactionEvent);
}
// emit a mouse event for "pen" pointers, the way a browser would emit a fallback event
else if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
var isRightButton = event.button === 2;
this.emit(isRightButton ? 'rightdown' : 'mousedown', this.eventData);
}
}
};
/**
* Processes the result of the pointer down check and dispatches the event if need be
*
* @private
* @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
* @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
* @param {boolean} hit - the result of the hit test on the display object
*/
InteractionManager.prototype.processPointerDown = function processPointerDown(interactionEvent, displayObject, hit) {
var data = interactionEvent.data;
var id = interactionEvent.data.identifier;
if (hit) {
if (!displayObject.trackedPointers[id]) {
displayObject.trackedPointers[id] = new _InteractionTrackingData2.default(id);
}
this.dispatchEvent(displayObject, 'pointerdown', interactionEvent);
if (data.pointerType === 'touch') {
this.dispatchEvent(displayObject, 'touchstart', interactionEvent);
} else if (data.pointerType === 'mouse' || data.pointerType === 'pen') {
var isRightButton = data.button === 2;
if (isRightButton) {
displayObject.trackedPointers[id].rightDown = true;
} else {
displayObject.trackedPointers[id].leftDown = true;
}
this.dispatchEvent(displayObject, isRightButton ? 'rightdown' : 'mousedown', interactionEvent);
}
}
};
/**
* Is called when the pointer button is released on the renderer element
*
* @private
* @param {PointerEvent} originalEvent - The DOM event of a pointer button being released
* @param {boolean} cancelled - true if the pointer is cancelled
* @param {Function} func - Function passed to {@link processInteractive}
*/
InteractionManager.prototype.onPointerComplete = function onPointerComplete(originalEvent, cancelled, func) {
var events = this.normalizeToPointerData(originalEvent);
var eventLen = events.length;
// if the event wasn't targeting our canvas, then consider it to be pointerupoutside
// in all cases (unless it was a pointercancel)
var eventAppend = originalEvent.target !== this.interactionDOMElement ? 'outside' : '';
for (var i = 0; i < eventLen; i++) {
var event = events[i];
var interactionData = this.getInteractionDataForPointerId(event);
var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
interactionEvent.data.originalEvent = originalEvent;
// perform hit testing for events targeting our canvas or cancel events
this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, func, cancelled || !eventAppend);
this.emit(cancelled ? 'pointercancel' : 'pointerup' + eventAppend, interactionEvent);
if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
var isRightButton = event.button === 2;
this.emit(isRightButton ? 'rightup' + eventAppend : 'mouseup' + eventAppend, interactionEvent);
} else if (event.pointerType === 'touch') {
this.emit(cancelled ? 'touchcancel' : 'touchend' + eventAppend, interactionEvent);
this.releaseInteractionDataForPointerId(event.pointerId, interactionData);
}
}
};
/**
* Is called when the pointer button is cancelled
*
* @private
* @param {PointerEvent} event - The DOM event of a pointer button being released
*/
InteractionManager.prototype.onPointerCancel = function onPointerCancel(event) {
// if we support touch events, then only use those for touch events, not pointer events
if (this.supportsTouchEvents && event.pointerType === 'touch') return;
this.onPointerComplete(event, true, this.processPointerCancel);
};
/**
* Processes the result of the pointer cancel check and dispatches the event if need be
*
* @private
* @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
* @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
*/
InteractionManager.prototype.processPointerCancel = function processPointerCancel(interactionEvent, displayObject) {
var data = interactionEvent.data;
var id = interactionEvent.data.identifier;
if (displayObject.trackedPointers[id] !== undefined) {
delete displayObject.trackedPointers[id];
this.dispatchEvent(displayObject, 'pointercancel', interactionEvent);
if (data.pointerType === 'touch') {
this.dispatchEvent(displayObject, 'touchcancel', interactionEvent);
}
}
};
/**
* Is called when the pointer button is released on the renderer element
*
* @private
* @param {PointerEvent} event - The DOM event of a pointer button being released
*/
InteractionManager.prototype.onPointerUp = function onPointerUp(event) {
// if we support touch events, then only use those for touch events, not pointer events
if (this.supportsTouchEvents && event.pointerType === 'touch') return;
this.onPointerComplete(event, false, this.processPointerUp);
};
/**
* Processes the result of the pointer up check and dispatches the event if need be
*
* @private
* @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
* @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
* @param {boolean} hit - the result of the hit test on the display object
*/
InteractionManager.prototype.processPointerUp = function processPointerUp(interactionEvent, displayObject, hit) {
var data = interactionEvent.data;
var id = interactionEvent.data.identifier;
var trackingData = displayObject.trackedPointers[id];
var isTouch = data.pointerType === 'touch';
var isMouse = data.pointerType === 'mouse' || data.pointerType === 'pen';
// Mouse only
if (isMouse) {
var isRightButton = data.button === 2;
var flags = _InteractionTrackingData2.default.FLAGS;
var test = isRightButton ? flags.RIGHT_DOWN : flags.LEFT_DOWN;
var isDown = trackingData !== undefined && trackingData.flags & test;
if (hit) {
this.dispatchEvent(displayObject, isRightButton ? 'rightup' : 'mouseup', interactionEvent);
if (isDown) {
this.dispatchEvent(displayObject, isRightButton ? 'rightclick' : 'click', interactionEvent);
}
} else if (isDown) {
this.dispatchEvent(displayObject, isRightButton ? 'rightupoutside' : 'mouseupoutside', interactionEvent);
}
// update the down state of the tracking data
if (trackingData) {
if (isRightButton) {
trackingData.rightDown = false;
} else {
trackingData.leftDown = false;
}
}
}
// Pointers and Touches, and Mouse
if (hit) {
this.dispatchEvent(displayObject, 'pointerup', interactionEvent);
if (isTouch) this.dispatchEvent(displayObject, 'touchend', interactionEvent);
if (trackingData) {
this.dispatchEvent(displayObject, 'pointertap', interactionEvent);
if (isTouch) {
this.dispatchEvent(displayObject, 'tap', interactionEvent);
// touches are no longer over (if they ever were) when we get the touchend
// so we should ensure that we don't keep pretending that they are
trackingData.over = false;
}
}
} else if (trackingData) {
this.dispatchEvent(displayObject, 'pointerupoutside', interactionEvent);
if (isTouch) this.dispatchEvent(displayObject, 'touchendoutside', interactionEvent);
}
// Only remove the tracking data if there is no over/down state still associated with it
if (trackingData && trackingData.none) {
delete displayObject.trackedPointers[id];
}
};
/**
* Is called when the pointer moves across the renderer element
*
* @private
* @param {PointerEvent} originalEvent - The DOM event of a pointer moving
*/
InteractionManager.prototype.onPointerMove = function onPointerMove(originalEvent) {
// if we support touch events, then only use those for touch events, not pointer events
if (this.supportsTouchEvents && originalEvent.pointerType === 'touch') return;
var events = this.normalizeToPointerData(originalEvent);
if (events[0].pointerType === 'mouse') {
this.didMove = true;
this.cursor = null;
}
var eventLen = events.length;
for (var i = 0; i < eventLen; i++) {
var event = events[i];
var interactionData = this.getInteractionDataForPointerId(event);
var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
interactionEvent.data.originalEvent = originalEvent;
var interactive = event.pointerType === 'touch' ? this.moveWhenInside : true;
this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerMove, interactive);
this.emit('pointermove', interactionEvent);
if (event.pointerType === 'touch') this.emit('touchmove', interactionEvent);
if (event.pointerType === 'mouse' || event.pointerType === 'pen') this.emit('mousemove', interactionEvent);
}
if (events[0].pointerType === 'mouse') {
this.setCursorMode(this.cursor);
// TODO BUG for parents interactive object (border order issue)
}
};
/**
* Processes the result of the pointer move check and dispatches the event if need be
*
* @private
* @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
* @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
* @param {boolean} hit - the result of the hit test on the display object
*/
InteractionManager.prototype.processPointerMove = function processPointerMove(interactionEvent, displayObject, hit) {
var data = interactionEvent.data;
var isTouch = data.pointerType === 'touch';
var isMouse = data.pointerType === 'mouse' || data.pointerType === 'pen';
if (isMouse) {
this.processPointerOverOut(interactionEvent, displayObject, hit);
}
if (!this.moveWhenInside || hit) {
this.dispatchEvent(displayObject, 'pointermove', interactionEvent);
if (isTouch) this.dispatchEvent(displayObject, 'touchmove', interactionEvent);
if (isMouse) this.dispatchEvent(displayObject, 'mousemove', interactionEvent);
}
};
/**
* Is called when the pointer is moved out of the renderer element
*
* @private
* @param {PointerEvent} originalEvent - The DOM event of a pointer being moved out
*/
InteractionManager.prototype.onPointerOut = function onPointerOut(originalEvent) {
// if we support touch events, then only use those for touch events, not pointer events
if (this.supportsTouchEvents && originalEvent.pointerType === 'touch') return;
var events = this.normalizeToPointerData(originalEvent);
// Only mouse and pointer can call onPointerOut, so events will always be length 1
var event = events[0];
if (event.pointerType === 'mouse') {
this.mouseOverRenderer = false;
this.setCursorMode(null);
}
var interactionData = this.getInteractionDataForPointerId(event);
var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
interactionEvent.data.originalEvent = event;
this.processInteractive(interactionEvent, this.renderer._lastObjectRendered, this.processPointerOverOut, false);
this.emit('pointerout', interactionEvent);
if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
this.emit('mouseout', interactionEvent);
} else {
// we can get touchleave events after touchend, so we want to make sure we don't
// introduce memory leaks
this.releaseInteractionDataForPointerId(interactionData.identifier);
}
};
/**
* Processes the result of the pointer over/out check and dispatches the event if need be
*
* @private
* @param {PIXI.interaction.InteractionEvent} interactionEvent - The interaction event wrapping the DOM event
* @param {PIXI.Container|PIXI.Sprite|PIXI.extras.TilingSprite} displayObject - The display object that was tested
* @param {boolean} hit - the result of the hit test on the display object
*/
InteractionManager.prototype.processPointerOverOut = function processPointerOverOut(interactionEvent, displayObject, hit) {
var data = interactionEvent.data;
var id = interactionEvent.data.identifier;
var isMouse = data.pointerType === 'mouse' || data.pointerType === 'pen';
var trackingData = displayObject.trackedPointers[id];
// if we just moused over the display object, then we need to track that state
if (hit && !trackingData) {
trackingData = displayObject.trackedPointers[id] = new _InteractionTrackingData2.default(id);
}
if (trackingData === undefined) return;
if (hit && this.mouseOverRenderer) {
if (!trackingData.over) {
trackingData.over = true;
this.dispatchEvent(displayObject, 'pointerover', interactionEvent);
if (isMouse) {
this.dispatchEvent(displayObject, 'mouseover', interactionEvent);
}
}
// only change the cursor if it has not already been changed (by something deeper in the
// display tree)
if (isMouse && this.cursor === null) {
this.cursor = displayObject.cursor;
}
} else if (trackingData.over) {
trackingData.over = false;
this.dispatchEvent(displayObject, 'pointerout', this.eventData);
if (isMouse) {
this.dispatchEvent(displayObject, 'mouseout', interactionEvent);
}
// if there is no mouse down information for the pointer, then it is safe to delete
if (trackingData.none) {
delete displayObject.trackedPointers[id];
}
}
};
/**
* Is called when the pointer is moved into the renderer element
*
* @private
* @param {PointerEvent} originalEvent - The DOM event of a pointer button being moved into the renderer view
*/
InteractionManager.prototype.onPointerOver = function onPointerOver(originalEvent) {
var events = this.normalizeToPointerData(originalEvent);
// Only mouse and pointer can call onPointerOver, so events will always be length 1
var event = events[0];
var interactionData = this.getInteractionDataForPointerId(event);
var interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);
interactionEvent.data.originalEvent = event;
if (event.pointerType === 'mouse') {
this.mouseOverRenderer = true;
}
this.emit('pointerover', interactionEvent);
if (event.pointerType === 'mouse' || event.pointerType === 'pen') {
this.emit('mouseover', interactionEvent);
}
};
/**
* Get InteractionData for a given pointerId. Store that data as well
*
* @private
* @param {PointerEvent} event - Normalized pointer event, output from normalizeToPointerData
* @return {PIXI.interaction.InteractionData} - Interaction data for the given pointer identifier
*/
InteractionManager.prototype.getInteractionDataForPointerId = function getInteractionDataForPointerId(event) {
var pointerId = event.pointerId;
var interactionData = void 0;
if (pointerId === MOUSE_POINTER_ID || event.pointerType === 'mouse') {
interactionData = this.mouse;
} else if (this.activeInteractionData[pointerId]) {
interactionData = this.activeInteractionData[pointerId];
} else {
interactionData = this.interactionDataPool.pop() || new _InteractionData2.default();
interactionData.identifier = pointerId;
this.activeInteractionData[pointerId] = interactionData;
}
// copy properties from the event, so that we can make sure that touch/pointer specific
// data is available
interactionData._copyEvent(event);
return interactionData;
};
/**
* Return unused InteractionData to the pool, for a given pointerId
*
* @private
* @param {number} pointerId - Identifier from a pointer event
*/
InteractionManager.prototype.releaseInteractionDataForPointerId = function releaseInteractionDataForPointerId(pointerId) {
var interactionData = this.activeInteractionData[pointerId];
if (interactionData) {
delete this.activeInteractionData[pointerId];
interactionData._reset();
this.interactionDataPool.push(interactionData);
}
};
/**
* Configure an InteractionEvent to wrap a DOM PointerEvent and InteractionData
*
* @private
* @param {PIXI.interaction.InteractionEvent} interactionEvent - The event to be configured
* @param {PointerEvent} pointerEvent - The DOM event that will be paired with the InteractionEvent
* @param {PIXI.interaction.InteractionData} interactionData - The InteractionData that will be paired
* with the InteractionEvent
* @return {PIXI.interaction.InteractionEvent} the interaction event that was passed in
*/
InteractionManager.prototype.configureInteractionEventForDOMEvent = function configureInteractionEventForDOMEvent(interactionEvent, pointerEvent, interactionData) {
interactionEvent.data = interactionData;
this.mapPositionToPoint(interactionData.global, pointerEvent.clientX, pointerEvent.clientY);
// This is the way InteractionManager processed touch events before the refactoring, so I've kept
// it here. But it doesn't make that much sense to me, since mapPositionToPoint already factors
// in this.resolution, so this just divides by this.resolution twice for touch events...
if (navigator.isCocoonJS && pointerEvent.pointerType === 'touch') {
interactionData.global.x = interactionData.global.x / this.resolution;
interactionData.global.y = interactionData.global.y / this.resolution;
}
// Not really sure why this is happening, but it's how a previous version handled things
if (pointerEvent.pointerType === 'touch') {
pointerEvent.globalX = interactionData.global.x;
pointerEvent.globalY = interactionData.global.y;
}
interactionData.originalEvent = pointerEvent;
interactionEvent._reset();
return interactionEvent;
};
/**
* Ensures that the original event object contains all data that a regular pointer event would have
*
* @private
* @param {TouchEvent|MouseEvent|PointerEvent} event - The original event data from a touch or mouse event
* @return {PointerEvent[]} An array containing a single normalized pointer event, in the case of a pointer
* or mouse event, or a multiple normalized pointer events if there are multiple changed touches
*/
InteractionManager.prototype.normalizeToPointerData = function normalizeToPointerData(event) {
var normalizedEvents = [];
if (this.supportsTouchEvents && event instanceof TouchEvent) {
for (var i = 0, li = event.changedTouches.length; i < li; i++) {
var touch = event.changedTouches[i];
if (typeof touch.button === 'undefined') touch.button = event.touches.length ? 1 : 0;
if (typeof touch.buttons === 'undefined') touch.buttons = event.touches.length ? 1 : 0;
if (typeof touch.isPrimary === 'undefined') {
touch.isPrimary = event.touches.length === 1 && event.type === 'touchstart';
}
if (typeof touch.width === 'undefined') touch.width = touch.radiusX || 1;
if (typeof touch.height === 'undefined') touch.height = touch.radiusY || 1;
if (typeof touch.tiltX === 'undefined') touch.tiltX = 0;
if (typeof touch.tiltY === 'undefined') touch.tiltY = 0;
if (typeof touch.pointerType === 'undefined') touch.pointerType = 'touch';
if (typeof touch.pointerId === 'undefined') touch.pointerId = touch.identifier || 0;
if (typeof touch.pressure === 'undefined') touch.pressure = touch.force || 0.5;
touch.twist = 0;
touch.tangentialPressure = 0;
// TODO: Remove these, as layerX/Y is not a standard, is deprecated, has uneven
// support, and the fill ins are not quite the same
// offsetX/Y might be okay, but is not the same as clientX/Y when the canvas's top
// left is not 0,0 on the page
if (typeof touch.layerX === 'undefined') touch.layerX = touch.offsetX = touch.clientX;
if (typeof touch.layerY === 'undefined') touch.layerY = touch.offsetY = touch.clientY;
// mark the touch as normalized, just so that we know we did it
touch.isNormalized = true;
normalizedEvents.push(touch);
}
}
// apparently PointerEvent subclasses MouseEvent, so yay
else if (event instanceof MouseEvent && (!this.supportsPointerEvents || !(event instanceof window.PointerEvent))) {
if (typeof event.isPrimary === 'undefined') event.isPrimary = true;
if (typeof event.width === 'undefined') event.width = 1;
if (typeof event.height === 'undefined') event.height = 1;
if (typeof event.tiltX === 'undefined') event.tiltX = 0;
if (typeof event.tiltY === 'undefined') event.tiltY = 0;
if (typeof event.pointerType === 'undefined') event.pointerType = 'mouse';
if (typeof event.pointerId === 'undefined') event.pointerId = MOUSE_POINTER_ID;
if (typeof event.pressure === 'undefined') event.pressure = 0.5;
event.twist = 0;
event.tangentialPressure = 0;
// mark the mouse event as normalized, just so that we know we did it
event.isNormalized = true;
normalizedEvents.push(event);
} else {
normalizedEvents.push(event);
}
return normalizedEvents;
};
/**
* Destroys the interaction manager
*
*/
InteractionManager.prototype.destroy = function destroy() {
this.removeEvents();
this.removeAllListeners();
this.renderer = null;
this.mouse = null;
this.eventData = null;
this.interactionDOMElement = null;
this.onPointerDown = null;
this.processPointerDown = null;
this.onPointerUp = null;
this.processPointerUp = null;
this.onPointerCancel = null;
this.processPointerCancel = null;
this.onPointerMove = null;
this.processPointerMove = null;
this.onPointerOut = null;
this.processPointerOverOut = null;
this.onPointerOver = null;
this._tempPoint = null;
};
return InteractionManager;
}(_eventemitter2.default);
exports.default = InteractionManager;
core.WebGLRenderer.registerPlugin('interaction', InteractionManager);
core.CanvasRenderer.registerPlugin('interaction', InteractionManager);
//# sourceMappingURL=InteractionManager.js.map


love and laughter she would bring, and they named her . . . Enuf—as in “Enough girls!” But her name also speaks of a family with more than enough: enough love and fun and laughter to go around. Nuffy, as they called her, grew up with a lovely smile and a mischievous personality, enjoying the love and attention of her big sisters.
When people hear her name and her story, they often respond with shock and surprise and ask if she is serious. They can’t believe that parents would give their little girl the name Enuf. But Nuffy loves having a name that no one else has. When asked how she feels about her name, Nuffy says, “Because my name creates a spotlight for me, all of a sudden this five-foot-three-inch girl with a big smile is not dismissed as just another sweetheart or pushover. My name gives me a voice . . . and I’m going to make the most out this blessing. I love reaching people, brightening their days, making an impression. No one else has an opportunity to spread God’s story and be remembered like I do.”
The sisters say they loved growing up in a family full of girls, each with her own distinct personality and approach to life. Their alphabetical names give them a sense of the bond they share in such a unique family filled with love.
Our final week together studying God’s impact on our names brings closure to our study. This week we’ll discover the story of a woman who was named by her past, and whose legacy is different than that of the other individuals we’ve studied because it is shaped by her lack of a name. Through her, we’ll find that God’s grace is enough—enough to reshape our lives after a rocky start; enough to change our stories and our names forever.


Run specs
Load jQuery
Load unpoly-migrate.js
Modern ES ES6
Raise exceptions
Random test order
All specs up.browser up.element up.error up.event up.feedback up.form up.fragment up.layer up.history up.migrate up.link up.log up.motion up.protocol up.network up.radio up.rails up.syntax up.tooltip up.util up.viewport


|
Savage
Garden
|
|
|
Affirmation
|
1.
Affirmation
2. Hold Me 3. I Knew I Loved You 4. The Best Thing 5. Crash And Burn 6. Chained To You 7. The Animal Song 8. The Lover After Me 9. Two Beds And A Coffee Machine 10. You Can Still Be Free 11. Gunning Down Romance |
|
|
|
|
Savage
Garden
|
1.
To The Moon & Back
2. I Want You 3. Truly Madly Deeply 4. Tears Of Pearls 5. Universe 6. Carry On Dancing 7. Violet 8. Break Me Shake Me 9. A Thousand Words 10. Promises 11. Santa Monica |


| Class | Description |
|---|---|
| AdditionalOutputTagProperty |
Additional Output Tag Execution Property for edge that contains tag for additional outputs.
|
| BroadcastVariableIdProperty |
Edges with this property fetch a broadcast variable.
|
| CacheIDProperty |
Cache ID ExecutionProperty.
|
| CommunicationPatternProperty |
DataCommunicationPattern ExecutionProperty.
|
| CompressionProperty |
Compression ExecutionProperty.
|
| DataFlowProperty |
DataFlowModel ExecutionProperty.
|
| DataPersistenceProperty |
Data persistence ExecutionProperty.
|
| DataSkewMetricProperty |
DataSkewMetric ExecutionProperty.
|
| DataStoreProperty |
DataStore ExecutionProperty.
|
| DecoderProperty |
Decoder ExecutionProperty.
|
| DecompressionProperty |
Decompression ExecutionProperty.
|
| DuplicateEdgeGroupProperty |
Invariant data ExecutionProperty.
|
| DuplicateEdgeGroupPropertyValue |
Value of DuplicateEdgeGroupProperty.
|
| EncoderProperty |
EncoderFactory ExecutionProperty.
|
| KeyDecoderProperty |
KeyDecoder ExecutionProperty.
|
| KeyEncoderProperty |
KeyEncoder ExecutionProperty.
|
| KeyExtractorProperty |
KeyExtractor ExecutionProperty.
|
| MetricCollectionProperty |
MetricCollection ExecutionProperty.
|
| PartitionerProperty |
Partitioner ExecutionProperty.
|
| Enum | Description |
|---|---|
| CommunicationPatternProperty.Value |
Possible values of DataCommunicationPattern ExecutionProperty.
|
| CompressionProperty.Value |
Possible values of Compression ExecutionProperty.
|
| DataFlowProperty.Value |
Possible values of DataFlowModel ExecutionProperty.
|
| DataPersistenceProperty.Value |
Possible options for the data persistence strategy.
|
| DataStoreProperty.Value |
Possible values of DataStore ExecutionProperty.
|
| MetricCollectionProperty.Value |
Possible values of MetricCollection ExecutionProperty.
|
| PartitionerProperty.Value |
Possible values of Partitioner ExecutionProperty.
|
Copyright © 2019 The Apache Software Foundation. All rights reserved.