code stringlengths 2 1.05M |
|---|
describe('Controller: MenuController', function () {
// load the controller's module
beforeEach(module('confusionApp'));
var MenuController, scope, $httpBackend;
// Initialize the controller and a mock scope
beforeEach(inject(function ($controller, _$httpBackend_, $rootScope, menuFactory) {
// place here mocked dependencies
$httpBackend = _$httpBackend_;
$httpBackend.expectGET("http://localhost:3000/dishes").respond([
{
"id": 0,
"name": "Uthapizza",
"image": "images/uthapizza.png",
"category": "mains",
"label": "Hot",
"price": "4.99",
"description": "A",
"comments":[{}]
},
{
"id": 1,
"name": "Zucchipakoda",
"image": "images/zucchipakoda.png",
"category": "mains",
"label": "New",
"price": "4.99",
"description": "A",
"comments":[{}]
}
]);
scope = $rootScope.$new();
MenuController = $controller('MenuController', {
$scope: scope, menuFactory: menuFactory
});
$httpBackend.flush();
}));
it('should have showDetails as false', function () {
expect(scope.showDetails).toBeFalsy();
});
it('should create "dishes" with 2 dishes fetched from xhr', function(){
expect(scope.showMenu).toBeTruthy();
expect(scope.dishes).toBeDefined();
expect(scope.dishes.length).toBe(2);
});
it('should have the correct data order in the dishes', function() {
expect(scope.dishes[0].name).toBe("Uthapizza");
expect(scope.dishes[1].label).toBe("New");
});
it('should change the tab selected based on tab clicked', function(){
expect(scope.tab).toEqual(1);
scope.select(3);
expect(scope.tab).toEqual(3);
expect(scope.filtText).toEqual('mains');
});
});
|
/* Thing > Intangible > Rating > AggregateRating - The average rating based on multiple ratings or reviews.. Generated automatically by the reactGenerator. */ var AggregateRating= React.createClass({
getDefaultProps: function(){
return {
}
},
render: function(){
var props = this.props.props;
var reviewCount;
if( props.reviewCount ){
if( props.reviewCount instanceof Array ){
reviewCount = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
reviewCount = reviewCount.concat( props.reviewCount.map( function(result, index){
return ( <Integer {...result} key={index} /> )
}) );
reviewCount.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
reviewCount = ( <Integer props={ props.reviewCount } /> ); }
}
var potentialAction;
if( props.potentialAction ){
if( props.potentialAction instanceof Array ){
potentialAction = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
potentialAction = potentialAction.concat( props.potentialAction.map( function(result, index){
return ( <Action {...result} key={index} /> )
}) );
potentialAction.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
potentialAction = ( <Action props={ props.potentialAction } /> ); }
}
var description;
if( props.description ){
if( props.description instanceof Array ){
description = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
description = description.concat( props.description.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. description is a Text.'></div> )
}) );
description.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
description = ( <div data-advice='Put your HTML here. description is a Text.'></div> );
}
}
var name;
if( props.name ){
if( props.name instanceof Array ){
name = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
name = name.concat( props.name.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. name is a Text.'></div> )
}) );
name.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
name = ( <div data-advice='Put your HTML here. name is a Text.'></div> );
}
}
var sameAs;
if( props.sameAs ){
if( props.sameAs instanceof Array ){
sameAs = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
sameAs = sameAs.concat( props.sameAs.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. sameAs is a URL.'></div> )
}) );
sameAs.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
sameAs = ( <div data-advice='Put your HTML here. sameAs is a URL.'></div> );
}
}
var image;
if( props.image ){
if( props.image instanceof Array ){
image = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
image = image.concat( props.image.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. image is a URL or
ImageObject.'></div> )
}) );
image.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
image = ( <div data-advice='Put your HTML here. image is a URL or
ImageObject.'></div> );
}
}
var bestRating;
if( props.bestRating ){
if( props.bestRating instanceof Array ){
bestRating = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
bestRating = bestRating.concat( props.bestRating.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. bestRating is a Number or
Text.'></div> )
}) );
bestRating.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
bestRating = ( <div data-advice='Put your HTML here. bestRating is a Number or
Text.'></div> );
}
}
var url;
if( props.url ){
if( props.url instanceof Array ){
url = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
url = url.concat( props.url.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. url is a URL.'></div> )
}) );
url.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
url = ( <div data-advice='Put your HTML here. url is a URL.'></div> );
}
}
var worstRating;
if( props.worstRating ){
if( props.worstRating instanceof Array ){
worstRating = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
worstRating = worstRating.concat( props.worstRating.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. worstRating is a Number or
Text.'></div> )
}) );
worstRating.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
worstRating = ( <div data-advice='Put your HTML here. worstRating is a Number or
Text.'></div> );
}
}
var ratingCount;
if( props.ratingCount ){
if( props.ratingCount instanceof Array ){
ratingCount = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
ratingCount = ratingCount.concat( props.ratingCount.map( function(result, index){
return ( <Integer {...result} key={index} /> )
}) );
ratingCount.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
ratingCount = ( <Integer props={ props.ratingCount } /> ); }
}
var mainEntityOfPage;
if( props.mainEntityOfPage ){
if( props.mainEntityOfPage instanceof Array ){
mainEntityOfPage = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
mainEntityOfPage = mainEntityOfPage.concat( props.mainEntityOfPage.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. mainEntityOfPage is a CreativeWork or
URL.'></div> )
}) );
mainEntityOfPage.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
mainEntityOfPage = ( <div data-advice='Put your HTML here. mainEntityOfPage is a CreativeWork or
URL.'></div> );
}
}
var additionalType;
if( props.additionalType ){
if( props.additionalType instanceof Array ){
additionalType = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
additionalType = additionalType.concat( props.additionalType.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. additionalType is a URL.'></div> )
}) );
additionalType.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
additionalType = ( <div data-advice='Put your HTML here. additionalType is a URL.'></div> );
}
}
var alternateName;
if( props.alternateName ){
if( props.alternateName instanceof Array ){
alternateName = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
alternateName = alternateName.concat( props.alternateName.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. alternateName is a Text.'></div> )
}) );
alternateName.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
alternateName = ( <div data-advice='Put your HTML here. alternateName is a Text.'></div> );
}
}
var itemReviewed;
if( props.itemReviewed ){
if( props.itemReviewed instanceof Array ){
itemReviewed = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
itemReviewed = itemReviewed.concat( props.itemReviewed.map( function(result, index){
return ( <Thing {...result} key={index} /> )
}) );
itemReviewed.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
itemReviewed = ( <Thing props={ props.itemReviewed } /> ); }
}
var ratingValue;
if( props.ratingValue ){
if( props.ratingValue instanceof Array ){
ratingValue = [ (<div key='header' data-advice='HTML for the *head* of the section'></div>) ]
ratingValue = ratingValue.concat( props.ratingValue.map( function(result, index){
return ( <div key={index} data-advice='Put your HTML here. ratingValue is a Text.'></div> )
}) );
ratingValue.push( ( <div key='footer' data-advice='HTML for the *footer* of the section'></div> ) );
} else {
ratingValue = ( <div data-advice='Put your HTML here. ratingValue is a Text.'></div> );
}
}
return (<div title='AggregateRating' className='AggregateRating entity'>
{ reviewCount }
{ potentialAction }
{ description }
{ name }
{ sameAs }
{ image }
{ bestRating }
{ url }
{ worstRating }
{ ratingCount }
{ mainEntityOfPage }
{ additionalType }
{ alternateName }
{ itemReviewed }
{ ratingValue }
</div>);
}
});
|
$(function() {
var relatedSolrUtils = kmapsSolrUtils.init({
termIndex: $('#related_js_data').data('termIndex'),
assetIndex: $('#related_js_data').data('assetIndex'),
featureId: $('#related_js_data').data('featureId'),
domain: $('#related_js_data').data('domain'),
perspective: $('#related_js_data').data('perspective'),
view: $('#related_js_data').data('view'),
tree: $('#related_js_data').data('tree'), //subjects
});
var summaryLoaded = false;
var collapsibleApplied = false;
var popupsSet = false;
var columnizedApplied = false;
$('#summary-tab-link[data-toggle="tab"]').on('shown.bs.tab', function (e) {
//Code for Summary
if(!summaryLoaded){
$("#relation_details .tab-content-loading").show();
relatedSolrUtils.getSubjectsSummaryElements().then(function(result){
var feature_label = $($('#related_js_data').data('featureLabel'))[0].innerText;
var feature_path = $('#related_js_data').data('featurePath');
relatedSolrUtils.addSubjectsSummaryItems(feature_label,feature_path,'parent',result);
relatedSolrUtils.addSubjectsSummaryItems(feature_label,feature_path,'child',result);
relatedSolrUtils.addSubjectsSummaryItems(feature_label,feature_path,'other',result);
if(!collapsibleApplied){
$('ul.collapsibleList').kmapsCollapsibleList();
collapsibleApplied = true;
}
if(!columnizedApplied){
// Functionality for columnizer
$('.kmaps-list-columns:not(.places-in-subjects):not(.already_columnized)').addClass('already_columnized').columnize({
width: 330,
lastNeverTallest : true,
buildOnce: true,
});
//reapply kmapsCollapsibleList if the element has lost the kmapscollapsibleList plugin
//columnizer seems to cause a bug when the clone doesn't keep the events previously assigned
$('ul.collapsibleList').each(function(){
if(!($(this).data('plugin_kmapsCollapsibleList'))) $(this).kmapsCollapsibleList();
});
columnizedApplied = true;
}
if(!popupsSet){
jQuery('#relation_details .popover-kmaps').kmapsPopup({
featuresPath: $('#related_js_data').data('featurePath'),
domain: $('#related_js_data').data('domain'),
featureId: "",
mandalaURL: $('#related_js_data').data('mandalaPath'),
solrUtils: relatedSolrUtils
});
popupsSet = true;
}
$("#relation_details .tab-content-loading").hide();
$("#relation_details .collapsible_btns_container").show();
summaryLoaded = true;
});
}
}); // END - Summary Tab on show action
$(".collapsible_expand_all").on("click",function(e){
$(".collapsible_collapse_all").removeClass("collapsible_all_btn_selected");
if (!$(".collapsible_expand_all").hasClass("collapsible_all_btn_selected")) {
$(".collapsible_expand_all").addClass("collapsible_all_btn_selected");
}
$('ul.collapsibleList').each(function(){
$(this).kmapsCollapsibleList('expandAll',this);
});
});
$(".collapsible_collapse_all").on("click",function(e){
$(".collapsible_expand_all").removeClass("collapsible_all_btn_selected");
if (!$(".collapsible_collapse_all").hasClass("collapsible_all_btn_selected")) {
$(".collapsible_collapse_all").addClass("collapsible_all_btn_selected");
}
$('ul.collapsibleList').each(function(){
$(this).kmapsCollapsibleList('collapseAll',this);
});
});
$("#relation_tree_container").kmapsRelationsTree({
featureId: $('#related_js_data').data('featureFid'),
termIndex: $('#related_js_data').data('termIndex'),
assetIndex: $('#related_js_data').data('assetIndex'),
perspective: $('#related_js_data').data('perspective'),
tree: $('#related_js_data').data('tree'), //subjects
domain: $('#related_js_data').data('domain'), //subjects
descendants: true,
directAncestors: true,
descendantsFullDetail: true,
displayPopup: true,
sortBy: "related_"+$('#related_js_data').data('domain')+"_header_s+ASC",
solrUtils: relatedSolrUtils,
language: $('#related_js_data').data('language'),
});
});
|
/**
* Index Class
*
* @class
*/
class Index {
/**
* class constructor
*
* @constructor
*/
constructor() {
this.indexObject = {};
this.fileArray = [];
}
/**
* validateJson
*
* Validates the file input
*
* @param {object} file - Content of the file
* @return {string}
*/
validateJson(file) {
if (!file.length) {
return 'Empty file';
}
try {
const jsonData = JSON.parse(file);
if (this.checkTitleAndText(jsonData)) {
return 'No title or text';
}
this.jsonData = jsonData;
return 'Correct file';
} catch (error) {
return 'Invalid JSON file';
}
}
/**
* cleanData
*
* Tokenizes data
*
* @param {string}
* @return {array}
*/
cleanData(data) {
const terms = (data)
.toLowerCase()
.replace(/[^a-z0-9 ]/gi, '')
.split(' ');
return terms;
}
/**
* checkTitleAndText
*
* Checks that the array has a title and a text.
*
* @param {array}
* @return {bool}
*/
checkTitleAndText(myArray) {
return myArray.some(value => !value.hasOwnProperty('title') || !value.hasOwnProperty('text'));
}
/**
* getUniqueTerms
*
* Gets the unique terms by ensuring none of the terms are repeated for example "alice" does not
* appear twice in the created array.
*
* @param {array}
* @return {array}
*/
getUniqueTerms(terms) {
return terms.filter((value, index, arr) => arr.indexOf(value) === index);
}
/**
* getValues
*
* Gets the values for each of the terms that show in which object the term is found.
*
* @param {object}
* @param {string}
* @return {array}
*/
getValues(jsonData, indexTerm) {
const objArray = [];
let i = 0;
jsonData.forEach((object) => {
Object.keys(object).forEach((key) => {
const terms = this.cleanData(object[key]);
if (terms.indexOf(indexTerm) > -1 && objArray.indexOf(i) < 0) {
objArray.push(i);
}
});
i += 1;
});
return objArray;
}
/**
* createIndex
*
* Ensures that a correct Index is created
*
* @param {object}
* @param {string}
*/
createIndex(filename, content) {
const message = this.validateJson(content);
if (message === 'Correct file') {
const jsonData = JSON.parse(content);
if (jsonData != null) {
let indexTerms = [];
const index = {};
jsonData.forEach((obj) => {
Object.keys(obj).forEach((key) => {
const terms = this.cleanData(obj[key]);
indexTerms = indexTerms.concat(this.getUniqueTerms(terms));
});
});
indexTerms.forEach((indexTerm) => {
const objArray = this.getValues(jsonData, indexTerm);
index[indexTerm] = objArray;
});
this.indexObject[filename] = index;
return message;
}
} else {
return message;
}
}
/**
* getIndex
*
* Gets the created Index from createIndex
*
* @param {object} file - Content of the file
* @return {object}
*/
getIndex(filename) {
return this.indexObject[filename];
}
/**
* getResult
*
* Searches the created index
*
* @param {string}
* @param {string}
* @return {object}
*/
getResult(items, filename) {
const fileResult = {};
items.forEach((item) => {
if (item !== '') {
fileResult[item] = this.indexObject[filename][item.toLowerCase()];
} else {
fileResult[item] = [];
}
});
return fileResult;
}
/**
* searchIndex
*
* Implements a full text search on the created Index using the getResult method.
*
* @param {string}
* @param {array}
*
* @return{object}
*/
searchIndex(filename, ...valuesToSearch) {
const results = {};
let items = valuesToSearch.toString();
items = this.cleanData(items);
if (filename === 'All') {
Object.keys(this.indexObject).forEach((file) => {
results[file] = this.getResult(items, file);
});
} else {
results[filename] = this.getResult(items, filename);
}
return results;
}
}
|
var Makery = require('../../makery'),
_ = require('underscore');
describe("Parameters", function() {
describe("parameters wrapped in function", function() {
beforeEach(function() {
this.Constructor = function (options) {
this.options = options;
};
Makery.blueprint(this.Constructor, function() {
return {
prop1: "value",
prop2: "another value"
}
});
});
it("creates an object with those properties set", function() {
var obj = this.Constructor.make();
expect(obj.options.prop1).toEqual("value");
expect(obj.options.prop2).toEqual("another value");
});
it("creates an object with the overriden properties", function() {
var obj = this.Constructor.make({
prop2: "modified value"
});
expect(obj.options.prop1).toEqual("value");
expect(obj.options.prop2).toEqual("modified value");
});
});
describe("multiple parameters", function() {
describe("two parameters", function() {
beforeEach(function() {
this.Constructor = function (array, options) {
this.array = array;
this.options = options;
};
Makery.blueprint(this.Constructor, function() {
return [[{
id: this.unique()
}, {
id: this.unique()
}, {
id: this.unique()
}], {
prop1: "A value!"
}];
});
});
it("creates the object with those two defaults", function() {
var obj = this.Constructor.make();
expect(obj.array.length).toBe(3);
expect(obj.options.prop1).toBe("A value!");
});
it("allows to use the helpers inside the function", function() {
var obj = this.Constructor.make();
var ids = _.map(obj.array, function(item) {return item.id;});
expect(ids[0]).not.toEqual(ids[1]);
expect(ids[1]).not.toEqual(ids[2]);
expect(ids[2]).not.toEqual(ids[0]);
});
it("creates the object with the overriden parameter and the rest of the defaults", function() {
var obj = this.Constructor.make([{}]);
expect(obj.array.length).toBe(1);
expect(obj.options.prop1).toBe("A value!");
});
it("allows setting undefined to use the default for a parameter", function() {
var obj = this.Constructor.make(undefined, {prop1: "Modified!"});
expect(obj.array.length).toBe(3);
expect(obj.options.prop1).toBe("Modified!");
});
});
});
}); |
import React from 'react';
import {Link, browserHistory} from 'react-router';
import {Card, CardActions, CardHeader, CardMedia, CardTitle, CardText} from 'material-ui/Card';
import FlatButton from 'material-ui/FlatButton';
import styled from 'styled-components';
import Avatar from '../icons/userprofile.jpg';
const ChatContent = styled.div`
display: flex;
width: 100%;
padding: 10px;
border-bottom: 1px #ececec solid;
cursor: pointer;
&:hover {
background: #ccc;
}
`;
const PullRight = styled.div`
width: 50%;
float: right
`;
export default class ChatUserList extends React.Component {
constructor(props) {
super(props);
this.state = {
};
}
componentDidMount() {
}
render() {
return (
<div>
{Object.keys(this.props.users).map((key, i, user) => {
const size = Object.keys(this.props.users).length;
if (size - 1 === i + 1) {
const chatId = (this.props.users[key].client) ? this.props.users[key].userid : this.props.users['.userid'];
const userName = (this.props.users[key].client) ? this.props.users[key].user : '';
return (<ChatContent onClick={this.props.onClick.bind('12', chatId, userName)} key={i}>
<img style={{width: '30px', height: '30px', marginRight: '1em', float: 'left', borderRadius: '50%'}}
src={Avatar} alt=""/>
<PullRight>
<p style={{width: '100%', color: 'rgb(134, 134, 134)', fontWeight: 'bold', fontSize: '13px', marginBottom: '3px'}}>{this.props.users[key].user}: </p>
<p style={{width: '100%', color: 'rgb(134, 134, 134)', fontSize: '12px'}}>{this.props.users[key].message}</p>
</PullRight>
</ChatContent>
);
}
return (
<div></div>
);
})}
</div>
);
}
}
|
// battle three steps:
// battle step 1) prepare (battle preparation)
// battle step 2) turn (battle turn)
// battle step 3) win (battle result)
var fs = require('fs');
var async = require('async');
var mysql = require('mysql');
var util = require('util');
var _ = require('underscore');
var npcUnitAllData = require('../../dao/union/npcUnitAllData');
var playerUnitAllData = require('../../dao/union/playerUnitAllData');
var Player = require('../../domain/Player');
var formula = require('../../util/formula');
var dataApi = require('../../util/dataApi');
var utils = require('../../util/utils');
var gameInit = require('../../../../shared/gameInit');
var commonUtils = require('../../../../shared/util/commonUtils');
var battleBase = require('./battleBase');
var battleAllData = module.exports;
/*
var isDodge = 0;
// dodge(ShanBi) or not
if (formula.stoneEffect(secondForce[i].dodge) {
// hit(MingZhong) or not
if (formula.stoneEffect(firstForce[i].hit) {
// set hit as stone effect
}
else {
// set dodge as stone effect
isDodge = 1;
}
}
if (!isDodge) {
// crit(BaoJi) or not
if (formula.stoneCrit(secondForce[i].dodge) {
// hit(MingZhong) or not
if (formula.stoneEffect(firstForce[i].hit) {
// set hit as stone effect
}
else {
// set dodge as stone effect
isDodge = 1;
}
}
var data = {
"atk": atker,
"be_atk": atkTarget,
"change": atkData
}
turnReport.push(
{
"type": "atk",
"sort_index": sortIndex,
"data": data,
"p1_sp": p1Sp,
"p2_sp": p2Sp
}
);
}
*/
battleAllData.calc = function(mysqlc, playerId, attackeeId, cb) {
async.auto({
attackerData: function(callback) {
playerUnitAllData.get(mysqlc, playerId, function(err, res) {
if (!!err || !res) {
console.log('Get player data failed!');
console.log(err);
}
callback(err, res);
});
},
attackeeData: function(callback) {
playerUnitAllData.get(mysqlc, attackeeId, function(err, res) {
if (!!err || !res) {
console.log('Get attackee data failed!');
console.log(err);
}
callback(err, res);
});
}
}, function(err, results) {
if (!!err || !results) {
console.log('data prepare failed!');
console.log(err);
utils.invokeCallback(cb, err, null);
return;
}
var battleProcess = [];
var battleReport = {};
//console.log(results);
var attackerData = battleBase.unitForce(results.attackerData);
var attackeeData = battleBase.unitForce(results.attackeeData);
var report = {};
report["prepare"] = battleBase.prepare(
results.attackerData,
attackerData,
results.attackeeData,
attackeeData
);
battleProcess = battleBase.calc(attackerData, attackeeData);
var queueRound = [0, 0, 0];
var curRound = 0;
var isSetRound = 0;
var curTurn = 1;
var isSetTurn = 0;
var curSortIndex = 0;
var p1_sp = 0; // player's pet skill point
var p2_sp = 0; // atkee's pet skill point
for (var i = 0; i < battleProcess.length; i++) {
var j = battleProcess[i].turn;
if (j > curTurn) { // init flag
isSetRound = 0;
isSetTurn = 0;
curSortIndex = 0;
curTurn = j;
}
if (typeof report[j] == 'undefined') {
report[j] = [];
}
if (isSetTurn == 0) {
if (!!battleProcess[i].turnPrepare) {
report[j].push(battleProcess[i].data);
report[j].push({
"type": "turn",
"sort_index": -1,
"data": {"turn": battleProcess[i].turn}
});
isSetTurn = 1;
}
}
if (!!battleProcess[i].round) {
if (battleProcess[i].round == curRound) {
}
else if (battleProcess[i].round > curRound) {
curRound = battleProcess[i].round;
report[j].push({
"type": "round",
"sort_index": -1,
"data": {"round": battleProcess[i].round}
});
}
for (var m = 0; m < battleProcess[i].data.length; m++) {
var temp = battleProcess[i].data;
var data = temp[m].data;
if (temp[m].atkeeGroup == 1) {
p1_sp = temp[m].atkeeSp;
}
else if (temp[m].atkeeGroup == 2) {
p2_sp = temp[m].atkeeSp;
}
data["p1_sp"] = p1_sp;
data["p2_sp"] = p2_sp;
// type "atk_skill"
if (!_.isEmpty(temp[m].skill)) {
var d = temp[m].data;
d["skill_id"] = temp[m].skill.skill_id;
d["skill_lv"] = temp[m].skill.skill_lv;
report[j].push({
"type": temp[m].atkType,
"sort_index": temp[m].sortIndex,
"data": data
});
}
else {
// type "atk"
report[j].push({
"type": temp[m].atkType,
"sort_index": temp[m].sortIndex,
"data": data
});
}
}
} // end of if (!!battleProcess[i].round)
if (!!battleProcess[i].battleOver) {
if (attackerData.playerId === battleProcess[i].data.winner) {
report["win"] = 1;
}
else if (attackeeData.playerId === battleProcess[i].data.winner) {
report["win"] = 0;
}
}
} // end of for loop
console.log('------------');
console.log('------------');
console.log('------------');
console.log('------------');
fs.writeFile("text.txt", util.inspect(report, { showHidden: true, depth: null }), function(e) {
if (e) {
console.log('error in writing file');
}
});
//console.log(util.inspect(report, { showHidden: true, depth: null }));
utils.invokeCallback(cb, null, report);
return;
});
}
|
var locale = require("locale")
module.exports = function(app) {
app.route('/')
.get(function(req, res) {
var osArr =req.headers['user-agent'].split("(");
console.log(req.headers['user-agent']);
var os = osArr[1].split(")");
var language =req.headers['accept-language'].split(",");
var language = language[0];
var user = {
OS: os[0], // User Agent we get from headers
lang: language,
ip: req.headers['x-forwarded-for'] || req.connection.remoteAddress, // Get IP - allow for proxy
};
res.send(user);
});
}; |
(function () {
'use strict';
angular
.module('angular-fancytree')
.directive('fancytree', fancytree);
fancytree.$inject = ['$timeout', 'fancytreeFactory'];
/* @ngInject */
function fancytree($timeout, fancytreeFactory) {
var directive = {
template: '<div id="{{ id }}"></div>',
restrict: 'EAC',
scope: {
id: "@",
activevisible: "@",
aria: "@",
autovctivate: "@",
autovollapse: "@",
autoscroll: "@",
clickfoldermode: "@",
checkbox: "@",
debuglevel: "@",
disabled: "@",
focusonselect: "@",
generateids: "@",
idprefix: "@",
icon: "@",
keyboard: "@",
keypathseparator: "@",
minexpandlevel: "@",
quicksearch: "@",
selectmode: "@",
tabbable: "@",
titlestabbable: "@"
},
link: function(scope, element, attrs) {
var initializeFancytree = function () {
return $timeout(function () {
var fancytree = $('#' + scope.id);
var options = {
source: fancytreeFactory.getData(scope.id),
activeVisible: scope.activevisible === 'true',
aria: scope.aria !== 'false',
autoActivate: scope.autoactivate === 'true',
autoCollapse: scope.autocollapse !== 'false',
autoScroll: scope.autoscroll !== 'false',
clickFolderMode: scope.clickfoldermode != null ? parseInt(scope.clickFolderMode) : 4,
checkbox: scope.checkbox !== 'false',
debugLevel: scope.debuglevel != null ? parseInt(scope.debugLevel) : 2,
disabled: scope.disabled !== 'false',
focusOnSelect: scope.focusonselect !== 'false',
generateIds: scope.generateids !== 'false',
idPrefix: scope.idprefix || "ft_",
icon: scope.icon === 'true',
keyboard: scope.keyboard === 'true',
keyPathSeparator: scope.keypathseparator || "/",
minExpandLevel: scope.minexpandlevel != null ? parseInt(scope.minExpandLevel) : 1,
quicksearch: scope.quicksearch !== 'false',
selectMode: scope.selectmode != null ? parseInt(scope.selectMode) : 2,
tabbable: scope.tabbable === 'true',
titlesTabbable: scope.titlestabbable !== 'false',
select: null
};
var methodsObj = fancytreeFactory.getMethods(scope.id);
$.each(methodsObj, function (key, callback) {
if(typeof callback == 'function') {
options[key] = callback;
}
});
fancytree.fancytree(options);
});
};
initializeFancytree();
}
};
return directive;
}
})();
|
// Course Action Types
export const LOAD_COURSES_SUCCESS = 'LOAD_COURSES_SUCCESS';
export const CREATE_COURSE_SUCCESS = 'CREATE_COURSE_SUCCESS';
export const UPDATE_COURSE_SUCCESS = 'UPDATE_COURSE_SUCCESS';
// Author Action Types
export const LOAD_AUTHORS_SUCCESS = 'LOAD_AUTHORS_SUCCESS';
//Loading animation types
export const BEGIN_AJAX_CALL = 'BEGIN_AJAX_CALL';
export const AJAX_CALL_ERROR = 'AJAX_CALL_ERROR';
|
module.exports = function (grunt) {
grunt.initConfig({
pkg: grunt.file.readJSON("package.json"),
clean: {
build: ["<%=pkg.public%>", "<%=pkg.assets%>css", "<%=pkg.assets%>bower_components", "<%=pkg.assets%>index.html"],
mvn: ["<%=pkg.public%>"]
},
copy: {
build: {
files: [
{
cwd: "<%=pkg.assets%>",
expand: true,
src: ["**"],
dest: "<%=pkg.public%>"
}
]
},
run: {
files: [
{
cwd: "<%=pkg.public%>",
expand: true,
src: ["bower_components/**", "css/**", "index.html"],
dest: "<%=pkg.assets%>"
}
]
}
},
"bower-install-simple": {
options: {
directory: "<%=pkg.public%>bower_components"
},
build: {
options: {
production: true,
forceLatest: true
}
}
},
wiredep: {
options: {
color: true,
directory: "<%=pkg.public%>bower_components",
fileTypes: {
html: {
block: /(([ \t]*)<!--\s*bower:*(\S*)\s*-->)(\n|\r|.)*?(<!--\s*endbower\s*-->)/gi,
detect: {
js: /<script.*src=['"]([^'"]+)/gi,
css: /<link.*href=['"]([^'"]+)/gi
},
replace: {
js: '<script src="{{filePath}}" charset="utf-8"></script>',
css: '<link rel="stylesheet" href="{{filePath}}" />'
}
}
}
},
target: {
src: ["<%=pkg.public%>index.html"]
}
},
includeSource: {
options: {
basePath: "<%=pkg.public%>",
duplicates: false,
debug: true
},
target: {
files: {
"<%=pkg.public%>index.html": "<%=pkg.public%>index.tem.html"
}
}
},
watch: {
scripts: {
files: ["*.js", "*.json"],
options: {
livereload: true
}
},
markup: {
files: ["*.html"],
options: {
livereload: true
}
},
stylesheets: {
files: ["*.css"],
options: {
livereload: true
}
}
},
connect: {
server: {
options: {
port: 8080,
base: "src/main/webapp/assets",
keepalive: true
}
}
},
ngAnnotate: {
main: {
files: [{
cwd: "<%=pkg.public%>",
expand: true,
ext: "css",
src: ['modules/**/*.js'],
dest: "<%=pkg.public%>"
}]
}
},
sass: {
options: {
sourceMap: false,
imagePath: "../images"
},
dist: {
files: [{
cwd: "<%=pkg.public%>/scss",
expand: true,
src: ['*.scss'],
ext: ".css",
dest: "<%=pkg.public%>/css"
}]
}
}
});
grunt.loadNpmTasks("grunt-contrib-watch");
grunt.loadNpmTasks("grunt-contrib-connect");
grunt.loadNpmTasks("grunt-include-source");
grunt.loadNpmTasks("grunt-wiredep");
grunt.loadNpmTasks("grunt-bower-install-simple");
grunt.loadNpmTasks("grunt-contrib-copy");
grunt.loadNpmTasks("grunt-contrib-clean");
grunt.loadNpmTasks("grunt-ng-annotate");
grunt.loadNpmTasks("grunt-sass");
grunt.registerTask("mvn", [
"clean:mvn",
"copy:build",
"bower-install-simple:build",
"includeSource:target",
"wiredep:target",
"ngAnnotate:main"
]);
grunt.registerTask("build", [
"clean:build",
"copy:build",
"sass",
"bower-install-simple:build",
"includeSource:target",
"wiredep:target",
"ngAnnotate:main"
]);
grunt.registerTask("jetty", ["build", "copy:run"]);
grunt.registerTask("run", ["build", "copy:run", "connect", "watch"]);
}; |
'use strict';
module.exports = function(grunt) {
// Load all grunt tasks
require('load-grunt-tasks')(grunt);
// Project configuration.
grunt.initConfig({
'json-replace': {
inline: {
files: [
{
expand: true,
flatten: true,
src: ['build/server/swagger.json'],
dest: 'build/server/'
}
],
options: {
space: ' ',
replace: {
"host": "localhost",
"schemes": [
"http"
]
}
}
}
},
shell: {
node_server: {
options: {
stdout: true
},
command: [
'cd node-server',
'mvn package',
'cd ..',
'java -cp swagger-codegen/modules/swagger-codegen-cli/target/lib/*:./node-server/target/* io.swagger.codegen.Codegen -i http://io.adafruit.com/api/docs/api.json -o build/server -l adafruit.codegen.AdafruitIoServerGenerator',
'wget --output-document=build/server/swagger.json http://io.adafruit.com/api/docs/api.json'
].join('&&')
}
}
});
// Default task.
grunt.registerTask('default', ['shell:node_server', 'json-replace']);
};
|
const yo = require('yo-yo')
const {action} = require('mobx')
function dragCorner (corner, index, onDrag) {
return yo`
<div
title="corner ${index}"
style="
background-color: white;
position: absolute;
left: ${corner.x}px;
top: ${corner.y}px;
width: 1rem;
height: 1rem;
text-align: center;
cursor: pointer;
"
draggable="true"
ondrag=${onDrag}
>
+
</div>
`
}
function dragCorners (item) {
const {corners} = item
return yo`
<div class="corners">
${corners.map(function (corner, index) {
const dragIndex = action(
function (event) {
const {x, y} = event
if (x === 0) return
corners[index].x = x
corners[index].y = y
}
)
return dragCorner(corner, index, dragIndex)
})}
</div>
`
}
module.exports = dragCorners
|
odoo.define("pos_product_category_discount.models", function(require) {
"use strict";
var models = require("point_of_sale.models");
var rpc = require("web.rpc");
models.load_models({
model: "pos.discount_program",
fields: [],
domain: function(self) {
return [["discount_program_active", "=", true]];
},
loaded: function(self, discount_program) {
var sorting_discount_program = function(idOne, idTwo) {
return idOne.discount_program_number - idTwo.discount_program_number;
};
if (discount_program) {
self.discount_program = discount_program.sort(sorting_discount_program);
}
},
});
models.load_models({
model: "pos.category_discount",
fields: [],
loaded: function(self, category_discount) {
if (category_discount) {
self.discount_categories = category_discount;
}
},
});
models.load_fields("product.product", ["discount_allowed"]);
models.load_fields("res.partner", ["discount_program_id"]);
var PosModelSuper = models.PosModel;
models.PosModel = models.PosModel.extend({
initialize: function(session, attributes) {
// <new-code>
var self = this;
var product_model = _.find(this.models, function(model) {
return model.model === "product.product";
});
var loaded_super = product_model.loaded;
product_model.loaded = function(that, products) {
loaded_super(that, products);
if (self.config.module_pos_discount) {
self.load_discount_product(product_model.fields, loaded_super);
}
};
// </new-code>
return PosModelSuper.prototype.initialize.call(this, session, attributes);
},
load_discount_product: function(fields, loaded_super) {
var self = this;
var discount_product_id = this.config.discount_product_id[0];
var product = this.db.get_product_by_id(discount_product_id);
if (!product) {
rpc.query({
model: "product.product",
method: "read",
args: [[discount_product_id], fields],
}).then(function(p) {
loaded_super(self, p);
});
}
},
get_discount_categories: function(id) {
return _.filter(this.discount_categories, function(item) {
return item.discount_program_id[0] === id;
});
},
set_discount_categories_by_program_id: function(id) {
if (this.config.module_pos_discount && this.config.discount_product_id) {
var self = this;
var discount_categories = this.get_discount_categories(id);
var order = this.get_order();
if (discount_categories) {
order.remove_all_discounts();
discount_categories.forEach(function(discount) {
self.apply_discount_category(discount);
});
}
}
},
apply_discount_category: function(discount) {
var self = this;
var order = this.get_order();
var lines = order.get_orderlines().filter(function(item) {
if (item.product.pos_category_ids) {
return (
item.product.pos_category_ids.indexOf(
discount.discount_category_id[0]
) !== -1 && item.product.discount_allowed
);
}
return (
item.product.pos_categ_id[0] === discount.discount_category_id[0] &&
item.product.discount_allowed
);
});
lines.forEach(function(line) {
line.discount_program_name = discount.discount_program_id[1];
line.set_discount(discount.category_discount_pc);
});
order.discount_program_id = discount.discount_program_id[0];
order.discount_program_name = discount.discount_program_id[1];
},
});
var OrderSuper = models.Order;
models.Order = models.Order.extend({
remove_all_discounts: function() {
if (
this.pos.config.module_pos_discount &&
this.pos.config.discount_product_id
) {
this.discount_program_id = false;
this.get_orderlines().forEach(function(line) {
if (line.discount_program_name) {
line.set_discount(false);
}
});
}
},
export_as_JSON: function() {
var json = OrderSuper.prototype.export_as_JSON.call(this);
json.product_discount = this.product_discount || false;
json.discount_program_id = this.discount_program_id;
json.discount_program_name = this.discount_program_name;
json.discount_percent = this.discount_percent;
return json;
},
init_from_JSON: function(json) {
OrderSuper.prototype.init_from_JSON.apply(this, arguments);
this.product_discount = json.product_discount || false;
this.discount_program_id = json.discount_program_id;
this.discount_program_name = json.discount_program_name;
this.discount_percent = json.discount_percent;
},
});
var OrderlineSuper = models.Orderline;
models.Orderline = models.Orderline.extend({
initialize: function(attr, options) {
OrderlineSuper.prototype.initialize.apply(this, arguments);
if (
this.order &&
this.order.discount_program_id &&
this.product.discount_allowed
) {
this.apply_product_discount(this.order.discount_program_id);
}
},
apply_product_discount: function(id) {
var self = this;
var discount_categories = this.pos.get_discount_categories(id);
discount_categories.forEach(function(res) {
if (
(self.product.pos_category_ids &&
self.product.pos_category_ids.indexOf(
res.discount_category_id[0]
) !== -1) ||
(self.product.pos_categ_id &&
res.discount_category_id[0] === self.product.pos_categ_id[0])
) {
self.discount_program_name = res.discount_program_id[1];
self.set_discount(res.category_discount_pc);
}
});
},
export_as_JSON: function() {
var json = OrderlineSuper.prototype.export_as_JSON.call(this);
json.discount_program_name = this.discount_program_name || false;
return json;
},
init_from_JSON: function(json) {
OrderlineSuper.prototype.init_from_JSON.apply(this, arguments);
this.discount_program_name = json.discount_program_name || false;
},
get_discount_name: function() {
return this.discount_program_name;
},
});
});
|
/* eslint-disable @typescript-eslint/no-var-requires */
// obtain a reference to the module
// when using the module in your project, this line would be
// const traffic = require('ukpd')
const UKPD = require('../build/src')
async function main () {
const result = await UKPD.availability()
const dates = result.map((item) => item.date)
console.log('data is available for', dates.join(', '))
}
main()
|
/**
* Copyright (c) 2011-2012 Jeff Hoefs <soundanalogous@gmail.com>
* Released under the MIT license. See LICENSE file for details.
*/
JSUTILS.namespace('BO.custom.ID12RFIDReader');
/**
* @namespace BO.custom
*/
BO.custom.ID12RFIDReader = (function() {
var ID12RFIDReader;
// private static constants:
var ID12_READER = 13,
READ_EVENT = 1,
REMOVE_EVENT = 2;
// dependencies
var EventDispatcher = JSUTILS.EventDispatcher,
IOBoardEvent = BO.IOBoardEvent,
RFIDEvent = BO.custom.RFIDEvent;
/**
* Creates an interface to an ID-12 RFID Reader. Other Innovations
* RFID readers will likely work but have not been tested. This object
* requires firmware other than StandardFirmata to be uploaded to the I/O board.
* See [Breakout/custom\_examples/rfid_example1.html](https://github.com/soundanalogous/Breakout/blob/master/custom_examples/rfid_example1.html)
* and [rfid\_example2.html](https://github.com/soundanalogous/Breakout/blob/master/custom_examples/rfid_example2.html) for
* example applications.
*
* <p>To use this object with standard io objects in Breakout,
* RFIDFirmata must be uploaded to the IOBoard rather than StandardFirmata.
* See custom_examples/readme.txt for insturctions.</p>
*
* <p>Is is also possible to create a custom application for your
* IOBoard that includes the RFID reader. See IDx_Reader_Firmata_Example
* in the IDxRFIDReader library example files.</p>
*
* @class ID12RFIDReader
* @constructor
* @uses JSUTILS.EventDispatcher
* @param {IOBoard} board A reference to the IOBoard instance
* @param {Number} readerId The ID assigned to the reader in the firmware
* running on the IOBoard (default = 13)
*/
ID12RFIDReader = function(board, readerId) {
"use strict";
this.name = "ID12RFIDReader";
this._readerId = readerId || ID12_READER;
this._board = board;
this._evtDispatcher = new EventDispatcher(this);
board.addEventListener(IOBoardEvent.SYSEX_MESSAGE, this.onSysExMessage.bind(this));
};
ID12RFIDReader.prototype = {
constructor: ID12RFIDReader,
// private methods:
/**
* @private
* @method onSysExMessage
*/
onSysExMessage: function(event) {
var message = event.message;
if (message[0] != this._readerId) {
return;
} else {
this.processRFIDData(message);
}
},
// this is nice! found it here:
// http://stackoverflow.com/questions/57803/how-to-convert-decimal-to-hex-in-javascript
/**
* @private
* @method dec2hex
*/
dec2hex: function(i) {
return (i + 0x100).toString(16).substr(-2).toUpperCase();
},
/**
* @private
* @method processRFIDData
*/
processRFIDData: function(data) {
var tagEvent = this._board.getValueFromTwo7bitBytes(data[1], data[2]);
var tagEventType = "";
var tag = "";
for (var i = 3, len = data.length; i < len; i += 2) {
tag += this.dec2hex(this._board.getValueFromTwo7bitBytes(data[i], data[i + 1]));
}
// change this to dispatch a single event and handle add or remove in object parameter?
if (tagEvent == READ_EVENT) {
this.dispatch(new RFIDEvent(RFIDEvent.ADD_TAG, tag));
} else if (tagEvent == REMOVE_EVENT) {
this.dispatch(new RFIDEvent(RFIDEvent.REMOVE_TAG, tag));
} else {
// got something else
return;
}
},
/**
* @private
* @method dispatch
*/
dispatch: function(event) {
this.dispatchEvent(event);
},
// public methods:
/* implement EventDispatcher */
/**
* @param {String} type The event type
* @param {Function} listener The function to be called when the event is fired
*/
addEventListener: function(type, listener) {
this._evtDispatcher.addEventListener(type, listener);
},
/**
* @param {String} type The event type
* @param {Function} listener The function to be called when the event is fired
*/
removeEventListener: function(type, listener) {
this._evtDispatcher.removeEventListener(type, listener);
},
/**
* @param {String} type The event type
* return {boolean} True is listener exists for this type, false if not.
*/
hasEventListener: function(type) {
return this._evtDispatcher.hasEventListener(type);
},
/**
* @param {Event} type The Event object
* @param {Object} optionalParams Optional parameters to assign to the event object.
* return {boolean} True if dispatch is successful, false if not.
*/
dispatchEvent: function(event, optionalParams) {
return this._evtDispatcher.dispatchEvent(event, optionalParams);
}
};
// document events
/**
* The addTag event is dispatched when a new tag is read.
* @type BO.custom.RFIDEvent.ADD_TAG
* @event addTag
* @param {BO.custom.ID12RFIDReader} target A reference to the ID12RFIDReader object.
* @param {String} tag The RFID tag value.
*/
/**
* The removeTag event is dispatched when a tag is removed from the reader.
* @type BO.custom.RFIDEvent.REMOVE_TAG
* @event removeTag
* @param {BO.custom.ID12RFIDReader} target A reference to the ID12RFIDReader object.
* @param {String} tag The RFID tag value.
*/
return ID12RFIDReader;
}());
|
'use strict'
const assert = require('assert')
const _ = require('lodash')
const WebServerTrailpack = require('../')
const Trailpack = require('trailpack')
describe('Web Server Trailpack', () => {
let pack
before(() => {
pack = global.app.packs.webservertest
})
it('should load', () => {
assert(pack)
})
it('should be an instance of Trailpack', () => {
assert(pack instanceof Trailpack)
})
it('should be an instance of WebServerTrailpack', () => {
assert(pack instanceof WebServerTrailpack)
})
describe('#getCriteriaFromQuery', () => {
it('should extract criteria from the query object', () => {
const query = {
foo: 'bar',
populate: 'foo',
limit: 100,
offset: 0
}
const criteria = pack.getCriteriaFromQuery(query)
assert.equal(criteria.foo, 'bar')
assert(!criteria.populate)
assert(!criteria.limit)
assert(!criteria.offset)
})
it('should parse criteria from the query object', () => {
const query = {
foo: 'bar',
boolTrue: 'true',
boolFalse: 'false',
nullOk: 'null',
numberOk: '10',
numberDecimalOk: '10.50'
}
const criteria = pack.getCriteriaFromQuery(query)
assert.equal(criteria.foo, 'bar')
assert.equal(criteria.boolTrue, true)
assert.equal(criteria.boolFalse, false)
assert.equal(criteria.nullOk, null)
assert.equal(criteria.numberOk, 10)
assert.equal(criteria.numberDecimalOk, 10.50)
})
})
describe('#getOptionsFromQuery', () => {
it('should extract non-criteria options from the query object', () => {
const query = {
foo: 'bar',
populate: 'foo',
limit: 100,
offset: 0
}
const options = pack.getOptionsFromQuery(query)
assert(!options.foo)
assert.equal(options.populate, 'foo')
assert.equal(options.limit, 100)
assert.equal(options.offset, 0)
})
it('should leave a query with no options untouched', () => {
const query = {
foo: 'bar'
}
const options = pack.getOptionsFromQuery(query)
assert.equal(query.foo, 'bar')
assert(_.isEmpty(options))
})
it('should parse non-criteria options from the query object', () => {
const query = {
foo: 'bar',
populate: 'foo',
limit: '100',
offset: '0'
}
const options = pack.getOptionsFromQuery(query)
assert(!options.foo)
assert.equal(options.populate, 'foo')
assert.equal(options.limit, 100)
assert.equal(options.offset, 0)
})
})
})
|
/**
* 1v1 Plugin
* because jd is a shit fucker
* by: panpawn
*/
exports.commands = {
one: function(target, room, user, connection) {
if (room.id !== '1v1') return this.sendReply("This command can only be used in the '1v1' room.");
if (!this.canTalk()) return;
if (!this.canBroadcast()) return;
var one = toId(target);
var reply = "";
if (!one || one === 'help' || one === 'help' || one === 'git') return this.sendReplyBox("For help, see <a href=\"https://raw.githubusercontent.com/jd4565/Pokemon-Showdown/master/chat-plugins/1v1.js\">here</a>.");
if (one === 'poll') return user.chat('/poll Next 1v1 Tour?, reg, cc1v1, inverse, mono gen, monoletter, monotype, monocolor, cap, eevee only, mega evos, bst based, metronome, lc starters, ubers, lc, 2v2, monopoke, ou choice, almost any ability 1v1, stabmons 1v1, abc cup, averagemons 1v1, balanced hackmons 1v1, tier shift 1v1, mediocremons 1v1, retro1v1', room, connection);
switch (one) {
case 'regular':
case 'reg':
reply += "Banlist is Sleep Inducing moves excluding rest, Focus Sash, and Ubers excluding Mega Gengar.";
break;
case 'onevone':
reply += "Banlist includes Imprison/Transform on the same moveset, Sleep Inducing moves excluding rest, Moody, Imposter, Sturdy if it does not naturally obtain it, Parental Bond if it does not naturally obtain it, Focus Sash, and your pokemon must be level 100.";
break;
case 'uu':
reply += "Anything OU or above.";
break;
case 'ru':
reply += "Anything UU or above.";
break;
case 'ubers':
reply += "Bring a team of ONE pokemon, Banlist is Sleep Inducing moves excluding rest, Focus Sash.";
break;
case 'nu':
reply += "Anything RU or above.";
break;
case 'lc':
reply += "Bring a team of ONE pokemon. These pokemon should be level 5. Banlist is Sleep Inducing moves excluding rest, Focus Sash.";
break;
case 'ubers':
reply += "Nothing but Ditto and Smeargle.";
break;
case 'monoletter':
reply += "A random letter is picked, only Pokemon starting with this letter can be used. Banlist is Sleep inducing moves excluding rest, Focus Sash.";
break;
case 'monotype':
reply += "A random type is picked, only Pokemon of this type can be used. Banlist is Sleep inducing moves excluding rest, Focus Sash.";
break;
case 'monocolor':
reply += "A random color is picked, only Pokemon of this color can be used. Banlist is Sleep inducing moves excluding rest, Focus Sash. Helpul <a href=\"http://bulbapedia.bulbagarden.net/wiki/List_of_Pok%C3%A9mon_by_color\">Link</a>.";
break;
case 'monopoke':
reply += "A random Pokemon is picked, and only that pokemon can be used. Banlist is Sleep inducing moves excluding rest, Focus Sash.";
break;
case 'monogen':
reply += "A random Pokemon generation is picked, and only Pokemon from that gen can be used. Banlist is Sleep inducing moves excluding rest, Focus Sash.";
break;
case 'cap':
reply += "Only Pokemon in the Create-a-Pokemon project can be used here. Ask staff for CAP Info. Banlist is Sleep inducing moves excluding rest, Focus Sash.";
break;
case 'eeveelutions':
reply += "Only Eevee and its many evolutions can be used. Banlist is Sleep Inducing moves excluding rest, Focus sash.";
break;
case 'lcstarters':
reply += "Only the first form of starter pokemon from and generation may be used. These pokemon should be level 5. Banlist is Sleep inducing moves excluding rest, Focus Sash.";
break;
case 'starters':
reply += "Only Starter Pokemon (from any game) may be used.";
break;
case 'bstbased':
reply += "Staff does !pickrandom 200-300, 300-400, 400-500, 500-600, 600-700, 700-800 Then, you must ONLY use pokemon within the range of base stat total chosen";
break;
case 'inverse':
reply += "1v1 Tour set in the Inverse Gamemode. Not-Very-Effective is not Super Effective and vice-versa. Banlist is Ambipom, Sleep Inducing moves, Focus Sash.";
break;
case 'metronome':
reply += "Only the move metronome is allowed in this tour, but on any Pokemon with a BST of 600 or less. Here is the <a href=\"http://pastebin.com/fe2Xtg4L\">banlist</a>.";
break;
case 'megaevos':
reply += "Custom Game format, this one allowing only Mega Evolutions to be used (with items other than mega stones). Here is its <a href=\"http://pastebin.com/d9pJWpya\">banlist</a>.";
break;
case 'stabmons':
reply += "Bring a team of ONE pokemon. Pokemon may use any move sharing a type with them in addition to normally learned moves.";
break;
case 'alphabetcup':
reply += "Bring a team of ONE pokemon. Abbreviated as \"abc cup,\" this is a 1v1 tour set in the alphabet cup <a href=\"http://www.smogon.com/forums/threads/alphabet-cup-other-metagame-of-the-month-march.3498167/\">tier</a>.";
break;
case 'averagemons':
reply += "Bring a team of ONE pokemon. All stats of Pokemon are set to 100! See <a href=\"http://www.smogon.com/forums/threads/averagemons.3495527/\">here</a>.";
break;
case 'balancedhackmons':
case 'bhacks':
reply += "Straight up balanced hackmons 1v1. Almost anything goes. <a href=\"http://www.smogon.com/smog/issue21/hackmons\">Reference</a>. Selection: These tours require you to pick one Pokemon from a team of six.";
break;
case 'ou':
reply += "Bring an OU team and pick one, forfeit/be disqualified if it dies.";
break;
case 'cc1v1':
reply += "Six completely random (Moves, IVs, Species, Item, etc) pokemon are given to you to choose one. Pick the best one and try to win!";
break;
case 'twovtwo':
reply += "<br />" +
"These tours are 2v2 but have the flavor of 1v1 as they are set in the Doubles format.<br />" +
"- Reg 2v2: Everything banned in Smogon Doubles is banned here. 1 Focus sash maximum per team.";
break;
}
this.sendReplyBox("<b>" + one + "</b> - " + reply);
}
};
|
export default class Tokenizer {
constructor(language) {
this.language = language
}
tokenizeLines(lines, sourceFilename) {
const tokenPattern = /^\s*(([0-9]+(\.[0-9]+)*)|([_A-Za-z][_A-Za-z0-9]*)|(\+\=)|(\-\=)|(\*\=)|(\/\=)|\*|\+|\-|\/|\(|\)|\[|\]|\{|\}|(\=\=)|\=|\"|(\<\=)|(\>\=)|\<|\>|(\!\=)|\!|\.|\,)/i
// Parse all lines
const tokens = []
let multilineComment = false
let lineNumber = 1
let linePosition = 0
let tokenIndex = 0
let tokenStartPosition = 0
let tokenEndPosition = linePosition
for (let line of lines) {
linePosition = 0
while (true) {
// Find token
let token = line.match(tokenPattern)
if (token === undefined || token === null) {
break
}
token = token[1].trim()
// Remove token from line
const resultingLine = line.replace(tokenPattern, '')
tokenStartPosition = linePosition
linePosition += line.length - resultingLine.length
tokenEndPosition = linePosition - 1
tokenIndex += 1
line = resultingLine
// Find token type
const type = token in this.language.tokenTypes ? this.language.tokenTypes[token] : this.language.tokenType.Unknown
// Single line comment - ignore rest of line
if (type == this.language.tokenType.SingleLineComment) {
line = ''
continue
}
// Multiline comment
if (type == this.language.tokenType.MultiLineComment) {
multilineComment = !multilineComment
continue
}
// String constant
if (type == this.language.tokenType.StringDelimiter) {
type = this.language.tokenType.StringConstant
const endIndex = line.indexOf('"')
token = line.substring(0, endIndex != -1 ? endIndex : line.length)
line = line.replace(token, '')
if (line.startsWith('"')) {
line = line.substring(1)
}
token = '"' + token + '"'
}
// Number
if (type == this.language.tokenType.Unknown && !isNaN(token)) {
type = this.language.tokenType.Number
}
// Name (upper case start)
if (type == this.language.tokenType.Unknown && token.charAt(0) == token.charAt(0).toUpperCase()) {
type = this.language.tokenType.Name
}
// Variable (lower case start)
if (type == this.language.tokenType.Unknown && token.charAt(0) == token.charAt(0).toLowerCase()) {
type = this.language.tokenType.Variable
}
// Add token if not part of multiline comment
if (!multilineComment) {
tokens.push({
'type': type,
'token': token,
'lineNumber': lineNumber,
'tokenStartPosition': tokenStartPosition,
'tokenEndPosition': tokenEndPosition,
'tokenIndex': tokenIndex,
'filename': sourceFilename
})
}
}
// Add EOL
tokens.push({
'type': this.language.tokenType.EOL,
'token': '',
'lineNumber': lineNumber,
'tokenStartPosition': tokenEndPosition,
'tokenEndPosition': tokenEndPosition,
'tokenIndex': tokenIndex,
'filename': sourceFilename
})
lineNumber += 1
}
// Add EOF
tokens.push({
'type': this.language.tokenType.EOF,
'token': '',
'lineNumber': lineNumber,
'tokenStartPosition': 0,
'tokenEndPosition': 0,
'tokenIndex': tokenIndex,
'filename': sourceFilename
})
return tokens
}
findTokenForwards(type, tokens, fromIndex = 0) {
for (let i = fromIndex; i < tokens.length; i++) {
if (tokens[i].type == type) {
return [i, tokens[i]]
}
}
return [undefined, undefined]
}
findTokenBackwards(type, tokens, toIndex = 0) {
for (let i = tokens.length - 1; i > toIndex; i--) {
if (tokens[i].type == type) {
return [i, tokens[i]]
}
}
return [undefined, undefined]
}
}
|
var should = require('should');
var RootHandler = require('../src/akera-rest-crud.js');
var root = new RootHandler();
var JSDOHandler = require('../src/jsdo/handler.js');
var jsdo = new JSDOHandler(root);
var Response = require('./response.js');
var Request = require('./request.js');
var router = require('./router.js');
var config = {
jsdo : {
asDataset : true,
sqlSafe : true
}
};
var newCustomer = null;
var broker = {
alias : 'sports',
host : '10.10.10.6',
port : 38900
};
var badBroker = {
alias : 'sportsbad',
host : '10.10.10.6',
port : 33333
};
describe('JSDO Handler - Initialization (as datasets)', function() {
it('should initialize correctly', function(done) {
jsdo.init(config, router);
done();
});
});
describe('JSDO Handler - Metadata (as datasets)', function() {
it('should fail to load all services with invalid broker', function(done) {
this.timeout(10000);
var req = new Request().reqParams({
db : 'sports2000'
}).reqBroker(badBroker);
jsdo.getCatalog(req, new Response(function(err, data) {
if (err)
done();
else
done(new Error('Should have returned connection error'));
}));
});
it('should load all services not given db name and table name',
function(done) {
this.timeout(20000);
var req = new Request().reqBroker(broker).reqParams({});
jsdo.getCatalog(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data.version).be.exactly('1.3');
should(data).have.property('services');
should(data.services instanceof Array).be['true']();
should(data.services.length > 0).be['true']();
var sportsService = data.services[0];
should(sportsService.name).be.exactly('sports2000');
should(sportsService).have.property('resources');
should(sportsService.resources instanceof Array).be['true'];
should(sportsService.resources.length > 0).be['true'];
var benefitsResource = sportsService.resources[0];
should(benefitsResource.name).be.exactly('benefits');
should(benefitsResource.path).be.exactly('/benefits');
should(benefitsResource.schema).have.property('properties');
should(benefitsResource.schema.properties).have
.property('dsbenefits');
done();
} catch (e) {
done(new Error(e.message));
}
}
}));
});
it('should load sports service with only customers resource', function(done) {
this.timeout(20000);
var req = new Request().reqParams({
db : 'sports2000',
table : 'customer'
}).reqBroker(broker);
jsdo.getCatalog(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data.services.length).be.exactly(1);
var sportsService = data.services[0];
should(sportsService.name).be.exactly('sports2000');
should(sportsService.resources.length).be.exactly(1);
var customersResource = sportsService.resources[0];
should(customersResource.name).be.exactly('customer');
should(customersResource.schema.properties).have
.property('dscustomer');
done();
} catch (e) {
done(new Error(e.message));
}
}
}));
});
});
describe('JSDO Handler - Crud (as datasets)', function() {
it('should fail to read with invalid broker', function(done) {
this.timeout(20000);
var req = new Request().reqBroker(badBroker).reqParams({
db : 'sports2000',
table : 'customer'
});
jsdo.doSelect(req, new Response(function(err, data) {
if (err)
done();
else
done(new Error('Should have returned connection error'));
}));
});
it('should load sports.customer records', function(done) {
this.timeout(20000);
var req = new Request().reqBroker(broker).reqParams({
db : 'sports',
table : 'customer'
});
jsdo.doSelect(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data).have.property('dscustomer');
should(data.dscustomer).have.property('customer');
var customer = data.dscustomer.customer;
should(customer).be.an.instanceOf(Array);
should(customer[0]).have.properties([ 'CustNum', 'Name', 'Country',
'City' ]);
done();
} catch (e) {
done(new Error(e.message));
}
}
}));
});
it('should load customer records', function(done) {
this.timeout(20000);
var req = new Request().reqBroker(broker).reqParams({
db : 'sports2000',
table : 'customer'
});
jsdo.doSelect(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data).have.property('dscustomer');
should(data.dscustomer).have.property('customer');
var customer = data.dscustomer.customer;
should(customer).be.an.instanceOf(Array);
should(customer[0]).have.properties([ 'CustNum', 'Name', 'Country',
'City' ]);
done();
} catch (e) {
done(new Error(e.message));
}
}
}));
});
it('should read customer records with pagination', function(done) {
this.timeout(10000);
var req = new Request().reqBroker(broker).reqParams({
db : 'sports2000',
table : 'customer'
}).queryString({
top : 5,
offset : 2
});
jsdo.doSelect(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
var customer = data.dscustomer.customer;
should(customer).be.an.instanceOf(Array);
(customer.length).should.be.exactly(5);
should(customer[0]).have.properties([ 'CustNum', 'Name', 'Country',
'City' ]);
(customer[0].CustNum).should.be.exactly(1);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should read customer records with filter', function(done) {
this.timeout(10000);
var req = new Request().reqParams({
db : 'sports2000',
table : 'customer'
}).reqBroker(broker).queryString({
filter : {
logic : 'and',
filters : [ {
operator : 'eq',
value : 5,
field : 'CustNum'
} ]
}
});
jsdo.doSelect(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
var customer = data.dscustomer.customer;
should(customer).be.an.instanceOf(Array);
(customer.length).should.be.exactly(1);
should(customer[0]).have.properties([ 'CustNum', 'Name', 'Country',
'City' ]);
(customer[0].CustNum).should.be.exactly(5);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should read customer records with rollbase filter', function(done) {
this.timeout(10000);
var req = new Request().reqParams({
db : 'sports2000',
table : 'customer'
}).reqBroker(broker).queryString({
filter : 'CustNum=5'
});
jsdo.doSelect(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
var customer = data.dscustomer.customer;
should(customer).be.an.instanceOf(Array);
(customer.length).should.be.exactly(1);
should(customer[0]).have.properties([ 'CustNum', 'Name', 'Country',
'City' ]);
(customer[0].CustNum).should.be.exactly(5);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should count customers', function(done) {
this.timeout(10000);
var req = new Request().reqParams({
db : 'sports2000',
table : 'customer'
}).reqBroker(broker);
jsdo.doCount(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data).have.property('response');
should(data.response).have.property('numRecs');
should(data.response.numRecs).be.above(1);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should count customers with filter', function(done) {
this.timeout(10000);
var req = new Request().reqParams({
db : 'sports2000',
table : 'customer'
}).queryString({
filter : {
logic : 'and',
filters : [ {
operator : 'lt',
value : 5,
field : 'CustNum'
} ]
}
}).reqBroker(broker);
jsdo.doCount(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data).have.property('response');
should(data.response).have.property('numRecs', 4);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should count customers with rollbase filter', function(done) {
this.timeout(10000);
var req = new Request().reqParams({
db : 'sports2000',
table : 'customer'
}).queryString({
filter : 'CustNum=5'
}).reqBroker(broker);
jsdo.doCount(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data).have.property('response');
should(data.response).have.property('numRecs', 1);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should fail to create if invalid table', function(done) {
this.timeout(10000);
var name = 'Medu - ' + new Date().toString();
var req = new Request().reqBroker(broker).reqParams({
db : 'sports2000',
table : 'progress'
}).reqBody({
"dscustomer" : {
"prods:hasChanges" : true,
"customer" : [ {
"prods:rowState" : "created",
"prods:clientId" : "1472579267707-11",
"Name" : name,
"City" : "Cluj"
} ]
}
});
jsdo.doCreate(req, new Response(function(err, data) {
if (err)
done();
else
done(new Error('Should have failed for invalid table'));
}));
});
it('should create customer record', function(done) {
this.timeout(10000);
var name = 'Medu - ' + new Date().toString();
var req = new Request().reqBroker(broker).reqParams({
db : 'sports2000',
table : 'customer'
}).reqBody({
"dscustomer" : {
"prods:hasChanges" : true,
"customer" : [ {
"prods:rowState" : "created",
"prods:clientId" : "1472579267707-11",
"Name" : name,
"City" : "Cluj"
} ]
}
});
jsdo.doCreate(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data.dscustomer.customer).be.an.instanceOf(Array);
data = data.dscustomer.customer[0];
should(data).be.an.instanceOf(Object);
should(data).have
.properties([ 'CustNum', 'Name', 'Country', 'City' ]);
(data.Name).should.be.exactly(name);
(data.City).should.be.exactly('Cluj');
(data.CustNum).should.be.above(1);
newCustomer = data.CustNum;
done();
} catch (err) {
done(err);
}
}
}));
});
it('should update customer record', function(done) {
this.timeout(10000);
var addr = 'Cluj - ' + new Date().toString();
var req = new Request().reqBroker(broker).reqParams({
db : 'sports2000',
table : 'customer'
}).reqBody({
dscustomer : {
'prods:before' : {
customer : [ {
CustNum : 5
} ]
},
customer : [ {
'prods:rowState': 'modified',
Address2 : addr,
Balance : 8080
} ]
}
});
jsdo.doUpdate(req, new Response(
function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data.dscustomer.customer).be.an.instanceOf(Array);
data = data.dscustomer.customer;
should(data[0]).have
.properties([ 'CustNum', 'Balance', 'Address2' ]);
(data[0].Address2).should.be.exactly(addr);
(data[0].Balance).should.be.exactly(8080);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should delete customer record', function(done) {
this.timeout(10000);
var req = new Request().reqBroker(broker).reqParams({
db : 'sports2000',
table : 'customer'
}).reqBody({
dscustomer : {
'prods:before' : {
customer : [ {
CustNum : newCustomer
} ]
}
}
});
jsdo.doDelete(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
(data).should.be.exactly(1);
done();
} catch (err) {
done(err);
}
}
}));
});
// sports hypens check
it('should create sports.customer record', function(done) {
this.timeout(10000);
var name = 'Medu - ' + new Date().toString();
var req = new Request().reqBroker(broker).reqParams({
db : 'sports',
table : 'customer'
}).reqBody({
"dscustomer" : {
"prods:hasChanges" : true,
"customer" : [ {
"prods:rowState" : "created",
"prods:clientId" : "1472579267707-11",
"Name" : name,
"City" : "Cluj"
} ]
}
});
jsdo.doCreate(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data.dscustomer.customer).be.an.instanceOf(Array);
data = data.dscustomer.customer[0];
should(data).be.an.instanceOf(Object);
should(data).have
.properties([ 'CustNum', 'Name', 'Country', 'City' ]);
(data.Name).should.be.exactly(name);
(data.City).should.be.exactly('Cluj');
(data.CustNum).should.be.above(1);
newCustomer = data.CustNum;
done();
} catch (err) {
done(err);
}
}
}));
});
it('should update sports.customer record', function(done) {
this.timeout(10000);
var addr = 'Cluj - ' + new Date().toString();
var req = new Request().reqBroker(broker).reqParams({
db : 'sports',
table : 'customer'
}).reqBody({
dscustomer : {
'prods:before' : {
customer : [ {
CustNum : newCustomer
} ]
},
customer : [ {
'prods:rowState': 'modified',
Address2 : addr,
Balance : 8080
} ]
}
});
jsdo.doUpdate(req, new Response(
function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
should(data.dscustomer.customer).be.an.instanceOf(Array);
data = data.dscustomer.customer;
should(data[0]).have
.properties([ 'CustNum', 'Balance', 'Address2' ]);
(data[0].Address2).should.be.exactly(addr);
(data[0].Balance).should.be.exactly(8080);
done();
} catch (err) {
done(err);
}
}
}));
});
it('should delete sports.customer record', function(done) {
this.timeout(10000);
var req = new Request().reqBroker(broker).reqParams({
db : 'sports',
table : 'customer'
}).reqBody({
dscustomer : {
'prods:before' : {
customer : [ {
CustNum : newCustomer
} ]
}
}
});
jsdo.doDelete(req, new Response(function(err, data) {
if (err)
done(new Error(err.message));
else {
try {
(data).should.be.exactly(1);
done();
} catch (err) {
done(err);
}
}
}));
});
});
|
export * from './functions'
export * from './hkt'
export * from './misc'
export {List, Map} from './immutable-ext'
|
const { describe, it, before } = require('mocha')
const assert = require('assert')
const bitcoin = require('../../')
const regtestUtils = require('./_regtest')
const regtest = regtestUtils.network
const bip65 = require('bip65')
const alice = bitcoin.ECPair.fromWIF('cScfkGjbzzoeewVWmU2hYPUHeVGJRDdFt7WhmrVVGkxpmPP8BHWe', regtest)
const bob = bitcoin.ECPair.fromWIF('cMkopUXKWsEzAjfa1zApksGRwjVpJRB3831qM9W4gKZsLwjHXA9x', regtest)
describe('bitcoinjs-lib (transactions w/ CLTV)', function () {
// force update MTP
before(function (done) {
regtestUtils.mine(11, done)
})
const hashType = bitcoin.Transaction.SIGHASH_ALL
function cltvCheckSigOutput (aQ, bQ, lockTime) {
return bitcoin.script.compile([
bitcoin.opcodes.OP_IF,
bitcoin.script.number.encode(lockTime),
bitcoin.opcodes.OP_CHECKLOCKTIMEVERIFY,
bitcoin.opcodes.OP_DROP,
bitcoin.opcodes.OP_ELSE,
bQ.publicKey,
bitcoin.opcodes.OP_CHECKSIGVERIFY,
bitcoin.opcodes.OP_ENDIF,
aQ.publicKey,
bitcoin.opcodes.OP_CHECKSIG
])
}
function utcNow () {
return Math.floor(Date.now() / 1000)
}
// expiry past, {Alice's signature} OP_TRUE
it('can create (and broadcast via 3PBP) a Transaction where Alice can redeem the output after the expiry (in the past)', function (done) {
// 3 hours ago
const lockTime = bip65.encode({ utc: utcNow() - (3600 * 3) })
const redeemScript = cltvCheckSigOutput(alice, bob, lockTime)
const { address } = bitcoin.payments.p2sh({ redeem: { output: redeemScript, network: regtest }, network: regtest })
// fund the P2SH(CLTV) address
regtestUtils.faucet(address, 1e5, function (err, unspent) {
if (err) return done(err)
const txb = new bitcoin.TransactionBuilder(regtest)
txb.setLockTime(lockTime)
txb.addInput(unspent.txId, unspent.vout, 0xfffffffe)
txb.addOutput(regtestUtils.RANDOM_ADDRESS, 7e4)
// {Alice's signature} OP_TRUE
const tx = txb.buildIncomplete()
const signatureHash = tx.hashForSignature(0, redeemScript, hashType)
const redeemScriptSig = bitcoin.payments.p2sh({
redeem: {
input: bitcoin.script.compile([
bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
bitcoin.opcodes.OP_TRUE
]),
output: redeemScript
}
}).input
tx.setInputScript(0, redeemScriptSig)
regtestUtils.broadcast(tx.toHex(), function (err) {
if (err) return done(err)
regtestUtils.verify({
txId: tx.getId(),
address: regtestUtils.RANDOM_ADDRESS,
vout: 0,
value: 7e4
}, done)
})
})
})
// expiry will pass, {Alice's signature} OP_TRUE
it('can create (and broadcast via 3PBP) a Transaction where Alice can redeem the output after the expiry (in the future)', function (done) {
regtestUtils.height(function (err, height) {
if (err) return done(err)
// 5 blocks from now
const lockTime = bip65.encode({ blocks: height + 5 })
const redeemScript = cltvCheckSigOutput(alice, bob, lockTime)
const { address } = bitcoin.payments.p2sh({ redeem: { output: redeemScript, network: regtest }, network: regtest })
// fund the P2SH(CLTV) address
regtestUtils.faucet(address, 1e5, function (err, unspent) {
if (err) return done(err)
const txb = new bitcoin.TransactionBuilder(regtest)
txb.setLockTime(lockTime)
txb.addInput(unspent.txId, unspent.vout, 0xfffffffe)
txb.addOutput(regtestUtils.RANDOM_ADDRESS, 7e4)
// {Alice's signature} OP_TRUE
const tx = txb.buildIncomplete()
const signatureHash = tx.hashForSignature(0, redeemScript, hashType)
const redeemScriptSig = bitcoin.payments.p2sh({
redeem: {
input: bitcoin.script.compile([
bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
bitcoin.opcodes.OP_TRUE
]),
output: redeemScript
}
}).input
tx.setInputScript(0, redeemScriptSig)
// TODO: test that it failures _prior_ to expiry, unfortunately, race conditions when run concurrently
// ...
// into the future!
regtestUtils.mine(5, function (err) {
if (err) return done(err)
regtestUtils.broadcast(tx.toHex(), function (err) {
if (err) return done(err)
regtestUtils.verify({
txId: tx.getId(),
address: regtestUtils.RANDOM_ADDRESS,
vout: 0,
value: 7e4
}, done)
})
})
})
})
})
// expiry ignored, {Bob's signature} {Alice's signature} OP_FALSE
it('can create (and broadcast via 3PBP) a Transaction where Alice and Bob can redeem the output at any time', function (done) {
// two hours ago
const lockTime = bip65.encode({ utc: utcNow() - (3600 * 2) })
const redeemScript = cltvCheckSigOutput(alice, bob, lockTime)
const { address } = bitcoin.payments.p2sh({ redeem: { output: redeemScript, network: regtest }, network: regtest })
// fund the P2SH(CLTV) address
regtestUtils.faucet(address, 2e5, function (err, unspent) {
if (err) return done(err)
const txb = new bitcoin.TransactionBuilder(regtest)
txb.setLockTime(lockTime)
txb.addInput(unspent.txId, unspent.vout, 0xfffffffe)
txb.addOutput(regtestUtils.RANDOM_ADDRESS, 8e4)
// {Alice's signature} {Bob's signature} OP_FALSE
const tx = txb.buildIncomplete()
const signatureHash = tx.hashForSignature(0, redeemScript, hashType)
const redeemScriptSig = bitcoin.payments.p2sh({
redeem: {
input: bitcoin.script.compile([
bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
bitcoin.script.signature.encode(bob.sign(signatureHash), hashType),
bitcoin.opcodes.OP_FALSE
]),
output: redeemScript
}
}).input
tx.setInputScript(0, redeemScriptSig)
regtestUtils.broadcast(tx.toHex(), function (err) {
if (err) return done(err)
regtestUtils.verify({
txId: tx.getId(),
address: regtestUtils.RANDOM_ADDRESS,
vout: 0,
value: 8e4
}, done)
})
})
})
// expiry in the future, {Alice's signature} OP_TRUE
it('can create (but fail to broadcast via 3PBP) a Transaction where Alice attempts to redeem before the expiry', function (done) {
// two hours from now
const lockTime = bip65.encode({ utc: utcNow() + (3600 * 2) })
const redeemScript = cltvCheckSigOutput(alice, bob, lockTime)
const { address } = bitcoin.payments.p2sh({ redeem: { output: redeemScript, network: regtest }, network: regtest })
// fund the P2SH(CLTV) address
regtestUtils.faucet(address, 2e4, function (err, unspent) {
if (err) return done(err)
const txb = new bitcoin.TransactionBuilder(regtest)
txb.setLockTime(lockTime)
txb.addInput(unspent.txId, unspent.vout, 0xfffffffe)
txb.addOutput(regtestUtils.RANDOM_ADDRESS, 1e4)
// {Alice's signature} OP_TRUE
const tx = txb.buildIncomplete()
const signatureHash = tx.hashForSignature(0, redeemScript, hashType)
const redeemScriptSig = bitcoin.payments.p2sh({
redeem: {
input: bitcoin.script.compile([
bitcoin.script.signature.encode(alice.sign(signatureHash), hashType),
bitcoin.script.signature.encode(bob.sign(signatureHash), hashType),
bitcoin.opcodes.OP_TRUE
]),
output: redeemScript
}
}).input
tx.setInputScript(0, redeemScriptSig)
regtestUtils.broadcast(tx.toHex(), function (err) {
assert.throws(function () {
if (err) throw err
}, /Error: non-final \(code 64\)/)
done()
})
})
})
})
|
const methods = require('methods');
const express = require('express');
const ActionsManager = require('./ActionsManager');
var middleware = module.exports = function(controllerPath) {
function Handler(req, res, next) {
Handler.handle(req, res, next);
};
Handler.__proto__ = middleware;
Handler.router = express.Router();
Handler.actionsManager = new ActionsManager(controllerPath);
return Handler;
};
middleware.setControllerPath = function(controllerPath) {
this.actionsManager.setPath(controllerPath);
}
middleware.setFileLoader = function(fileLoader) {
this.actionsManager.setFileLoader(fileLoader);
}
middleware.setActionLoader = function(actionLoader) {
this.actionsManager.setActionLoader(actionLoader);
}
middleware.setControllerLoader = function(controllerLoader) {
this.actionsManager.setControllerLoader(controllerLoader);
}
middleware.use = function(routerPath, handlerName) {
var action = this.actionsManager.getAction(handlerName);
if (typeof action !== 'function') {
throw new TypeError('Can not find \'' + handlerName + '\' action.');
}
this.router.use(routerPath, action);
}
methods.forEach(function(method) {
middleware[method] = function(routePath, handlerName) {
var action = this.actionsManager.getAction(handlerName);
if (typeof action !== 'function') {
throw new TypeError('Can not find \'' + handlerName + '\' action.');
}
this.router[method].call(this.router, routePath, action);
}
});
middleware.handle = function(req, res, next) {
this.router(req, res, next);
}
|
var async = require('async')
var Metalsmith = require('metalsmith')
var path = require('path')
var prompt = require('cli-prompt')
var render = require('consolidate').handlebars.render
module.exports = function (dest) {
console.log('Generating custom Mithril scaffolding...')
console.log()
var metalsmith = Metalsmith(__dirname)
.use(ask)
.use(template)
.clean(false)
.source(path.resolve(__dirname, '../src'))
.destination(dest)
.build(function(err){
if (err) throw err
})
}
/**
* Prompt plugin.
*
* @param {Object} files
* @param {Metalsmith} metalsmith
* @param {Function} done
*/
function ask(files, metalsmith, done){
var prompts = ['name', 'description', 'author']
var metadata = metalsmith.metadata()
async.eachSeries(prompts, run, done)
function run(key, done){
prompt(' ' + key + ': ', function(val){
metadata[key] = val
done()
})
}
}
/**
* Template in place plugin.
*
* @param {Object} files
* @param {Metalsmith} metalsmith
* @param {Function} done
*/
function template(files, metalsmith, done){
var keys = Object.keys(files)
var metadata = metalsmith.metadata()
async.each(keys, run, done)
function run(file, done){
var str = files[file].contents.toString()
render(str, metadata, function(err, res){
if (err) return done(err)
files[file].contents = new Buffer(res)
done()
})
}
} |
var f = function(){
var _ = NEJ.P,
_f = NEJ.F,
_u = _('nej.u'),
_e = _('nej.e'),
_p = _('nej.ut'),
_j = _('nej.j'),
_proCacheCustom,
_supCacheCustom;
_p._$$CacheCustom = NEJ.C();
_proCacheCustom = _p._$$CacheCustom._$extend(_p._$$Cache);
_supCacheCustom = _proCacheCustom._$supro;
_proCacheCustom.__reset = function(_options){
this.__supReset(_options);
this.__getCache(_options._id);
};
_proCacheCustom.__getCache = function(_id){
var _cache = {};
if (!!_id){
_cache = this.__cache[_id];
if (!_cache){
_cache = {};
this.__cache[_id] = _cache;
}
}
this.__myCache = _cache;
};
/**
* 从cache中获取数据
* @param {Object} _id
*/
_proCacheCustom._$getItemInCache = function(_rkey){
// 这里去缓存中拿
return this.__myCache[_rkey];
}
/**
* 对外保留的获取数据接口
*/
_proCacheCustom._$getData = (function(){
return function(_id,_key){
var _rkey = _id+_key;
var _ropt = {id:_id,key:_key||''},
_item = this._$getItemInCache(_rkey);
if (!!_item){
this._$dispatchEvent('ondataload',_ropt);
return this;
}
if (!this.__doQueueRequest(_rkey,
this._$dispatchEvent._$bind(this,'ondataload'))){
_ropt.rkey = _rkey;
_ropt.onload = this.__getData._$bind(this,_ropt);
this._$dispatchEvent('dodataload',_ropt);
}
return this;
};
})();
_proCacheCustom.__doSaveToCache = function(_rkey,_data){
if(!this.__myCache[_rkey])
this.__myCache[_rkey] = _data;
}
/**
* 请求返回数据后处理
* @param {Object} _ropt
* @param {Object} _data
*/
_proCacheCustom.__getData = function(_ropt,_data){
_ropt = _ropt||_o;
// 这里缓存到列表中去
this.__doSaveToCache(_ropt.rkey,_data);
this.__doCallbackRequest(_ropt.rkey,_ropt);
};
}
define('{pro}util/cacheCustom.js',['{lib}util/cache/cache.js'],f);
|
import { fromJS } from 'immutable';
import userContainerReducer from '../reducer';
describe('userContainerReducer', () => {
it('returns the initial state', () => {
expect(userContainerReducer(undefined, {})).toEqual(fromJS({}));
});
});
|
class Project {
constructor(project){
this.id = project.id
this.title = project.title
this.hours = project.hours
this.words = project.words
this.wordGoal = project.word_goal
this.percent = project.percent_complete_rounded
this.genres = project.genres
this.user = project.user
}
hoursHTML(){
if(this.hours){
return `<div>Hours: ${this.hours}</div>`
} else {
return ""
}
}
goalHTML(){
if(this.wordGoal){
return `<div>Word Goal: ${this.wordGoal}</div>`
} else {
return ""
}
}
progressHTML(){
if(this.wordGoal && this.percent){
return `<div class="progress">
<div class="progress-bar progress-bar-info progress-bar-striped" role="progressbar" aria-valuenow="${this.percent.toFixed(0)}" aria-valuemin="0" aria-valuemax="100" style="width:${this.percent.toFixed(0)}%"></div>
</div>
<span class="text-muted">
${this.percent}% complete
</span>`
} else {
return ""
}
}
genresHTML(){
let genreString = "<div>"
this.genres.forEach(function(genre){
genreString += `<span class="badge badge-info">${genre.name}</span> `
})
genreString += "</div>"
return genreString
}
projectHTML(){
return `<div class="col-12 col-md-6">
<div class="box">
<h3><a href="/projects/${this.id}">${this.title}</a></h3>
${this.genresHTML()}
<div>Created by <a href="/users/${this.user.id}">${this.user.name}</a></div>
${this.hoursHTML()}
${this.goalHTML()}
${this.progressHTML()}
</div>
</div>`
}
}
$(document).on('turbolinks:load', function(){
$(".filter-form").on('submit', function(e){
e.stopImmediatePropagation()
e.preventDefault()
$.get(this.action + ".json?" + $(this).serialize(), renderProjects)
})
})
const renderProjects = projects => {
const renderedProjects = projects.map(project => {
const newProject = new Project(project)
return newProject.projectHTML()
}).join("")
$(".project-index").html("")
$(".project-index").append(renderedProjects)
}
|
const fa_external_link_square = 'M1408 928v-480q0-26-19-45t-45-19h-480q-42 0-59 39-17 41 14 70l144 144-534 534q-19 19-19 45t19 45l102 102q19 19 45 19t45-19l534-534 144 144q18 19 45 19 12 0 25-5 39-17 39-59zm256-512v960q0 119-84.5 203.5t-203.5 84.5h-960q-119 0-203.5-84.5t-84.5-203.5v-960q0-119 84.5-203.5t203.5-84.5h960q119 0 203.5 84.5t84.5 203.5z'
export default fa_external_link_square |
it('/*{{it}}*/',function(done){
var request = connection['/*{{verb}}*/'];
request&&request('/*{{url}}*/',function(err,data){
tools.testOData(data);
done();
});
});
|
export { default } from 'ember-paper-compact-fields/components/paper-radio-with-content'; |
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var core_1 = require('@angular/core');
var LoggerService = (function () {
// TODO: logサーバに飛ばすべ
function LoggerService(_api) {
this._api = _api;
this.authenticated = false;
//
// Loglevel
// 1: error
// 2: warn
// 3: notice
// 4: info
// 5: debug
this._logLevel = 5;
}
LoggerService.prototype.debug = function (arg) {
if (this._logLevel >= 5) {
this._log(arg);
}
};
LoggerService.prototype.info = function (arg) {
if (this._logLevel >= 4) {
this._log(arg);
}
};
LoggerService.prototype.notice = function (arg) {
if (this._logLevel >= 3) {
this._log(arg);
}
};
LoggerService.prototype.warn = function (arg) {
if (this._logLevel >= 2) {
this._log(arg);
}
};
LoggerService.prototype.error = function (arg) {
if (this._logLevel >= 1) {
this._log(arg);
}
};
LoggerService.prototype._log = function (arg) {
console.log(arg);
};
LoggerService = __decorate([
core_1.Injectable()
], LoggerService);
return LoggerService;
}());
exports.LoggerService = LoggerService;
//# sourceMappingURL=logger.service.js.map |
/**
* Created by root on 16-1-19.
*/
var ChatRoomModule = angular.module("ChatRoomModule", ['ngContextMenu']);
ChatRoomModule.controller("chatRoomCtrl", function($rootScope, $scope, $filter, UserService, SocketService){
$scope.editAreaCtn = "";
$scope.currentUserName = "";
$scope.currentNickName = "";
$scope.chatUserList = []; //user chat List
$scope.chatContent = {}; //message Object
$scope.messages = "";
$scope.receiver = "";
$scope.isMacOS = false;
//could use it to judge system os
//console.log(window.navigator);
var messageWrapper = $(".chat-content .list");
$scope.scrollToBottom=function() {
messageWrapper.scrollTop(messageWrapper[0].scrollHeight);
}
var chatListWrapper = $(".panel-body .list .ngscroll-content-container");
//get user list
UserService.getAllOnlineUser()
.then(function(data){
if(data.msg == "success"){
var tmpTime = (Date.parse(new Date) / 1000) - 1000;
var dataList = data.userList;
for(var user in dataList){
dataList[user].MMDigest = "";
dataList[user].noticeCount = 0;
tmpTime += 1;
dataList[user].time = tmpTime;
dataList[user].lastTime = 0;
$scope.chatUserList.push(dataList[user]);
}
}
})
.catch(function(err) {
console.info(err);
})
//mouse right click to clear
$scope.lists = [{
label: 'clear'
}]
$scope.menuOptions = {
itemLabel: 'label',
isMultiple: false
}
$scope.clickMenu = function (item) {
$scope.messages = $scope.chatContent[$scope.currentUserName] = "";
};
$scope.currentContact = {
displayName : "",
getDisplayName : function(){
if($scope.currentContact.displayName){
return true;
} else {
return false;
}
},
setDisplayName : function(nickname) {
$scope.currentNickName = nickname;
$scope.currentContact.displayName = nickname;
}
};
$scope.searchChatList = function(nickname){
}
$scope.itemClick = function(username, nickname){
$scope.currentUserName = username;
$scope.currentContact.setDisplayName(nickname);
var currentChatUserList = $filter('findObject')($scope.chatUserList, username);
currentChatUserList.noticeCount = 0;
if(typeof($scope.chatContent[username]) != "undefined"){
$scope.messages = $scope.chatContent[username];
} else {
$scope.messages = "";
}
}
$scope.editAreaKeydown = function($event){
if ($event.keyCode == 13 && $event.ctrlKey) {
$scope.sendTextMessage();
}
if($event.keyCode == 13 && !$event.ctrlKey){
//$scope.editAreaCtn = $scope.editAreaCtn + "\n";
}
}
$scope.editAreaKeyup = function($event){
//console.log($event);
//console.log("editAreaKeyup");
}
$scope.editAreaClick = function($event){
//console.log($event);
//console.log("editAreaClick");
}
$scope.editAreaBlur = function($event){
//console.log($event);
//console.log("editAreaBlur");
}
$scope.sendTextMessage = function(){
if($scope.editAreaCtn.replace(/(^\s*)|(\s*$)/g, "")){
var rec = $scope.currentUserName;
var currentChatUserList = $filter('findObject')($scope.chatUserList, rec);
var time = 0;
var currentTime = Date.parse(new Date);
if(currentTime - currentChatUserList.lastTime > 60000){
time = currentTime;
currentChatUserList.lastTime = currentTime;
}
var msg = {content : $scope.editAreaCtn, from : $rootScope.username, to : $scope.currentUserName, time : time};
if(!$scope.chatContent[rec]){
$scope.chatContent[rec]=[];
}
$scope.chatContent[rec].push(msg);
if(rec !== $rootScope.username) { //except send to myself
SocketService.emit("sendMessage", msg);
currentChatUserList.MMDigest = $scope.editAreaCtn;
currentChatUserList.time = Date.parse(new Date) / 1000;
$scope.editAreaCtn = "";
$scope.messages = $scope.chatContent[rec];
chatListWrapper.css("margin-top", "0");
}
}
}
//recept the new message
SocketService.on('messageAdded', function(data) {
console.log(data.time);
document.getElementById("jp_audio_0").play();
if(!$scope.chatContent[data.from]){
$scope.chatContent[data.from]=[];
}
$scope.chatContent[data.from].push(data);
var currentChatUserList = $filter('findObject')($scope.chatUserList, data.from);
console.log(currentChatUserList);
if(currentChatUserList.lastTime == 0){
currentChatUserList.lastTime = data.time;
}
console.log(currentChatUserList.lastTime);
currentChatUserList.MMDigest = data.content;
currentChatUserList.time = Date.parse(new Date) / 1000;
chatListWrapper.css("margin-top", "0");
if($scope.currentUserName != data.from){
currentChatUserList.noticeCount++;
} else {
$scope.messages = $scope.chatContent[data.from];
}
});
SocketService.on('userAddingResult', function(data){
var chatUser = [];
chatUser.username = data.username;
chatUser.nickname = data.nickname;
chatUser.MMDigest = "";
chatUser.noticeCount = 0;
chatUser.time = Date.parse(new Date) / 1000;
chatUser.lastTime = 0;
$scope.chatUserList.push(chatUser);
});
SocketService.on('userLogout', function(data) {
for(var i in $scope.chatUserList){
if( $scope.chatUserList[i].username == data.username){
$scope.chatUserList.splice(i, 1);
break;
}
}
});
});
|
/*
* This file is part of the Sulu CMS.
*
* (c) MASSIVE ART WebServices GmbH
*
* This source file is subject to the MIT license that is bundled
* with this source code in the file LICENSE.
*/
/**
* handles single internal link selection
*
* @class SingleInternalLink
* @constructor
*/
define([], function() {
'use strict';
var defaults = {
visibleItems: 999,
instanceName: null,
url: '',
columnNavigationUrl: '',
idsParameter: 'ids',
preselected: null,
idKey: 'id',
titleKey: 'title',
resultKey: '',
disabledIds: [],
translations: {
overlayTitle: 'single-internal-link.title',
noTitle: 'public.no-title'
}
},
/**
* namespace for events
* @type {string}
*/
eventNamespace = 'sulu.single-internal-link.',
/**
* raised when the overlay data has been changed
* @event sulu.internal-links.data-changed
*/
DATA_CHANGED = function() {
return createEventName.call(this, 'data-changed');
},
/**
* returns normalized event names
*/
createEventName = function(postFix) {
return eventNamespace + (this.options.instanceName ? this.options.instanceName + '.' : '') + postFix;
},
templates = {
skeleton: function(options) {
return [
'<div class="single-internal-link container form-element" id="', options.ids.container, '">',
' <a class="fa-link icon action choose" href="#" id="', options.ids.button, '"></a>',
' <a class="fa-times-circle clear" href="#" id="', options.ids.clearButton, '"></a>',
' <input type="text" class="form-element preview-update trigger-save-button" readonly="readonly" id="', options.ids.input, '"/>',
'</div>'
].join('');
},
data: function(options) {
return[
'<div id="', options.ids.columnNavigation, '"/>',
].join('');
}
},
/**
* returns id for given type
*/
getId = function(type) {
return '#' + this.options.ids[type];
},
/**
* render component
*/
render = function() {
// init ids
this.options.ids = {
container: 'single-internal-link-' + this.options.instanceName + '-container',
input: 'single-internal-link-' + this.options.instanceName + '-input',
button: 'single-internal-link-' + this.options.instanceName + '-button',
clearButton: 'single-internal-link-' + this.options.instanceName + '-clear-button',
columnNavigation: 'single-internal-link-' + this.options.instanceName + '-column-navigation'
};
this.sandbox.dom.html(this.$el, templates.skeleton(this.options));
// init container
this.$container = this.sandbox.dom.find(getId.call(this, 'container'), this.$el);
this.$input = this.sandbox.dom.find(getId.call(this, 'input'), this.$el);
this.$button = this.sandbox.dom.find(getId.call(this, 'button'), this.$el);
// set preselected values
if (!!this.sandbox.dom.data(this.$el, 'single-internal-link')) {
var data = this.sandbox.dom.data(this.$el, 'single-internal-link');
setData.call(this, data);
} else {
setData.call(this, this.options.preselected);
}
// sandbox event handling
bindCustomEvents.call(this);
// init vars
this.URI = {
str: '',
hasChanged: false
};
// start overlay
initOverlay.call(this);
// init selected node
if (this.data !== null) {
loadSelectedNode.call(this);
}
bindDomEvents.call(this);
},
setData = function(data) {
this.data = data;
this.sandbox.dom.data(this.$el, 'single-internal-link', this.data);
if (!!data) {
$('#' + this.options.ids.clearButton).show();
} else {
$('#' + this.options.ids.clearButton).hide();
}
},
bindCustomEvents = function() {
this.sandbox.on('husky.overlay.single-internal-link.' + this.options.instanceName + '.initialized', initColumnNavigation.bind(this));
this.sandbox.on('husky.column-navigation.' + this.options.instanceName + '.action', function(item) {
setData.call(this, item.id);
loadSelectedNode.call(this);
this.sandbox.emit(DATA_CHANGED.call(this), this.data, this.$el);
this.sandbox.emit('husky.overlay.single-internal-link.' + this.options.instanceName + '.close');
}.bind(this));
},
bindDomEvents = function() {
this.sandbox.dom.on('#' + this.options.ids.clearButton, 'click', function() {
setData.call(this, '');
this.$input.val('');
return false;
}.bind(this));
},
initOverlay = function() {
var $element = this.sandbox.dom.createElement('<div/>');
this.sandbox.dom.append(this.$el, $element);
this.sandbox.start([
{
name: 'overlay@husky',
options: {
triggerEl: this.$el,
cssClass: 'single-internal-overlay',
el: $element,
container: this.$el,
removeOnClose: false,
instanceName: 'single-internal-link.' + this.options.instanceName,
skin: 'wide',
slides: [
{
title: this.sandbox.translate(this.options.translations.overlayTitle),
data: templates.data(this.options),
buttons: [
{
type: 'cancel'
}
]
}
]
}
}
]);
},
/**
* initialize column navigation
*/
initColumnNavigation = function() {
var url = getSelectUrl(this.options.columnNavigationUrl, this.data);
this.sandbox.start(
[
{
name: 'column-navigation@husky',
options: {
el: getId.call(this, 'columnNavigation'),
selected: this.data,
url: url,
instanceName: this.options.instanceName,
actionIcon: 'fa-plus-circle',
resultKey: this.options.resultKey,
showOptions: false,
showStatus: false,
responsive: false,
sortable: false,
skin: 'fixed-height-small',
disableIds: this.options.disabledIds
}
}
]
);
},
loadSelectedNode = function() {
this.sandbox.util.load(getSingleUrl(this.options.url, this.data)).then(function(data) {
this.$input.val((data.title || this.sandbox.translate(this.options.translations.noTitle)) + ' (' + (data.path || '/') + ')');
}.bind(this));
},
getSelectUrl = function(url, data) {
return url.replace('{id=uuid&}', (!!data ? 'id=' + data + '&' : ''));
},
getSingleUrl = function(url, data) {
return url.replace('{/uuid}', (!!data ? '/' + data : ''));
};
return {
initialize: function() {
// extend default options
this.options = this.sandbox.util.extend({}, defaults, this.options);
render.call(this);
}
};
});
|
/*!
* jQuery Mobile 1.4.3
* Git HEAD hash: b9c6473e3d90af26570e6f14e5a0307897ab385c <> Date: Tue Jul 1 2014 15:37:36 UTC
* http://jquerymobile.com
*
* Copyright 2010, 2014 jQuery Foundation, Inc. and othercontributors
* Released under the MIT license.
* http://jquery.org/license
*
*/
(function ( root, doc, factory ) {
if ( typeof define === "function" && define.amd ) {
// AMD. Register as an anonymous module.
define( [ "jquery" ], function ( $ ) {
factory( $, root, doc );
return $.mobile;
});
} else {
// Browser globals
factory( root.jQuery, root, doc );
}
}( this, document, function ( jQuery, window, document, undefined ) {
(function( $ ) {
$.mobile = {};
}( jQuery ));
(function( $, window, undefined ) {
$.extend( $.mobile, {
// Version of the jQuery Mobile Framework
version: "1.4.3",
// Deprecated and no longer used in 1.4 remove in 1.5
// Define the url parameter used for referencing widget-generated sub-pages.
// Translates to example.html&ui-page=subpageIdentifier
// hash segment before &ui-page= is used to make Ajax request
subPageUrlKey: "ui-page",
hideUrlBar: true,
// Keepnative Selector
keepNative: ":jqmData(role='none'), :jqmData(role='nojs')",
// Deprecated in 1.4 remove in 1.5
// Class assigned to page currently in view, and during transitions
activePageClass: "ui-page-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "active" button state, from CSS framework
activeBtnClass: "ui-btn-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "focus" form element state, from CSS framework
focusClass: "ui-focus",
// Automatically handle clicks and form submissions through Ajax, when same-domain
ajaxEnabled: false,
// Automatically load and show pages based on location.hash
hashListeningEnabled: true,
// disable to prevent jquery from bothering with links
linkBindingEnabled: true,
// Set default page transition - 'none' for no transitions
defaultPageTransition: "fade",
// Set maximum window width for transitions to apply - 'false' for no limit
maxTransitionWidth: false,
// Minimum scroll distance that will be remembered when returning to a page
// Deprecated remove in 1.5
minScrollBack: 0,
// Set default dialog transition - 'none' for no transitions
defaultDialogTransition: "pop",
// Error response message - appears when an Ajax page request fails
pageLoadErrorMessage: "Error Loading Page",
// For error messages, which theme does the box use?
pageLoadErrorMessageTheme: "a",
// replace calls to window.history.back with phonegaps navigation helper
// where it is provided on the window object
phonegapNavigationEnabled: false,
//automatically initialize the DOM when it's ready
autoInitializePage: true,
pushStateEnabled: true,
// allows users to opt in to ignoring content by marking a parent element as
// data-ignored
ignoreContentEnabled: false,
buttonMarkup: {
hoverDelay: 200
},
// disable the alteration of the dynamic base tag or links in the case
// that a dynamic base tag isn't supported
dynamicBaseEnabled: true,
// default the property to remove dependency on assignment in init module
pageContainer: $(),
//enable cross-domain page support
allowCrossDomainPages: false,
dialogHashKey: "&ui-state=dialog"
});
})( jQuery, this );
(function( $, window, undefined ) {
var nsNormalizeDict = {},
oldFind = $.find,
rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
jqmDataRE = /:jqmData\(([^)]*)\)/g;
$.extend( $.mobile, {
// Namespace used framework-wide for data-attrs. Default is no namespace
ns: "",
// Retrieve an attribute from an element and perform some massaging of the value
getAttribute: function( element, key ) {
var data;
element = element.jquery ? element[0] : element;
if ( element && element.getAttribute ) {
data = element.getAttribute( "data-" + $.mobile.ns + key );
}
// Copied from core's src/data.js:dataAttr()
// Convert from a string to a proper data type
try {
data = data === "true" ? true :
data === "false" ? false :
data === "null" ? null :
// Only convert to a number if it doesn't change the string
+data + "" === data ? +data :
rbrace.test( data ) ? JSON.parse( data ) :
data;
} catch( err ) {}
return data;
},
// Expose our cache for testing purposes.
nsNormalizeDict: nsNormalizeDict,
// Take a data attribute property, prepend the namespace
// and then camel case the attribute string. Add the result
// to our nsNormalizeDict so we don't have to do this again.
nsNormalize: function( prop ) {
return nsNormalizeDict[ prop ] ||
( nsNormalizeDict[ prop ] = $.camelCase( $.mobile.ns + prop ) );
},
// Find the closest javascript page element to gather settings data jsperf test
// http://jsperf.com/single-complex-selector-vs-many-complex-selectors/edit
// possibly naive, but it shows that the parsing overhead for *just* the page selector vs
// the page and dialog selector is negligable. This could probably be speed up by
// doing a similar parent node traversal to the one found in the inherited theme code above
closestPageData: function( $target ) {
return $target
.closest( ":jqmData(role='page'), :jqmData(role='dialog')" )
.data( "mobile-page" );
}
});
// Mobile version of data and removeData and hasData methods
// ensures all data is set and retrieved using jQuery Mobile's data namespace
$.fn.jqmData = function( prop, value ) {
var result;
if ( typeof prop !== "undefined" ) {
if ( prop ) {
prop = $.mobile.nsNormalize( prop );
}
// undefined is permitted as an explicit input for the second param
// in this case it returns the value and does not set it to undefined
if ( arguments.length < 2 || value === undefined ) {
result = this.data( prop );
} else {
result = this.data( prop, value );
}
}
return result;
};
$.jqmData = function( elem, prop, value ) {
var result;
if ( typeof prop !== "undefined" ) {
result = $.data( elem, prop ? $.mobile.nsNormalize( prop ) : prop, value );
}
return result;
};
$.fn.jqmRemoveData = function( prop ) {
return this.removeData( $.mobile.nsNormalize( prop ) );
};
$.jqmRemoveData = function( elem, prop ) {
return $.removeData( elem, $.mobile.nsNormalize( prop ) );
};
$.find = function( selector, context, ret, extra ) {
if ( selector.indexOf( ":jqmData" ) > -1 ) {
selector = selector.replace( jqmDataRE, "[data-" + ( $.mobile.ns || "" ) + "$1]" );
}
return oldFind.call( this, selector, context, ret, extra );
};
$.extend( $.find, oldFind );
})( jQuery, this );
/*!
* jQuery UI Core c0ab71056b936627e8a7821f03c044aec6280a40
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/category/ui-core/
*/
(function( $, undefined ) {
var uuid = 0,
runiqueId = /^ui-id-\d+$/;
// $.ui might exist from components with no dependencies, e.g., $.ui.position
$.ui = $.ui || {};
$.extend( $.ui, {
version: "c0ab71056b936627e8a7821f03c044aec6280a40",
keyCode: {
BACKSPACE: 8,
COMMA: 188,
DELETE: 46,
DOWN: 40,
END: 35,
ENTER: 13,
ESCAPE: 27,
HOME: 36,
LEFT: 37,
PAGE_DOWN: 34,
PAGE_UP: 33,
PERIOD: 190,
RIGHT: 39,
SPACE: 32,
TAB: 9,
UP: 38
}
});
// plugins
$.fn.extend({
focus: (function( orig ) {
return function( delay, fn ) {
return typeof delay === "number" ?
this.each(function() {
var elem = this;
setTimeout(function() {
$( elem ).focus();
if ( fn ) {
fn.call( elem );
}
}, delay );
}) :
orig.apply( this, arguments );
};
})( $.fn.focus ),
scrollParent: function() {
var scrollParent;
if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
scrollParent = this.parents().filter(function() {
return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
}).eq(0);
} else {
scrollParent = this.parents().filter(function() {
return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
}).eq(0);
}
return ( /fixed/ ).test( this.css( "position") ) || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
},
uniqueId: function() {
return this.each(function() {
if ( !this.id ) {
this.id = "ui-id-" + (++uuid);
}
});
},
removeUniqueId: function() {
return this.each(function() {
if ( runiqueId.test( this.id ) ) {
$( this ).removeAttr( "id" );
}
});
}
});
// selectors
function focusable( element, isTabIndexNotNaN ) {
var map, mapName, img,
nodeName = element.nodeName.toLowerCase();
if ( "area" === nodeName ) {
map = element.parentNode;
mapName = map.name;
if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
return false;
}
img = $( "img[usemap=#" + mapName + "]" )[0];
return !!img && visible( img );
}
return ( /input|select|textarea|button|object/.test( nodeName ) ?
!element.disabled :
"a" === nodeName ?
element.href || isTabIndexNotNaN :
isTabIndexNotNaN) &&
// the element and all of its ancestors must be visible
visible( element );
}
function visible( element ) {
return $.expr.filters.visible( element ) &&
!$( element ).parents().addBack().filter(function() {
return $.css( this, "visibility" ) === "hidden";
}).length;
}
$.extend( $.expr[ ":" ], {
data: $.expr.createPseudo ?
$.expr.createPseudo(function( dataName ) {
return function( elem ) {
return !!$.data( elem, dataName );
};
}) :
// support: jQuery <1.8
function( elem, i, match ) {
return !!$.data( elem, match[ 3 ] );
},
focusable: function( element ) {
return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
},
tabbable: function( element ) {
var tabIndex = $.attr( element, "tabindex" ),
isTabIndexNaN = isNaN( tabIndex );
return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
}
});
// support: jQuery <1.8
if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
$.each( [ "Width", "Height" ], function( i, name ) {
var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
type = name.toLowerCase(),
orig = {
innerWidth: $.fn.innerWidth,
innerHeight: $.fn.innerHeight,
outerWidth: $.fn.outerWidth,
outerHeight: $.fn.outerHeight
};
function reduce( elem, size, border, margin ) {
$.each( side, function() {
size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
if ( border ) {
size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
}
if ( margin ) {
size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
}
});
return size;
}
$.fn[ "inner" + name ] = function( size ) {
if ( size === undefined ) {
return orig[ "inner" + name ].call( this );
}
return this.each(function() {
$( this ).css( type, reduce( this, size ) + "px" );
});
};
$.fn[ "outer" + name] = function( size, margin ) {
if ( typeof size !== "number" ) {
return orig[ "outer" + name ].call( this, size );
}
return this.each(function() {
$( this).css( type, reduce( this, size, true, margin ) + "px" );
});
};
});
}
// support: jQuery <1.8
if ( !$.fn.addBack ) {
$.fn.addBack = function( selector ) {
return this.add( selector == null ?
this.prevObject : this.prevObject.filter( selector )
);
};
}
// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
$.fn.removeData = (function( removeData ) {
return function( key ) {
if ( arguments.length ) {
return removeData.call( this, $.camelCase( key ) );
} else {
return removeData.call( this );
}
};
})( $.fn.removeData );
}
// deprecated
$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
$.support.selectstart = "onselectstart" in document.createElement( "div" );
$.fn.extend({
disableSelection: function() {
return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
".ui-disableSelection", function( event ) {
event.preventDefault();
});
},
enableSelection: function() {
return this.unbind( ".ui-disableSelection" );
},
zIndex: function( zIndex ) {
if ( zIndex !== undefined ) {
return this.css( "zIndex", zIndex );
}
if ( this.length ) {
var elem = $( this[ 0 ] ), position, value;
while ( elem.length && elem[ 0 ] !== document ) {
// Ignore z-index if position is set to a value where z-index is ignored by the browser
// This makes behavior of this function consistent across browsers
// WebKit always returns auto if the element is positioned
position = elem.css( "position" );
if ( position === "absolute" || position === "relative" || position === "fixed" ) {
// IE returns 0 when zIndex is not specified
// other browsers return a string
// we ignore the case of nested elements with an explicit value of 0
// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
value = parseInt( elem.css( "zIndex" ), 10 );
if ( !isNaN( value ) && value !== 0 ) {
return value;
}
}
elem = elem.parent();
}
}
return 0;
}
});
// $.ui.plugin is deprecated. Use $.widget() extensions instead.
$.ui.plugin = {
add: function( module, option, set ) {
var i,
proto = $.ui[ module ].prototype;
for ( i in set ) {
proto.plugins[ i ] = proto.plugins[ i ] || [];
proto.plugins[ i ].push( [ option, set[ i ] ] );
}
},
call: function( instance, name, args, allowDisconnected ) {
var i,
set = instance.plugins[ name ];
if ( !set ) {
return;
}
if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
return;
}
for ( i = 0; i < set.length; i++ ) {
if ( instance.options[ set[ i ][ 0 ] ] ) {
set[ i ][ 1 ].apply( instance.element, args );
}
}
}
};
})( jQuery );
(function( $, window, undefined ) {
// Subtract the height of external toolbars from the page height, if the page does not have
// internal toolbars of the same type
var compensateToolbars = function( page, desiredHeight ) {
var pageParent = page.parent(),
toolbarsAffectingHeight = [],
externalHeaders = pageParent.children( ":jqmData(role='header')" ),
internalHeaders = page.children( ":jqmData(role='header')" ),
externalFooters = pageParent.children( ":jqmData(role='footer')" ),
internalFooters = page.children( ":jqmData(role='footer')" );
// If we have no internal headers, but we do have external headers, then their height
// reduces the page height
if ( internalHeaders.length === 0 && externalHeaders.length > 0 ) {
toolbarsAffectingHeight = toolbarsAffectingHeight.concat( externalHeaders.toArray() );
}
// If we have no internal footers, but we do have external footers, then their height
// reduces the page height
if ( internalFooters.length === 0 && externalFooters.length > 0 ) {
toolbarsAffectingHeight = toolbarsAffectingHeight.concat( externalFooters.toArray() );
}
$.each( toolbarsAffectingHeight, function( index, value ) {
desiredHeight -= $( value ).outerHeight();
});
// Height must be at least zero
return Math.max( 0, desiredHeight );
};
$.extend( $.mobile, {
// define the window and the document objects
window: $( window ),
document: $( document ),
// TODO: Remove and use $.ui.keyCode directly
keyCode: $.ui.keyCode,
// Place to store various widget extensions
behaviors: {},
// Scroll page vertically: scroll to 0 to hide iOS address bar, or pass a Y value
silentScroll: function( ypos ) {
if ( $.type( ypos ) !== "number" ) {
ypos = $.mobile.defaultHomeScroll;
}
// prevent scrollstart and scrollstop events
$.event.special.scrollstart.enabled = false;
setTimeout(function() {
window.scrollTo( 0, ypos );
$.mobile.document.trigger( "silentscroll", { x: 0, y: ypos });
}, 20 );
setTimeout(function() {
$.event.special.scrollstart.enabled = true;
}, 150 );
},
getClosestBaseUrl: function( ele ) {
// Find the closest page and extract out its url.
var url = $( ele ).closest( ".ui-page" ).jqmData( "url" ),
base = $.mobile.path.documentBase.hrefNoHash;
if ( !$.mobile.dynamicBaseEnabled || !url || !$.mobile.path.isPath( url ) ) {
url = base;
}
return $.mobile.path.makeUrlAbsolute( url, base );
},
removeActiveLinkClass: function( forceRemoval ) {
if ( !!$.mobile.activeClickedLink &&
( !$.mobile.activeClickedLink.closest( "." + $.mobile.activePageClass ).length ||
forceRemoval ) ) {
$.mobile.activeClickedLink.removeClass( $.mobile.activeBtnClass );
}
$.mobile.activeClickedLink = null;
},
// DEPRECATED in 1.4
// Find the closest parent with a theme class on it. Note that
// we are not using $.fn.closest() on purpose here because this
// method gets called quite a bit and we need it to be as fast
// as possible.
getInheritedTheme: function( el, defaultTheme ) {
var e = el[ 0 ],
ltr = "",
re = /ui-(bar|body|overlay)-([a-z])\b/,
c, m;
while ( e ) {
c = e.className || "";
if ( c && ( m = re.exec( c ) ) && ( ltr = m[ 2 ] ) ) {
// We found a parent with a theme class
// on it so bail from this loop.
break;
}
e = e.parentNode;
}
// Return the theme letter we found, if none, return the
// specified default.
return ltr || defaultTheme || "a";
},
enhanceable: function( elements ) {
return this.haveParents( elements, "enhance" );
},
hijackable: function( elements ) {
return this.haveParents( elements, "ajax" );
},
haveParents: function( elements, attr ) {
if ( !$.mobile.ignoreContentEnabled ) {
return elements;
}
var count = elements.length,
$newSet = $(),
e, $element, excluded,
i, c;
for ( i = 0; i < count; i++ ) {
$element = elements.eq( i );
excluded = false;
e = elements[ i ];
while ( e ) {
c = e.getAttribute ? e.getAttribute( "data-" + $.mobile.ns + attr ) : "";
if ( c === "false" ) {
excluded = true;
break;
}
e = e.parentNode;
}
if ( !excluded ) {
$newSet = $newSet.add( $element );
}
}
return $newSet;
},
getScreenHeight: function() {
// Native innerHeight returns more accurate value for this across platforms,
// jQuery version is here as a normalized fallback for platforms like Symbian
return window.innerHeight || $.mobile.window.height();
},
//simply set the active page's minimum height to screen height, depending on orientation
resetActivePageHeight: function( height ) {
var page = $( "." + $.mobile.activePageClass ),
pageHeight = page.height(),
pageOuterHeight = page.outerHeight( true );
height = compensateToolbars( page,
( typeof height === "number" ) ? height : $.mobile.getScreenHeight() );
// Remove any previous min-height setting
page.css( "min-height", "" );
// Set the minimum height only if the height as determined by CSS is insufficient
if ( page.height() < height ) {
page.css( "min-height", height - ( pageOuterHeight - pageHeight ) );
}
},
loading: function() {
// If this is the first call to this function, instantiate a loader widget
var loader = this.loading._widget || $( $.mobile.loader.prototype.defaultHtml ).loader(),
// Call the appropriate method on the loader
returnValue = loader.loader.apply( loader, arguments );
// Make sure the loader is retained for future calls to this function.
this.loading._widget = loader;
return returnValue;
}
});
$.addDependents = function( elem, newDependents ) {
var $elem = $( elem ),
dependents = $elem.jqmData( "dependents" ) || $();
$elem.jqmData( "dependents", $( dependents ).add( newDependents ) );
};
// plugins
$.fn.extend({
removeWithDependents: function() {
$.removeWithDependents( this );
},
// Enhance child elements
enhanceWithin: function() {
var index,
widgetElements = {},
keepNative = $.mobile.page.prototype.keepNativeSelector(),
that = this;
// Add no js class to elements
if ( $.mobile.nojs ) {
$.mobile.nojs( this );
}
// Bind links for ajax nav
if ( $.mobile.links ) {
$.mobile.links( this );
}
// Degrade inputs for styleing
if ( $.mobile.degradeInputsWithin ) {
$.mobile.degradeInputsWithin( this );
}
// Run buttonmarkup
if ( $.fn.buttonMarkup ) {
this.find( $.fn.buttonMarkup.initSelector ).not( keepNative )
.jqmEnhanceable().buttonMarkup();
}
// Add classes for fieldContain
if ( $.fn.fieldcontain ) {
this.find( ":jqmData(role='fieldcontain')" ).not( keepNative )
.jqmEnhanceable().fieldcontain();
}
// Enhance widgets
$.each( $.mobile.widgets, function( name, constructor ) {
// If initSelector not false find elements
if ( constructor.initSelector ) {
// Filter elements that should not be enhanced based on parents
var elements = $.mobile.enhanceable( that.find( constructor.initSelector ) );
// If any matching elements remain filter ones with keepNativeSelector
if ( elements.length > 0 ) {
// $.mobile.page.prototype.keepNativeSelector is deprecated this is just for backcompat
// Switch to $.mobile.keepNative in 1.5 which is just a value not a function
elements = elements.not( keepNative );
}
// Enhance whatever is left
if ( elements.length > 0 ) {
widgetElements[ constructor.prototype.widgetName ] = elements;
}
}
});
for ( index in widgetElements ) {
widgetElements[ index ][ index ]();
}
return this;
},
addDependents: function( newDependents ) {
$.addDependents( this, newDependents );
},
// note that this helper doesn't attempt to handle the callback
// or setting of an html element's text, its only purpose is
// to return the html encoded version of the text in all cases. (thus the name)
getEncodedText: function() {
return $( "<a>" ).text( this.text() ).html();
},
// fluent helper function for the mobile namespaced equivalent
jqmEnhanceable: function() {
return $.mobile.enhanceable( this );
},
jqmHijackable: function() {
return $.mobile.hijackable( this );
}
});
$.removeWithDependents = function( nativeElement ) {
var element = $( nativeElement );
( element.jqmData( "dependents" ) || $() ).remove();
element.remove();
};
$.addDependents = function( nativeElement, newDependents ) {
var element = $( nativeElement ),
dependents = element.jqmData( "dependents" ) || $();
element.jqmData( "dependents", $( dependents ).add( newDependents ) );
};
$.find.matches = function( expr, set ) {
return $.find( expr, null, null, set );
};
$.find.matchesSelector = function( node, expr ) {
return $.find( expr, null, null, [ node ] ).length > 0;
};
})( jQuery, this );
/*!
* jQuery UI Widget c0ab71056b936627e8a7821f03c044aec6280a40
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/jQuery.widget/
*/
(function( $, undefined ) {
var uuid = 0,
slice = Array.prototype.slice,
_cleanData = $.cleanData;
$.cleanData = function( elems ) {
for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
try {
$( elem ).triggerHandler( "remove" );
// http://bugs.jquery.com/ticket/8235
} catch( e ) {}
}
_cleanData( elems );
};
$.widget = function( name, base, prototype ) {
var fullName, existingConstructor, constructor, basePrototype,
// proxiedPrototype allows the provided prototype to remain unmodified
// so that it can be used as a mixin for multiple widgets (#8876)
proxiedPrototype = {},
namespace = name.split( "." )[ 0 ];
name = name.split( "." )[ 1 ];
fullName = namespace + "-" + name;
if ( !prototype ) {
prototype = base;
base = $.Widget;
}
// create selector for plugin
$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
return !!$.data( elem, fullName );
};
$[ namespace ] = $[ namespace ] || {};
existingConstructor = $[ namespace ][ name ];
constructor = $[ namespace ][ name ] = function( options, element ) {
// allow instantiation without "new" keyword
if ( !this._createWidget ) {
return new constructor( options, element );
}
// allow instantiation without initializing for simple inheritance
// must use "new" keyword (the code above always passes args)
if ( arguments.length ) {
this._createWidget( options, element );
}
};
// extend with the existing constructor to carry over any static properties
$.extend( constructor, existingConstructor, {
version: prototype.version,
// copy the object used to create the prototype in case we need to
// redefine the widget later
_proto: $.extend( {}, prototype ),
// track widgets that inherit from this widget in case this widget is
// redefined after a widget inherits from it
_childConstructors: []
});
basePrototype = new base();
// we need to make the options hash a property directly on the new instance
// otherwise we'll modify the options hash on the prototype that we're
// inheriting from
basePrototype.options = $.widget.extend( {}, basePrototype.options );
$.each( prototype, function( prop, value ) {
if ( !$.isFunction( value ) ) {
proxiedPrototype[ prop ] = value;
return;
}
proxiedPrototype[ prop ] = (function() {
var _super = function() {
return base.prototype[ prop ].apply( this, arguments );
},
_superApply = function( args ) {
return base.prototype[ prop ].apply( this, args );
};
return function() {
var __super = this._super,
__superApply = this._superApply,
returnValue;
this._super = _super;
this._superApply = _superApply;
returnValue = value.apply( this, arguments );
this._super = __super;
this._superApply = __superApply;
return returnValue;
};
})();
});
constructor.prototype = $.widget.extend( basePrototype, {
// TODO: remove support for widgetEventPrefix
// always use the name + a colon as the prefix, e.g., draggable:start
// don't prefix for widgets that aren't DOM-based
widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
}, proxiedPrototype, {
constructor: constructor,
namespace: namespace,
widgetName: name,
widgetFullName: fullName
});
// If this widget is being redefined then we need to find all widgets that
// are inheriting from it and redefine all of them so that they inherit from
// the new version of this widget. We're essentially trying to replace one
// level in the prototype chain.
if ( existingConstructor ) {
$.each( existingConstructor._childConstructors, function( i, child ) {
var childPrototype = child.prototype;
// redefine the child widget using the same prototype that was
// originally used, but inherit from the new version of the base
$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
});
// remove the list of existing child constructors from the old constructor
// so the old child constructors can be garbage collected
delete existingConstructor._childConstructors;
} else {
base._childConstructors.push( constructor );
}
$.widget.bridge( name, constructor );
return constructor;
};
$.widget.extend = function( target ) {
var input = slice.call( arguments, 1 ),
inputIndex = 0,
inputLength = input.length,
key,
value;
for ( ; inputIndex < inputLength; inputIndex++ ) {
for ( key in input[ inputIndex ] ) {
value = input[ inputIndex ][ key ];
if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
// Clone objects
if ( $.isPlainObject( value ) ) {
target[ key ] = $.isPlainObject( target[ key ] ) ?
$.widget.extend( {}, target[ key ], value ) :
// Don't extend strings, arrays, etc. with objects
$.widget.extend( {}, value );
// Copy everything else by reference
} else {
target[ key ] = value;
}
}
}
}
return target;
};
$.widget.bridge = function( name, object ) {
var fullName = object.prototype.widgetFullName || name;
$.fn[ name ] = function( options ) {
var isMethodCall = typeof options === "string",
args = slice.call( arguments, 1 ),
returnValue = this;
// allow multiple hashes to be passed on init
options = !isMethodCall && args.length ?
$.widget.extend.apply( null, [ options ].concat(args) ) :
options;
if ( isMethodCall ) {
this.each(function() {
var methodValue,
instance = $.data( this, fullName );
if ( options === "instance" ) {
returnValue = instance;
return false;
}
if ( !instance ) {
return $.error( "cannot call methods on " + name + " prior to initialization; " +
"attempted to call method '" + options + "'" );
}
if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
return $.error( "no such method '" + options + "' for " + name + " widget instance" );
}
methodValue = instance[ options ].apply( instance, args );
if ( methodValue !== instance && methodValue !== undefined ) {
returnValue = methodValue && methodValue.jquery ?
returnValue.pushStack( methodValue.get() ) :
methodValue;
return false;
}
});
} else {
this.each(function() {
var instance = $.data( this, fullName );
if ( instance ) {
instance.option( options || {} )._init();
} else {
$.data( this, fullName, new object( options, this ) );
}
});
}
return returnValue;
};
};
$.Widget = function( /* options, element */ ) {};
$.Widget._childConstructors = [];
$.Widget.prototype = {
widgetName: "widget",
widgetEventPrefix: "",
defaultElement: "<div>",
options: {
disabled: false,
// callbacks
create: null
},
_createWidget: function( options, element ) {
element = $( element || this.defaultElement || this )[ 0 ];
this.element = $( element );
this.uuid = uuid++;
this.eventNamespace = "." + this.widgetName + this.uuid;
this.options = $.widget.extend( {},
this.options,
this._getCreateOptions(),
options );
this.bindings = $();
this.hoverable = $();
this.focusable = $();
if ( element !== this ) {
$.data( element, this.widgetFullName, this );
this._on( true, this.element, {
remove: function( event ) {
if ( event.target === element ) {
this.destroy();
}
}
});
this.document = $( element.style ?
// element within the document
element.ownerDocument :
// element is window or document
element.document || element );
this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
}
this._create();
this._trigger( "create", null, this._getCreateEventData() );
this._init();
},
_getCreateOptions: $.noop,
_getCreateEventData: $.noop,
_create: $.noop,
_init: $.noop,
destroy: function() {
this._destroy();
// we can probably remove the unbind calls in 2.0
// all event bindings should go through this._on()
this.element
.unbind( this.eventNamespace )
.removeData( this.widgetFullName )
// support: jquery <1.6.3
// http://bugs.jquery.com/ticket/9413
.removeData( $.camelCase( this.widgetFullName ) );
this.widget()
.unbind( this.eventNamespace )
.removeAttr( "aria-disabled" )
.removeClass(
this.widgetFullName + "-disabled " +
"ui-state-disabled" );
// clean up events and states
this.bindings.unbind( this.eventNamespace );
this.hoverable.removeClass( "ui-state-hover" );
this.focusable.removeClass( "ui-state-focus" );
},
_destroy: $.noop,
widget: function() {
return this.element;
},
option: function( key, value ) {
var options = key,
parts,
curOption,
i;
if ( arguments.length === 0 ) {
// don't return a reference to the internal hash
return $.widget.extend( {}, this.options );
}
if ( typeof key === "string" ) {
// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
options = {};
parts = key.split( "." );
key = parts.shift();
if ( parts.length ) {
curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
for ( i = 0; i < parts.length - 1; i++ ) {
curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
curOption = curOption[ parts[ i ] ];
}
key = parts.pop();
if ( value === undefined ) {
return curOption[ key ] === undefined ? null : curOption[ key ];
}
curOption[ key ] = value;
} else {
if ( value === undefined ) {
return this.options[ key ] === undefined ? null : this.options[ key ];
}
options[ key ] = value;
}
}
this._setOptions( options );
return this;
},
_setOptions: function( options ) {
var key;
for ( key in options ) {
this._setOption( key, options[ key ] );
}
return this;
},
_setOption: function( key, value ) {
this.options[ key ] = value;
if ( key === "disabled" ) {
this.widget()
.toggleClass( this.widgetFullName + "-disabled", !!value );
this.hoverable.removeClass( "ui-state-hover" );
this.focusable.removeClass( "ui-state-focus" );
}
return this;
},
enable: function() {
return this._setOptions({ disabled: false });
},
disable: function() {
return this._setOptions({ disabled: true });
},
_on: function( suppressDisabledCheck, element, handlers ) {
var delegateElement,
instance = this;
// no suppressDisabledCheck flag, shuffle arguments
if ( typeof suppressDisabledCheck !== "boolean" ) {
handlers = element;
element = suppressDisabledCheck;
suppressDisabledCheck = false;
}
// no element argument, shuffle and use this.element
if ( !handlers ) {
handlers = element;
element = this.element;
delegateElement = this.widget();
} else {
// accept selectors, DOM elements
element = delegateElement = $( element );
this.bindings = this.bindings.add( element );
}
$.each( handlers, function( event, handler ) {
function handlerProxy() {
// allow widgets to customize the disabled handling
// - disabled as an array instead of boolean
// - disabled class as method for disabling individual parts
if ( !suppressDisabledCheck &&
( instance.options.disabled === true ||
$( this ).hasClass( "ui-state-disabled" ) ) ) {
return;
}
return ( typeof handler === "string" ? instance[ handler ] : handler )
.apply( instance, arguments );
}
// copy the guid so direct unbinding works
if ( typeof handler !== "string" ) {
handlerProxy.guid = handler.guid =
handler.guid || handlerProxy.guid || $.guid++;
}
var match = event.match( /^(\w+)\s*(.*)$/ ),
eventName = match[1] + instance.eventNamespace,
selector = match[2];
if ( selector ) {
delegateElement.delegate( selector, eventName, handlerProxy );
} else {
element.bind( eventName, handlerProxy );
}
});
},
_off: function( element, eventName ) {
eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
element.unbind( eventName ).undelegate( eventName );
},
_delay: function( handler, delay ) {
function handlerProxy() {
return ( typeof handler === "string" ? instance[ handler ] : handler )
.apply( instance, arguments );
}
var instance = this;
return setTimeout( handlerProxy, delay || 0 );
},
_hoverable: function( element ) {
this.hoverable = this.hoverable.add( element );
this._on( element, {
mouseenter: function( event ) {
$( event.currentTarget ).addClass( "ui-state-hover" );
},
mouseleave: function( event ) {
$( event.currentTarget ).removeClass( "ui-state-hover" );
}
});
},
_focusable: function( element ) {
this.focusable = this.focusable.add( element );
this._on( element, {
focusin: function( event ) {
$( event.currentTarget ).addClass( "ui-state-focus" );
},
focusout: function( event ) {
$( event.currentTarget ).removeClass( "ui-state-focus" );
}
});
},
_trigger: function( type, event, data ) {
var prop, orig,
callback = this.options[ type ];
data = data || {};
event = $.Event( event );
event.type = ( type === this.widgetEventPrefix ?
type :
this.widgetEventPrefix + type ).toLowerCase();
// the original event may come from any element
// so we need to reset the target on the new event
event.target = this.element[ 0 ];
// copy original event properties over to the new event
orig = event.originalEvent;
if ( orig ) {
for ( prop in orig ) {
if ( !( prop in event ) ) {
event[ prop ] = orig[ prop ];
}
}
}
this.element.trigger( event, data );
return !( $.isFunction( callback ) &&
callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
event.isDefaultPrevented() );
}
};
$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
if ( typeof options === "string" ) {
options = { effect: options };
}
var hasOptions,
effectName = !options ?
method :
options === true || typeof options === "number" ?
defaultEffect :
options.effect || defaultEffect;
options = options || {};
if ( typeof options === "number" ) {
options = { duration: options };
}
hasOptions = !$.isEmptyObject( options );
options.complete = callback;
if ( options.delay ) {
element.delay( options.delay );
}
if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
element[ method ]( options );
} else if ( effectName !== method && element[ effectName ] ) {
element[ effectName ]( options.duration, options.easing, callback );
} else {
element.queue(function( next ) {
$( this )[ method ]();
if ( callback ) {
callback.call( element[ 0 ] );
}
next();
});
}
};
});
})( jQuery );
(function( $, undefined ) {
var rcapitals = /[A-Z]/g,
replaceFunction = function( c ) {
return "-" + c.toLowerCase();
};
$.extend( $.Widget.prototype, {
_getCreateOptions: function() {
var option, value,
elem = this.element[ 0 ],
options = {};
//
if ( !$.mobile.getAttribute( elem, "defaults" ) ) {
for ( option in this.options ) {
value = $.mobile.getAttribute( elem, option.replace( rcapitals, replaceFunction ) );
if ( value != null ) {
options[ option ] = value;
}
}
}
return options;
}
});
//TODO: Remove in 1.5 for backcompat only
$.mobile.widget = $.Widget;
})( jQuery );
(function( $ ) {
// TODO move loader class down into the widget settings
var loaderClass = "ui-loader", $html = $( "html" );
$.widget( "mobile.loader", {
// NOTE if the global config settings are defined they will override these
// options
options: {
// the theme for the loading message
theme: "a",
// whether the text in the loading message is shown
textVisible: false,
// custom html for the inner content of the loading message
html: "",
// the text to be displayed when the popup is shown
text: "loading"
},
defaultHtml: "<div class='" + loaderClass + "'>" +
"<span class='ui-icon-loading'></span>" +
"<h1></h1>" +
"</div>",
// For non-fixed supportin browsers. Position at y center (if scrollTop supported), above the activeBtn (if defined), or just 100px from top
fakeFixLoader: function() {
var activeBtn = $( "." + $.mobile.activeBtnClass ).first();
this.element
.css({
top: $.support.scrollTop && this.window.scrollTop() + this.window.height() / 2 ||
activeBtn.length && activeBtn.offset().top || 100
});
},
// check position of loader to see if it appears to be "fixed" to center
// if not, use abs positioning
checkLoaderPosition: function() {
var offset = this.element.offset(),
scrollTop = this.window.scrollTop(),
screenHeight = $.mobile.getScreenHeight();
if ( offset.top < scrollTop || ( offset.top - scrollTop ) > screenHeight ) {
this.element.addClass( "ui-loader-fakefix" );
this.fakeFixLoader();
this.window
.unbind( "scroll", this.checkLoaderPosition )
.bind( "scroll", $.proxy( this.fakeFixLoader, this ) );
}
},
resetHtml: function() {
this.element.html( $( this.defaultHtml ).html() );
},
// Turn on/off page loading message. Theme doubles as an object argument
// with the following shape: { theme: '', text: '', html: '', textVisible: '' }
// NOTE that the $.mobile.loading* settings and params past the first are deprecated
// TODO sweet jesus we need to break some of this out
show: function( theme, msgText, textonly ) {
var textVisible, message, loadSettings;
this.resetHtml();
// use the prototype options so that people can set them globally at
// mobile init. Consistency, it's what's for dinner
if ( $.type( theme ) === "object" ) {
loadSettings = $.extend( {}, this.options, theme );
theme = loadSettings.theme;
} else {
loadSettings = this.options;
// here we prefer the theme value passed as a string argument, then
// we prefer the global option because we can't use undefined default
// prototype options, then the prototype option
theme = theme || loadSettings.theme;
}
// set the message text, prefer the param, then the settings object
// then loading message
message = msgText || ( loadSettings.text === false ? "" : loadSettings.text );
// prepare the dom
$html.addClass( "ui-loading" );
textVisible = loadSettings.textVisible;
// add the proper css given the options (theme, text, etc)
// Force text visibility if the second argument was supplied, or
// if the text was explicitly set in the object args
this.element.attr("class", loaderClass +
" ui-corner-all ui-body-" + theme +
" ui-loader-" + ( textVisible || msgText || theme.text ? "verbose" : "default" ) +
( loadSettings.textonly || textonly ? " ui-loader-textonly" : "" ) );
// TODO verify that jquery.fn.html is ok to use in both cases here
// this might be overly defensive in preventing unknowing xss
// if the html attribute is defined on the loading settings, use that
// otherwise use the fallbacks from above
if ( loadSettings.html ) {
this.element.html( loadSettings.html );
} else {
this.element.find( "h1" ).text( message );
}
// attach the loader to the DOM
this.element.appendTo( $.mobile.pageContainer );
// check that the loader is visible
this.checkLoaderPosition();
// on scroll check the loader position
this.window.bind( "scroll", $.proxy( this.checkLoaderPosition, this ) );
},
hide: function() {
$html.removeClass( "ui-loading" );
if ( this.options.text ) {
this.element.removeClass( "ui-loader-fakefix" );
}
$.mobile.window.unbind( "scroll", this.fakeFixLoader );
$.mobile.window.unbind( "scroll", this.checkLoaderPosition );
}
});
})(jQuery, this);
/*!
* jQuery hashchange event - v1.3 - 7/21/2010
* http://benalman.com/projects/jquery-hashchange-plugin/
*
* Copyright (c) 2010 "Cowboy" Ben Alman
* Dual licensed under the MIT and GPL licenses.
* http://benalman.com/about/license/
*/
// Script: jQuery hashchange event
//
// *Version: 1.3, Last updated: 7/21/2010*
//
// Project Home - http://benalman.com/projects/jquery-hashchange-plugin/
// GitHub - http://github.com/cowboy/jquery-hashchange/
// Source - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js
// (Minified) - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (0.8kb gzipped)
//
// About: License
//
// Copyright (c) 2010 "Cowboy" Ben Alman,
// Dual licensed under the MIT and GPL licenses.
// http://benalman.com/about/license/
//
// About: Examples
//
// These working examples, complete with fully commented code, illustrate a few
// ways in which this plugin can be used.
//
// hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/
// document.domain - http://benalman.com/code/projects/jquery-hashchange/examples/document_domain/
//
// About: Support and Testing
//
// Information about what version or versions of jQuery this plugin has been
// tested with, what browsers it has been tested in, and where the unit tests
// reside (so you can test it yourself).
//
// jQuery Versions - 1.2.6, 1.3.2, 1.4.1, 1.4.2
// Browsers Tested - Internet Explorer 6-8, Firefox 2-4, Chrome 5-6, Safari 3.2-5,
// Opera 9.6-10.60, iPhone 3.1, Android 1.6-2.2, BlackBerry 4.6-5.
// Unit Tests - http://benalman.com/code/projects/jquery-hashchange/unit/
//
// About: Known issues
//
// While this jQuery hashchange event implementation is quite stable and
// robust, there are a few unfortunate browser bugs surrounding expected
// hashchange event-based behaviors, independent of any JavaScript
// window.onhashchange abstraction. See the following examples for more
// information:
//
// Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/
// Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/
// WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/
// Safari: Back Button from a different domain - http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/
//
// Also note that should a browser natively support the window.onhashchange
// event, but not report that it does, the fallback polling loop will be used.
//
// About: Release History
//
// 1.3 - (7/21/2010) Reorganized IE6/7 Iframe code to make it more
// "removable" for mobile-only development. Added IE6/7 document.title
// support. Attempted to make Iframe as hidden as possible by using
// techniques from http://www.paciellogroup.com/blog/?p=604. Added
// support for the "shortcut" format $(window).hashchange( fn ) and
// $(window).hashchange() like jQuery provides for built-in events.
// Renamed jQuery.hashchangeDelay to <jQuery.fn.hashchange.delay> and
// lowered its default value to 50. Added <jQuery.fn.hashchange.domain>
// and <jQuery.fn.hashchange.src> properties plus document-domain.html
// file to address access denied issues when setting document.domain in
// IE6/7.
// 1.2 - (2/11/2010) Fixed a bug where coming back to a page using this plugin
// from a page on another domain would cause an error in Safari 4. Also,
// IE6/7 Iframe is now inserted after the body (this actually works),
// which prevents the page from scrolling when the event is first bound.
// Event can also now be bound before DOM ready, but it won't be usable
// before then in IE6/7.
// 1.1 - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug
// where browser version is incorrectly reported as 8.0, despite
// inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag.
// 1.0 - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special
// window.onhashchange functionality into a separate plugin for users
// who want just the basic event & back button support, without all the
// extra awesomeness that BBQ provides. This plugin will be included as
// part of jQuery BBQ, but also be available separately.
(function($,window,undefined){
'$:nomunge'; // Used by YUI compressor.
// Reused string.
var str_hashchange = 'hashchange',
// Method / object references.
doc = document,
fake_onhashchange,
special = $.event.special,
// Does the browser support window.onhashchange? Note that IE8 running in
// IE7 compatibility mode reports true for 'onhashchange' in window, even
// though the event isn't supported, so also test document.documentMode.
doc_mode = doc.documentMode,
supports_onhashchange = 'on' + str_hashchange in window && ( doc_mode === undefined || doc_mode > 7 );
// Get location.hash (or what you'd expect location.hash to be) sans any
// leading #. Thanks for making this necessary, Firefox!
function get_fragment( url ) {
url = url || location.href;
return '#' + url.replace( /^[^#]*#?(.*)$/, '$1' );
};
// Method: jQuery.fn.hashchange
//
// Bind a handler to the window.onhashchange event or trigger all bound
// window.onhashchange event handlers. This behavior is consistent with
// jQuery's built-in event handlers.
//
// Usage:
//
// > jQuery(window).hashchange( [ handler ] );
//
// Arguments:
//
// handler - (Function) Optional handler to be bound to the hashchange
// event. This is a "shortcut" for the more verbose form:
// jQuery(window).bind( 'hashchange', handler ). If handler is omitted,
// all bound window.onhashchange event handlers will be triggered. This
// is a shortcut for the more verbose
// jQuery(window).trigger( 'hashchange' ). These forms are described in
// the <hashchange event> section.
//
// Returns:
//
// (jQuery) The initial jQuery collection of elements.
// Allow the "shortcut" format $(elem).hashchange( fn ) for binding and
// $(elem).hashchange() for triggering, like jQuery does for built-in events.
$.fn[ str_hashchange ] = function( fn ) {
return fn ? this.bind( str_hashchange, fn ) : this.trigger( str_hashchange );
};
// Property: jQuery.fn.hashchange.delay
//
// The numeric interval (in milliseconds) at which the <hashchange event>
// polling loop executes. Defaults to 50.
// Property: jQuery.fn.hashchange.domain
//
// If you're setting document.domain in your JavaScript, and you want hash
// history to work in IE6/7, not only must this property be set, but you must
// also set document.domain BEFORE jQuery is loaded into the page. This
// property is only applicable if you are supporting IE6/7 (or IE8 operating
// in "IE7 compatibility" mode).
//
// In addition, the <jQuery.fn.hashchange.src> property must be set to the
// path of the included "document-domain.html" file, which can be renamed or
// modified if necessary (note that the document.domain specified must be the
// same in both your main JavaScript as well as in this file).
//
// Usage:
//
// jQuery.fn.hashchange.domain = document.domain;
// Property: jQuery.fn.hashchange.src
//
// If, for some reason, you need to specify an Iframe src file (for example,
// when setting document.domain as in <jQuery.fn.hashchange.domain>), you can
// do so using this property. Note that when using this property, history
// won't be recorded in IE6/7 until the Iframe src file loads. This property
// is only applicable if you are supporting IE6/7 (or IE8 operating in "IE7
// compatibility" mode).
//
// Usage:
//
// jQuery.fn.hashchange.src = 'path/to/file.html';
$.fn[ str_hashchange ].delay = 50;
/*
$.fn[ str_hashchange ].domain = null;
$.fn[ str_hashchange ].src = null;
*/
// Event: hashchange event
//
// Fired when location.hash changes. In browsers that support it, the native
// HTML5 window.onhashchange event is used, otherwise a polling loop is
// initialized, running every <jQuery.fn.hashchange.delay> milliseconds to
// see if the hash has changed. In IE6/7 (and IE8 operating in "IE7
// compatibility" mode), a hidden Iframe is created to allow the back button
// and hash-based history to work.
//
// Usage as described in <jQuery.fn.hashchange>:
//
// > // Bind an event handler.
// > jQuery(window).hashchange( function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).hashchange();
//
// A more verbose usage that allows for event namespacing:
//
// > // Bind an event handler.
// > jQuery(window).bind( 'hashchange', function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).trigger( 'hashchange' );
//
// Additional Notes:
//
// * The polling loop and Iframe are not created until at least one handler
// is actually bound to the 'hashchange' event.
// * If you need the bound handler(s) to execute immediately, in cases where
// a location.hash exists on page load, via bookmark or page refresh for
// example, use jQuery(window).hashchange() or the more verbose
// jQuery(window).trigger( 'hashchange' ).
// * The event can be bound before DOM ready, but since it won't be usable
// before then in IE6/7 (due to the necessary Iframe), recommended usage is
// to bind it inside a DOM ready handler.
// Override existing $.event.special.hashchange methods (allowing this plugin
// to be defined after jQuery BBQ in BBQ's source code).
special[ str_hashchange ] = $.extend( special[ str_hashchange ], {
// Called only when the first 'hashchange' event is bound to window.
setup: function() {
// If window.onhashchange is supported natively, there's nothing to do..
if ( supports_onhashchange ) { return false; }
// Otherwise, we need to create our own. And we don't want to call this
// until the user binds to the event, just in case they never do, since it
// will create a polling loop and possibly even a hidden Iframe.
$( fake_onhashchange.start );
},
// Called only when the last 'hashchange' event is unbound from window.
teardown: function() {
// If window.onhashchange is supported natively, there's nothing to do..
if ( supports_onhashchange ) { return false; }
// Otherwise, we need to stop ours (if possible).
$( fake_onhashchange.stop );
}
});
// fake_onhashchange does all the work of triggering the window.onhashchange
// event for browsers that don't natively support it, including creating a
// polling loop to watch for hash changes and in IE 6/7 creating a hidden
// Iframe to enable back and forward.
fake_onhashchange = (function(){
var self = {},
timeout_id,
// Remember the initial hash so it doesn't get triggered immediately.
last_hash = get_fragment(),
fn_retval = function(val){ return val; },
history_set = fn_retval,
history_get = fn_retval;
// Start the polling loop.
self.start = function() {
timeout_id || poll();
};
// Stop the polling loop.
self.stop = function() {
timeout_id && clearTimeout( timeout_id );
timeout_id = undefined;
};
// This polling loop checks every $.fn.hashchange.delay milliseconds to see
// if location.hash has changed, and triggers the 'hashchange' event on
// window when necessary.
function poll() {
var hash = get_fragment(),
history_hash = history_get( last_hash );
if ( hash !== last_hash ) {
history_set( last_hash = hash, history_hash );
$(window).trigger( str_hashchange );
} else if ( history_hash !== last_hash ) {
location.href = location.href.replace( /#.*/, '' ) + history_hash;
}
timeout_id = setTimeout( poll, $.fn[ str_hashchange ].delay );
};
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvv REMOVE IF NOT SUPPORTING IE6/7/8 vvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
window.attachEvent && !window.addEventListener && !supports_onhashchange && (function(){
// Not only do IE6/7 need the "magical" Iframe treatment, but so does IE8
// when running in "IE7 compatibility" mode.
var iframe,
iframe_src;
// When the event is bound and polling starts in IE 6/7, create a hidden
// Iframe for history handling.
self.start = function(){
if ( !iframe ) {
iframe_src = $.fn[ str_hashchange ].src;
iframe_src = iframe_src && iframe_src + get_fragment();
// Create hidden Iframe. Attempt to make Iframe as hidden as possible
// by using techniques from http://www.paciellogroup.com/blog/?p=604.
iframe = $('<iframe tabindex="-1" title="empty"/>').hide()
// When Iframe has completely loaded, initialize the history and
// start polling.
.one( 'load', function(){
iframe_src || history_set( get_fragment() );
poll();
})
// Load Iframe src if specified, otherwise nothing.
.attr( 'src', iframe_src || 'javascript:0' )
// Append Iframe after the end of the body to prevent unnecessary
// initial page scrolling (yes, this works).
.insertAfter( 'body' )[0].contentWindow;
// Whenever `document.title` changes, update the Iframe's title to
// prettify the back/next history menu entries. Since IE sometimes
// errors with "Unspecified error" the very first time this is set
// (yes, very useful) wrap this with a try/catch block.
doc.onpropertychange = function(){
try {
if ( event.propertyName === 'title' ) {
iframe.document.title = doc.title;
}
} catch(e) {}
};
}
};
// Override the "stop" method since an IE6/7 Iframe was created. Even
// if there are no longer any bound event handlers, the polling loop
// is still necessary for back/next to work at all!
self.stop = fn_retval;
// Get history by looking at the hidden Iframe's location.hash.
history_get = function() {
return get_fragment( iframe.location.href );
};
// Set a new history item by opening and then closing the Iframe
// document, *then* setting its location.hash. If document.domain has
// been set, update that as well.
history_set = function( hash, history_hash ) {
var iframe_doc = iframe.document,
domain = $.fn[ str_hashchange ].domain;
if ( hash !== history_hash ) {
// Update Iframe with any initial `document.title` that might be set.
iframe_doc.title = doc.title;
// Opening the Iframe's document after it has been closed is what
// actually adds a history entry.
iframe_doc.open();
// Set document.domain for the Iframe document as well, if necessary.
domain && iframe_doc.write( '\x3cscript>document.domain="' + domain + '"\x3c/script>' );
iframe_doc.close();
// Update the Iframe's hash, for great justice.
iframe.location.hash = hash;
}
};
})();
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^ REMOVE IF NOT SUPPORTING IE6/7/8 ^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self;
})();
})(jQuery,this);
(function( $, undefined ) {
/*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas. Dual MIT/BSD license */
window.matchMedia = window.matchMedia || (function( doc, undefined ) {
var bool,
docElem = doc.documentElement,
refNode = docElem.firstElementChild || docElem.firstChild,
// fakeBody required for <FF4 when executed in <head>
fakeBody = doc.createElement( "body" ),
div = doc.createElement( "div" );
div.id = "mq-test-1";
div.style.cssText = "position:absolute;top:-100em";
fakeBody.style.background = "none";
fakeBody.appendChild(div);
return function(q){
div.innerHTML = "­<style media=\"" + q + "\"> #mq-test-1 { width: 42px; }</style>";
docElem.insertBefore( fakeBody, refNode );
bool = div.offsetWidth === 42;
docElem.removeChild( fakeBody );
return {
matches: bool,
media: q
};
};
}( document ));
// $.mobile.media uses matchMedia to return a boolean.
$.mobile.media = function( q ) {
return window.matchMedia( q ).matches;
};
})(jQuery);
(function( $, undefined ) {
var support = {
touch: "ontouchend" in document
};
$.mobile.support = $.mobile.support || {};
$.extend( $.support, support );
$.extend( $.mobile.support, support );
}( jQuery ));
(function( $, undefined ) {
$.extend( $.support, {
orientation: "orientation" in window && "onorientationchange" in window
});
}( jQuery ));
(function( $, undefined ) {
// thx Modernizr
function propExists( prop ) {
var uc_prop = prop.charAt( 0 ).toUpperCase() + prop.substr( 1 ),
props = ( prop + " " + vendors.join( uc_prop + " " ) + uc_prop ).split( " " ),
v;
for ( v in props ) {
if ( fbCSS[ props[ v ] ] !== undefined ) {
return true;
}
}
}
var fakeBody = $( "<body>" ).prependTo( "html" ),
fbCSS = fakeBody[ 0 ].style,
vendors = [ "Webkit", "Moz", "O" ],
webos = "palmGetResource" in window, //only used to rule out scrollTop
operamini = window.operamini && ({}).toString.call( window.operamini ) === "[object OperaMini]",
bb = window.blackberry && !propExists( "-webkit-transform" ), //only used to rule out box shadow, as it's filled opaque on BB 5 and lower
nokiaLTE7_3;
// inline SVG support test
function inlineSVG() {
// Thanks Modernizr & Erik Dahlstrom
var w = window,
svg = !!w.document.createElementNS && !!w.document.createElementNS( "http://www.w3.org/2000/svg", "svg" ).createSVGRect && !( w.opera && navigator.userAgent.indexOf( "Chrome" ) === -1 ),
support = function( data ) {
if ( !( data && svg ) ) {
$( "html" ).addClass( "ui-nosvg" );
}
},
img = new w.Image();
img.onerror = function() {
support( false );
};
img.onload = function() {
support( img.width === 1 && img.height === 1 );
};
img.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==";
}
function transform3dTest() {
var mqProp = "transform-3d",
// Because the `translate3d` test below throws false positives in Android:
ret = $.mobile.media( "(-" + vendors.join( "-" + mqProp + "),(-" ) + "-" + mqProp + "),(" + mqProp + ")" ),
el, transforms, t;
if ( ret ) {
return !!ret;
}
el = document.createElement( "div" );
transforms = {
// We’re omitting Opera for the time being; MS uses unprefixed.
"MozTransform": "-moz-transform",
"transform": "transform"
};
fakeBody.append( el );
for ( t in transforms ) {
if ( el.style[ t ] !== undefined ) {
el.style[ t ] = "translate3d( 100px, 1px, 1px )";
ret = window.getComputedStyle( el ).getPropertyValue( transforms[ t ] );
}
}
return ( !!ret && ret !== "none" );
}
// Test for dynamic-updating base tag support ( allows us to avoid href,src attr rewriting )
function baseTagTest() {
var fauxBase = location.protocol + "//" + location.host + location.pathname + "ui-dir/",
base = $( "head base" ),
fauxEle = null,
href = "",
link, rebase;
if ( !base.length ) {
base = fauxEle = $( "<base>", { "href": fauxBase }).appendTo( "head" );
} else {
href = base.attr( "href" );
}
link = $( "<a href='testurl' />" ).prependTo( fakeBody );
rebase = link[ 0 ].href;
base[ 0 ].href = href || location.pathname;
if ( fauxEle ) {
fauxEle.remove();
}
return rebase.indexOf( fauxBase ) === 0;
}
// Thanks Modernizr
function cssPointerEventsTest() {
var element = document.createElement( "x" ),
documentElement = document.documentElement,
getComputedStyle = window.getComputedStyle,
supports;
if ( !( "pointerEvents" in element.style ) ) {
return false;
}
element.style.pointerEvents = "auto";
element.style.pointerEvents = "x";
documentElement.appendChild( element );
supports = getComputedStyle &&
getComputedStyle( element, "" ).pointerEvents === "auto";
documentElement.removeChild( element );
return !!supports;
}
function boundingRect() {
var div = document.createElement( "div" );
return typeof div.getBoundingClientRect !== "undefined";
}
// non-UA-based IE version check by James Padolsey, modified by jdalton - from http://gist.github.com/527683
// allows for inclusion of IE 6+, including Windows Mobile 7
$.extend( $.mobile, { browser: {} } );
$.mobile.browser.oldIE = (function() {
var v = 3,
div = document.createElement( "div" ),
a = div.all || [];
do {
div.innerHTML = "<!--[if gt IE " + ( ++v ) + "]><br><![endif]-->";
} while( a[0] );
return v > 4 ? v : !v;
})();
function fixedPosition() {
var w = window,
ua = navigator.userAgent,
platform = navigator.platform,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match( /AppleWebKit\/([0-9]+)/ ),
wkversion = !!wkmatch && wkmatch[ 1 ],
ffmatch = ua.match( /Fennec\/([0-9]+)/ ),
ffversion = !!ffmatch && ffmatch[ 1 ],
operammobilematch = ua.match( /Opera Mobi\/([0-9]+)/ ),
omversion = !!operammobilematch && operammobilematch[ 1 ];
if (
// iOS 4.3 and older : Platform is iPhone/Pad/Touch and Webkit version is less than 534 (ios5)
( ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1 || platform.indexOf( "iPod" ) > -1 ) && wkversion && wkversion < 534 ) ||
// Opera Mini
( w.operamini && ({}).toString.call( w.operamini ) === "[object OperaMini]" ) ||
( operammobilematch && omversion < 7458 ) ||
//Android lte 2.1: Platform is Android and Webkit version is less than 533 (Android 2.2)
( ua.indexOf( "Android" ) > -1 && wkversion && wkversion < 533 ) ||
// Firefox Mobile before 6.0 -
( ffversion && ffversion < 6 ) ||
// WebOS less than 3
( "palmGetResource" in window && wkversion && wkversion < 534 ) ||
// MeeGo
( ua.indexOf( "MeeGo" ) > -1 && ua.indexOf( "NokiaBrowser/8.5.0" ) > -1 ) ) {
return false;
}
return true;
}
$.extend( $.support, {
// Note, Chrome for iOS has an extremely quirky implementation of popstate.
// We've chosen to take the shortest path to a bug fix here for issue #5426
// See the following link for information about the regex chosen
// https://developers.google.com/chrome/mobile/docs/user-agent#chrome_for_ios_user-agent
pushState: "pushState" in history &&
"replaceState" in history &&
// When running inside a FF iframe, calling replaceState causes an error
!( window.navigator.userAgent.indexOf( "Firefox" ) >= 0 && window.top !== window ) &&
( window.navigator.userAgent.search(/CriOS/) === -1 ),
mediaquery: $.mobile.media( "only all" ),
cssPseudoElement: !!propExists( "content" ),
touchOverflow: !!propExists( "overflowScrolling" ),
cssTransform3d: transform3dTest(),
boxShadow: !!propExists( "boxShadow" ) && !bb,
fixedPosition: fixedPosition(),
scrollTop: ("pageXOffset" in window ||
"scrollTop" in document.documentElement ||
"scrollTop" in fakeBody[ 0 ]) && !webos && !operamini,
dynamicBaseTag: baseTagTest(),
cssPointerEvents: cssPointerEventsTest(),
boundingRect: boundingRect(),
inlineSVG: inlineSVG
});
fakeBody.remove();
// $.mobile.ajaxBlacklist is used to override ajaxEnabled on platforms that have known conflicts with hash history updates (BB5, Symbian)
// or that generally work better browsing in regular http for full page refreshes (Opera Mini)
// Note: This detection below is used as a last resort.
// We recommend only using these detection methods when all other more reliable/forward-looking approaches are not possible
nokiaLTE7_3 = (function() {
var ua = window.navigator.userAgent;
//The following is an attempt to match Nokia browsers that are running Symbian/s60, with webkit, version 7.3 or older
return ua.indexOf( "Nokia" ) > -1 &&
( ua.indexOf( "Symbian/3" ) > -1 || ua.indexOf( "Series60/5" ) > -1 ) &&
ua.indexOf( "AppleWebKit" ) > -1 &&
ua.match( /(BrowserNG|NokiaBrowser)\/7\.[0-3]/ );
})();
// Support conditions that must be met in order to proceed
// default enhanced qualifications are media query support OR IE 7+
$.mobile.gradeA = function() {
return ( ( $.support.mediaquery && $.support.cssPseudoElement ) || $.mobile.browser.oldIE && $.mobile.browser.oldIE >= 8 ) && ( $.support.boundingRect || $.fn.jquery.match(/1\.[0-7+]\.[0-9+]?/) !== null );
};
$.mobile.ajaxBlacklist =
// BlackBerry browsers, pre-webkit
window.blackberry && !window.WebKitPoint ||
// Opera Mini
operamini ||
// Symbian webkits pre 7.3
nokiaLTE7_3;
// Lastly, this workaround is the only way we've found so far to get pre 7.3 Symbian webkit devices
// to render the stylesheets when they're referenced before this script, as we'd recommend doing.
// This simply reappends the CSS in place, which for some reason makes it apply
if ( nokiaLTE7_3 ) {
$(function() {
$( "head link[rel='stylesheet']" ).attr( "rel", "alternate stylesheet" ).attr( "rel", "stylesheet" );
});
}
// For ruling out shadows via css
if ( !$.support.boxShadow ) {
$( "html" ).addClass( "ui-noboxshadow" );
}
})( jQuery );
(function( $, undefined ) {
var $win = $.mobile.window, self,
dummyFnToInitNavigate = function() {
};
$.event.special.beforenavigate = {
setup: function() {
$win.on( "navigate", dummyFnToInitNavigate );
},
teardown: function() {
$win.off( "navigate", dummyFnToInitNavigate );
}
};
$.event.special.navigate = self = {
bound: false,
pushStateEnabled: true,
originalEventName: undefined,
// If pushstate support is present and push state support is defined to
// be true on the mobile namespace.
isPushStateEnabled: function() {
return $.support.pushState &&
$.mobile.pushStateEnabled === true &&
this.isHashChangeEnabled();
},
// !! assumes mobile namespace is present
isHashChangeEnabled: function() {
return $.mobile.hashListeningEnabled === true;
},
// TODO a lot of duplication between popstate and hashchange
popstate: function( event ) {
var newEvent = new $.Event( "navigate" ),
beforeNavigate = new $.Event( "beforenavigate" ),
state = event.originalEvent.state || {};
beforeNavigate.originalEvent = event;
$win.trigger( beforeNavigate );
if ( beforeNavigate.isDefaultPrevented() ) {
return;
}
if ( event.historyState ) {
$.extend(state, event.historyState);
}
// Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event;
// NOTE we let the current stack unwind because any assignment to
// location.hash will stop the world and run this event handler. By
// doing this we create a similar behavior to hashchange on hash
// assignment
setTimeout(function() {
$win.trigger( newEvent, {
state: state
});
}, 0);
},
hashchange: function( event /*, data */ ) {
var newEvent = new $.Event( "navigate" ),
beforeNavigate = new $.Event( "beforenavigate" );
beforeNavigate.originalEvent = event;
$win.trigger( beforeNavigate );
if ( beforeNavigate.isDefaultPrevented() ) {
return;
}
// Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event;
// Trigger the hashchange with state provided by the user
// that altered the hash
$win.trigger( newEvent, {
// Users that want to fully normalize the two events
// will need to do history management down the stack and
// add the state to the event before this binding is fired
// TODO consider allowing for the explicit addition of callbacks
// to be fired before this value is set to avoid event timing issues
state: event.hashchangeState || {}
});
},
// TODO We really only want to set this up once
// but I'm not clear if there's a beter way to achieve
// this with the jQuery special event structure
setup: function( /* data, namespaces */ ) {
if ( self.bound ) {
return;
}
self.bound = true;
if ( self.isPushStateEnabled() ) {
self.originalEventName = "popstate";
$win.bind( "popstate.navigate", self.popstate );
} else if ( self.isHashChangeEnabled() ) {
self.originalEventName = "hashchange";
$win.bind( "hashchange.navigate", self.hashchange );
}
}
};
})( jQuery );
(function( $, undefined ) {
var path, $base, dialogHashKey = "&ui-state=dialog";
$.mobile.path = path = {
uiStateKey: "&ui-state",
// This scary looking regular expression parses an absolute URL or its relative
// variants (protocol, site, document, query, and hash), into the various
// components (protocol, host, path, query, fragment, etc that make up the
// URL as well as some other commonly used sub-parts. When used with RegExp.exec()
// or String.match, it parses the URL into a results array that looks like this:
//
// [0]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread#msg-content
// [1]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread
// [2]: http://jblas:password@mycompany.com:8080/mail/inbox
// [3]: http://jblas:password@mycompany.com:8080
// [4]: http:
// [5]: //
// [6]: jblas:password@mycompany.com:8080
// [7]: jblas:password
// [8]: jblas
// [9]: password
// [10]: mycompany.com:8080
// [11]: mycompany.com
// [12]: 8080
// [13]: /mail/inbox
// [14]: /mail/
// [15]: inbox
// [16]: ?msg=1234&type=unread
// [17]: #msg-content
//
urlParseRE: /^\s*(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/,
// Abstraction to address xss (Issue #4787) by removing the authority in
// browsers that auto-decode it. All references to location.href should be
// replaced with a call to this method so that it can be dealt with properly here
getLocation: function( url ) {
var parsedUrl = this.parseUrl( url || location.href ),
uri = url ? parsedUrl : location,
// Make sure to parse the url or the location object for the hash because using
// location.hash is autodecoded in firefox, the rest of the url should be from
// the object (location unless we're testing) to avoid the inclusion of the
// authority
hash = parsedUrl.hash;
// mimic the browser with an empty string when the hash is empty
hash = hash === "#" ? "" : hash;
return uri.protocol +
parsedUrl.doubleSlash +
uri.host +
// The pathname must start with a slash if there's a protocol, because you
// can't have a protocol followed by a relative path. Also, it's impossible to
// calculate absolute URLs from relative ones if the absolute one doesn't have
// a leading "/".
( ( uri.protocol !== "" && uri.pathname.substring( 0, 1 ) !== "/" ) ?
"/" : "" ) +
uri.pathname +
uri.search +
hash;
},
//return the original document url
getDocumentUrl: function( asParsedObject ) {
return asParsedObject ? $.extend( {}, path.documentUrl ) : path.documentUrl.href;
},
parseLocation: function() {
return this.parseUrl( this.getLocation() );
},
//Parse a URL into a structure that allows easy access to
//all of the URL components by name.
parseUrl: function( url ) {
// If we're passed an object, we'll assume that it is
// a parsed url object and just return it back to the caller.
if ( $.type( url ) === "object" ) {
return url;
}
var matches = path.urlParseRE.exec( url || "" ) || [];
// Create an object that allows the caller to access the sub-matches
// by name. Note that IE returns an empty string instead of undefined,
// like all other browsers do, so we normalize everything so its consistent
// no matter what browser we're running on.
return {
href: matches[ 0 ] || "",
hrefNoHash: matches[ 1 ] || "",
hrefNoSearch: matches[ 2 ] || "",
domain: matches[ 3 ] || "",
protocol: matches[ 4 ] || "",
doubleSlash: matches[ 5 ] || "",
authority: matches[ 6 ] || "",
username: matches[ 8 ] || "",
password: matches[ 9 ] || "",
host: matches[ 10 ] || "",
hostname: matches[ 11 ] || "",
port: matches[ 12 ] || "",
pathname: matches[ 13 ] || "",
directory: matches[ 14 ] || "",
filename: matches[ 15 ] || "",
search: matches[ 16 ] || "",
hash: matches[ 17 ] || ""
};
},
//Turn relPath into an asbolute path. absPath is
//an optional absolute path which describes what
//relPath is relative to.
makePathAbsolute: function( relPath, absPath ) {
var absStack,
relStack,
i, d;
if ( relPath && relPath.charAt( 0 ) === "/" ) {
return relPath;
}
relPath = relPath || "";
absPath = absPath ? absPath.replace( /^\/|(\/[^\/]*|[^\/]+)$/g, "" ) : "";
absStack = absPath ? absPath.split( "/" ) : [];
relStack = relPath.split( "/" );
for ( i = 0; i < relStack.length; i++ ) {
d = relStack[ i ];
switch ( d ) {
case ".":
break;
case "..":
if ( absStack.length ) {
absStack.pop();
}
break;
default:
absStack.push( d );
break;
}
}
return "/" + absStack.join( "/" );
},
//Returns true if both urls have the same domain.
isSameDomain: function( absUrl1, absUrl2 ) {
return path.parseUrl( absUrl1 ).domain === path.parseUrl( absUrl2 ).domain;
},
//Returns true for any relative variant.
isRelativeUrl: function( url ) {
// All relative Url variants have one thing in common, no protocol.
return path.parseUrl( url ).protocol === "";
},
//Returns true for an absolute url.
isAbsoluteUrl: function( url ) {
return path.parseUrl( url ).protocol !== "";
},
//Turn the specified realtive URL into an absolute one. This function
//can handle all relative variants (protocol, site, document, query, fragment).
makeUrlAbsolute: function( relUrl, absUrl ) {
if ( !path.isRelativeUrl( relUrl ) ) {
return relUrl;
}
if ( absUrl === undefined ) {
absUrl = this.documentBase;
}
var relObj = path.parseUrl( relUrl ),
absObj = path.parseUrl( absUrl ),
protocol = relObj.protocol || absObj.protocol,
doubleSlash = relObj.protocol ? relObj.doubleSlash : ( relObj.doubleSlash || absObj.doubleSlash ),
authority = relObj.authority || absObj.authority,
hasPath = relObj.pathname !== "",
pathname = path.makePathAbsolute( relObj.pathname || absObj.filename, absObj.pathname ),
search = relObj.search || ( !hasPath && absObj.search ) || "",
hash = relObj.hash;
return protocol + doubleSlash + authority + pathname + search + hash;
},
//Add search (aka query) params to the specified url.
addSearchParams: function( url, params ) {
var u = path.parseUrl( url ),
p = ( typeof params === "object" ) ? $.param( params ) : params,
s = u.search || "?";
return u.hrefNoSearch + s + ( s.charAt( s.length - 1 ) !== "?" ? "&" : "" ) + p + ( u.hash || "" );
},
convertUrlToDataUrl: function( absUrl ) {
var u = path.parseUrl( absUrl );
if ( path.isEmbeddedPage( u ) ) {
// For embedded pages, remove the dialog hash key as in getFilePath(),
// and remove otherwise the Data Url won't match the id of the embedded Page.
return u.hash
.split( dialogHashKey )[0]
.replace( /^#/, "" )
.replace( /\?.*$/, "" );
} else if ( path.isSameDomain( u, this.documentBase ) ) {
return u.hrefNoHash.replace( this.documentBase.domain, "" ).split( dialogHashKey )[0];
}
return window.decodeURIComponent(absUrl);
},
//get path from current hash, or from a file path
get: function( newPath ) {
if ( newPath === undefined ) {
newPath = path.parseLocation().hash;
}
return path.stripHash( newPath ).replace( /[^\/]*\.[^\/*]+$/, "" );
},
//set location hash to path
set: function( path ) {
location.hash = path;
},
//test if a given url (string) is a path
//NOTE might be exceptionally naive
isPath: function( url ) {
return ( /\// ).test( url );
},
//return a url path with the window's location protocol/hostname/pathname removed
clean: function( url ) {
return url.replace( this.documentBase.domain, "" );
},
//just return the url without an initial #
stripHash: function( url ) {
return url.replace( /^#/, "" );
},
stripQueryParams: function( url ) {
return url.replace( /\?.*$/, "" );
},
//remove the preceding hash, any query params, and dialog notations
cleanHash: function( hash ) {
return path.stripHash( hash.replace( /\?.*$/, "" ).replace( dialogHashKey, "" ) );
},
isHashValid: function( hash ) {
return ( /^#[^#]+$/ ).test( hash );
},
//check whether a url is referencing the same domain, or an external domain or different protocol
//could be mailto, etc
isExternal: function( url ) {
var u = path.parseUrl( url );
return u.protocol && u.domain !== this.documentUrl.domain ? true : false;
},
hasProtocol: function( url ) {
return ( /^(:?\w+:)/ ).test( url );
},
isEmbeddedPage: function( url ) {
var u = path.parseUrl( url );
//if the path is absolute, then we need to compare the url against
//both the this.documentUrl and the documentBase. The main reason for this
//is that links embedded within external documents will refer to the
//application document, whereas links embedded within the application
//document will be resolved against the document base.
if ( u.protocol !== "" ) {
return ( !this.isPath(u.hash) && u.hash && ( u.hrefNoHash === this.documentUrl.hrefNoHash || ( this.documentBaseDiffers && u.hrefNoHash === this.documentBase.hrefNoHash ) ) );
}
return ( /^#/ ).test( u.href );
},
squash: function( url, resolutionUrl ) {
var href, cleanedUrl, search, stateIndex,
isPath = this.isPath( url ),
uri = this.parseUrl( url ),
preservedHash = uri.hash,
uiState = "";
// produce a url against which we can resole the provided path
resolutionUrl = resolutionUrl || (path.isPath(url) ? path.getLocation() : path.getDocumentUrl());
// If the url is anything but a simple string, remove any preceding hash
// eg #foo/bar -> foo/bar
// #foo -> #foo
cleanedUrl = isPath ? path.stripHash( url ) : url;
// If the url is a full url with a hash check if the parsed hash is a path
// if it is, strip the #, and use it otherwise continue without change
cleanedUrl = path.isPath( uri.hash ) ? path.stripHash( uri.hash ) : cleanedUrl;
// Split the UI State keys off the href
stateIndex = cleanedUrl.indexOf( this.uiStateKey );
// store the ui state keys for use
if ( stateIndex > -1 ) {
uiState = cleanedUrl.slice( stateIndex );
cleanedUrl = cleanedUrl.slice( 0, stateIndex );
}
// make the cleanedUrl absolute relative to the resolution url
href = path.makeUrlAbsolute( cleanedUrl, resolutionUrl );
// grab the search from the resolved url since parsing from
// the passed url may not yield the correct result
search = this.parseUrl( href ).search;
// TODO all this crap is terrible, clean it up
if ( isPath ) {
// reject the hash if it's a path or it's just a dialog key
if ( path.isPath( preservedHash ) || preservedHash.replace("#", "").indexOf( this.uiStateKey ) === 0) {
preservedHash = "";
}
// Append the UI State keys where it exists and it's been removed
// from the url
if ( uiState && preservedHash.indexOf( this.uiStateKey ) === -1) {
preservedHash += uiState;
}
// make sure that pound is on the front of the hash
if ( preservedHash.indexOf( "#" ) === -1 && preservedHash !== "" ) {
preservedHash = "#" + preservedHash;
}
// reconstruct each of the pieces with the new search string and hash
href = path.parseUrl( href );
href = href.protocol + href.doubleSlash + href.host + href.pathname + search +
preservedHash;
} else {
href += href.indexOf( "#" ) > -1 ? uiState : "#" + uiState;
}
return href;
},
isPreservableHash: function( hash ) {
return hash.replace( "#", "" ).indexOf( this.uiStateKey ) === 0;
},
// Escape weird characters in the hash if it is to be used as a selector
hashToSelector: function( hash ) {
var hasHash = ( hash.substring( 0, 1 ) === "#" );
if ( hasHash ) {
hash = hash.substring( 1 );
}
return ( hasHash ? "#" : "" ) + hash.replace( /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, "\\$1" );
},
// return the substring of a filepath before the sub-page key, for making
// a server request
getFilePath: function( path ) {
var splitkey = "&" + $.mobile.subPageUrlKey;
return path && path.split( splitkey )[0].split( dialogHashKey )[0];
},
// check if the specified url refers to the first page in the main
// application document.
isFirstPageUrl: function( url ) {
// We only deal with absolute paths.
var u = path.parseUrl( path.makeUrlAbsolute( url, this.documentBase ) ),
// Does the url have the same path as the document?
samePath = u.hrefNoHash === this.documentUrl.hrefNoHash ||
( this.documentBaseDiffers &&
u.hrefNoHash === this.documentBase.hrefNoHash ),
// Get the first page element.
fp = $.mobile.firstPage,
// Get the id of the first page element if it has one.
fpId = fp && fp[0] ? fp[0].id : undefined;
// The url refers to the first page if the path matches the document and
// it either has no hash value, or the hash is exactly equal to the id
// of the first page element.
return samePath &&
( !u.hash ||
u.hash === "#" ||
( fpId && u.hash.replace( /^#/, "" ) === fpId ) );
},
// Some embedded browsers, like the web view in Phone Gap, allow
// cross-domain XHR requests if the document doing the request was loaded
// via the file:// protocol. This is usually to allow the application to
// "phone home" and fetch app specific data. We normally let the browser
// handle external/cross-domain urls, but if the allowCrossDomainPages
// option is true, we will allow cross-domain http/https requests to go
// through our page loading logic.
isPermittedCrossDomainRequest: function( docUrl, reqUrl ) {
return $.mobile.allowCrossDomainPages &&
(docUrl.protocol === "file:" || docUrl.protocol === "content:") &&
reqUrl.search( /^https?:/ ) !== -1;
}
};
path.documentUrl = path.parseLocation();
$base = $( "head" ).find( "base" );
path.documentBase = $base.length ?
path.parseUrl( path.makeUrlAbsolute( $base.attr( "href" ), path.documentUrl.href ) ) :
path.documentUrl;
path.documentBaseDiffers = (path.documentUrl.hrefNoHash !== path.documentBase.hrefNoHash);
//return the original document base url
path.getDocumentBase = function( asParsedObject ) {
return asParsedObject ? $.extend( {}, path.documentBase ) : path.documentBase.href;
};
// DEPRECATED as of 1.4.0 - remove in 1.5.0
$.extend( $.mobile, {
//return the original document url
getDocumentUrl: path.getDocumentUrl,
//return the original document base url
getDocumentBase: path.getDocumentBase
});
})( jQuery );
(function( $, undefined ) {
$.mobile.History = function( stack, index ) {
this.stack = stack || [];
this.activeIndex = index || 0;
};
$.extend($.mobile.History.prototype, {
getActive: function() {
return this.stack[ this.activeIndex ];
},
getLast: function() {
return this.stack[ this.previousIndex ];
},
getNext: function() {
return this.stack[ this.activeIndex + 1 ];
},
getPrev: function() {
return this.stack[ this.activeIndex - 1 ];
},
// addNew is used whenever a new page is added
add: function( url, data ) {
data = data || {};
//if there's forward history, wipe it
if ( this.getNext() ) {
this.clearForward();
}
// if the hash is included in the data make sure the shape
// is consistent for comparison
if ( data.hash && data.hash.indexOf( "#" ) === -1) {
data.hash = "#" + data.hash;
}
data.url = url;
this.stack.push( data );
this.activeIndex = this.stack.length - 1;
},
//wipe urls ahead of active index
clearForward: function() {
this.stack = this.stack.slice( 0, this.activeIndex + 1 );
},
find: function( url, stack, earlyReturn ) {
stack = stack || this.stack;
var entry, i, length = stack.length, index;
for ( i = 0; i < length; i++ ) {
entry = stack[i];
if ( decodeURIComponent(url) === decodeURIComponent(entry.url) ||
decodeURIComponent(url) === decodeURIComponent(entry.hash) ) {
index = i;
if ( earlyReturn ) {
return index;
}
}
}
return index;
},
closest: function( url ) {
var closest, a = this.activeIndex;
// First, take the slice of the history stack before the current index and search
// for a url match. If one is found, we'll avoid avoid looking through forward history
// NOTE the preference for backward history movement is driven by the fact that
// most mobile browsers only have a dedicated back button, and users rarely use
// the forward button in desktop browser anyhow
closest = this.find( url, this.stack.slice(0, a) );
// If nothing was found in backward history check forward. The `true`
// value passed as the third parameter causes the find method to break
// on the first match in the forward history slice. The starting index
// of the slice must then be added to the result to get the element index
// in the original history stack :( :(
//
// TODO this is hyper confusing and should be cleaned up (ugh so bad)
if ( closest === undefined ) {
closest = this.find( url, this.stack.slice(a), true );
closest = closest === undefined ? closest : closest + a;
}
return closest;
},
direct: function( opts ) {
var newActiveIndex = this.closest( opts.url ), a = this.activeIndex;
// save new page index, null check to prevent falsey 0 result
// record the previous index for reference
if ( newActiveIndex !== undefined ) {
this.activeIndex = newActiveIndex;
this.previousIndex = a;
}
// invoke callbacks where appropriate
//
// TODO this is also convoluted and confusing
if ( newActiveIndex < a ) {
( opts.present || opts.back || $.noop )( this.getActive(), "back" );
} else if ( newActiveIndex > a ) {
( opts.present || opts.forward || $.noop )( this.getActive(), "forward" );
} else if ( newActiveIndex === undefined && opts.missing ) {
opts.missing( this.getActive() );
}
}
});
})( jQuery );
(function( $, undefined ) {
var path = $.mobile.path,
initialHref = location.href;
$.mobile.Navigator = function( history ) {
this.history = history;
this.ignoreInitialHashChange = true;
$.mobile.window.bind({
"popstate.history": $.proxy( this.popstate, this ),
"hashchange.history": $.proxy( this.hashchange, this )
});
};
$.extend($.mobile.Navigator.prototype, {
squash: function( url, data ) {
var state, href, hash = path.isPath(url) ? path.stripHash(url) : url;
href = path.squash( url );
// make sure to provide this information when it isn't explicitly set in the
// data object that was passed to the squash method
state = $.extend({
hash: hash,
url: href
}, data);
// replace the current url with the new href and store the state
// Note that in some cases we might be replacing an url with the
// same url. We do this anyways because we need to make sure that
// all of our history entries have a state object associated with
// them. This allows us to work around the case where $.mobile.back()
// is called to transition from an external page to an embedded page.
// In that particular case, a hashchange event is *NOT* generated by the browser.
// Ensuring each history entry has a state object means that onPopState()
// will always trigger our hashchange callback even when a hashchange event
// is not fired.
window.history.replaceState( state, state.title || document.title, href );
return state;
},
hash: function( url, href ) {
var parsed, loc, hash, resolved;
// Grab the hash for recording. If the passed url is a path
// we used the parsed version of the squashed url to reconstruct,
// otherwise we assume it's a hash and store it directly
parsed = path.parseUrl( url );
loc = path.parseLocation();
if ( loc.pathname + loc.search === parsed.pathname + parsed.search ) {
// If the pathname and search of the passed url is identical to the current loc
// then we must use the hash. Otherwise there will be no event
// eg, url = "/foo/bar?baz#bang", location.href = "http://example.com/foo/bar?baz"
hash = parsed.hash ? parsed.hash : parsed.pathname + parsed.search;
} else if ( path.isPath(url) ) {
resolved = path.parseUrl( href );
// If the passed url is a path, make it domain relative and remove any trailing hash
hash = resolved.pathname + resolved.search + (path.isPreservableHash( resolved.hash )? resolved.hash.replace( "#", "" ) : "");
} else {
hash = url;
}
return hash;
},
// TODO reconsider name
go: function( url, data, noEvents ) {
var state, href, hash, popstateEvent,
isPopStateEvent = $.event.special.navigate.isPushStateEnabled();
// Get the url as it would look squashed on to the current resolution url
href = path.squash( url );
// sort out what the hash sould be from the url
hash = this.hash( url, href );
// Here we prevent the next hash change or popstate event from doing any
// history management. In the case of hashchange we don't swallow it
// if there will be no hashchange fired (since that won't reset the value)
// and will swallow the following hashchange
if ( noEvents && hash !== path.stripHash(path.parseLocation().hash) ) {
this.preventNextHashChange = noEvents;
}
// IMPORTANT in the case where popstate is supported the event will be triggered
// directly, stopping further execution - ie, interupting the flow of this
// method call to fire bindings at this expression. Below the navigate method
// there is a binding to catch this event and stop its propagation.
//
// We then trigger a new popstate event on the window with a null state
// so that the navigate events can conclude their work properly
//
// if the url is a path we want to preserve the query params that are available on
// the current url.
this.preventHashAssignPopState = true;
window.location.hash = hash;
// If popstate is enabled and the browser triggers `popstate` events when the hash
// is set (this often happens immediately in browsers like Chrome), then the
// this flag will be set to false already. If it's a browser that does not trigger
// a `popstate` on hash assignement or `replaceState` then we need avoid the branch
// that swallows the event created by the popstate generated by the hash assignment
// At the time of this writing this happens with Opera 12 and some version of IE
this.preventHashAssignPopState = false;
state = $.extend({
url: href,
hash: hash,
title: document.title
}, data);
if ( isPopStateEvent ) {
popstateEvent = new $.Event( "popstate" );
popstateEvent.originalEvent = {
type: "popstate",
state: null
};
this.squash( url, state );
// Trigger a new faux popstate event to replace the one that we
// caught that was triggered by the hash setting above.
if ( !noEvents ) {
this.ignorePopState = true;
$.mobile.window.trigger( popstateEvent );
}
}
// record the history entry so that the information can be included
// in hashchange event driven navigate events in a similar fashion to
// the state that's provided by popstate
this.history.add( state.url, state );
},
// This binding is intended to catch the popstate events that are fired
// when execution of the `$.navigate` method stops at window.location.hash = url;
// and completely prevent them from propagating. The popstate event will then be
// retriggered after execution resumes
//
// TODO grab the original event here and use it for the synthetic event in the
// second half of the navigate execution that will follow this binding
popstate: function( event ) {
var hash, state;
// Partly to support our test suite which manually alters the support
// value to test hashchange. Partly to prevent all around weirdness
if ( !$.event.special.navigate.isPushStateEnabled() ) {
return;
}
// If this is the popstate triggered by the actual alteration of the hash
// prevent it completely. History is tracked manually
if ( this.preventHashAssignPopState ) {
this.preventHashAssignPopState = false;
event.stopImmediatePropagation();
return;
}
// if this is the popstate triggered after the `replaceState` call in the go
// method, then simply ignore it. The history entry has already been captured
if ( this.ignorePopState ) {
this.ignorePopState = false;
return;
}
// If there is no state, and the history stack length is one were
// probably getting the page load popstate fired by browsers like chrome
// avoid it and set the one time flag to false.
// TODO: Do we really need all these conditions? Comparing location hrefs
// should be sufficient.
if ( !event.originalEvent.state &&
this.history.stack.length === 1 &&
this.ignoreInitialHashChange ) {
this.ignoreInitialHashChange = false;
if ( location.href === initialHref ) {
event.preventDefault();
return;
}
}
// account for direct manipulation of the hash. That is, we will receive a popstate
// when the hash is changed by assignment, and it won't have a state associated. We
// then need to squash the hash. See below for handling of hash assignment that
// matches an existing history entry
// TODO it might be better to only add to the history stack
// when the hash is adjacent to the active history entry
hash = path.parseLocation().hash;
if ( !event.originalEvent.state && hash ) {
// squash the hash that's been assigned on the URL with replaceState
// also grab the resulting state object for storage
state = this.squash( hash );
// record the new hash as an additional history entry
// to match the browser's treatment of hash assignment
this.history.add( state.url, state );
// pass the newly created state information
// along with the event
event.historyState = state;
// do not alter history, we've added a new history entry
// so we know where we are
return;
}
// If all else fails this is a popstate that comes from the back or forward buttons
// make sure to set the state of our history stack properly, and record the directionality
this.history.direct({
url: (event.originalEvent.state || {}).url || hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function( historyEntry, direction ) {
// make sure to create a new object to pass down as the navigate event data
event.historyState = $.extend({}, historyEntry);
event.historyState.direction = direction;
}
});
},
// NOTE must bind before `navigate` special event hashchange binding otherwise the
// navigation data won't be attached to the hashchange event in time for those
// bindings to attach it to the `navigate` special event
// TODO add a check here that `hashchange.navigate` is bound already otherwise it's
// broken (exception?)
hashchange: function( event ) {
var history, hash;
// If hashchange listening is explicitly disabled or pushstate is supported
// avoid making use of the hashchange handler.
if (!$.event.special.navigate.isHashChangeEnabled() ||
$.event.special.navigate.isPushStateEnabled() ) {
return;
}
// On occasion explicitly want to prevent the next hash from propogating because we only
// with to alter the url to represent the new state do so here
if ( this.preventNextHashChange ) {
this.preventNextHashChange = false;
event.stopImmediatePropagation();
return;
}
history = this.history;
hash = path.parseLocation().hash;
// If this is a hashchange caused by the back or forward button
// make sure to set the state of our history stack properly
this.history.direct({
url: hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function( historyEntry, direction ) {
// make sure to create a new object to pass down as the navigate event data
event.hashchangeState = $.extend({}, historyEntry);
event.hashchangeState.direction = direction;
},
// When we don't find a hash in our history clearly we're aiming to go there
// record the entry as new for future traversal
//
// NOTE it's not entirely clear that this is the right thing to do given that we
// can't know the users intention. It might be better to explicitly _not_
// support location.hash assignment in preference to $.navigate calls
// TODO first arg to add should be the href, but it causes issues in identifying
// embeded pages
missing: function() {
history.add( hash, {
hash: hash,
title: document.title
});
}
});
}
});
})( jQuery );
(function( $, undefined ) {
// TODO consider queueing navigation activity until previous activities have completed
// so that end users don't have to think about it. Punting for now
// TODO !! move the event bindings into callbacks on the navigate event
$.mobile.navigate = function( url, data, noEvents ) {
$.mobile.navigate.navigator.go( url, data, noEvents );
};
// expose the history on the navigate method in anticipation of full integration with
// existing navigation functionalty that is tightly coupled to the history information
$.mobile.navigate.history = new $.mobile.History();
// instantiate an instance of the navigator for use within the $.navigate method
$.mobile.navigate.navigator = new $.mobile.Navigator( $.mobile.navigate.history );
var loc = $.mobile.path.parseLocation();
$.mobile.navigate.history.add( loc.href, {hash: loc.hash} );
})( jQuery );
(function( $, undefined ) {
var props = {
"animation": {},
"transition": {}
},
testElement = document.createElement( "a" ),
vendorPrefixes = [ "", "webkit-", "moz-", "o-" ];
$.each( [ "animation", "transition" ], function( i, test ) {
// Get correct name for test
var testName = ( i === 0 ) ? test + "-" + "name" : test;
$.each( vendorPrefixes, function( j, prefix ) {
if ( testElement.style[ $.camelCase( prefix + testName ) ] !== undefined ) {
props[ test ][ "prefix" ] = prefix;
return false;
}
});
// Set event and duration names for later use
props[ test ][ "duration" ] =
$.camelCase( props[ test ][ "prefix" ] + test + "-" + "duration" );
props[ test ][ "event" ] =
$.camelCase( props[ test ][ "prefix" ] + test + "-" + "end" );
// All lower case if not a vendor prop
if ( props[ test ][ "prefix" ] === "" ) {
props[ test ][ "event" ] = props[ test ][ "event" ].toLowerCase();
}
});
// If a valid prefix was found then the it is supported by the browser
$.support.cssTransitions = ( props[ "transition" ][ "prefix" ] !== undefined );
$.support.cssAnimations = ( props[ "animation" ][ "prefix" ] !== undefined );
// Remove the testElement
$( testElement ).remove();
// Animation complete callback
$.fn.animationComplete = function( callback, type, fallbackTime ) {
var timer, duration,
that = this,
eventBinding = function() {
// Clear the timer so we don't call callback twice
clearTimeout( timer );
callback.apply( this, arguments );
},
animationType = ( !type || type === "animation" ) ? "animation" : "transition";
// Make sure selected type is supported by browser
if ( ( $.support.cssTransitions && animationType === "transition" ) ||
( $.support.cssAnimations && animationType === "animation" ) ) {
// If a fallback time was not passed set one
if ( fallbackTime === undefined ) {
// Make sure the was not bound to document before checking .css
if ( $( this ).context !== document ) {
// Parse the durration since its in second multiple by 1000 for milliseconds
// Multiply by 3 to make sure we give the animation plenty of time.
duration = parseFloat(
$( this ).css( props[ animationType ].duration )
) * 3000;
}
// If we could not read a duration use the default
if ( duration === 0 || duration === undefined || isNaN( duration ) ) {
duration = $.fn.animationComplete.defaultDuration;
}
}
// Sets up the fallback if event never comes
timer = setTimeout( function() {
$( that ).off( props[ animationType ].event, eventBinding );
callback.apply( that );
}, duration );
// Bind the event
return $( this ).one( props[ animationType ].event, eventBinding );
} else {
// CSS animation / transitions not supported
// Defer execution for consistency between webkit/non webkit
setTimeout( $.proxy( callback, this ), 0 );
return $( this );
}
};
// Allow default callback to be configured on mobileInit
$.fn.animationComplete.defaultDuration = 1000;
})( jQuery );
// This plugin is an experiment for abstracting away the touch and mouse
// events so that developers don't have to worry about which method of input
// the device their document is loaded on supports.
//
// The idea here is to allow the developer to register listeners for the
// basic mouse events, such as mousedown, mousemove, mouseup, and click,
// and the plugin will take care of registering the correct listeners
// behind the scenes to invoke the listener at the fastest possible time
// for that device, while still retaining the order of event firing in
// the traditional mouse environment, should multiple handlers be registered
// on the same element for different events.
//
// The current version exposes the following virtual events to jQuery bind methods:
// "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel"
(function( $, window, document, undefined ) {
var dataPropertyName = "virtualMouseBindings",
touchTargetPropertyName = "virtualTouchID",
virtualEventNames = "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split( " " ),
touchEventProps = "clientX clientY pageX pageY screenX screenY".split( " " ),
mouseHookProps = $.event.mouseHooks ? $.event.mouseHooks.props : [],
mouseEventProps = $.event.props.concat( mouseHookProps ),
activeDocHandlers = {},
resetTimerID = 0,
startX = 0,
startY = 0,
didScroll = false,
clickBlockList = [],
blockMouseTriggers = false,
blockTouchTriggers = false,
eventCaptureSupported = "addEventListener" in document,
$document = $( document ),
nextTouchID = 1,
lastTouchID = 0, threshold,
i;
$.vmouse = {
moveDistanceThreshold: 10,
clickDistanceThreshold: 10,
resetTimerDuration: 1500
};
function getNativeEvent( event ) {
while ( event && typeof event.originalEvent !== "undefined" ) {
event = event.originalEvent;
}
return event;
}
function createVirtualEvent( event, eventType ) {
var t = event.type,
oe, props, ne, prop, ct, touch, i, j, len;
event = $.Event( event );
event.type = eventType;
oe = event.originalEvent;
props = $.event.props;
// addresses separation of $.event.props in to $.event.mouseHook.props and Issue 3280
// https://github.com/jquery/jquery-mobile/issues/3280
if ( t.search( /^(mouse|click)/ ) > -1 ) {
props = mouseEventProps;
}
// copy original event properties over to the new event
// this would happen if we could call $.event.fix instead of $.Event
// but we don't have a way to force an event to be fixed multiple times
if ( oe ) {
for ( i = props.length, prop; i; ) {
prop = props[ --i ];
event[ prop ] = oe[ prop ];
}
}
// make sure that if the mouse and click virtual events are generated
// without a .which one is defined
if ( t.search(/mouse(down|up)|click/) > -1 && !event.which ) {
event.which = 1;
}
if ( t.search(/^touch/) !== -1 ) {
ne = getNativeEvent( oe );
t = ne.touches;
ct = ne.changedTouches;
touch = ( t && t.length ) ? t[0] : ( ( ct && ct.length ) ? ct[ 0 ] : undefined );
if ( touch ) {
for ( j = 0, len = touchEventProps.length; j < len; j++) {
prop = touchEventProps[ j ];
event[ prop ] = touch[ prop ];
}
}
}
return event;
}
function getVirtualBindingFlags( element ) {
var flags = {},
b, k;
while ( element ) {
b = $.data( element, dataPropertyName );
for ( k in b ) {
if ( b[ k ] ) {
flags[ k ] = flags.hasVirtualBinding = true;
}
}
element = element.parentNode;
}
return flags;
}
function getClosestElementWithVirtualBinding( element, eventType ) {
var b;
while ( element ) {
b = $.data( element, dataPropertyName );
if ( b && ( !eventType || b[ eventType ] ) ) {
return element;
}
element = element.parentNode;
}
return null;
}
function enableTouchBindings() {
blockTouchTriggers = false;
}
function disableTouchBindings() {
blockTouchTriggers = true;
}
function enableMouseBindings() {
lastTouchID = 0;
clickBlockList.length = 0;
blockMouseTriggers = false;
// When mouse bindings are enabled, our
// touch bindings are disabled.
disableTouchBindings();
}
function disableMouseBindings() {
// When mouse bindings are disabled, our
// touch bindings are enabled.
enableTouchBindings();
}
function startResetTimer() {
clearResetTimer();
resetTimerID = setTimeout( function() {
resetTimerID = 0;
enableMouseBindings();
}, $.vmouse.resetTimerDuration );
}
function clearResetTimer() {
if ( resetTimerID ) {
clearTimeout( resetTimerID );
resetTimerID = 0;
}
}
function triggerVirtualEvent( eventType, event, flags ) {
var ve;
if ( ( flags && flags[ eventType ] ) ||
( !flags && getClosestElementWithVirtualBinding( event.target, eventType ) ) ) {
ve = createVirtualEvent( event, eventType );
$( event.target).trigger( ve );
}
return ve;
}
function mouseEventCallback( event ) {
var touchID = $.data( event.target, touchTargetPropertyName ),
ve;
if ( !blockMouseTriggers && ( !lastTouchID || lastTouchID !== touchID ) ) {
ve = triggerVirtualEvent( "v" + event.type, event );
if ( ve ) {
if ( ve.isDefaultPrevented() ) {
event.preventDefault();
}
if ( ve.isPropagationStopped() ) {
event.stopPropagation();
}
if ( ve.isImmediatePropagationStopped() ) {
event.stopImmediatePropagation();
}
}
}
}
function handleTouchStart( event ) {
var touches = getNativeEvent( event ).touches,
target, flags, t;
if ( touches && touches.length === 1 ) {
target = event.target;
flags = getVirtualBindingFlags( target );
if ( flags.hasVirtualBinding ) {
lastTouchID = nextTouchID++;
$.data( target, touchTargetPropertyName, lastTouchID );
clearResetTimer();
disableMouseBindings();
didScroll = false;
t = getNativeEvent( event ).touches[ 0 ];
startX = t.pageX;
startY = t.pageY;
triggerVirtualEvent( "vmouseover", event, flags );
triggerVirtualEvent( "vmousedown", event, flags );
}
}
}
function handleScroll( event ) {
if ( blockTouchTriggers ) {
return;
}
if ( !didScroll ) {
triggerVirtualEvent( "vmousecancel", event, getVirtualBindingFlags( event.target ) );
}
didScroll = true;
startResetTimer();
}
function handleTouchMove( event ) {
if ( blockTouchTriggers ) {
return;
}
var t = getNativeEvent( event ).touches[ 0 ],
didCancel = didScroll,
moveThreshold = $.vmouse.moveDistanceThreshold,
flags = getVirtualBindingFlags( event.target );
didScroll = didScroll ||
( Math.abs( t.pageX - startX ) > moveThreshold ||
Math.abs( t.pageY - startY ) > moveThreshold );
if ( didScroll && !didCancel ) {
triggerVirtualEvent( "vmousecancel", event, flags );
}
triggerVirtualEvent( "vmousemove", event, flags );
startResetTimer();
}
function handleTouchEnd( event ) {
if ( blockTouchTriggers ) {
return;
}
disableTouchBindings();
var flags = getVirtualBindingFlags( event.target ),
ve, t;
triggerVirtualEvent( "vmouseup", event, flags );
if ( !didScroll ) {
ve = triggerVirtualEvent( "vclick", event, flags );
if ( ve && ve.isDefaultPrevented() ) {
// The target of the mouse events that follow the touchend
// event don't necessarily match the target used during the
// touch. This means we need to rely on coordinates for blocking
// any click that is generated.
t = getNativeEvent( event ).changedTouches[ 0 ];
clickBlockList.push({
touchID: lastTouchID,
x: t.clientX,
y: t.clientY
});
// Prevent any mouse events that follow from triggering
// virtual event notifications.
blockMouseTriggers = true;
}
}
triggerVirtualEvent( "vmouseout", event, flags);
didScroll = false;
startResetTimer();
}
function hasVirtualBindings( ele ) {
var bindings = $.data( ele, dataPropertyName ),
k;
if ( bindings ) {
for ( k in bindings ) {
if ( bindings[ k ] ) {
return true;
}
}
}
return false;
}
function dummyMouseHandler() {}
function getSpecialEventObject( eventType ) {
var realType = eventType.substr( 1 );
return {
setup: function(/* data, namespace */) {
// If this is the first virtual mouse binding for this element,
// add a bindings object to its data.
if ( !hasVirtualBindings( this ) ) {
$.data( this, dataPropertyName, {} );
}
// If setup is called, we know it is the first binding for this
// eventType, so initialize the count for the eventType to zero.
var bindings = $.data( this, dataPropertyName );
bindings[ eventType ] = true;
// If this is the first virtual mouse event for this type,
// register a global handler on the document.
activeDocHandlers[ eventType ] = ( activeDocHandlers[ eventType ] || 0 ) + 1;
if ( activeDocHandlers[ eventType ] === 1 ) {
$document.bind( realType, mouseEventCallback );
}
// Some browsers, like Opera Mini, won't dispatch mouse/click events
// for elements unless they actually have handlers registered on them.
// To get around this, we register dummy handlers on the elements.
$( this ).bind( realType, dummyMouseHandler );
// For now, if event capture is not supported, we rely on mouse handlers.
if ( eventCaptureSupported ) {
// If this is the first virtual mouse binding for the document,
// register our touchstart handler on the document.
activeDocHandlers[ "touchstart" ] = ( activeDocHandlers[ "touchstart" ] || 0) + 1;
if ( activeDocHandlers[ "touchstart" ] === 1 ) {
$document.bind( "touchstart", handleTouchStart )
.bind( "touchend", handleTouchEnd )
// On touch platforms, touching the screen and then dragging your finger
// causes the window content to scroll after some distance threshold is
// exceeded. On these platforms, a scroll prevents a click event from being
// dispatched, and on some platforms, even the touchend is suppressed. To
// mimic the suppression of the click event, we need to watch for a scroll
// event. Unfortunately, some platforms like iOS don't dispatch scroll
// events until *AFTER* the user lifts their finger (touchend). This means
// we need to watch both scroll and touchmove events to figure out whether
// or not a scroll happenens before the touchend event is fired.
.bind( "touchmove", handleTouchMove )
.bind( "scroll", handleScroll );
}
}
},
teardown: function(/* data, namespace */) {
// If this is the last virtual binding for this eventType,
// remove its global handler from the document.
--activeDocHandlers[ eventType ];
if ( !activeDocHandlers[ eventType ] ) {
$document.unbind( realType, mouseEventCallback );
}
if ( eventCaptureSupported ) {
// If this is the last virtual mouse binding in existence,
// remove our document touchstart listener.
--activeDocHandlers[ "touchstart" ];
if ( !activeDocHandlers[ "touchstart" ] ) {
$document.unbind( "touchstart", handleTouchStart )
.unbind( "touchmove", handleTouchMove )
.unbind( "touchend", handleTouchEnd )
.unbind( "scroll", handleScroll );
}
}
var $this = $( this ),
bindings = $.data( this, dataPropertyName );
// teardown may be called when an element was
// removed from the DOM. If this is the case,
// jQuery core may have already stripped the element
// of any data bindings so we need to check it before
// using it.
if ( bindings ) {
bindings[ eventType ] = false;
}
// Unregister the dummy event handler.
$this.unbind( realType, dummyMouseHandler );
// If this is the last virtual mouse binding on the
// element, remove the binding data from the element.
if ( !hasVirtualBindings( this ) ) {
$this.removeData( dataPropertyName );
}
}
};
}
// Expose our custom events to the jQuery bind/unbind mechanism.
for ( i = 0; i < virtualEventNames.length; i++ ) {
$.event.special[ virtualEventNames[ i ] ] = getSpecialEventObject( virtualEventNames[ i ] );
}
// Add a capture click handler to block clicks.
// Note that we require event capture support for this so if the device
// doesn't support it, we punt for now and rely solely on mouse events.
if ( eventCaptureSupported ) {
document.addEventListener( "click", function( e ) {
var cnt = clickBlockList.length,
target = e.target,
x, y, ele, i, o, touchID;
if ( cnt ) {
x = e.clientX;
y = e.clientY;
threshold = $.vmouse.clickDistanceThreshold;
// The idea here is to run through the clickBlockList to see if
// the current click event is in the proximity of one of our
// vclick events that had preventDefault() called on it. If we find
// one, then we block the click.
//
// Why do we have to rely on proximity?
//
// Because the target of the touch event that triggered the vclick
// can be different from the target of the click event synthesized
// by the browser. The target of a mouse/click event that is synthesized
// from a touch event seems to be implementation specific. For example,
// some browsers will fire mouse/click events for a link that is near
// a touch event, even though the target of the touchstart/touchend event
// says the user touched outside the link. Also, it seems that with most
// browsers, the target of the mouse/click event is not calculated until the
// time it is dispatched, so if you replace an element that you touched
// with another element, the target of the mouse/click will be the new
// element underneath that point.
//
// Aside from proximity, we also check to see if the target and any
// of its ancestors were the ones that blocked a click. This is necessary
// because of the strange mouse/click target calculation done in the
// Android 2.1 browser, where if you click on an element, and there is a
// mouse/click handler on one of its ancestors, the target will be the
// innermost child of the touched element, even if that child is no where
// near the point of touch.
ele = target;
while ( ele ) {
for ( i = 0; i < cnt; i++ ) {
o = clickBlockList[ i ];
touchID = 0;
if ( ( ele === target && Math.abs( o.x - x ) < threshold && Math.abs( o.y - y ) < threshold ) ||
$.data( ele, touchTargetPropertyName ) === o.touchID ) {
// XXX: We may want to consider removing matches from the block list
// instead of waiting for the reset timer to fire.
e.preventDefault();
e.stopPropagation();
return;
}
}
ele = ele.parentNode;
}
}
}, true);
}
})( jQuery, window, document );
(function( $, window, undefined ) {
var $document = $( document ),
supportTouch = $.mobile.support.touch,
scrollEvent = "touchmove scroll",
touchStartEvent = supportTouch ? "touchstart" : "mousedown",
touchStopEvent = supportTouch ? "touchend" : "mouseup",
touchMoveEvent = supportTouch ? "touchmove" : "mousemove";
// setup new event shortcuts
$.each( ( "touchstart touchmove touchend " +
"tap taphold " +
"swipe swipeleft swiperight " +
"scrollstart scrollstop" ).split( " " ), function( i, name ) {
$.fn[ name ] = function( fn ) {
return fn ? this.bind( name, fn ) : this.trigger( name );
};
// jQuery < 1.8
if ( $.attrFn ) {
$.attrFn[ name ] = true;
}
});
function triggerCustomEvent( obj, eventType, event, bubble ) {
var originalType = event.type;
event.type = eventType;
if ( bubble ) {
$.event.trigger( event, undefined, obj );
} else {
$.event.dispatch.call( obj, event );
}
event.type = originalType;
}
// also handles scrollstop
$.event.special.scrollstart = {
enabled: true,
setup: function() {
var thisObject = this,
$this = $( thisObject ),
scrolling,
timer;
function trigger( event, state ) {
scrolling = state;
triggerCustomEvent( thisObject, scrolling ? "scrollstart" : "scrollstop", event );
}
// iPhone triggers scroll after a small delay; use touchmove instead
$this.bind( scrollEvent, function( event ) {
if ( !$.event.special.scrollstart.enabled ) {
return;
}
if ( !scrolling ) {
trigger( event, true );
}
clearTimeout( timer );
timer = setTimeout( function() {
trigger( event, false );
}, 50 );
});
},
teardown: function() {
$( this ).unbind( scrollEvent );
}
};
// also handles taphold
$.event.special.tap = {
tapholdThreshold: 750,
emitTapOnTaphold: true,
setup: function() {
var thisObject = this,
$this = $( thisObject ),
isTaphold = false;
$this.bind( "vmousedown", function( event ) {
isTaphold = false;
if ( event.which && event.which !== 1 ) {
return false;
}
var origTarget = event.target,
timer;
function clearTapTimer() {
clearTimeout( timer );
}
function clearTapHandlers() {
clearTapTimer();
$this.unbind( "vclick", clickHandler )
.unbind( "vmouseup", clearTapTimer );
$document.unbind( "vmousecancel", clearTapHandlers );
}
function clickHandler( event ) {
clearTapHandlers();
// ONLY trigger a 'tap' event if the start target is
// the same as the stop target.
if ( !isTaphold && origTarget === event.target ) {
triggerCustomEvent( thisObject, "tap", event );
} else if ( isTaphold ) {
event.preventDefault();
}
}
$this.bind( "vmouseup", clearTapTimer )
.bind( "vclick", clickHandler );
$document.bind( "vmousecancel", clearTapHandlers );
timer = setTimeout( function() {
if ( !$.event.special.tap.emitTapOnTaphold ) {
isTaphold = true;
}
triggerCustomEvent( thisObject, "taphold", $.Event( "taphold", { target: origTarget } ) );
}, $.event.special.tap.tapholdThreshold );
});
},
teardown: function() {
$( this ).unbind( "vmousedown" ).unbind( "vclick" ).unbind( "vmouseup" );
$document.unbind( "vmousecancel" );
}
};
// Also handles swipeleft, swiperight
$.event.special.swipe = {
// More than this horizontal displacement, and we will suppress scrolling.
scrollSupressionThreshold: 30,
// More time than this, and it isn't a swipe.
durationThreshold: 1000,
// Swipe horizontal displacement must be more than this.
horizontalDistanceThreshold: 30,
// Swipe vertical displacement must be less than this.
verticalDistanceThreshold: 30,
getLocation: function ( event ) {
var winPageX = window.pageXOffset,
winPageY = window.pageYOffset,
x = event.clientX,
y = event.clientY;
if ( event.pageY === 0 && Math.floor( y ) > Math.floor( event.pageY ) ||
event.pageX === 0 && Math.floor( x ) > Math.floor( event.pageX ) ) {
// iOS4 clientX/clientY have the value that should have been
// in pageX/pageY. While pageX/page/ have the value 0
x = x - winPageX;
y = y - winPageY;
} else if ( y < ( event.pageY - winPageY) || x < ( event.pageX - winPageX ) ) {
// Some Android browsers have totally bogus values for clientX/Y
// when scrolling/zooming a page. Detectable since clientX/clientY
// should never be smaller than pageX/pageY minus page scroll
x = event.pageX - winPageX;
y = event.pageY - winPageY;
}
return {
x: x,
y: y
};
},
start: function( event ) {
var data = event.originalEvent.touches ?
event.originalEvent.touches[ 0 ] : event,
location = $.event.special.swipe.getLocation( data );
return {
time: ( new Date() ).getTime(),
coords: [ location.x, location.y ],
origin: $( event.target )
};
},
stop: function( event ) {
var data = event.originalEvent.touches ?
event.originalEvent.touches[ 0 ] : event,
location = $.event.special.swipe.getLocation( data );
return {
time: ( new Date() ).getTime(),
coords: [ location.x, location.y ]
};
},
handleSwipe: function( start, stop, thisObject, origTarget ) {
if ( stop.time - start.time < $.event.special.swipe.durationThreshold &&
Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.horizontalDistanceThreshold &&
Math.abs( start.coords[ 1 ] - stop.coords[ 1 ] ) < $.event.special.swipe.verticalDistanceThreshold ) {
var direction = start.coords[0] > stop.coords[ 0 ] ? "swipeleft" : "swiperight";
triggerCustomEvent( thisObject, "swipe", $.Event( "swipe", { target: origTarget, swipestart: start, swipestop: stop }), true );
triggerCustomEvent( thisObject, direction,$.Event( direction, { target: origTarget, swipestart: start, swipestop: stop } ), true );
return true;
}
return false;
},
// This serves as a flag to ensure that at most one swipe event event is
// in work at any given time
eventInProgress: false,
setup: function() {
var events,
thisObject = this,
$this = $( thisObject ),
context = {};
// Retrieve the events data for this element and add the swipe context
events = $.data( this, "mobile-events" );
if ( !events ) {
events = { length: 0 };
$.data( this, "mobile-events", events );
}
events.length++;
events.swipe = context;
context.start = function( event ) {
// Bail if we're already working on a swipe event
if ( $.event.special.swipe.eventInProgress ) {
return;
}
$.event.special.swipe.eventInProgress = true;
var stop,
start = $.event.special.swipe.start( event ),
origTarget = event.target,
emitted = false;
context.move = function( event ) {
if ( !start ) {
return;
}
stop = $.event.special.swipe.stop( event );
if ( !emitted ) {
emitted = $.event.special.swipe.handleSwipe( start, stop, thisObject, origTarget );
if ( emitted ) {
// Reset the context to make way for the next swipe event
$.event.special.swipe.eventInProgress = false;
}
}
// prevent scrolling
if ( Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.scrollSupressionThreshold ) {
event.preventDefault();
}
};
context.stop = function() {
emitted = true;
// Reset the context to make way for the next swipe event
$.event.special.swipe.eventInProgress = false;
$document.off( touchMoveEvent, context.move );
context.move = null;
};
$document.on( touchMoveEvent, context.move )
.one( touchStopEvent, context.stop );
};
$this.on( touchStartEvent, context.start );
},
teardown: function() {
var events, context;
events = $.data( this, "mobile-events" );
if ( events ) {
context = events.swipe;
delete events.swipe;
events.length--;
if ( events.length === 0 ) {
$.removeData( this, "mobile-events" );
}
}
if ( context ) {
if ( context.start ) {
$( this ).off( touchStartEvent, context.start );
}
if ( context.move ) {
$document.off( touchMoveEvent, context.move );
}
if ( context.stop ) {
$document.off( touchStopEvent, context.stop );
}
}
}
};
$.each({
scrollstop: "scrollstart",
taphold: "tap",
swipeleft: "swipe.left",
swiperight: "swipe.right"
}, function( event, sourceEvent ) {
$.event.special[ event ] = {
setup: function() {
$( this ).bind( sourceEvent, $.noop );
},
teardown: function() {
$( this ).unbind( sourceEvent );
}
};
});
})( jQuery, this );
// throttled resize event
(function( $ ) {
$.event.special.throttledresize = {
setup: function() {
$( this ).bind( "resize", handler );
},
teardown: function() {
$( this ).unbind( "resize", handler );
}
};
var throttle = 250,
handler = function() {
curr = ( new Date() ).getTime();
diff = curr - lastCall;
if ( diff >= throttle ) {
lastCall = curr;
$( this ).trigger( "throttledresize" );
} else {
if ( heldCall ) {
clearTimeout( heldCall );
}
// Promise a held call will still execute
heldCall = setTimeout( handler, throttle - diff );
}
},
lastCall = 0,
heldCall,
curr,
diff;
})( jQuery );
(function( $, window ) {
var win = $( window ),
event_name = "orientationchange",
get_orientation,
last_orientation,
initial_orientation_is_landscape,
initial_orientation_is_default,
portrait_map = { "0": true, "180": true },
ww, wh, landscape_threshold;
// It seems that some device/browser vendors use window.orientation values 0 and 180 to
// denote the "default" orientation. For iOS devices, and most other smart-phones tested,
// the default orientation is always "portrait", but in some Android and RIM based tablets,
// the default orientation is "landscape". The following code attempts to use the window
// dimensions to figure out what the current orientation is, and then makes adjustments
// to the to the portrait_map if necessary, so that we can properly decode the
// window.orientation value whenever get_orientation() is called.
//
// Note that we used to use a media query to figure out what the orientation the browser
// thinks it is in:
//
// initial_orientation_is_landscape = $.mobile.media("all and (orientation: landscape)");
//
// but there was an iPhone/iPod Touch bug beginning with iOS 4.2, up through iOS 5.1,
// where the browser *ALWAYS* applied the landscape media query. This bug does not
// happen on iPad.
if ( $.support.orientation ) {
// Check the window width and height to figure out what the current orientation
// of the device is at this moment. Note that we've initialized the portrait map
// values to 0 and 180, *AND* we purposely check for landscape so that if we guess
// wrong, , we default to the assumption that portrait is the default orientation.
// We use a threshold check below because on some platforms like iOS, the iPhone
// form-factor can report a larger width than height if the user turns on the
// developer console. The actual threshold value is somewhat arbitrary, we just
// need to make sure it is large enough to exclude the developer console case.
ww = window.innerWidth || win.width();
wh = window.innerHeight || win.height();
landscape_threshold = 50;
initial_orientation_is_landscape = ww > wh && ( ww - wh ) > landscape_threshold;
// Now check to see if the current window.orientation is 0 or 180.
initial_orientation_is_default = portrait_map[ window.orientation ];
// If the initial orientation is landscape, but window.orientation reports 0 or 180, *OR*
// if the initial orientation is portrait, but window.orientation reports 90 or -90, we
// need to flip our portrait_map values because landscape is the default orientation for
// this device/browser.
if ( ( initial_orientation_is_landscape && initial_orientation_is_default ) || ( !initial_orientation_is_landscape && !initial_orientation_is_default ) ) {
portrait_map = { "-90": true, "90": true };
}
}
$.event.special.orientationchange = $.extend( {}, $.event.special.orientationchange, {
setup: function() {
// If the event is supported natively, return false so that jQuery
// will bind to the event using DOM methods.
if ( $.support.orientation && !$.event.special.orientationchange.disabled ) {
return false;
}
// Get the current orientation to avoid initial double-triggering.
last_orientation = get_orientation();
// Because the orientationchange event doesn't exist, simulate the
// event by testing window dimensions on resize.
win.bind( "throttledresize", handler );
},
teardown: function() {
// If the event is not supported natively, return false so that
// jQuery will unbind the event using DOM methods.
if ( $.support.orientation && !$.event.special.orientationchange.disabled ) {
return false;
}
// Because the orientationchange event doesn't exist, unbind the
// resize event handler.
win.unbind( "throttledresize", handler );
},
add: function( handleObj ) {
// Save a reference to the bound event handler.
var old_handler = handleObj.handler;
handleObj.handler = function( event ) {
// Modify event object, adding the .orientation property.
event.orientation = get_orientation();
// Call the originally-bound event handler and return its result.
return old_handler.apply( this, arguments );
};
}
});
// If the event is not supported natively, this handler will be bound to
// the window resize event to simulate the orientationchange event.
function handler() {
// Get the current orientation.
var orientation = get_orientation();
if ( orientation !== last_orientation ) {
// The orientation has changed, so trigger the orientationchange event.
last_orientation = orientation;
win.trigger( event_name );
}
}
// Get the current page orientation. This method is exposed publicly, should it
// be needed, as jQuery.event.special.orientationchange.orientation()
$.event.special.orientationchange.orientation = get_orientation = function() {
var isPortrait = true, elem = document.documentElement;
// prefer window orientation to the calculation based on screensize as
// the actual screen resize takes place before or after the orientation change event
// has been fired depending on implementation (eg android 2.3 is before, iphone after).
// More testing is required to determine if a more reliable method of determining the new screensize
// is possible when orientationchange is fired. (eg, use media queries + element + opacity)
if ( $.support.orientation ) {
// if the window orientation registers as 0 or 180 degrees report
// portrait, otherwise landscape
isPortrait = portrait_map[ window.orientation ];
} else {
isPortrait = elem && elem.clientWidth / elem.clientHeight < 1.1;
}
return isPortrait ? "portrait" : "landscape";
};
$.fn[ event_name ] = function( fn ) {
return fn ? this.bind( event_name, fn ) : this.trigger( event_name );
};
// jQuery < 1.8
if ( $.attrFn ) {
$.attrFn[ event_name ] = true;
}
}( jQuery, this ));
(function( $, undefined ) {
// existing base tag?
var baseElement = $( "head" ).children( "base" ),
// base element management, defined depending on dynamic base tag support
// TODO move to external widget
base = {
// define base element, for use in routing asset urls that are referenced
// in Ajax-requested markup
element: ( baseElement.length ? baseElement :
$( "<base>", { href: $.mobile.path.documentBase.hrefNoHash } ).prependTo( $( "head" ) ) ),
linkSelector: "[src], link[href], a[rel='external'], :jqmData(ajax='false'), a[target]",
// set the generated BASE element's href to a new page's base path
set: function( href ) {
// we should do nothing if the user wants to manage their url base
// manually
if ( !$.mobile.dynamicBaseEnabled ) {
return;
}
// we should use the base tag if we can manipulate it dynamically
if ( $.support.dynamicBaseTag ) {
base.element.attr( "href",
$.mobile.path.makeUrlAbsolute( href, $.mobile.path.documentBase ) );
}
},
rewrite: function( href, page ) {
var newPath = $.mobile.path.get( href );
page.find( base.linkSelector ).each(function( i, link ) {
var thisAttr = $( link ).is( "[href]" ) ? "href" :
$( link ).is( "[src]" ) ? "src" : "action",
theLocation = $.mobile.path.parseLocation(),
thisUrl = $( link ).attr( thisAttr );
// XXX_jblas: We need to fix this so that it removes the document
// base URL, and then prepends with the new page URL.
// if full path exists and is same, chop it - helps IE out
thisUrl = thisUrl.replace( theLocation.protocol + theLocation.doubleSlash +
theLocation.host + theLocation.pathname, "" );
if ( !/^(\w+:|#|\/)/.test( thisUrl ) ) {
$( link ).attr( thisAttr, newPath + thisUrl );
}
});
},
// set the generated BASE element's href to a new page's base path
reset: function(/* href */) {
base.element.attr( "href", $.mobile.path.documentBase.hrefNoSearch );
}
};
$.mobile.base = base;
})( jQuery );
(function( $, undefined ) {
$.mobile.widgets = {};
var originalWidget = $.widget,
// Record the original, non-mobileinit-modified version of $.mobile.keepNative
// so we can later determine whether someone has modified $.mobile.keepNative
keepNativeFactoryDefault = $.mobile.keepNative;
$.widget = (function( orig ) {
return function() {
var constructor = orig.apply( this, arguments ),
name = constructor.prototype.widgetName;
constructor.initSelector = ( ( constructor.prototype.initSelector !== undefined ) ?
constructor.prototype.initSelector : ":jqmData(role='" + name + "')" );
$.mobile.widgets[ name ] = constructor;
return constructor;
};
})( $.widget );
// Make sure $.widget still has bridge and extend methods
$.extend( $.widget, originalWidget );
// For backcompat remove in 1.5
$.mobile.document.on( "create", function( event ) {
$( event.target ).enhanceWithin();
});
$.widget( "mobile.page", {
options: {
theme: "a",
domCache: false,
// Deprecated in 1.4 remove in 1.5
keepNativeDefault: $.mobile.keepNative,
// Deprecated in 1.4 remove in 1.5
contentTheme: null,
enhanced: false
},
// DEPRECATED for > 1.4
// TODO remove at 1.5
_createWidget: function() {
$.Widget.prototype._createWidget.apply( this, arguments );
this._trigger( "init" );
},
_create: function() {
// If false is returned by the callbacks do not create the page
if ( this._trigger( "beforecreate" ) === false ) {
return false;
}
if ( !this.options.enhanced ) {
this._enhance();
}
this._on( this.element, {
pagebeforehide: "removeContainerBackground",
pagebeforeshow: "_handlePageBeforeShow"
});
this.element.enhanceWithin();
// Dialog widget is deprecated in 1.4 remove this in 1.5
if ( $.mobile.getAttribute( this.element[0], "role" ) === "dialog" && $.mobile.dialog ) {
this.element.dialog();
}
},
_enhance: function () {
var attrPrefix = "data-" + $.mobile.ns,
self = this;
if ( this.options.role ) {
this.element.attr( "data-" + $.mobile.ns + "role", this.options.role );
}
this.element
.attr( "tabindex", "0" )
.addClass( "ui-page ui-page-theme-" + this.options.theme );
// Manipulation of content os Deprecated as of 1.4 remove in 1.5
this.element.find( "[" + attrPrefix + "role='content']" ).each( function() {
var $this = $( this ),
theme = this.getAttribute( attrPrefix + "theme" ) || undefined;
self.options.contentTheme = theme || self.options.contentTheme || ( self.options.dialog && self.options.theme ) || ( self.element.jqmData("role") === "dialog" && self.options.theme );
$this.addClass( "ui-content" );
if ( self.options.contentTheme ) {
$this.addClass( "ui-body-" + ( self.options.contentTheme ) );
}
// Add ARIA role
$this.attr( "role", "main" ).addClass( "ui-content" );
});
},
bindRemove: function( callback ) {
var page = this.element;
// when dom caching is not enabled or the page is embedded bind to remove the page on hide
if ( !page.data( "mobile-page" ).options.domCache &&
page.is( ":jqmData(external-page='true')" ) ) {
// TODO use _on - that is, sort out why it doesn't work in this case
page.bind( "pagehide.remove", callback || function( e, data ) {
//check if this is a same page transition and if so don't remove the page
if( !data.samePage ){
var $this = $( this ),
prEvent = new $.Event( "pageremove" );
$this.trigger( prEvent );
if ( !prEvent.isDefaultPrevented() ) {
$this.removeWithDependents();
}
}
});
}
},
_setOptions: function( o ) {
if ( o.theme !== undefined ) {
this.element.removeClass( "ui-page-theme-" + this.options.theme ).addClass( "ui-page-theme-" + o.theme );
}
if ( o.contentTheme !== undefined ) {
this.element.find( "[data-" + $.mobile.ns + "='content']" ).removeClass( "ui-body-" + this.options.contentTheme )
.addClass( "ui-body-" + o.contentTheme );
}
},
_handlePageBeforeShow: function(/* e */) {
this.setContainerBackground();
},
// Deprecated in 1.4 remove in 1.5
removeContainerBackground: function() {
this.element.closest( ":mobile-pagecontainer" ).pagecontainer({ "theme": "none" });
},
// Deprecated in 1.4 remove in 1.5
// set the page container background to the page theme
setContainerBackground: function( theme ) {
this.element.parent().pagecontainer( { "theme": theme || this.options.theme } );
},
// Deprecated in 1.4 remove in 1.5
keepNativeSelector: function() {
var options = this.options,
keepNative = $.trim( options.keepNative || "" ),
globalValue = $.trim( $.mobile.keepNative ),
optionValue = $.trim( options.keepNativeDefault ),
// Check if $.mobile.keepNative has changed from the factory default
newDefault = ( keepNativeFactoryDefault === globalValue ?
"" : globalValue ),
// If $.mobile.keepNative has not changed, use options.keepNativeDefault
oldDefault = ( newDefault === "" ? optionValue : "" );
// Concatenate keepNative selectors from all sources where the value has
// changed or, if nothing has changed, return the default
return ( ( keepNative ? [ keepNative ] : [] )
.concat( newDefault ? [ newDefault ] : [] )
.concat( oldDefault ? [ oldDefault ] : [] )
.join( ", " ) );
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.pagecontainer", {
options: {
theme: "a"
},
initSelector: false,
_create: function() {
this._trigger( "beforecreate" );
this.setLastScrollEnabled = true;
this._on( this.window, {
// disable an scroll setting when a hashchange has been fired,
// this only works because the recording of the scroll position
// is delayed for 100ms after the browser might have changed the
// position because of the hashchange
navigate: "_disableRecordScroll",
// bind to scrollstop for the first page, "pagechange" won't be
// fired in that case
scrollstop: "_delayedRecordScroll"
});
// TODO consider moving the navigation handler OUT of widget into
// some other object as glue between the navigate event and the
// content widget load and change methods
this._on( this.window, { navigate: "_filterNavigateEvents" });
// TODO move from page* events to content* events
this._on({ pagechange: "_afterContentChange" });
// handle initial hashchange from chrome :(
this.window.one( "navigate", $.proxy(function() {
this.setLastScrollEnabled = true;
}, this));
},
_setOptions: function( options ) {
if ( options.theme !== undefined && options.theme !== "none" ) {
this.element.removeClass( "ui-overlay-" + this.options.theme )
.addClass( "ui-overlay-" + options.theme );
} else if ( options.theme !== undefined ) {
this.element.removeClass( "ui-overlay-" + this.options.theme );
}
this._super( options );
},
_disableRecordScroll: function() {
this.setLastScrollEnabled = false;
},
_enableRecordScroll: function() {
this.setLastScrollEnabled = true;
},
// TODO consider the name here, since it's purpose specific
_afterContentChange: function() {
// once the page has changed, re-enable the scroll recording
this.setLastScrollEnabled = true;
// remove any binding that previously existed on the get scroll
// which may or may not be different than the scroll element
// determined for this page previously
this._off( this.window, "scrollstop" );
// determine and bind to the current scoll element which may be the
// window or in the case of touch overflow the element touch overflow
this._on( this.window, { scrollstop: "_delayedRecordScroll" });
},
_recordScroll: function() {
// this barrier prevents setting the scroll value based on
// the browser scrolling the window based on a hashchange
if ( !this.setLastScrollEnabled ) {
return;
}
var active = this._getActiveHistory(),
currentScroll, minScroll, defaultScroll;
if ( active ) {
currentScroll = this._getScroll();
minScroll = this._getMinScroll();
defaultScroll = this._getDefaultScroll();
// Set active page's lastScroll prop. If the location we're
// scrolling to is less than minScrollBack, let it go.
active.lastScroll = currentScroll < minScroll ? defaultScroll : currentScroll;
}
},
_delayedRecordScroll: function() {
setTimeout( $.proxy(this, "_recordScroll"), 100 );
},
_getScroll: function() {
return this.window.scrollTop();
},
_getMinScroll: function() {
return $.mobile.minScrollBack;
},
_getDefaultScroll: function() {
return $.mobile.defaultHomeScroll;
},
_filterNavigateEvents: function( e, data ) {
var url;
if ( e.originalEvent && e.originalEvent.isDefaultPrevented() ) {
return;
}
url = e.originalEvent.type.indexOf( "hashchange" ) > -1 ? data.state.hash : data.state.url;
if ( !url ) {
url = this._getHash();
}
if ( !url || url === "#" || url.indexOf( "#" + $.mobile.path.uiStateKey ) === 0 ) {
url = location.href;
}
this._handleNavigate( url, data.state );
},
_getHash: function() {
return $.mobile.path.parseLocation().hash;
},
// TODO active page should be managed by the container (ie, it should be a property)
getActivePage: function() {
return this.activePage;
},
// TODO the first page should be a property set during _create using the logic
// that currently resides in init
_getInitialContent: function() {
return $.mobile.firstPage;
},
// TODO each content container should have a history object
_getHistory: function() {
return $.mobile.navigate.history;
},
// TODO use _getHistory
_getActiveHistory: function() {
return $.mobile.navigate.history.getActive();
},
// TODO the document base should be determined at creation
_getDocumentBase: function() {
return $.mobile.path.documentBase;
},
back: function() {
this.go( -1 );
},
forward: function() {
this.go( 1 );
},
go: function( steps ) {
//if hashlistening is enabled use native history method
if ( $.mobile.hashListeningEnabled ) {
window.history.go( steps );
} else {
//we are not listening to the hash so handle history internally
var activeIndex = $.mobile.navigate.history.activeIndex,
index = activeIndex + parseInt( steps, 10 ),
url = $.mobile.navigate.history.stack[ index ].url,
direction = ( steps >= 1 )? "forward" : "back";
//update the history object
$.mobile.navigate.history.activeIndex = index;
$.mobile.navigate.history.previousIndex = activeIndex;
//change to the new page
this.change( url, { direction: direction, changeHash: false, fromHashChange: true } );
}
},
// TODO rename _handleDestination
_handleDestination: function( to ) {
var history;
// clean the hash for comparison if it's a url
if ( $.type(to) === "string" ) {
to = $.mobile.path.stripHash( to );
}
if ( to ) {
history = this._getHistory();
// At this point, 'to' can be one of 3 things, a cached page
// element from a history stack entry, an id, or site-relative /
// absolute URL. If 'to' is an id, we need to resolve it against
// the documentBase, not the location.href, since the hashchange
// could've been the result of a forward/backward navigation
// that crosses from an external page/dialog to an internal
// page/dialog.
//
// TODO move check to history object or path object?
to = !$.mobile.path.isPath( to ) ? ( $.mobile.path.makeUrlAbsolute( "#" + to, this._getDocumentBase() ) ) : to;
// If we're about to go to an initial URL that contains a
// reference to a non-existent internal page, go to the first
// page instead. We know that the initial hash refers to a
// non-existent page, because the initial hash did not end
// up in the initial history entry
// TODO move check to history object?
if ( to === $.mobile.path.makeUrlAbsolute( "#" + history.initialDst, this._getDocumentBase() ) &&
history.stack.length &&
history.stack[0].url !== history.initialDst.replace( $.mobile.dialogHashKey, "" ) ) {
to = this._getInitialContent();
}
}
return to || this._getInitialContent();
},
_handleDialog: function( changePageOptions, data ) {
var to, active, activeContent = this.getActivePage();
// If current active page is not a dialog skip the dialog and continue
// in the same direction
if ( activeContent && !activeContent.hasClass( "ui-dialog" ) ) {
// determine if we're heading forward or backward and continue
// accordingly past the current dialog
if ( data.direction === "back" ) {
this.back();
} else {
this.forward();
}
// prevent changePage call
return false;
} else {
// if the current active page is a dialog and we're navigating
// to a dialog use the dialog objected saved in the stack
to = data.pageUrl;
active = this._getActiveHistory();
// make sure to set the role, transition and reversal
// as most of this is lost by the domCache cleaning
$.extend( changePageOptions, {
role: active.role,
transition: active.transition,
reverse: data.direction === "back"
});
}
return to;
},
_handleNavigate: function( url, data ) {
//find first page via hash
// TODO stripping the hash twice with handleUrl
var to = $.mobile.path.stripHash( url ), history = this._getHistory(),
// transition is false if it's the first page, undefined
// otherwise (and may be overridden by default)
transition = history.stack.length === 0 ? "none" : undefined,
// default options for the changPage calls made after examining
// the current state of the page and the hash, NOTE that the
// transition is derived from the previous history entry
changePageOptions = {
changeHash: false,
fromHashChange: true,
reverse: data.direction === "back"
};
$.extend( changePageOptions, data, {
transition: ( history.getLast() || {} ).transition || transition
});
// TODO move to _handleDestination ?
// If this isn't the first page, if the current url is a dialog hash
// key, and the initial destination isn't equal to the current target
// page, use the special dialog handling
if ( history.activeIndex > 0 &&
to.indexOf( $.mobile.dialogHashKey ) > -1 &&
history.initialDst !== to ) {
to = this._handleDialog( changePageOptions, data );
if ( to === false ) {
return;
}
}
this._changeContent( this._handleDestination( to ), changePageOptions );
},
_changeContent: function( to, opts ) {
$.mobile.changePage( to, opts );
},
_getBase: function() {
return $.mobile.base;
},
_getNs: function() {
return $.mobile.ns;
},
_enhance: function( content, role ) {
// TODO consider supporting a custom callback, and passing in
// the settings which includes the role
return content.page({ role: role });
},
_include: function( page, settings ) {
// append to page and enhance
page.appendTo( this.element );
// use the page widget to enhance
this._enhance( page, settings.role );
// remove page on hide
page.page( "bindRemove" );
},
_find: function( absUrl ) {
// TODO consider supporting a custom callback
var fileUrl = this._createFileUrl( absUrl ),
dataUrl = this._createDataUrl( absUrl ),
page, initialContent = this._getInitialContent();
// Check to see if the page already exists in the DOM.
// NOTE do _not_ use the :jqmData pseudo selector because parenthesis
// are a valid url char and it breaks on the first occurence
page = this.element
.children( "[data-" + this._getNs() +"url='" + dataUrl + "']" );
// If we failed to find the page, check to see if the url is a
// reference to an embedded page. If so, it may have been dynamically
// injected by a developer, in which case it would be lacking a
// data-url attribute and in need of enhancement.
if ( page.length === 0 && dataUrl && !$.mobile.path.isPath( dataUrl ) ) {
page = this.element.children( $.mobile.path.hashToSelector("#" + dataUrl) )
.attr( "data-" + this._getNs() + "url", dataUrl )
.jqmData( "url", dataUrl );
}
// If we failed to find a page in the DOM, check the URL to see if it
// refers to the first page in the application. Also check to make sure
// our cached-first-page is actually in the DOM. Some user deployed
// apps are pruning the first page from the DOM for various reasons.
// We check for this case here because we don't want a first-page with
// an id falling through to the non-existent embedded page error case.
if ( page.length === 0 &&
$.mobile.path.isFirstPageUrl( fileUrl ) &&
initialContent &&
initialContent.parent().length ) {
page = $( initialContent );
}
return page;
},
_getLoader: function() {
return $.mobile.loading();
},
_showLoading: function( delay, theme, msg, textonly ) {
// This configurable timeout allows cached pages a brief
// delay to load without showing a message
if ( this._loadMsg ) {
return;
}
this._loadMsg = setTimeout($.proxy(function() {
this._getLoader().loader( "show", theme, msg, textonly );
this._loadMsg = 0;
}, this), delay );
},
_hideLoading: function() {
// Stop message show timer
clearTimeout( this._loadMsg );
this._loadMsg = 0;
// Hide loading message
this._getLoader().loader( "hide" );
},
_showError: function() {
// make sure to remove the current loading message
this._hideLoading();
// show the error message
this._showLoading( 0, $.mobile.pageLoadErrorMessageTheme, $.mobile.pageLoadErrorMessage, true );
// hide the error message after a delay
// TODO configuration
setTimeout( $.proxy(this, "_hideLoading"), 1500 );
},
_parse: function( html, fileUrl ) {
// TODO consider allowing customization of this method. It's very JQM specific
var page, all = $( "<div></div>" );
//workaround to allow scripts to execute when included in page divs
all.get( 0 ).innerHTML = html;
page = all.find( ":jqmData(role='page'), :jqmData(role='dialog')" ).first();
//if page elem couldn't be found, create one and insert the body element's contents
if ( !page.length ) {
page = $( "<div data-" + this._getNs() + "role='page'>" +
( html.split( /<\/?body[^>]*>/gmi )[1] || "" ) +
"</div>" );
}
// TODO tagging a page with external to make sure that embedded pages aren't
// removed by the various page handling code is bad. Having page handling code
// in many places is bad. Solutions post 1.0
page.attr( "data-" + this._getNs() + "url", $.mobile.path.convertUrlToDataUrl(fileUrl) )
.attr( "data-" + this._getNs() + "external-page", true );
return page;
},
_setLoadedTitle: function( page, html ) {
//page title regexp
var newPageTitle = html.match( /<title[^>]*>([^<]*)/ ) && RegExp.$1;
if ( newPageTitle && !page.jqmData("title") ) {
newPageTitle = $( "<div>" + newPageTitle + "</div>" ).text();
page.jqmData( "title", newPageTitle );
}
},
_isRewritableBaseTag: function() {
return $.mobile.dynamicBaseEnabled && !$.support.dynamicBaseTag;
},
_createDataUrl: function( absoluteUrl ) {
return $.mobile.path.convertUrlToDataUrl( absoluteUrl );
},
_createFileUrl: function( absoluteUrl ) {
return $.mobile.path.getFilePath( absoluteUrl );
},
_triggerWithDeprecated: function( name, data, page ) {
var deprecatedEvent = $.Event( "page" + name ),
newEvent = $.Event( this.widgetName + name );
// DEPRECATED
// trigger the old deprecated event on the page if it's provided
( page || this.element ).trigger( deprecatedEvent, data );
// use the widget trigger method for the new content* event
this._trigger( name, newEvent, data );
return {
deprecatedEvent: deprecatedEvent,
event: newEvent
};
},
// TODO it would be nice to split this up more but everything appears to be "one off"
// or require ordering such that other bits are sprinkled in between parts that
// could be abstracted out as a group
_loadSuccess: function( absUrl, triggerData, settings, deferred ) {
var fileUrl = this._createFileUrl( absUrl ),
dataUrl = this._createDataUrl( absUrl );
return $.proxy(function( html, textStatus, xhr ) {
//pre-parse html to check for a data-url,
//use it as the new fileUrl, base path, etc
var content,
// TODO handle dialogs again
pageElemRegex = new RegExp( "(<[^>]+\\bdata-" + this._getNs() + "role=[\"']?page[\"']?[^>]*>)" ),
dataUrlRegex = new RegExp( "\\bdata-" + this._getNs() + "url=[\"']?([^\"'>]*)[\"']?" );
// data-url must be provided for the base tag so resource requests
// can be directed to the correct url. loading into a temprorary
// element makes these requests immediately
if ( pageElemRegex.test( html ) &&
RegExp.$1 &&
dataUrlRegex.test( RegExp.$1 ) &&
RegExp.$1 ) {
fileUrl = $.mobile.path.getFilePath( $("<div>" + RegExp.$1 + "</div>").text() );
}
//dont update the base tag if we are prefetching
if ( settings.prefetch === undefined ) {
this._getBase().set( fileUrl );
}
content = this._parse( html, fileUrl );
this._setLoadedTitle( content, html );
// Add the content reference and xhr to our triggerData.
triggerData.xhr = xhr;
triggerData.textStatus = textStatus;
// DEPRECATED
triggerData.page = content;
triggerData.content = content;
triggerData.toPage = content;
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
if ( this._triggerWithDeprecated( "load" ).event.isDefaultPrevented() ) {
return;
}
// rewrite src and href attrs to use a base url if the base tag won't work
if ( this._isRewritableBaseTag() && content ) {
this._getBase().rewrite( fileUrl, content );
}
this._include( content, settings );
// Enhancing the content may result in new dialogs/sub content being inserted
// into the DOM. If the original absUrl refers to a sub-content, that is the
// real content we are interested in.
if ( absUrl.indexOf( "&" + $.mobile.subPageUrlKey ) > -1 ) {
content = this.element.children( "[data-" + this._getNs() +"url='" + dataUrl + "']" );
}
// Remove loading message.
if ( settings.showLoadMsg ) {
this._hideLoading();
}
deferred.resolve( absUrl, settings, content );
}, this);
},
_loadDefaults: {
type: "get",
data: undefined,
// DEPRECATED
reloadPage: false,
reload: false,
// By default we rely on the role defined by the @data-role attribute.
role: undefined,
showLoadMsg: false,
// This delay allows loads that pull from browser cache to
// occur without showing the loading message.
loadMsgDelay: 50
},
load: function( url, options ) {
// This function uses deferred notifications to let callers
// know when the content is done loading, or if an error has occurred.
var deferred = ( options && options.deferred ) || $.Deferred(),
// The default load options with overrides specified by the caller.
settings = $.extend( {}, this._loadDefaults, options ),
// The DOM element for the content after it has been loaded.
content = null,
// The absolute version of the URL passed into the function. This
// version of the URL may contain dialog/subcontent params in it.
absUrl = $.mobile.path.makeUrlAbsolute( url, this._findBaseWithDefault() ),
fileUrl, dataUrl, pblEvent, triggerData;
// DEPRECATED reloadPage
settings.reload = settings.reloadPage;
// If the caller provided data, and we're using "get" request,
// append the data to the URL.
if ( settings.data && settings.type === "get" ) {
absUrl = $.mobile.path.addSearchParams( absUrl, settings.data );
settings.data = undefined;
}
// If the caller is using a "post" request, reload must be true
if ( settings.data && settings.type === "post" ) {
settings.reload = true;
}
// The absolute version of the URL minus any dialog/subcontent params.
// In otherwords the real URL of the content to be loaded.
fileUrl = this._createFileUrl( absUrl );
// The version of the Url actually stored in the data-url attribute of
// the content. For embedded content, it is just the id of the page. For
// content within the same domain as the document base, it is the site
// relative path. For cross-domain content (Phone Gap only) the entire
// absolute Url is used to load the content.
dataUrl = this._createDataUrl( absUrl );
content = this._find( absUrl );
// If it isn't a reference to the first content and refers to missing
// embedded content reject the deferred and return
if ( content.length === 0 &&
$.mobile.path.isEmbeddedPage(fileUrl) &&
!$.mobile.path.isFirstPageUrl(fileUrl) ) {
deferred.reject( absUrl, settings );
return deferred.promise();
}
// Reset base to the default document base
// TODO figure out why we doe this
this._getBase().reset();
// If the content we are interested in is already in the DOM,
// and the caller did not indicate that we should force a
// reload of the file, we are done. Resolve the deferrred so that
// users can bind to .done on the promise
if ( content.length && !settings.reload ) {
this._enhance( content, settings.role );
deferred.resolve( absUrl, settings, content );
//if we are reloading the content make sure we update
// the base if its not a prefetch
if ( !settings.prefetch ) {
this._getBase().set(url);
}
return deferred.promise();
}
triggerData = {
url: url,
absUrl: absUrl,
toPage: url,
prevPage: options ? options.fromPage : undefined,
dataUrl: dataUrl,
deferred: deferred,
options: settings
};
// Let listeners know we're about to load content.
pblEvent = this._triggerWithDeprecated( "beforeload", triggerData );
// If the default behavior is prevented, stop here!
if ( pblEvent.deprecatedEvent.isDefaultPrevented() ||
pblEvent.event.isDefaultPrevented() ) {
return deferred.promise();
}
if ( settings.showLoadMsg ) {
this._showLoading( settings.loadMsgDelay );
}
// Reset base to the default document base.
// only reset if we are not prefetching
if ( settings.prefetch === undefined ) {
this._getBase().reset();
}
if ( !( $.mobile.allowCrossDomainPages ||
$.mobile.path.isSameDomain($.mobile.path.documentUrl, absUrl ) ) ) {
deferred.reject( absUrl, settings );
return deferred.promise();
}
// Load the new content.
$.ajax({
url: fileUrl,
type: settings.type,
data: settings.data,
contentType: settings.contentType,
dataType: "html",
success: this._loadSuccess( absUrl, triggerData, settings, deferred ),
error: this._loadError( absUrl, triggerData, settings, deferred )
});
return deferred.promise();
},
_loadError: function( absUrl, triggerData, settings, deferred ) {
return $.proxy(function( xhr, textStatus, errorThrown ) {
//set base back to current path
this._getBase().set( $.mobile.path.get() );
// Add error info to our triggerData.
triggerData.xhr = xhr;
triggerData.textStatus = textStatus;
triggerData.errorThrown = errorThrown;
// Let listeners know the page load failed.
var plfEvent = this._triggerWithDeprecated( "loadfailed", triggerData );
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
if ( plfEvent.deprecatedEvent.isDefaultPrevented() ||
plfEvent.event.isDefaultPrevented() ) {
return;
}
// Remove loading message.
if ( settings.showLoadMsg ) {
this._showError();
}
deferred.reject( absUrl, settings );
}, this);
},
_getTransitionHandler: function( transition ) {
transition = $.mobile._maybeDegradeTransition( transition );
//find the transition handler for the specified transition. If there
//isn't one in our transitionHandlers dictionary, use the default one.
//call the handler immediately to kick-off the transition.
return $.mobile.transitionHandlers[ transition ] || $.mobile.defaultTransitionHandler;
},
// TODO move into transition handlers?
_triggerCssTransitionEvents: function( to, from, prefix ) {
var samePage = false;
prefix = prefix || "";
// TODO decide if these events should in fact be triggered on the container
if ( from ) {
//Check if this is a same page transition and tell the handler in page
if( to[0] === from[0] ){
samePage = true;
}
//trigger before show/hide events
// TODO deprecate nextPage in favor of next
this._triggerWithDeprecated( prefix + "hide", {
// Deprecated in 1.4 remove in 1.5
nextPage: to,
toPage: to,
prevPage: from,
samePage: samePage
}, from );
}
// TODO deprecate prevPage in favor of previous
this._triggerWithDeprecated( prefix + "show", {
prevPage: from || $( "" ),
toPage: to
}, to );
},
// TODO make private once change has been defined in the widget
_cssTransition: function( to, from, options ) {
var transition = options.transition,
reverse = options.reverse,
deferred = options.deferred,
TransitionHandler,
promise;
this._triggerCssTransitionEvents( to, from, "before" );
// TODO put this in a binding to events *outside* the widget
this._hideLoading();
TransitionHandler = this._getTransitionHandler( transition );
promise = ( new TransitionHandler( transition, reverse, to, from ) ).transition();
promise.done( $.proxy( function() {
this._triggerCssTransitionEvents( to, from );
}, this ));
// TODO temporary accomodation of argument deferred
promise.done(function() {
deferred.resolve.apply( deferred, arguments );
});
},
_releaseTransitionLock: function() {
//release transition lock so navigation is free again
isPageTransitioning = false;
if ( pageTransitionQueue.length > 0 ) {
$.mobile.changePage.apply( null, pageTransitionQueue.pop() );
}
},
_removeActiveLinkClass: function( force ) {
//clear out the active button state
$.mobile.removeActiveLinkClass( force );
},
_loadUrl: function( to, triggerData, settings ) {
// preserve the original target as the dataUrl value will be
// simplified eg, removing ui-state, and removing query params
// from the hash this is so that users who want to use query
// params have access to them in the event bindings for the page
// life cycle See issue #5085
settings.target = to;
settings.deferred = $.Deferred();
this.load( to, settings );
settings.deferred.done($.proxy(function( url, options, content ) {
isPageTransitioning = false;
// store the original absolute url so that it can be provided
// to events in the triggerData of the subsequent changePage call
options.absUrl = triggerData.absUrl;
this.transition( content, triggerData, options );
}, this));
settings.deferred.fail($.proxy(function(/* url, options */) {
this._removeActiveLinkClass( true );
this._releaseTransitionLock();
this._triggerWithDeprecated( "changefailed", triggerData );
}, this));
},
_triggerPageBeforeChange: function( to, triggerData, settings ) {
var returnEvents;
triggerData.prevPage = this.activePage;
$.extend( triggerData, {
toPage: to,
options: settings
});
// NOTE: preserve the original target as the dataUrl value will be
// simplified eg, removing ui-state, and removing query params from
// the hash this is so that users who want to use query params have
// access to them in the event bindings for the page life cycle
// See issue #5085
if ( $.type(to) === "string" ) {
// if the toPage is a string simply convert it
triggerData.absUrl = $.mobile.path.makeUrlAbsolute( to, this._findBaseWithDefault() );
} else {
// if the toPage is a jQuery object grab the absolute url stored
// in the loadPage callback where it exists
triggerData.absUrl = settings.absUrl;
}
// Let listeners know we're about to change the current page.
returnEvents = this._triggerWithDeprecated( "beforechange", triggerData );
// If the default behavior is prevented, stop here!
if ( returnEvents.event.isDefaultPrevented() ||
returnEvents.deprecatedEvent.isDefaultPrevented() ) {
return false;
}
return true;
},
change: function( to, options ) {
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if ( isPageTransitioning ) {
pageTransitionQueue.unshift( arguments );
return;
}
var settings = $.extend( {}, $.mobile.changePage.defaults, options ),
triggerData = {};
// Make sure we have a fromPage.
settings.fromPage = settings.fromPage || this.activePage;
// if the page beforechange default is prevented return early
if ( !this._triggerPageBeforeChange(to, triggerData, settings) ) {
return;
}
// We allow "pagebeforechange" observers to modify the to in
// the trigger data to allow for redirects. Make sure our to is
// updated. We also need to re-evaluate whether it is a string,
// because an object can also be replaced by a string
to = triggerData.toPage;
// If the caller passed us a url, call loadPage()
// to make sure it is loaded into the DOM. We'll listen
// to the promise object it returns so we know when
// it is done loading or if an error ocurred.
if ( $.type(to) === "string" ) {
// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = true;
this._loadUrl( to, triggerData, settings );
} else {
this.transition( to, triggerData, settings );
}
},
transition: function( toPage, triggerData, settings ) {
var fromPage, url, pageUrl, fileUrl,
active, activeIsInitialPage,
historyDir, pageTitle, isDialog,
alreadyThere, newPageTitle,
params, cssTransitionDeferred,
beforeTransition;
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if ( isPageTransitioning ) {
// make sure to only queue the to and settings values so the arguments
// work with a call to the change method
pageTransitionQueue.unshift( [toPage, settings] );
return;
}
// DEPRECATED - this call only, in favor of the before transition
// if the page beforechange default is prevented return early
if ( !this._triggerPageBeforeChange(toPage, triggerData, settings) ) {
return;
}
triggerData.prevPage = settings.fromPage;
// if the (content|page)beforetransition default is prevented return early
// Note, we have to check for both the deprecated and new events
beforeTransition = this._triggerWithDeprecated( "beforetransition", triggerData );
if (beforeTransition.deprecatedEvent.isDefaultPrevented() ||
beforeTransition.event.isDefaultPrevented() ) {
return;
}
// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = true;
// If we are going to the first-page of the application, we need to make
// sure settings.dataUrl is set to the application document url. This allows
// us to avoid generating a document url with an id hash in the case where the
// first-page of the document has an id attribute specified.
if ( toPage[ 0 ] === $.mobile.firstPage[ 0 ] && !settings.dataUrl ) {
settings.dataUrl = $.mobile.path.documentUrl.hrefNoHash;
}
// The caller passed us a real page DOM element. Update our
// internal state and then trigger a transition to the page.
fromPage = settings.fromPage;
url = ( settings.dataUrl && $.mobile.path.convertUrlToDataUrl(settings.dataUrl) ) ||
toPage.jqmData( "url" );
// The pageUrl var is usually the same as url, except when url is obscured
// as a dialog url. pageUrl always contains the file path
pageUrl = url;
fileUrl = $.mobile.path.getFilePath( url );
active = $.mobile.navigate.history.getActive();
activeIsInitialPage = $.mobile.navigate.history.activeIndex === 0;
historyDir = 0;
pageTitle = document.title;
isDialog = ( settings.role === "dialog" ||
toPage.jqmData( "role" ) === "dialog" ) &&
toPage.jqmData( "dialog" ) !== true;
// By default, we prevent changePage requests when the fromPage and toPage
// are the same element, but folks that generate content
// manually/dynamically and reuse pages want to be able to transition to
// the same page. To allow this, they will need to change the default
// value of allowSamePageTransition to true, *OR*, pass it in as an
// option when they manually call changePage(). It should be noted that
// our default transition animations assume that the formPage and toPage
// are different elements, so they may behave unexpectedly. It is up to
// the developer that turns on the allowSamePageTransitiona option to
// either turn off transition animations, or make sure that an appropriate
// animation transition is used.
if ( fromPage && fromPage[0] === toPage[0] &&
!settings.allowSamePageTransition ) {
isPageTransitioning = false;
this._triggerWithDeprecated( "transition", triggerData );
this._triggerWithDeprecated( "change", triggerData );
// Even if there is no page change to be done, we should keep the
// urlHistory in sync with the hash changes
if ( settings.fromHashChange ) {
$.mobile.navigate.history.direct({ url: url });
}
return;
}
// We need to make sure the page we are given has already been enhanced.
toPage.page({ role: settings.role });
// If the changePage request was sent from a hashChange event, check to
// see if the page is already within the urlHistory stack. If so, we'll
// assume the user hit the forward/back button and will try to match the
// transition accordingly.
if ( settings.fromHashChange ) {
historyDir = settings.direction === "back" ? -1 : 1;
}
// Kill the keyboard.
// XXX_jblas: We need to stop crawling the entire document to kill focus.
// Instead, we should be tracking focus with a delegate()
// handler so we already have the element in hand at this
// point.
// Wrap this in a try/catch block since IE9 throw "Unspecified error" if
// document.activeElement is undefined when we are in an IFrame.
try {
if ( document.activeElement &&
document.activeElement.nodeName.toLowerCase() !== "body" ) {
$( document.activeElement ).blur();
} else {
$( "input:focus, textarea:focus, select:focus" ).blur();
}
} catch( e ) {}
// Record whether we are at a place in history where a dialog used to be -
// if so, do not add a new history entry and do not change the hash either
alreadyThere = false;
// If we're displaying the page as a dialog, we don't want the url
// for the dialog content to be used in the hash. Instead, we want
// to append the dialogHashKey to the url of the current page.
if ( isDialog && active ) {
// on the initial page load active.url is undefined and in that case
// should be an empty string. Moving the undefined -> empty string back
// into urlHistory.addNew seemed imprudent given undefined better
// represents the url state
// If we are at a place in history that once belonged to a dialog, reuse
// this state without adding to urlHistory and without modifying the
// hash. However, if a dialog is already displayed at this point, and
// we're about to display another dialog, then we must add another hash
// and history entry on top so that one may navigate back to the
// original dialog
if ( active.url &&
active.url.indexOf( $.mobile.dialogHashKey ) > -1 &&
this.activePage &&
!this.activePage.hasClass( "ui-dialog" ) &&
$.mobile.navigate.history.activeIndex > 0 ) {
settings.changeHash = false;
alreadyThere = true;
}
// Normally, we tack on a dialog hash key, but if this is the location
// of a stale dialog, we reuse the URL from the entry
url = ( active.url || "" );
// account for absolute urls instead of just relative urls use as hashes
if ( !alreadyThere && url.indexOf("#") > -1 ) {
url += $.mobile.dialogHashKey;
} else {
url += "#" + $.mobile.dialogHashKey;
}
// tack on another dialogHashKey if this is the same as the initial hash
// this makes sure that a history entry is created for this dialog
if ( $.mobile.navigate.history.activeIndex === 0 && url === $.mobile.navigate.history.initialDst ) {
url += $.mobile.dialogHashKey;
}
}
// if title element wasn't found, try the page div data attr too
// If this is a deep-link or a reload ( active === undefined ) then just
// use pageTitle
newPageTitle = ( !active ) ? pageTitle : toPage.jqmData( "title" ) ||
toPage.children( ":jqmData(role='header')" ).find( ".ui-title" ).text();
if ( !!newPageTitle && pageTitle === document.title ) {
pageTitle = newPageTitle;
}
if ( !toPage.jqmData( "title" ) ) {
toPage.jqmData( "title", pageTitle );
}
// Make sure we have a transition defined.
settings.transition = settings.transition ||
( ( historyDir && !activeIsInitialPage ) ? active.transition : undefined ) ||
( isDialog ? $.mobile.defaultDialogTransition : $.mobile.defaultPageTransition );
//add page to history stack if it's not back or forward
if ( !historyDir && alreadyThere ) {
$.mobile.navigate.history.getActive().pageUrl = pageUrl;
}
// Set the location hash.
if ( url && !settings.fromHashChange ) {
// rebuilding the hash here since we loose it earlier on
// TODO preserve the originally passed in path
if ( !$.mobile.path.isPath( url ) && url.indexOf( "#" ) < 0 ) {
url = "#" + url;
}
// TODO the property names here are just silly
params = {
transition: settings.transition,
title: pageTitle,
pageUrl: pageUrl,
role: settings.role
};
if ( settings.changeHash !== false && $.mobile.hashListeningEnabled ) {
$.mobile.navigate( url, params, true);
} else if ( toPage[ 0 ] !== $.mobile.firstPage[ 0 ] ) {
$.mobile.navigate.history.add( url, params );
}
}
//set page title
document.title = pageTitle;
//set "toPage" as activePage deprecated in 1.4 remove in 1.5
$.mobile.activePage = toPage;
//new way to handle activePage
this.activePage = toPage;
// If we're navigating back in the URL history, set reverse accordingly.
settings.reverse = settings.reverse || historyDir < 0;
cssTransitionDeferred = $.Deferred();
this._cssTransition(toPage, fromPage, {
transition: settings.transition,
reverse: settings.reverse,
deferred: cssTransitionDeferred
});
cssTransitionDeferred.done($.proxy(function( name, reverse, $to, $from, alreadyFocused ) {
$.mobile.removeActiveLinkClass();
//if there's a duplicateCachedPage, remove it from the DOM now that it's hidden
if ( settings.duplicateCachedPage ) {
settings.duplicateCachedPage.remove();
}
// despite visibility: hidden addresses issue #2965
// https://github.com/jquery/jquery-mobile/issues/2965
if ( !alreadyFocused ) {
$.mobile.focusPage( toPage );
}
this._releaseTransitionLock();
this._triggerWithDeprecated( "transition", triggerData );
this._triggerWithDeprecated( "change", triggerData );
}, this));
},
// determine the current base url
_findBaseWithDefault: function() {
var closestBase = ( this.activePage &&
$.mobile.getClosestBaseUrl( this.activePage ) );
return closestBase || $.mobile.path.documentBase.hrefNoHash;
}
});
// The following handlers should be bound after mobileinit has been triggered
// the following deferred is resolved in the init file
$.mobile.navreadyDeferred = $.Deferred();
//these variables make all page containers use the same queue and only navigate one at a time
// queue to hold simultanious page transitions
var pageTransitionQueue = [],
// indicates whether or not page is in process of transitioning
isPageTransitioning = false;
})( jQuery );
(function( $, undefined ) {
// resolved on domready
var domreadyDeferred = $.Deferred(),
// resolved and nulled on window.load()
loadDeferred = $.Deferred(),
// function that resolves the above deferred
pageIsFullyLoaded = function() {
// Resolve and null the deferred
loadDeferred.resolve();
loadDeferred = null;
},
documentUrl = $.mobile.path.documentUrl,
// used to track last vclicked element to make sure its value is added to form data
$lastVClicked = null;
/* Event Bindings - hashchange, submit, and click */
function findClosestLink( ele ) {
while ( ele ) {
// Look for the closest element with a nodeName of "a".
// Note that we are checking if we have a valid nodeName
// before attempting to access it. This is because the
// node we get called with could have originated from within
// an embedded SVG document where some symbol instance elements
// don't have nodeName defined on them, or strings are of type
// SVGAnimatedString.
if ( ( typeof ele.nodeName === "string" ) && ele.nodeName.toLowerCase() === "a" ) {
break;
}
ele = ele.parentNode;
}
return ele;
}
$.mobile.loadPage = function( url, opts ) {
var container;
opts = opts || {};
container = ( opts.pageContainer || $.mobile.pageContainer );
// create the deferred that will be supplied to loadPage callers
// and resolved by the content widget's load method
opts.deferred = $.Deferred();
// Preferring to allow exceptions for uninitialized opts.pageContainer
// widgets so we know if we need to force init here for users
container.pagecontainer( "load", url, opts );
// provide the deferred
return opts.deferred.promise();
};
//define vars for interal use
/* internal utility functions */
// NOTE Issue #4950 Android phonegap doesn't navigate back properly
// when a full page refresh has taken place. It appears that hashchange
// and replacestate history alterations work fine but we need to support
// both forms of history traversal in our code that uses backward history
// movement
$.mobile.back = function() {
var nav = window.navigator;
// if the setting is on and the navigator object is
// available use the phonegap navigation capability
if ( this.phonegapNavigationEnabled &&
nav &&
nav.app &&
nav.app.backHistory ) {
nav.app.backHistory();
} else {
$.mobile.pageContainer.pagecontainer( "back" );
}
};
// Direct focus to the page title, or otherwise first focusable element
$.mobile.focusPage = function ( page ) {
var autofocus = page.find( "[autofocus]" ),
pageTitle = page.find( ".ui-title:eq(0)" );
if ( autofocus.length ) {
autofocus.focus();
return;
}
if ( pageTitle.length ) {
pageTitle.focus();
} else{
page.focus();
}
};
// No-op implementation of transition degradation
$.mobile._maybeDegradeTransition = $.mobile._maybeDegradeTransition || function( transition ) {
return transition;
};
// Exposed $.mobile methods
$.mobile.changePage = function( to, options ) {
$.mobile.pageContainer.pagecontainer( "change", to, options );
};
$.mobile.changePage.defaults = {
transition: undefined,
reverse: false,
changeHash: true,
fromHashChange: false,
role: undefined, // By default we rely on the role defined by the @data-role attribute.
duplicateCachedPage: undefined,
pageContainer: undefined,
showLoadMsg: true, //loading message shows by default when pages are being fetched during changePage
dataUrl: undefined,
fromPage: undefined,
allowSamePageTransition: false
};
$.mobile._registerInternalEvents = function() {
var getAjaxFormData = function( $form, calculateOnly ) {
var url, ret = true, formData, vclickedName, method;
if ( !$.mobile.ajaxEnabled ||
// test that the form is, itself, ajax false
$form.is( ":jqmData(ajax='false')" ) ||
// test that $.mobile.ignoreContentEnabled is set and
// the form or one of it's parents is ajax=false
!$form.jqmHijackable().length ||
$form.attr( "target" ) ) {
return false;
}
url = ( $lastVClicked && $lastVClicked.attr( "formaction" ) ) ||
$form.attr( "action" );
method = ( $form.attr( "method" ) || "get" ).toLowerCase();
// If no action is specified, browsers default to using the
// URL of the document containing the form. Since we dynamically
// pull in pages from external documents, the form should submit
// to the URL for the source document of the page containing
// the form.
if ( !url ) {
// Get the @data-url for the page containing the form.
url = $.mobile.getClosestBaseUrl( $form );
// NOTE: If the method is "get", we need to strip off the query string
// because it will get replaced with the new form data. See issue #5710.
if ( method === "get" ) {
url = $.mobile.path.parseUrl( url ).hrefNoSearch;
}
if ( url === $.mobile.path.documentBase.hrefNoHash ) {
// The url we got back matches the document base,
// which means the page must be an internal/embedded page,
// so default to using the actual document url as a browser
// would.
url = documentUrl.hrefNoSearch;
}
}
url = $.mobile.path.makeUrlAbsolute( url, $.mobile.getClosestBaseUrl( $form ) );
if ( ( $.mobile.path.isExternal( url ) && !$.mobile.path.isPermittedCrossDomainRequest( documentUrl, url ) ) ) {
return false;
}
if ( !calculateOnly ) {
formData = $form.serializeArray();
if ( $lastVClicked && $lastVClicked[ 0 ].form === $form[ 0 ] ) {
vclickedName = $lastVClicked.attr( "name" );
if ( vclickedName ) {
// Make sure the last clicked element is included in the form
$.each( formData, function( key, value ) {
if ( value.name === vclickedName ) {
// Unset vclickedName - we've found it in the serialized data already
vclickedName = "";
return false;
}
});
if ( vclickedName ) {
formData.push( { name: vclickedName, value: $lastVClicked.attr( "value" ) } );
}
}
}
ret = {
url: url,
options: {
type: method,
data: $.param( formData ),
transition: $form.jqmData( "transition" ),
reverse: $form.jqmData( "direction" ) === "reverse",
reloadPage: true
}
};
}
return ret;
};
//bind to form submit events, handle with Ajax
$.mobile.document.delegate( "form", "submit", function( event ) {
var formData;
if ( !event.isDefaultPrevented() ) {
formData = getAjaxFormData( $( this ) );
if ( formData ) {
$.mobile.changePage( formData.url, formData.options );
event.preventDefault();
}
}
});
//add active state on vclick
$.mobile.document.bind( "vclick", function( event ) {
var $btn, btnEls, target = event.target, needClosest = false;
// if this isn't a left click we don't care. Its important to note
// that when the virtual event is generated it will create the which attr
if ( event.which > 1 || !$.mobile.linkBindingEnabled ) {
return;
}
// Record that this element was clicked, in case we need it for correct
// form submission during the "submit" handler above
$lastVClicked = $( target );
// Try to find a target element to which the active class will be applied
if ( $.data( target, "mobile-button" ) ) {
// If the form will not be submitted via AJAX, do not add active class
if ( !getAjaxFormData( $( target ).closest( "form" ), true ) ) {
return;
}
// We will apply the active state to this button widget - the parent
// of the input that was clicked will have the associated data
if ( target.parentNode ) {
target = target.parentNode;
}
} else {
target = findClosestLink( target );
if ( !( target && $.mobile.path.parseUrl( target.getAttribute( "href" ) || "#" ).hash !== "#" ) ) {
return;
}
// TODO teach $.mobile.hijackable to operate on raw dom elements so the
// link wrapping can be avoided
if ( !$( target ).jqmHijackable().length ) {
return;
}
}
// Avoid calling .closest by using the data set during .buttonMarkup()
// List items have the button data in the parent of the element clicked
if ( !!~target.className.indexOf( "ui-link-inherit" ) ) {
if ( target.parentNode ) {
btnEls = $.data( target.parentNode, "buttonElements" );
}
// Otherwise, look for the data on the target itself
} else {
btnEls = $.data( target, "buttonElements" );
}
// If found, grab the button's outer element
if ( btnEls ) {
target = btnEls.outer;
} else {
needClosest = true;
}
$btn = $( target );
// If the outer element wasn't found by the our heuristics, use .closest()
if ( needClosest ) {
$btn = $btn.closest( ".ui-btn" );
}
if ( $btn.length > 0 &&
!( $btn.hasClass( "ui-state-disabled" ||
// DEPRECATED as of 1.4.0 - remove after 1.4.0 release
// only ui-state-disabled should be present thereafter
$btn.hasClass( "ui-disabled" ) ) ) ) {
$.mobile.removeActiveLinkClass( true );
$.mobile.activeClickedLink = $btn;
$.mobile.activeClickedLink.addClass( $.mobile.activeBtnClass );
}
});
// click routing - direct to HTTP or Ajax, accordingly
$.mobile.document.bind( "click", function( event ) {
if ( !$.mobile.linkBindingEnabled || event.isDefaultPrevented() ) {
return;
}
var link = findClosestLink( event.target ),
$link = $( link ),
//remove active link class if external (then it won't be there if you come back)
httpCleanup = function() {
window.setTimeout(function() { $.mobile.removeActiveLinkClass( true ); }, 200 );
},
baseUrl, href,
useDefaultUrlHandling, isExternal,
transition, reverse, role;
// If a button was clicked, clean up the active class added by vclick above
if ( $.mobile.activeClickedLink &&
$.mobile.activeClickedLink[ 0 ] === event.target.parentNode ) {
httpCleanup();
}
// If there is no link associated with the click or its not a left
// click we want to ignore the click
// TODO teach $.mobile.hijackable to operate on raw dom elements so the link wrapping
// can be avoided
if ( !link || event.which > 1 || !$link.jqmHijackable().length ) {
return;
}
//if there's a data-rel=back attr, go back in history
if ( $link.is( ":jqmData(rel='back')" ) ) {
$.mobile.back();
return false;
}
baseUrl = $.mobile.getClosestBaseUrl( $link );
//get href, if defined, otherwise default to empty hash
href = $.mobile.path.makeUrlAbsolute( $link.attr( "href" ) || "#", baseUrl );
//if ajax is disabled, exit early
if ( !$.mobile.ajaxEnabled && !$.mobile.path.isEmbeddedPage( href ) ) {
httpCleanup();
//use default click handling
return;
}
// XXX_jblas: Ideally links to application pages should be specified as
// an url to the application document with a hash that is either
// the site relative path or id to the page. But some of the
// internal code that dynamically generates sub-pages for nested
// lists and select dialogs, just write a hash in the link they
// create. This means the actual URL path is based on whatever
// the current value of the base tag is at the time this code
// is called. For now we are just assuming that any url with a
// hash in it is an application page reference.
if ( href.search( "#" ) !== -1 ) {
href = href.replace( /[^#]*#/, "" );
if ( !href ) {
//link was an empty hash meant purely
//for interaction, so we ignore it.
event.preventDefault();
return;
} else if ( $.mobile.path.isPath( href ) ) {
//we have apath so make it the href we want to load.
href = $.mobile.path.makeUrlAbsolute( href, baseUrl );
} else {
//we have a simple id so use the documentUrl as its base.
href = $.mobile.path.makeUrlAbsolute( "#" + href, documentUrl.hrefNoHash );
}
}
// Should we handle this link, or let the browser deal with it?
useDefaultUrlHandling = $link.is( "[rel='external']" ) || $link.is( ":jqmData(ajax='false')" ) || $link.is( "[target]" );
// Some embedded browsers, like the web view in Phone Gap, allow cross-domain XHR
// requests if the document doing the request was loaded via the file:// protocol.
// This is usually to allow the application to "phone home" and fetch app specific
// data. We normally let the browser handle external/cross-domain urls, but if the
// allowCrossDomainPages option is true, we will allow cross-domain http/https
// requests to go through our page loading logic.
//check for protocol or rel and its not an embedded page
//TODO overlap in logic from isExternal, rel=external check should be
// moved into more comprehensive isExternalLink
isExternal = useDefaultUrlHandling || ( $.mobile.path.isExternal( href ) && !$.mobile.path.isPermittedCrossDomainRequest( documentUrl, href ) );
if ( isExternal ) {
httpCleanup();
//use default click handling
return;
}
//use ajax
transition = $link.jqmData( "transition" );
reverse = $link.jqmData( "direction" ) === "reverse" ||
// deprecated - remove by 1.0
$link.jqmData( "back" );
//this may need to be more specific as we use data-rel more
role = $link.attr( "data-" + $.mobile.ns + "rel" ) || undefined;
$.mobile.changePage( href, { transition: transition, reverse: reverse, role: role, link: $link } );
event.preventDefault();
});
//prefetch pages when anchors with data-prefetch are encountered
$.mobile.document.delegate( ".ui-page", "pageshow.prefetch", function() {
var urls = [];
$( this ).find( "a:jqmData(prefetch)" ).each(function() {
var $link = $( this ),
url = $link.attr( "href" );
if ( url && $.inArray( url, urls ) === -1 ) {
urls.push( url );
$.mobile.loadPage( url, { role: $link.attr( "data-" + $.mobile.ns + "rel" ),prefetch: true } );
}
});
});
// TODO ensure that the navigate binding in the content widget happens at the right time
$.mobile.pageContainer.pagecontainer();
//set page min-heights to be device specific
$.mobile.document.bind( "pageshow", function() {
// We need to wait for window.load to make sure that styles have already been rendered,
// otherwise heights of external toolbars will have the wrong value
if ( loadDeferred ) {
loadDeferred.done( $.mobile.resetActivePageHeight );
} else {
$.mobile.resetActivePageHeight();
}
});
$.mobile.window.bind( "throttledresize", $.mobile.resetActivePageHeight );
};//navreadyDeferred done callback
$( function() { domreadyDeferred.resolve(); } );
// Account for the possibility that the load event has already fired
if ( document.readyState === "complete" ) {
pageIsFullyLoaded();
} else {
$.mobile.window.load( pageIsFullyLoaded );
}
$.when( domreadyDeferred, $.mobile.navreadyDeferred ).done( function() { $.mobile._registerInternalEvents(); } );
})( jQuery );
(function( $, window, undefined ) {
// TODO remove direct references to $.mobile and properties, we should
// favor injection with params to the constructor
$.mobile.Transition = function() {
this.init.apply( this, arguments );
};
$.extend($.mobile.Transition.prototype, {
toPreClass: " ui-page-pre-in",
init: function( name, reverse, $to, $from ) {
$.extend(this, {
name: name,
reverse: reverse,
$to: $to,
$from: $from,
deferred: new $.Deferred()
});
},
cleanFrom: function() {
this.$from
.removeClass( $.mobile.activePageClass + " out in reverse " + this.name )
.height( "" );
},
// NOTE overridden by child object prototypes, noop'd here as defaults
beforeDoneIn: function() {},
beforeDoneOut: function() {},
beforeStartOut: function() {},
doneIn: function() {
this.beforeDoneIn();
this.$to.removeClass( "out in reverse " + this.name ).height( "" );
this.toggleViewportClass();
// In some browsers (iOS5), 3D transitions block the ability to scroll to the desired location during transition
// This ensures we jump to that spot after the fact, if we aren't there already.
if ( $.mobile.window.scrollTop() !== this.toScroll ) {
this.scrollPage();
}
if ( !this.sequential ) {
this.$to.addClass( $.mobile.activePageClass );
}
this.deferred.resolve( this.name, this.reverse, this.$to, this.$from, true );
},
doneOut: function( screenHeight, reverseClass, none, preventFocus ) {
this.beforeDoneOut();
this.startIn( screenHeight, reverseClass, none, preventFocus );
},
hideIn: function( callback ) {
// Prevent flickering in phonegap container: see comments at #4024 regarding iOS
this.$to.css( "z-index", -10 );
callback.call( this );
this.$to.css( "z-index", "" );
},
scrollPage: function() {
// By using scrollTo instead of silentScroll, we can keep things better in order
// Just to be precautios, disable scrollstart listening like silentScroll would
$.event.special.scrollstart.enabled = false;
//if we are hiding the url bar or the page was previously scrolled scroll to hide or return to position
if ( $.mobile.hideUrlBar || this.toScroll !== $.mobile.defaultHomeScroll ) {
window.scrollTo( 0, this.toScroll );
}
// reenable scrollstart listening like silentScroll would
setTimeout( function() {
$.event.special.scrollstart.enabled = true;
}, 150 );
},
startIn: function( screenHeight, reverseClass, none, preventFocus ) {
this.hideIn(function() {
this.$to.addClass( $.mobile.activePageClass + this.toPreClass );
// Send focus to page as it is now display: block
if ( !preventFocus ) {
$.mobile.focusPage( this.$to );
}
// Set to page height
this.$to.height( screenHeight + this.toScroll );
if ( !none ) {
this.scrollPage();
}
});
this.$to
.removeClass( this.toPreClass )
.addClass( this.name + " in " + reverseClass );
if ( !none ) {
this.$to.animationComplete( $.proxy(function() {
this.doneIn();
}, this ));
} else {
this.doneIn();
}
},
startOut: function( screenHeight, reverseClass, none ) {
this.beforeStartOut( screenHeight, reverseClass, none );
// Set the from page's height and start it transitioning out
// Note: setting an explicit height helps eliminate tiling in the transitions
this.$from
.height( screenHeight + $.mobile.window.scrollTop() )
.addClass( this.name + " out" + reverseClass );
},
toggleViewportClass: function() {
$.mobile.pageContainer.toggleClass( "ui-mobile-viewport-transitioning viewport-" + this.name );
},
transition: function() {
// NOTE many of these could be calculated/recorded in the constructor, it's my
// opinion that binding them as late as possible has value with regards to
// better transitions with fewer bugs. Ie, it's not guaranteed that the
// object will be created and transition will be run immediately after as
// it is today. So we wait until transition is invoked to gather the following
var none,
reverseClass = this.reverse ? " reverse" : "",
screenHeight = $.mobile.getScreenHeight(),
maxTransitionOverride = $.mobile.maxTransitionWidth !== false &&
$.mobile.window.width() > $.mobile.maxTransitionWidth;
this.toScroll = $.mobile.navigate.history.getActive().lastScroll || $.mobile.defaultHomeScroll;
none = !$.support.cssTransitions || !$.support.cssAnimations ||
maxTransitionOverride || !this.name || this.name === "none" ||
Math.max( $.mobile.window.scrollTop(), this.toScroll ) >
$.mobile.getMaxScrollForTransition();
this.toggleViewportClass();
if ( this.$from && !none ) {
this.startOut( screenHeight, reverseClass, none );
} else {
this.doneOut( screenHeight, reverseClass, none, true );
}
return this.deferred.promise();
}
});
})( jQuery, this );
(function( $ ) {
$.mobile.SerialTransition = function() {
this.init.apply(this, arguments);
};
$.extend($.mobile.SerialTransition.prototype, $.mobile.Transition.prototype, {
sequential: true,
beforeDoneOut: function() {
if ( this.$from ) {
this.cleanFrom();
}
},
beforeStartOut: function( screenHeight, reverseClass, none ) {
this.$from.animationComplete($.proxy(function() {
this.doneOut( screenHeight, reverseClass, none );
}, this ));
}
});
})( jQuery );
(function( $ ) {
$.mobile.ConcurrentTransition = function() {
this.init.apply(this, arguments);
};
$.extend($.mobile.ConcurrentTransition.prototype, $.mobile.Transition.prototype, {
sequential: false,
beforeDoneIn: function() {
if ( this.$from ) {
this.cleanFrom();
}
},
beforeStartOut: function( screenHeight, reverseClass, none ) {
this.doneOut( screenHeight, reverseClass, none );
}
});
})( jQuery );
(function( $ ) {
// generate the handlers from the above
var defaultGetMaxScrollForTransition = function() {
return $.mobile.getScreenHeight() * 3;
};
//transition handler dictionary for 3rd party transitions
$.mobile.transitionHandlers = {
"sequential": $.mobile.SerialTransition,
"simultaneous": $.mobile.ConcurrentTransition
};
// Make our transition handler the public default.
$.mobile.defaultTransitionHandler = $.mobile.transitionHandlers.sequential;
$.mobile.transitionFallbacks = {};
// If transition is defined, check if css 3D transforms are supported, and if not, if a fallback is specified
$.mobile._maybeDegradeTransition = function( transition ) {
if ( transition && !$.support.cssTransform3d && $.mobile.transitionFallbacks[ transition ] ) {
transition = $.mobile.transitionFallbacks[ transition ];
}
return transition;
};
// Set the getMaxScrollForTransition to default if no implementation was set by user
$.mobile.getMaxScrollForTransition = $.mobile.getMaxScrollForTransition || defaultGetMaxScrollForTransition;
})( jQuery );
/*
* fallback transition for flip in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
$.mobile.transitionFallbacks.flip = "fade";
})( jQuery, this );
/*
* fallback transition for flow in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
$.mobile.transitionFallbacks.flow = "fade";
})( jQuery, this );
/*
* fallback transition for pop in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
$.mobile.transitionFallbacks.pop = "fade";
})( jQuery, this );
/*
* fallback transition for slide in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
// Use the simultaneous transitions handler for slide transitions
$.mobile.transitionHandlers.slide = $.mobile.transitionHandlers.simultaneous;
// Set the slide transitions's fallback to "fade"
$.mobile.transitionFallbacks.slide = "fade";
})( jQuery, this );
/*
* fallback transition for slidedown in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
$.mobile.transitionFallbacks.slidedown = "fade";
})( jQuery, this );
/*
* fallback transition for slidefade in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
// Set the slide transitions's fallback to "fade"
$.mobile.transitionFallbacks.slidefade = "fade";
})( jQuery, this );
/*
* fallback transition for slideup in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
$.mobile.transitionFallbacks.slideup = "fade";
})( jQuery, this );
/*
* fallback transition for turn in non-3D supporting browsers (which tend to handle complex transitions poorly in general
*/
(function( $, window, undefined ) {
$.mobile.transitionFallbacks.turn = "fade";
})( jQuery, this );
(function( $, undefined ) {
$.mobile.degradeInputs = {
color: false,
date: false,
datetime: false,
"datetime-local": false,
email: false,
month: false,
number: false,
range: "number",
search: "text",
tel: false,
time: false,
url: false,
week: false
};
// Backcompat remove in 1.5
$.mobile.page.prototype.options.degradeInputs = $.mobile.degradeInputs;
// Auto self-init widgets
$.mobile.degradeInputsWithin = function( target ) {
target = $( target );
// Degrade inputs to avoid poorly implemented native functionality
target.find( "input" ).not( $.mobile.page.prototype.keepNativeSelector() ).each(function() {
var element = $( this ),
type = this.getAttribute( "type" ),
optType = $.mobile.degradeInputs[ type ] || "text",
html, hasType, findstr, repstr;
if ( $.mobile.degradeInputs[ type ] ) {
html = $( "<div>" ).html( element.clone() ).html();
// In IE browsers, the type sometimes doesn't exist in the cloned markup, so we replace the closing tag instead
hasType = html.indexOf( " type=" ) > -1;
findstr = hasType ? /\s+type=["']?\w+['"]?/ : /\/?>/;
repstr = " type=\"" + optType + "\" data-" + $.mobile.ns + "type=\"" + type + "\"" + ( hasType ? "" : ">" );
element.replaceWith( html.replace( findstr, repstr ) );
}
});
};
})( jQuery );
(function( $, window, undefined ) {
$.widget( "mobile.page", $.mobile.page, {
options: {
// Accepts left, right and none
closeBtn: "left",
closeBtnText: "Close",
overlayTheme: "a",
corners: true,
dialog: false
},
_create: function() {
this._super();
if ( this.options.dialog ) {
$.extend( this, {
_inner: this.element.children(),
_headerCloseButton: null
});
if ( !this.options.enhanced ) {
this._setCloseBtn( this.options.closeBtn );
}
}
},
_enhance: function() {
this._super();
// Class the markup for dialog styling and wrap interior
if ( this.options.dialog ) {
this.element.addClass( "ui-dialog" )
.wrapInner( $( "<div/>", {
// ARIA role
"role" : "dialog",
"class" : "ui-dialog-contain ui-overlay-shadow" +
( this.options.corners ? " ui-corner-all" : "" )
}));
}
},
_setOptions: function( options ) {
var closeButtonLocation, closeButtonText,
currentOpts = this.options;
if ( options.corners !== undefined ) {
this._inner.toggleClass( "ui-corner-all", !!options.corners );
}
if ( options.overlayTheme !== undefined ) {
if ( $.mobile.activePage[ 0 ] === this.element[ 0 ] ) {
currentOpts.overlayTheme = options.overlayTheme;
this._handlePageBeforeShow();
}
}
if ( options.closeBtnText !== undefined ) {
closeButtonLocation = currentOpts.closeBtn;
closeButtonText = options.closeBtnText;
}
if ( options.closeBtn !== undefined ) {
closeButtonLocation = options.closeBtn;
}
if ( closeButtonLocation ) {
this._setCloseBtn( closeButtonLocation, closeButtonText );
}
this._super( options );
},
_handlePageBeforeShow: function () {
if ( this.options.overlayTheme && this.options.dialog ) {
this.removeContainerBackground();
this.setContainerBackground( this.options.overlayTheme );
} else {
this._super();
}
},
_setCloseBtn: function( location, text ) {
var dst,
btn = this._headerCloseButton;
// Sanitize value
location = "left" === location ? "left" : "right" === location ? "right" : "none";
if ( "none" === location ) {
if ( btn ) {
btn.remove();
btn = null;
}
} else if ( btn ) {
btn.removeClass( "ui-btn-left ui-btn-right" ).addClass( "ui-btn-" + location );
if ( text ) {
btn.text( text );
}
} else {
dst = this._inner.find( ":jqmData(role='header')" ).first();
btn = $( "<a></a>", {
"href": "#",
"class": "ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" + location
})
.attr( "data-" + $.mobile.ns + "rel", "back" )
.text( text || this.options.closeBtnText || "" )
.prependTo( dst );
}
this._headerCloseButton = btn;
}
});
})( jQuery, this );
(function( $, window, undefined ) {
$.widget( "mobile.dialog", {
options: {
// Accepts left, right and none
closeBtn: "left",
closeBtnText: "Close",
overlayTheme: "a",
corners: true
},
// Override the theme set by the page plugin on pageshow
_handlePageBeforeShow: function() {
this._isCloseable = true;
if ( this.options.overlayTheme ) {
this.element
.page( "removeContainerBackground" )
.page( "setContainerBackground", this.options.overlayTheme );
}
},
_handlePageBeforeHide: function() {
this._isCloseable = false;
},
// click and submit events:
// - clicks and submits should use the closing transition that the dialog
// opened with unless a data-transition is specified on the link/form
// - if the click was on the close button, or the link has a data-rel="back"
// it'll go back in history naturally
_handleVClickSubmit: function( event ) {
var attrs,
$target = $( event.target ).closest( event.type === "vclick" ? "a" : "form" );
if ( $target.length && !$target.jqmData( "transition" ) ) {
attrs = {};
attrs[ "data-" + $.mobile.ns + "transition" ] =
( $.mobile.navigate.history.getActive() || {} )[ "transition" ] ||
$.mobile.defaultDialogTransition;
attrs[ "data-" + $.mobile.ns + "direction" ] = "reverse";
$target.attr( attrs );
}
},
_create: function() {
var elem = this.element,
opts = this.options;
// Class the markup for dialog styling and wrap interior
elem.addClass( "ui-dialog" )
.wrapInner( $( "<div/>", {
// ARIA role
"role" : "dialog",
"class" : "ui-dialog-contain ui-overlay-shadow" +
( !!opts.corners ? " ui-corner-all" : "" )
}));
$.extend( this, {
_isCloseable: false,
_inner: elem.children(),
_headerCloseButton: null
});
this._on( elem, {
vclick: "_handleVClickSubmit",
submit: "_handleVClickSubmit",
pagebeforeshow: "_handlePageBeforeShow",
pagebeforehide: "_handlePageBeforeHide"
});
this._setCloseBtn( opts.closeBtn );
},
_setOptions: function( options ) {
var closeButtonLocation, closeButtonText,
currentOpts = this.options;
if ( options.corners !== undefined ) {
this._inner.toggleClass( "ui-corner-all", !!options.corners );
}
if ( options.overlayTheme !== undefined ) {
if ( $.mobile.activePage[ 0 ] === this.element[ 0 ] ) {
currentOpts.overlayTheme = options.overlayTheme;
this._handlePageBeforeShow();
}
}
if ( options.closeBtnText !== undefined ) {
closeButtonLocation = currentOpts.closeBtn;
closeButtonText = options.closeBtnText;
}
if ( options.closeBtn !== undefined ) {
closeButtonLocation = options.closeBtn;
}
if ( closeButtonLocation ) {
this._setCloseBtn( closeButtonLocation, closeButtonText );
}
this._super( options );
},
_setCloseBtn: function( location, text ) {
var dst,
btn = this._headerCloseButton;
// Sanitize value
location = "left" === location ? "left" : "right" === location ? "right" : "none";
if ( "none" === location ) {
if ( btn ) {
btn.remove();
btn = null;
}
} else if ( btn ) {
btn.removeClass( "ui-btn-left ui-btn-right" ).addClass( "ui-btn-" + location );
if ( text ) {
btn.text( text );
}
} else {
dst = this._inner.find( ":jqmData(role='header')" ).first();
btn = $( "<a></a>", {
"role": "button",
"href": "#",
"class": "ui-btn ui-corner-all ui-icon-delete ui-btn-icon-notext ui-btn-" + location
})
.text( text || this.options.closeBtnText || "" )
.prependTo( dst );
this._on( btn, { click: "close" } );
}
this._headerCloseButton = btn;
},
// Close method goes back in history
close: function() {
var hist = $.mobile.navigate.history;
if ( this._isCloseable ) {
this._isCloseable = false;
// If the hash listening is enabled and there is at least one preceding history
// entry it's ok to go back. Initial pages with the dialog hash state are an example
// where the stack check is necessary
if ( $.mobile.hashListeningEnabled && hist.activeIndex > 0 ) {
$.mobile.back();
} else {
$.mobile.pageContainer.pagecontainer( "back" );
}
}
}
});
})( jQuery, this );
(function( $, undefined ) {
var rInitialLetter = /([A-Z])/g,
// Construct iconpos class from iconpos value
iconposClass = function( iconpos ) {
return ( "ui-btn-icon-" + ( iconpos === null ? "left" : iconpos ) );
};
$.widget( "mobile.collapsible", {
options: {
enhanced: false,
expandCueText: null,
collapseCueText: null,
collapsed: true,
heading: "h1,h2,h3,h4,h5,h6,legend",
collapsedIcon: null,
expandedIcon: null,
iconpos: null,
theme: null,
contentTheme: null,
inset: null,
corners: null,
mini: null
},
_create: function() {
var elem = this.element,
ui = {
accordion: elem
.closest( ":jqmData(role='collapsible-set')," +
":jqmData(role='collapsibleset')" +
( $.mobile.collapsibleset ? ", :mobile-collapsibleset" :
"" ) )
.addClass( "ui-collapsible-set" )
};
this._ui = ui;
this._renderedOptions = this._getOptions( this.options );
if ( this.options.enhanced ) {
ui.heading = $( ".ui-collapsible-heading", this.element[ 0 ] );
ui.content = ui.heading.next();
ui.anchor = $( "a", ui.heading[ 0 ] ).first();
ui.status = ui.anchor.children( ".ui-collapsible-heading-status" );
} else {
this._enhance( elem, ui );
}
this._on( ui.heading, {
"tap": function() {
ui.heading.find( "a" ).first().addClass( $.mobile.activeBtnClass );
},
"click": function( event ) {
this._handleExpandCollapse( !ui.heading.hasClass( "ui-collapsible-heading-collapsed" ) );
event.preventDefault();
event.stopPropagation();
}
});
},
// Adjust the keys inside options for inherited values
_getOptions: function( options ) {
var key,
accordion = this._ui.accordion,
accordionWidget = this._ui.accordionWidget;
// Copy options
options = $.extend( {}, options );
if ( accordion.length && !accordionWidget ) {
this._ui.accordionWidget =
accordionWidget = accordion.data( "mobile-collapsibleset" );
}
for ( key in options ) {
// Retrieve the option value first from the options object passed in and, if
// null, from the parent accordion or, if that's null too, or if there's no
// parent accordion, then from the defaults.
options[ key ] =
( options[ key ] != null ) ? options[ key ] :
( accordionWidget ) ? accordionWidget.options[ key ] :
accordion.length ? $.mobile.getAttribute( accordion[ 0 ],
key.replace( rInitialLetter, "-$1" ).toLowerCase() ):
null;
if ( null == options[ key ] ) {
options[ key ] = $.mobile.collapsible.defaults[ key ];
}
}
return options;
},
_themeClassFromOption: function( prefix, value ) {
return ( value ? ( value === "none" ? "" : prefix + value ) : "" );
},
_enhance: function( elem, ui ) {
var iconclass,
opts = this._renderedOptions,
contentThemeClass = this._themeClassFromOption( "ui-body-", opts.contentTheme );
elem.addClass( "ui-collapsible " +
( opts.inset ? "ui-collapsible-inset " : "" ) +
( opts.inset && opts.corners ? "ui-corner-all " : "" ) +
( contentThemeClass ? "ui-collapsible-themed-content " : "" ) );
ui.originalHeading = elem.children( this.options.heading ).first(),
ui.content = elem
.wrapInner( "<div " +
"class='ui-collapsible-content " +
contentThemeClass + "'></div>" )
.children( ".ui-collapsible-content" ),
ui.heading = ui.originalHeading;
// Replace collapsibleHeading if it's a legend
if ( ui.heading.is( "legend" ) ) {
ui.heading = $( "<div role='heading'>"+ ui.heading.html() +"</div>" );
ui.placeholder = $( "<div><!-- placeholder for legend --></div>" ).insertBefore( ui.originalHeading );
ui.originalHeading.remove();
}
iconclass = ( opts.collapsed ? ( opts.collapsedIcon ? "ui-icon-" + opts.collapsedIcon : "" ):
( opts.expandedIcon ? "ui-icon-" + opts.expandedIcon : "" ) );
ui.status = $( "<span class='ui-collapsible-heading-status'></span>" );
ui.anchor = ui.heading
.detach()
//modify markup & attributes
.addClass( "ui-collapsible-heading" )
.append( ui.status )
.wrapInner( "<a href='#' class='ui-collapsible-heading-toggle'></a>" )
.find( "a" )
.first()
.addClass( "ui-btn " +
( iconclass ? iconclass + " " : "" ) +
( iconclass ? iconposClass( opts.iconpos ) +
" " : "" ) +
this._themeClassFromOption( "ui-btn-", opts.theme ) + " " +
( opts.mini ? "ui-mini " : "" ) );
//drop heading in before content
ui.heading.insertBefore( ui.content );
this._handleExpandCollapse( this.options.collapsed );
return ui;
},
refresh: function() {
this._applyOptions( this.options );
this._renderedOptions = this._getOptions( this.options );
},
_applyOptions: function( options ) {
var isCollapsed, newTheme, oldTheme, hasCorners, hasIcon,
elem = this.element,
currentOpts = this._renderedOptions,
ui = this._ui,
anchor = ui.anchor,
status = ui.status,
opts = this._getOptions( options );
// First and foremost we need to make sure the collapsible is in the proper
// state, in case somebody decided to change the collapsed option at the
// same time as another option
if ( options.collapsed !== undefined ) {
this._handleExpandCollapse( options.collapsed );
}
isCollapsed = elem.hasClass( "ui-collapsible-collapsed" );
// We only need to apply the cue text for the current state right away.
// The cue text for the alternate state will be stored in the options
// and applied the next time the collapsible's state is toggled
if ( isCollapsed ) {
if ( opts.expandCueText !== undefined ) {
status.text( opts.expandCueText );
}
} else {
if ( opts.collapseCueText !== undefined ) {
status.text( opts.collapseCueText );
}
}
// Update icon
// Is it supposed to have an icon?
hasIcon =
// If the collapsedIcon is being set, consult that
( opts.collapsedIcon !== undefined ? opts.collapsedIcon !== false :
// Otherwise consult the existing option value
currentOpts.collapsedIcon !== false );
// If any icon-related options have changed, make sure the new icon
// state is reflected by first removing all icon-related classes
// reflecting the current state and then adding all icon-related
// classes for the new state
if ( !( opts.iconpos === undefined &&
opts.collapsedIcon === undefined &&
opts.expandedIcon === undefined ) ) {
// Remove all current icon-related classes
anchor.removeClass( [ iconposClass( currentOpts.iconpos ) ]
.concat( ( currentOpts.expandedIcon ?
[ "ui-icon-" + currentOpts.expandedIcon ] : [] ) )
.concat( ( currentOpts.collapsedIcon ?
[ "ui-icon-" + currentOpts.collapsedIcon ] : [] ) )
.join( " " ) );
// Add new classes if an icon is supposed to be present
if ( hasIcon ) {
anchor.addClass(
[ iconposClass( opts.iconpos !== undefined ?
opts.iconpos : currentOpts.iconpos ) ]
.concat( isCollapsed ?
[ "ui-icon-" + ( opts.collapsedIcon !== undefined ?
opts.collapsedIcon :
currentOpts.collapsedIcon ) ] :
[ "ui-icon-" + ( opts.expandedIcon !== undefined ?
opts.expandedIcon :
currentOpts.expandedIcon ) ] )
.join( " " ) );
}
}
if ( opts.theme !== undefined ) {
oldTheme = this._themeClassFromOption( "ui-btn-", currentOpts.theme );
newTheme = this._themeClassFromOption( "ui-btn-", opts.theme );
anchor.removeClass( oldTheme ).addClass( newTheme );
}
if ( opts.contentTheme !== undefined ) {
oldTheme = this._themeClassFromOption( "ui-body-",
currentOpts.contentTheme );
newTheme = this._themeClassFromOption( "ui-body-",
opts.contentTheme );
ui.content.removeClass( oldTheme ).addClass( newTheme );
}
if ( opts.inset !== undefined ) {
elem.toggleClass( "ui-collapsible-inset", opts.inset );
hasCorners = !!( opts.inset && ( opts.corners || currentOpts.corners ) );
}
if ( opts.corners !== undefined ) {
hasCorners = !!( opts.corners && ( opts.inset || currentOpts.inset ) );
}
if ( hasCorners !== undefined ) {
elem.toggleClass( "ui-corner-all", hasCorners );
}
if ( opts.mini !== undefined ) {
anchor.toggleClass( "ui-mini", opts.mini );
}
},
_setOptions: function( options ) {
this._applyOptions( options );
this._super( options );
this._renderedOptions = this._getOptions( this.options );
},
_handleExpandCollapse: function( isCollapse ) {
var opts = this._renderedOptions,
ui = this._ui;
ui.status.text( isCollapse ? opts.expandCueText : opts.collapseCueText );
ui.heading
.toggleClass( "ui-collapsible-heading-collapsed", isCollapse )
.find( "a" ).first()
.toggleClass( "ui-icon-" + opts.expandedIcon, !isCollapse )
// logic or cause same icon for expanded/collapsed state would remove the ui-icon-class
.toggleClass( "ui-icon-" + opts.collapsedIcon, ( isCollapse || opts.expandedIcon === opts.collapsedIcon ) )
.removeClass( $.mobile.activeBtnClass );
this.element.toggleClass( "ui-collapsible-collapsed", isCollapse );
ui.content
.toggleClass( "ui-collapsible-content-collapsed", isCollapse )
.attr( "aria-hidden", isCollapse )
.trigger( "updatelayout" );
this.options.collapsed = isCollapse;
this._trigger( isCollapse ? "collapse" : "expand" );
},
expand: function() {
this._handleExpandCollapse( false );
},
collapse: function() {
this._handleExpandCollapse( true );
},
_destroy: function() {
var ui = this._ui,
opts = this.options;
if ( opts.enhanced ) {
return;
}
if ( ui.placeholder ) {
ui.originalHeading.insertBefore( ui.placeholder );
ui.placeholder.remove();
ui.heading.remove();
} else {
ui.status.remove();
ui.heading
.removeClass( "ui-collapsible-heading ui-collapsible-heading-collapsed" )
.children()
.contents()
.unwrap();
}
ui.anchor.contents().unwrap();
ui.content.contents().unwrap();
this.element
.removeClass( "ui-collapsible ui-collapsible-collapsed " +
"ui-collapsible-themed-content ui-collapsible-inset ui-corner-all" );
}
});
// Defaults to be used by all instances of collapsible if per-instance values
// are unset or if nothing is specified by way of inheritance from an accordion.
// Note that this hash does not contain options "collapsed" or "heading",
// because those are not inheritable.
$.mobile.collapsible.defaults = {
expandCueText: " click to expand contents",
collapseCueText: " click to collapse contents",
collapsedIcon: "plus",
contentTheme: "inherit",
expandedIcon: "minus",
iconpos: "left",
inset: true,
corners: true,
theme: "inherit",
mini: false
};
})( jQuery );
(function( $, undefined ) {
var uiScreenHiddenRegex = /\bui-screen-hidden\b/;
function noHiddenClass( elements ) {
var index,
length = elements.length,
result = [];
for ( index = 0; index < length; index++ ) {
if ( !elements[ index ].className.match( uiScreenHiddenRegex ) ) {
result.push( elements[ index ] );
}
}
return $( result );
}
$.mobile.behaviors.addFirstLastClasses = {
_getVisibles: function( $els, create ) {
var visibles;
if ( create ) {
visibles = noHiddenClass( $els );
} else {
visibles = $els.filter( ":visible" );
if ( visibles.length === 0 ) {
visibles = noHiddenClass( $els );
}
}
return visibles;
},
_addFirstLastClasses: function( $els, $visibles, create ) {
$els.removeClass( "ui-first-child ui-last-child" );
$visibles.eq( 0 ).addClass( "ui-first-child" ).end().last().addClass( "ui-last-child" );
if ( !create ) {
this.element.trigger( "updatelayout" );
}
},
_removeFirstLastClasses: function( $els ) {
$els.removeClass( "ui-first-child ui-last-child" );
}
};
})( jQuery );
(function( $, undefined ) {
var childCollapsiblesSelector = ":mobile-collapsible, " + $.mobile.collapsible.initSelector;
$.widget( "mobile.collapsibleset", $.extend( {
// The initSelector is deprecated as of 1.4.0. In 1.5.0 we will use
// :jqmData(role='collapsibleset') which will allow us to get rid of the line
// below altogether, because the autoinit will generate such an initSelector
initSelector: ":jqmData(role='collapsible-set'),:jqmData(role='collapsibleset')",
options: $.extend( {
enhanced: false
}, $.mobile.collapsible.defaults ),
_handleCollapsibleExpand: function( event ) {
var closestCollapsible = $( event.target ).closest( ".ui-collapsible" );
if ( closestCollapsible.parent().is( ":mobile-collapsibleset, :jqmData(role='collapsible-set')" ) ) {
closestCollapsible
.siblings( ".ui-collapsible:not(.ui-collapsible-collapsed)" )
.collapsible( "collapse" );
}
},
_create: function() {
var elem = this.element,
opts = this.options;
$.extend( this, {
_classes: ""
});
if ( !opts.enhanced ) {
elem.addClass( "ui-collapsible-set " +
this._themeClassFromOption( "ui-group-theme-", opts.theme ) + " " +
( opts.corners && opts.inset ? "ui-corner-all " : "" ) );
this.element.find( $.mobile.collapsible.initSelector ).collapsible();
}
this._on( elem, { collapsibleexpand: "_handleCollapsibleExpand" } );
},
_themeClassFromOption: function( prefix, value ) {
return ( value ? ( value === "none" ? "" : prefix + value ) : "" );
},
_init: function() {
this._refresh( true );
// Because the corners are handled by the collapsible itself and the default state is collapsed
// That was causing https://github.com/jquery/jquery-mobile/issues/4116
this.element
.children( childCollapsiblesSelector )
.filter( ":jqmData(collapsed='false')" )
.collapsible( "expand" );
},
_setOptions: function( options ) {
var ret, hasCorners,
elem = this.element,
themeClass = this._themeClassFromOption( "ui-group-theme-", options.theme );
if ( themeClass ) {
elem
.removeClass( this._themeClassFromOption( "ui-group-theme-", this.options.theme ) )
.addClass( themeClass );
}
if ( options.inset !== undefined ) {
hasCorners = !!( options.inset && ( options.corners || this.options.corners ) );
}
if ( options.corners !== undefined ) {
hasCorners = !!( options.corners && ( options.inset || this.options.inset ) );
}
if ( hasCorners !== undefined ) {
elem.toggleClass( "ui-corner-all", hasCorners );
}
ret = this._super( options );
this.element.children( ":mobile-collapsible" ).collapsible( "refresh" );
return ret;
},
_destroy: function() {
var el = this.element;
this._removeFirstLastClasses( el.children( childCollapsiblesSelector ) );
el
.removeClass( "ui-collapsible-set ui-corner-all " +
this._themeClassFromOption( "ui-group-theme-", this.options.theme ) )
.children( ":mobile-collapsible" )
.collapsible( "destroy" );
},
_refresh: function( create ) {
var collapsiblesInSet = this.element.children( childCollapsiblesSelector );
this.element.find( $.mobile.collapsible.initSelector ).not( ".ui-collapsible" ).collapsible();
this._addFirstLastClasses( collapsiblesInSet, this._getVisibles( collapsiblesInSet, create ), create );
},
refresh: function() {
this._refresh( false );
}
}, $.mobile.behaviors.addFirstLastClasses ) );
})( jQuery );
(function( $, undefined ) {
// Deprecated in 1.4
$.fn.fieldcontain = function(/* options */) {
return this.addClass( "ui-field-contain" );
};
})( jQuery );
(function( $, undefined ) {
$.fn.grid = function( options ) {
return this.each(function() {
var $this = $( this ),
o = $.extend({
grid: null
}, options ),
$kids = $this.children(),
gridCols = { solo:1, a:2, b:3, c:4, d:5 },
grid = o.grid,
iterator,
letter;
if ( !grid ) {
if ( $kids.length <= 5 ) {
for ( letter in gridCols ) {
if ( gridCols[ letter ] === $kids.length ) {
grid = letter;
}
}
} else {
grid = "a";
$this.addClass( "ui-grid-duo" );
}
}
iterator = gridCols[grid];
$this.addClass( "ui-grid-" + grid );
$kids.filter( ":nth-child(" + iterator + "n+1)" ).addClass( "ui-block-a" );
if ( iterator > 1 ) {
$kids.filter( ":nth-child(" + iterator + "n+2)" ).addClass( "ui-block-b" );
}
if ( iterator > 2 ) {
$kids.filter( ":nth-child(" + iterator + "n+3)" ).addClass( "ui-block-c" );
}
if ( iterator > 3 ) {
$kids.filter( ":nth-child(" + iterator + "n+4)" ).addClass( "ui-block-d" );
}
if ( iterator > 4 ) {
$kids.filter( ":nth-child(" + iterator + "n+5)" ).addClass( "ui-block-e" );
}
});
};
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.navbar", {
options: {
iconpos: "top",
grid: null
},
_create: function() {
var $navbar = this.element,
$navbtns = $navbar.find( "a" ),
iconpos = $navbtns.filter( ":jqmData(icon)" ).length ? this.options.iconpos : undefined;
$navbar.addClass( "ui-navbar" )
.attr( "role", "navigation" )
.find( "ul" )
.jqmEnhanceable()
.grid({ grid: this.options.grid });
$navbtns
.each( function() {
var icon = $.mobile.getAttribute( this, "icon" ),
theme = $.mobile.getAttribute( this, "theme" ),
classes = "ui-btn";
if ( theme ) {
classes += " ui-btn-" + theme;
}
if ( icon ) {
classes += " ui-icon-" + icon + " ui-btn-icon-" + iconpos;
}
$( this ).addClass( classes );
});
$navbar.delegate( "a", "vclick", function( /* event */ ) {
var activeBtn = $( this );
if ( !( activeBtn.hasClass( "ui-state-disabled" ) ||
// DEPRECATED as of 1.4.0 - remove after 1.4.0 release
// only ui-state-disabled should be present thereafter
activeBtn.hasClass( "ui-disabled" ) ||
activeBtn.hasClass( $.mobile.activeBtnClass ) ) ) {
$navbtns.removeClass( $.mobile.activeBtnClass );
activeBtn.addClass( $.mobile.activeBtnClass );
// The code below is a workaround to fix #1181
$( document ).one( "pagehide", function() {
activeBtn.removeClass( $.mobile.activeBtnClass );
});
}
});
// Buttons in the navbar with ui-state-persist class should regain their active state before page show
$navbar.closest( ".ui-page" ).bind( "pagebeforeshow", function() {
$navbtns.filter( ".ui-state-persist" ).addClass( $.mobile.activeBtnClass );
});
}
});
})( jQuery );
(function( $, undefined ) {
var getAttr = $.mobile.getAttribute;
$.widget( "mobile.listview", $.extend( {
options: {
theme: null,
countTheme: null, /* Deprecated in 1.4 */
dividerTheme: null,
icon: "carat-r",
splitIcon: "carat-r",
splitTheme: null,
corners: true,
shadow: true,
inset: false
},
_create: function() {
var t = this,
listviewClasses = "";
listviewClasses += t.options.inset ? " ui-listview-inset" : "";
if ( !!t.options.inset ) {
listviewClasses += t.options.corners ? " ui-corner-all" : "";
listviewClasses += t.options.shadow ? " ui-shadow" : "";
}
// create listview markup
t.element.addClass( " ui-listview" + listviewClasses );
t.refresh( true );
},
// TODO: Remove in 1.5
_findFirstElementByTagName: function( ele, nextProp, lcName, ucName ) {
var dict = {};
dict[ lcName ] = dict[ ucName ] = true;
while ( ele ) {
if ( dict[ ele.nodeName ] ) {
return ele;
}
ele = ele[ nextProp ];
}
return null;
},
// TODO: Remove in 1.5
_addThumbClasses: function( containers ) {
var i, img, len = containers.length;
for ( i = 0; i < len; i++ ) {
img = $( this._findFirstElementByTagName( containers[ i ].firstChild, "nextSibling", "img", "IMG" ) );
if ( img.length ) {
$( this._findFirstElementByTagName( img[ 0 ].parentNode, "parentNode", "li", "LI" ) ).addClass( img.hasClass( "ui-li-icon" ) ? "ui-li-has-icon" : "ui-li-has-thumb" );
}
}
},
_getChildrenByTagName: function( ele, lcName, ucName ) {
var results = [],
dict = {};
dict[ lcName ] = dict[ ucName ] = true;
ele = ele.firstChild;
while ( ele ) {
if ( dict[ ele.nodeName ] ) {
results.push( ele );
}
ele = ele.nextSibling;
}
return $( results );
},
_beforeListviewRefresh: $.noop,
_afterListviewRefresh: $.noop,
refresh: function( create ) {
var buttonClass, pos, numli, item, itemClass, itemTheme, itemIcon, icon, a,
isDivider, startCount, newStartCount, value, last, splittheme, splitThemeClass, spliticon,
altButtonClass, dividerTheme, li,
o = this.options,
$list = this.element,
ol = !!$.nodeName( $list[ 0 ], "ol" ),
start = $list.attr( "start" ),
itemClassDict = {},
countBubbles = $list.find( ".ui-li-count" ),
countTheme = getAttr( $list[ 0 ], "counttheme" ) || this.options.countTheme,
countThemeClass = countTheme ? "ui-body-" + countTheme : "ui-body-inherit";
if ( o.theme ) {
$list.addClass( "ui-group-theme-" + o.theme );
}
// Check if a start attribute has been set while taking a value of 0 into account
if ( ol && ( start || start === 0 ) ) {
startCount = parseInt( start, 10 ) - 1;
$list.css( "counter-reset", "listnumbering " + startCount );
}
this._beforeListviewRefresh();
li = this._getChildrenByTagName( $list[ 0 ], "li", "LI" );
for ( pos = 0, numli = li.length; pos < numli; pos++ ) {
item = li.eq( pos );
itemClass = "";
if ( create || item[ 0 ].className.search( /\bui-li-static\b|\bui-li-divider\b/ ) < 0 ) {
a = this._getChildrenByTagName( item[ 0 ], "a", "A" );
isDivider = ( getAttr( item[ 0 ], "role" ) === "list-divider" );
value = item.attr( "value" );
itemTheme = getAttr( item[ 0 ], "theme" );
if ( a.length && a[ 0 ].className.search( /\bui-btn\b/ ) < 0 && !isDivider ) {
itemIcon = getAttr( item[ 0 ], "icon" );
icon = ( itemIcon === false ) ? false : ( itemIcon || o.icon );
// TODO: Remove in 1.5 together with links.js (links.js / .ui-link deprecated in 1.4)
a.removeClass( "ui-link" );
buttonClass = "ui-btn";
if ( itemTheme ) {
buttonClass += " ui-btn-" + itemTheme;
}
if ( a.length > 1 ) {
itemClass = "ui-li-has-alt";
last = a.last();
splittheme = getAttr( last[ 0 ], "theme" ) || o.splitTheme || getAttr( item[ 0 ], "theme", true );
splitThemeClass = splittheme ? " ui-btn-" + splittheme : "";
spliticon = getAttr( last[ 0 ], "icon" ) || getAttr( item[ 0 ], "icon" ) || o.splitIcon;
altButtonClass = "ui-btn ui-btn-icon-notext ui-icon-" + spliticon + splitThemeClass;
last
.attr( "title", $.trim( last.getEncodedText() ) )
.addClass( altButtonClass )
.empty();
// Reduce to the first anchor, because only the first gets the buttonClass
a = a.first();
} else if ( icon ) {
buttonClass += " ui-btn-icon-right ui-icon-" + icon;
}
// Apply buttonClass to the (first) anchor
a.addClass( buttonClass );
} else if ( isDivider ) {
dividerTheme = ( getAttr( item[ 0 ], "theme" ) || o.dividerTheme || o.theme );
itemClass = "ui-li-divider ui-bar-" + ( dividerTheme ? dividerTheme : "inherit" );
item.attr( "role", "heading" );
} else if ( a.length <= 0 ) {
itemClass = "ui-li-static ui-body-" + ( itemTheme ? itemTheme : "inherit" );
}
if ( ol && value ) {
newStartCount = parseInt( value , 10 ) - 1;
item.css( "counter-reset", "listnumbering " + newStartCount );
}
}
// Instead of setting item class directly on the list item
// at this point in time, push the item into a dictionary
// that tells us what class to set on it so we can do this after this
// processing loop is finished.
if ( !itemClassDict[ itemClass ] ) {
itemClassDict[ itemClass ] = [];
}
itemClassDict[ itemClass ].push( item[ 0 ] );
}
// Set the appropriate listview item classes on each list item.
// The main reason we didn't do this
// in the for-loop above is because we can eliminate per-item function overhead
// by calling addClass() and children() once or twice afterwards. This
// can give us a significant boost on platforms like WP7.5.
for ( itemClass in itemClassDict ) {
$( itemClassDict[ itemClass ] ).addClass( itemClass );
}
countBubbles.each( function() {
$( this ).closest( "li" ).addClass( "ui-li-has-count" );
});
if ( countThemeClass ) {
countBubbles.not( "[class*='ui-body-']" ).addClass( countThemeClass );
}
// Deprecated in 1.4. From 1.5 you have to add class ui-li-has-thumb or ui-li-has-icon to the LI.
this._addThumbClasses( li );
this._addThumbClasses( li.find( ".ui-btn" ) );
this._afterListviewRefresh();
this._addFirstLastClasses( li, this._getVisibles( li, create ), create );
}
}, $.mobile.behaviors.addFirstLastClasses ) );
})( jQuery );
(function( $, undefined ) {
function defaultAutodividersSelector( elt ) {
// look for the text in the given element
var text = $.trim( elt.text() ) || null;
if ( !text ) {
return null;
}
// create the text for the divider (first uppercased letter)
text = text.slice( 0, 1 ).toUpperCase();
return text;
}
$.widget( "mobile.listview", $.mobile.listview, {
options: {
autodividers: false,
autodividersSelector: defaultAutodividersSelector
},
_beforeListviewRefresh: function() {
if ( this.options.autodividers ) {
this._replaceDividers();
this._superApply( arguments );
}
},
_replaceDividers: function() {
var i, lis, li, dividerText,
lastDividerText = null,
list = this.element,
divider;
list.children( "li:jqmData(role='list-divider')" ).remove();
lis = list.children( "li" );
for ( i = 0; i < lis.length ; i++ ) {
li = lis[ i ];
dividerText = this.options.autodividersSelector( $( li ) );
if ( dividerText && lastDividerText !== dividerText ) {
divider = document.createElement( "li" );
divider.appendChild( document.createTextNode( dividerText ) );
divider.setAttribute( "data-" + $.mobile.ns + "role", "list-divider" );
li.parentNode.insertBefore( divider, li );
}
lastDividerText = dividerText;
}
}
});
})( jQuery );
(function( $, undefined ) {
var rdivider = /(^|\s)ui-li-divider($|\s)/,
rhidden = /(^|\s)ui-screen-hidden($|\s)/;
$.widget( "mobile.listview", $.mobile.listview, {
options: {
hideDividers: false
},
_afterListviewRefresh: function() {
var items, idx, item, hideDivider = true;
this._superApply( arguments );
if ( this.options.hideDividers ) {
items = this._getChildrenByTagName( this.element[ 0 ], "li", "LI" );
for ( idx = items.length - 1 ; idx > -1 ; idx-- ) {
item = items[ idx ];
if ( item.className.match( rdivider ) ) {
if ( hideDivider ) {
item.className = item.className + " ui-screen-hidden";
}
hideDivider = true;
} else {
if ( !item.className.match( rhidden ) ) {
hideDivider = false;
}
}
}
}
}
});
})( jQuery );
(function( $, undefined ) {
$.mobile.nojs = function( target ) {
$( ":jqmData(role='nojs')", target ).addClass( "ui-nojs" );
};
})( jQuery );
(function( $, undefined ) {
$.mobile.behaviors.formReset = {
_handleFormReset: function() {
this._on( this.element.closest( "form" ), {
reset: function() {
this._delay( "_reset" );
}
});
}
};
})( jQuery );
/*
* "checkboxradio" plugin
*/
(function( $, undefined ) {
var escapeId = $.mobile.path.hashToSelector;
$.widget( "mobile.checkboxradio", $.extend( {
initSelector: "input:not( :jqmData(role='flipswitch' ) )[type='checkbox'],input[type='radio']:not( :jqmData(role='flipswitch' ))",
options: {
theme: "inherit",
mini: false,
wrapperClass: null,
enhanced: false,
iconpos: "left"
},
_create: function() {
var input = this.element,
o = this.options,
inheritAttr = function( input, dataAttr ) {
return input.jqmData( dataAttr ) ||
input.closest( "form, fieldset" ).jqmData( dataAttr );
},
label = this.options.enhanced ?
{
element: this.element.siblings( "label" ),
isParent: false
} :
this._findLabel(),
inputtype = input[0].type,
checkedClass = "ui-" + inputtype + "-on",
uncheckedClass = "ui-" + inputtype + "-off";
if ( inputtype !== "checkbox" && inputtype !== "radio" ) {
return;
}
if ( this.element[0].disabled ) {
this.options.disabled = true;
}
o.iconpos = inheritAttr( input, "iconpos" ) ||
label.element.attr( "data-" + $.mobile.ns + "iconpos" ) || o.iconpos,
// Establish options
o.mini = inheritAttr( input, "mini" ) || o.mini;
// Expose for other methods
$.extend( this, {
input: input,
label: label.element,
labelIsParent: label.isParent,
inputtype: inputtype,
checkedClass: checkedClass,
uncheckedClass: uncheckedClass
});
if ( !this.options.enhanced ) {
this._enhance();
}
this._on( label.element, {
vmouseover: "_handleLabelVMouseOver",
vclick: "_handleLabelVClick"
});
this._on( input, {
vmousedown: "_cacheVals",
vclick: "_handleInputVClick",
focus: "_handleInputFocus",
blur: "_handleInputBlur"
});
this._handleFormReset();
this.refresh();
},
_findLabel: function() {
var parentLabel, label, isParent,
input = this.element,
labelsList = input[ 0 ].labels;
if( labelsList && labelsList.length > 0 ) {
label = $( labelsList[ 0 ] );
isParent = $.contains( label[ 0 ], input[ 0 ] );
} else {
parentLabel = input.closest( "label" );
isParent = ( parentLabel.length > 0 );
// NOTE: Windows Phone could not find the label through a selector
// filter works though.
label = isParent ? parentLabel :
$( this.document[ 0 ].getElementsByTagName( "label" ) )
.filter( "[for='" + escapeId( input[ 0 ].id ) + "']" )
.first();
}
return {
element: label,
isParent: isParent
};
},
_enhance: function() {
this.label.addClass( "ui-btn ui-corner-all");
if ( this.labelIsParent ) {
this.input.add( this.label ).wrapAll( this._wrapper() );
} else {
//this.element.replaceWith( this.input.add( this.label ).wrapAll( this._wrapper() ) );
this.element.wrap( this._wrapper() );
this.element.parent().prepend( this.label );
}
// Wrap the input + label in a div
this._setOptions({
"theme": this.options.theme,
"iconpos": this.options.iconpos,
"mini": this.options.mini
});
},
_wrapper: function() {
return $( "<div class='" +
( this.options.wrapperClass ? this.options.wrapperClass : "" ) +
" ui-" + this.inputtype +
( this.options.disabled ? " ui-state-disabled" : "" ) + "' ></div>" );
},
_handleInputFocus: function() {
this.label.addClass( $.mobile.focusClass );
},
_handleInputBlur: function() {
this.label.removeClass( $.mobile.focusClass );
},
_handleInputVClick: function() {
// Adds checked attribute to checked input when keyboard is used
this.element.prop( "checked", this.element.is( ":checked" ) );
this._getInputSet().not( this.element ).prop( "checked", false );
this._updateAll( true );
},
_handleLabelVMouseOver: function( event ) {
if ( this.label.parent().hasClass( "ui-state-disabled" ) ) {
event.stopPropagation();
}
},
_handleLabelVClick: function( event ) {
var input = this.element;
if ( input.is( ":disabled" ) ) {
event.preventDefault();
return;
}
this._cacheVals();
input.prop( "checked", this.inputtype === "radio" && true || !input.prop( "checked" ) );
// trigger click handler's bound directly to the input as a substitute for
// how label clicks behave normally in the browsers
// TODO: it would be nice to let the browser's handle the clicks and pass them
// through to the associate input. we can swallow that click at the parent
// wrapper element level
input.triggerHandler( "click" );
// Input set for common radio buttons will contain all the radio
// buttons, but will not for checkboxes. clearing the checked status
// of other radios ensures the active button state is applied properly
this._getInputSet().not( input ).prop( "checked", false );
this._updateAll();
return false;
},
_cacheVals: function() {
this._getInputSet().each( function() {
$( this ).attr("data-" + $.mobile.ns + "cacheVal", this.checked );
});
},
// Returns those radio buttons that are supposed to be in the same group as
// this radio button. In the case of a checkbox or a radio lacking a name
// attribute, it returns this.element.
_getInputSet: function() {
var selector, formId,
radio = this.element[ 0 ],
name = radio.name,
form = radio.form,
doc = this.element.parents().last().get( 0 ),
// A radio is always a member of its own group
radios = this.element;
// Only start running selectors if this is an attached radio button with a name
if ( name && this.inputtype === "radio" && doc ) {
selector = "input[type='radio'][name='" + escapeId( name ) + "']";
// If we're inside a form
if ( form ) {
formId = form.getAttribute( "id" );
// If the form has an ID, collect radios scattered throught the document which
// nevertheless are part of the form by way of the value of their form attribute
if ( formId ) {
radios = $( selector + "[form='" + escapeId( formId ) + "']", doc );
}
// Also add to those the radios in the form itself
radios = $( form ).find( selector ).filter( function() {
// Some radios inside the form may belong to some other form by virtue of
// having a form attribute defined on them, so we must filter them out here
return ( this.form === form );
}).add( radios );
// If we're outside a form
} else {
// Collect all those radios which are also outside of a form and match our name
radios = $( selector, doc ).filter( function() {
return !this.form;
});
}
}
return radios;
},
_updateAll: function( changeTriggered ) {
var self = this;
this._getInputSet().each( function() {
var $this = $( this );
if ( ( this.checked || self.inputtype === "checkbox" ) && !changeTriggered ) {
$this.trigger( "change" );
}
})
.checkboxradio( "refresh" );
},
_reset: function() {
this.refresh();
},
// Is the widget supposed to display an icon?
_hasIcon: function() {
var controlgroup, controlgroupWidget,
controlgroupConstructor = $.mobile.controlgroup;
// If the controlgroup widget is defined ...
if ( controlgroupConstructor ) {
controlgroup = this.element.closest(
":mobile-controlgroup," +
controlgroupConstructor.prototype.initSelector );
// ... and the checkbox is in a controlgroup ...
if ( controlgroup.length > 0 ) {
// ... look for a controlgroup widget instance, and ...
controlgroupWidget = $.data( controlgroup[ 0 ], "mobile-controlgroup" );
// ... if found, decide based on the option value, ...
return ( ( controlgroupWidget ? controlgroupWidget.options.type :
// ... otherwise decide based on the "type" data attribute.
controlgroup.attr( "data-" + $.mobile.ns + "type" ) ) !== "horizontal" );
}
}
// Normally, the widget displays an icon.
return true;
},
refresh: function() {
var hasIcon = this._hasIcon(),
isChecked = this.element[ 0 ].checked,
active = $.mobile.activeBtnClass,
iconposClass = "ui-btn-icon-" + this.options.iconpos,
addClasses = [],
removeClasses = [];
if ( hasIcon ) {
removeClasses.push( active );
addClasses.push( iconposClass );
} else {
removeClasses.push( iconposClass );
( isChecked ? addClasses : removeClasses ).push( active );
}
if ( isChecked ) {
addClasses.push( this.checkedClass );
removeClasses.push( this.uncheckedClass );
} else {
addClasses.push( this.uncheckedClass );
removeClasses.push( this.checkedClass );
}
this.label
.addClass( addClasses.join( " " ) )
.removeClass( removeClasses.join( " " ) );
},
widget: function() {
return this.label.parent();
},
_setOptions: function( options ) {
var label = this.label,
currentOptions = this.options,
outer = this.widget(),
hasIcon = this._hasIcon();
if ( options.disabled !== undefined ) {
this.input.prop( "disabled", !!options.disabled );
outer.toggleClass( "ui-state-disabled", !!options.disabled );
}
if ( options.mini !== undefined ) {
outer.toggleClass( "ui-mini", !!options.mini );
}
if ( options.theme !== undefined ) {
label
.removeClass( "ui-btn-" + currentOptions.theme )
.addClass( "ui-btn-" + options.theme );
}
if ( options.wrapperClass !== undefined ) {
outer
.removeClass( currentOptions.wrapperClass )
.addClass( options.wrapperClass );
}
if ( options.iconpos !== undefined && hasIcon ) {
label.removeClass( "ui-btn-icon-" + currentOptions.iconpos ).addClass( "ui-btn-icon-" + options.iconpos );
} else if ( !hasIcon ) {
label.removeClass( "ui-btn-icon-" + currentOptions.iconpos );
}
this._super( options );
}
}, $.mobile.behaviors.formReset ) );
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.button", {
initSelector: "input[type='button'], input[type='reset']",
options: {
theme: null,
icon: null,
iconpos: "left",
iconshadow: false, /* TODO: Deprecated in 1.4, remove in 1.5. */
corners: true,
shadow: true,
inline: null,
mini: null,
wrapperClass: null,
enhanced: false
},
_create: function() {
if ( this.element.is( ":disabled" ) ) {
this.options.disabled = true;
}
if ( !this.options.enhanced ) {
this._enhance();
}
$.extend( this, {
wrapper: this.element.parent()
});
this._on( {
focus: function() {
this.widget().addClass( $.mobile.focusClass );
},
blur: function() {
this.widget().removeClass( $.mobile.focusClass );
}
});
this.refresh( true );
},
_enhance: function() {
this.element.wrap( this._button() );
},
_button: function() {
var options = this.options,
iconClasses = this._getIconClasses( this.options );
return $("<div class='ui-btn ui-input-btn" +
( options.wrapperClass ? " " + options.wrapperClass : "" ) +
( options.theme ? " ui-btn-" + options.theme : "" ) +
( options.corners ? " ui-corner-all" : "" ) +
( options.shadow ? " ui-shadow" : "" ) +
( options.inline ? " ui-btn-inline" : "" ) +
( options.mini ? " ui-mini" : "" ) +
( options.disabled ? " ui-state-disabled" : "" ) +
( iconClasses ? ( " " + iconClasses ) : "" ) +
"' >" + this.element.val() + "</div>" );
},
widget: function() {
return this.wrapper;
},
_destroy: function() {
this.element.insertBefore( this.button );
this.button.remove();
},
_getIconClasses: function( options ) {
return ( options.icon ? ( "ui-icon-" + options.icon +
( options.iconshadow ? " ui-shadow-icon" : "" ) + /* TODO: Deprecated in 1.4, remove in 1.5. */
" ui-btn-icon-" + options.iconpos ) : "" );
},
_setOptions: function( options ) {
var outer = this.widget();
if ( options.theme !== undefined ) {
outer
.removeClass( this.options.theme )
.addClass( "ui-btn-" + options.theme );
}
if ( options.corners !== undefined ) {
outer.toggleClass( "ui-corner-all", options.corners );
}
if ( options.shadow !== undefined ) {
outer.toggleClass( "ui-shadow", options.shadow );
}
if ( options.inline !== undefined ) {
outer.toggleClass( "ui-btn-inline", options.inline );
}
if ( options.mini !== undefined ) {
outer.toggleClass( "ui-mini", options.mini );
}
if ( options.disabled !== undefined ) {
this.element.prop( "disabled", options.disabled );
outer.toggleClass( "ui-state-disabled", options.disabled );
}
if ( options.icon !== undefined ||
options.iconshadow !== undefined || /* TODO: Deprecated in 1.4, remove in 1.5. */
options.iconpos !== undefined ) {
outer
.removeClass( this._getIconClasses( this.options ) )
.addClass( this._getIconClasses(
$.extend( {}, this.options, options ) ) );
}
this._super( options );
},
refresh: function( create ) {
var originalElement,
isDisabled = this.element.prop( "disabled" );
if ( this.options.icon && this.options.iconpos === "notext" && this.element.attr( "title" ) ) {
this.element.attr( "title", this.element.val() );
}
if ( !create ) {
originalElement = this.element.detach();
$( this.wrapper ).text( this.element.val() ).append( originalElement );
}
if ( this.options.disabled !== isDisabled ) {
this._setOptions({ disabled: isDisabled });
}
}
});
})( jQuery );
(function( $ ) {
var meta = $( "meta[name=viewport]" ),
initialContent = meta.attr( "content" ),
disabledZoom = initialContent + ",maximum-scale=1, user-scalable=no",
enabledZoom = initialContent + ",maximum-scale=10, user-scalable=yes",
disabledInitially = /(user-scalable[\s]*=[\s]*no)|(maximum-scale[\s]*=[\s]*1)[$,\s]/.test( initialContent );
$.mobile.zoom = $.extend( {}, {
enabled: !disabledInitially,
locked: false,
disable: function( lock ) {
if ( !disabledInitially && !$.mobile.zoom.locked ) {
meta.attr( "content", disabledZoom );
$.mobile.zoom.enabled = false;
$.mobile.zoom.locked = lock || false;
}
},
enable: function( unlock ) {
if ( !disabledInitially && ( !$.mobile.zoom.locked || unlock === true ) ) {
meta.attr( "content", enabledZoom );
$.mobile.zoom.enabled = true;
$.mobile.zoom.locked = false;
}
},
restore: function() {
if ( !disabledInitially ) {
meta.attr( "content", initialContent );
$.mobile.zoom.enabled = true;
}
}
});
}( jQuery ));
(function( $, undefined ) {
$.widget( "mobile.textinput", {
initSelector: "input[type='text']," +
"input[type='search']," +
":jqmData(type='search')," +
"input[type='number']," +
":jqmData(type='number')," +
"input[type='password']," +
"input[type='email']," +
"input[type='url']," +
"input[type='tel']," +
"textarea," +
"input[type='time']," +
"input[type='date']," +
"input[type='month']," +
"input[type='week']," +
"input[type='datetime']," +
"input[type='datetime-local']," +
"input[type='color']," +
"input:not([type])," +
"input[type='file']",
options: {
theme: null,
corners: true,
mini: false,
// This option defaults to true on iOS devices.
preventFocusZoom: /iPhone|iPad|iPod/.test( navigator.platform ) && navigator.userAgent.indexOf( "AppleWebKit" ) > -1,
wrapperClass: "",
enhanced: false
},
_create: function() {
var options = this.options,
isSearch = this.element.is( "[type='search'], :jqmData(type='search')" ),
isTextarea = this.element[ 0 ].tagName === "TEXTAREA",
isRange = this.element.is( "[data-" + ( $.mobile.ns || "" ) + "type='range']" ),
inputNeedsWrap = ( (this.element.is( "input" ) ||
this.element.is( "[data-" + ( $.mobile.ns || "" ) + "type='search']" ) ) &&
!isRange );
if ( this.element.prop( "disabled" ) ) {
options.disabled = true;
}
$.extend( this, {
classes: this._classesFromOptions(),
isSearch: isSearch,
isTextarea: isTextarea,
isRange: isRange,
inputNeedsWrap: inputNeedsWrap
});
this._autoCorrect();
if ( !options.enhanced ) {
this._enhance();
}
this._on( {
"focus": "_handleFocus",
"blur": "_handleBlur"
});
},
refresh: function() {
this.setOptions({
"disabled" : this.element.is( ":disabled" )
});
},
_enhance: function() {
var elementClasses = [];
if ( this.isTextarea ) {
elementClasses.push( "ui-input-text" );
}
if ( this.isTextarea || this.isRange ) {
elementClasses.push( "ui-shadow-inset" );
}
//"search" and "text" input widgets
if ( this.inputNeedsWrap ) {
this.element.wrap( this._wrap() );
} else {
elementClasses = elementClasses.concat( this.classes );
}
this.element.addClass( elementClasses.join( " " ) );
},
widget: function() {
return ( this.inputNeedsWrap ) ? this.element.parent() : this.element;
},
_classesFromOptions: function() {
var options = this.options,
classes = [];
classes.push( "ui-body-" + ( ( options.theme === null ) ? "inherit" : options.theme ) );
if ( options.corners ) {
classes.push( "ui-corner-all" );
}
if ( options.mini ) {
classes.push( "ui-mini" );
}
if ( options.disabled ) {
classes.push( "ui-state-disabled" );
}
if ( options.wrapperClass ) {
classes.push( options.wrapperClass );
}
return classes;
},
_wrap: function() {
return $( "<div class='" +
( this.isSearch ? "ui-input-search " : "ui-input-text " ) +
this.classes.join( " " ) + " " +
"ui-shadow-inset'></div>" );
},
_autoCorrect: function() {
// XXX: Temporary workaround for issue 785 (Apple bug 8910589).
// Turn off autocorrect and autocomplete on non-iOS 5 devices
// since the popup they use can't be dismissed by the user. Note
// that we test for the presence of the feature by looking for
// the autocorrect property on the input element. We currently
// have no test for iOS 5 or newer so we're temporarily using
// the touchOverflow support flag for jQM 1.0. Yes, I feel dirty.
// - jblas
if ( typeof this.element[0].autocorrect !== "undefined" &&
!$.support.touchOverflow ) {
// Set the attribute instead of the property just in case there
// is code that attempts to make modifications via HTML.
this.element[0].setAttribute( "autocorrect", "off" );
this.element[0].setAttribute( "autocomplete", "off" );
}
},
_handleBlur: function() {
this.widget().removeClass( $.mobile.focusClass );
if ( this.options.preventFocusZoom ) {
$.mobile.zoom.enable( true );
}
},
_handleFocus: function() {
// In many situations, iOS will zoom into the input upon tap, this
// prevents that from happening
if ( this.options.preventFocusZoom ) {
$.mobile.zoom.disable( true );
}
this.widget().addClass( $.mobile.focusClass );
},
_setOptions: function ( options ) {
var outer = this.widget();
this._super( options );
if ( !( options.disabled === undefined &&
options.mini === undefined &&
options.corners === undefined &&
options.theme === undefined &&
options.wrapperClass === undefined ) ) {
outer.removeClass( this.classes.join( " " ) );
this.classes = this._classesFromOptions();
outer.addClass( this.classes.join( " " ) );
}
if ( options.disabled !== undefined ) {
this.element.prop( "disabled", !!options.disabled );
}
},
_destroy: function() {
if ( this.options.enhanced ) {
return;
}
if ( this.inputNeedsWrap ) {
this.element.unwrap();
}
this.element.removeClass( "ui-input-text " + this.classes.join( " " ) );
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.slider", $.extend( {
initSelector: "input[type='range'], :jqmData(type='range'), :jqmData(role='slider')",
widgetEventPrefix: "slide",
options: {
theme: null,
trackTheme: null,
corners: true,
mini: false,
highlight: false
},
_create: function() {
// TODO: Each of these should have comments explain what they're for
var self = this,
control = this.element,
trackTheme = this.options.trackTheme || $.mobile.getAttribute( control[ 0 ], "theme" ),
trackThemeClass = trackTheme ? " ui-bar-" + trackTheme : " ui-bar-inherit",
cornerClass = ( this.options.corners || control.jqmData( "corners" ) ) ? " ui-corner-all" : "",
miniClass = ( this.options.mini || control.jqmData( "mini" ) ) ? " ui-mini" : "",
cType = control[ 0 ].nodeName.toLowerCase(),
isToggleSwitch = ( cType === "select" ),
isRangeslider = control.parent().is( ":jqmData(role='rangeslider')" ),
selectClass = ( isToggleSwitch ) ? "ui-slider-switch" : "",
controlID = control.attr( "id" ),
$label = $( "[for='" + controlID + "']" ),
labelID = $label.attr( "id" ) || controlID + "-label",
min = !isToggleSwitch ? parseFloat( control.attr( "min" ) ) : 0,
max = !isToggleSwitch ? parseFloat( control.attr( "max" ) ) : control.find( "option" ).length-1,
step = window.parseFloat( control.attr( "step" ) || 1 ),
domHandle = document.createElement( "a" ),
handle = $( domHandle ),
domSlider = document.createElement( "div" ),
slider = $( domSlider ),
valuebg = this.options.highlight && !isToggleSwitch ? (function() {
var bg = document.createElement( "div" );
bg.className = "ui-slider-bg " + $.mobile.activeBtnClass;
return $( bg ).prependTo( slider );
})() : false,
options,
wrapper,
j, length,
i, optionsCount, origTabIndex,
side, activeClass, sliderImg;
$label.attr( "id", labelID );
this.isToggleSwitch = isToggleSwitch;
domHandle.setAttribute( "href", "#" );
domSlider.setAttribute( "role", "application" );
domSlider.className = [ this.isToggleSwitch ? "ui-slider ui-slider-track ui-shadow-inset " : "ui-slider-track ui-shadow-inset ", selectClass, trackThemeClass, cornerClass, miniClass ].join( "" );
domHandle.className = "ui-slider-handle";
domSlider.appendChild( domHandle );
handle.attr({
"role": "slider",
"aria-valuemin": min,
"aria-valuemax": max,
"aria-valuenow": this._value(),
"aria-valuetext": this._value(),
"title": this._value(),
"aria-labelledby": labelID
});
$.extend( this, {
slider: slider,
handle: handle,
control: control,
type: cType,
step: step,
max: max,
min: min,
valuebg: valuebg,
isRangeslider: isRangeslider,
dragging: false,
beforeStart: null,
userModified: false,
mouseMoved: false
});
if ( isToggleSwitch ) {
// TODO: restore original tabindex (if any) in a destroy method
origTabIndex = control.attr( "tabindex" );
if ( origTabIndex ) {
handle.attr( "tabindex", origTabIndex );
}
control.attr( "tabindex", "-1" ).focus(function() {
$( this ).blur();
handle.focus();
});
wrapper = document.createElement( "div" );
wrapper.className = "ui-slider-inneroffset";
for ( j = 0, length = domSlider.childNodes.length; j < length; j++ ) {
wrapper.appendChild( domSlider.childNodes[j] );
}
domSlider.appendChild( wrapper );
// slider.wrapInner( "<div class='ui-slider-inneroffset'></div>" );
// make the handle move with a smooth transition
handle.addClass( "ui-slider-handle-snapping" );
options = control.find( "option" );
for ( i = 0, optionsCount = options.length; i < optionsCount; i++ ) {
side = !i ? "b" : "a";
activeClass = !i ? "" : " " + $.mobile.activeBtnClass;
sliderImg = document.createElement( "span" );
sliderImg.className = [ "ui-slider-label ui-slider-label-", side, activeClass ].join( "" );
sliderImg.setAttribute( "role", "img" );
sliderImg.appendChild( document.createTextNode( options[i].innerHTML ) );
$( sliderImg ).prependTo( slider );
}
self._labels = $( ".ui-slider-label", slider );
}
// monitor the input for updated values
control.addClass( isToggleSwitch ? "ui-slider-switch" : "ui-slider-input" );
this._on( control, {
"change": "_controlChange",
"keyup": "_controlKeyup",
"blur": "_controlBlur",
"vmouseup": "_controlVMouseUp"
});
slider.bind( "vmousedown", $.proxy( this._sliderVMouseDown, this ) )
.bind( "vclick", false );
// We have to instantiate a new function object for the unbind to work properly
// since the method itself is defined in the prototype (causing it to unbind everything)
this._on( document, { "vmousemove": "_preventDocumentDrag" });
this._on( slider.add( document ), { "vmouseup": "_sliderVMouseUp" });
slider.insertAfter( control );
// wrap in a div for styling purposes
if ( !isToggleSwitch && !isRangeslider ) {
wrapper = this.options.mini ? "<div class='ui-slider ui-mini'>" : "<div class='ui-slider'>";
control.add( slider ).wrapAll( wrapper );
}
// bind the handle event callbacks and set the context to the widget instance
this._on( this.handle, {
"vmousedown": "_handleVMouseDown",
"keydown": "_handleKeydown",
"keyup": "_handleKeyup"
});
this.handle.bind( "vclick", false );
this._handleFormReset();
this.refresh( undefined, undefined, true );
},
_setOptions: function( options ) {
if ( options.theme !== undefined ) {
this._setTheme( options.theme );
}
if ( options.trackTheme !== undefined ) {
this._setTrackTheme( options.trackTheme );
}
if ( options.corners !== undefined ) {
this._setCorners( options.corners );
}
if ( options.mini !== undefined ) {
this._setMini( options.mini );
}
if ( options.highlight !== undefined ) {
this._setHighlight( options.highlight );
}
if ( options.disabled !== undefined ) {
this._setDisabled( options.disabled );
}
this._super( options );
},
_controlChange: function( event ) {
// if the user dragged the handle, the "change" event was triggered from inside refresh(); don't call refresh() again
if ( this._trigger( "controlchange", event ) === false ) {
return false;
}
if ( !this.mouseMoved ) {
this.refresh( this._value(), true );
}
},
_controlKeyup: function(/* event */) { // necessary?
this.refresh( this._value(), true, true );
},
_controlBlur: function(/* event */) {
this.refresh( this._value(), true );
},
// it appears the clicking the up and down buttons in chrome on
// range/number inputs doesn't trigger a change until the field is
// blurred. Here we check thif the value has changed and refresh
_controlVMouseUp: function(/* event */) {
this._checkedRefresh();
},
// NOTE force focus on handle
_handleVMouseDown: function(/* event */) {
this.handle.focus();
},
_handleKeydown: function( event ) {
var index = this._value();
if ( this.options.disabled ) {
return;
}
// In all cases prevent the default and mark the handle as active
switch ( event.keyCode ) {
case $.mobile.keyCode.HOME:
case $.mobile.keyCode.END:
case $.mobile.keyCode.PAGE_UP:
case $.mobile.keyCode.PAGE_DOWN:
case $.mobile.keyCode.UP:
case $.mobile.keyCode.RIGHT:
case $.mobile.keyCode.DOWN:
case $.mobile.keyCode.LEFT:
event.preventDefault();
if ( !this._keySliding ) {
this._keySliding = true;
this.handle.addClass( "ui-state-active" ); /* TODO: We don't use this class for styling. Do we need to add it? */
}
break;
}
// move the slider according to the keypress
switch ( event.keyCode ) {
case $.mobile.keyCode.HOME:
this.refresh( this.min );
break;
case $.mobile.keyCode.END:
this.refresh( this.max );
break;
case $.mobile.keyCode.PAGE_UP:
case $.mobile.keyCode.UP:
case $.mobile.keyCode.RIGHT:
this.refresh( index + this.step );
break;
case $.mobile.keyCode.PAGE_DOWN:
case $.mobile.keyCode.DOWN:
case $.mobile.keyCode.LEFT:
this.refresh( index - this.step );
break;
}
}, // remove active mark
_handleKeyup: function(/* event */) {
if ( this._keySliding ) {
this._keySliding = false;
this.handle.removeClass( "ui-state-active" ); /* See comment above. */
}
},
_sliderVMouseDown: function( event ) {
// NOTE: we don't do this in refresh because we still want to
// support programmatic alteration of disabled inputs
if ( this.options.disabled || !( event.which === 1 || event.which === 0 || event.which === undefined ) ) {
return false;
}
if ( this._trigger( "beforestart", event ) === false ) {
return false;
}
this.dragging = true;
this.userModified = false;
this.mouseMoved = false;
if ( this.isToggleSwitch ) {
this.beforeStart = this.element[0].selectedIndex;
}
this.refresh( event );
this._trigger( "start" );
return false;
},
_sliderVMouseUp: function() {
if ( this.dragging ) {
this.dragging = false;
if ( this.isToggleSwitch ) {
// make the handle move with a smooth transition
this.handle.addClass( "ui-slider-handle-snapping" );
if ( this.mouseMoved ) {
// this is a drag, change the value only if user dragged enough
if ( this.userModified ) {
this.refresh( this.beforeStart === 0 ? 1 : 0 );
} else {
this.refresh( this.beforeStart );
}
} else {
// this is just a click, change the value
this.refresh( this.beforeStart === 0 ? 1 : 0 );
}
}
this.mouseMoved = false;
this._trigger( "stop" );
return false;
}
},
_preventDocumentDrag: function( event ) {
// NOTE: we don't do this in refresh because we still want to
// support programmatic alteration of disabled inputs
if ( this._trigger( "drag", event ) === false) {
return false;
}
if ( this.dragging && !this.options.disabled ) {
// this.mouseMoved must be updated before refresh() because it will be used in the control "change" event
this.mouseMoved = true;
if ( this.isToggleSwitch ) {
// make the handle move in sync with the mouse
this.handle.removeClass( "ui-slider-handle-snapping" );
}
this.refresh( event );
// only after refresh() you can calculate this.userModified
this.userModified = this.beforeStart !== this.element[0].selectedIndex;
return false;
}
},
_checkedRefresh: function() {
if ( this.value !== this._value() ) {
this.refresh( this._value() );
}
},
_value: function() {
return this.isToggleSwitch ? this.element[0].selectedIndex : parseFloat( this.element.val() ) ;
},
_reset: function() {
this.refresh( undefined, false, true );
},
refresh: function( val, isfromControl, preventInputUpdate ) {
// NOTE: we don't return here because we want to support programmatic
// alteration of the input value, which should still update the slider
var self = this,
parentTheme = $.mobile.getAttribute( this.element[ 0 ], "theme" ),
theme = this.options.theme || parentTheme,
themeClass = theme ? " ui-btn-" + theme : "",
trackTheme = this.options.trackTheme || parentTheme,
trackThemeClass = trackTheme ? " ui-bar-" + trackTheme : " ui-bar-inherit",
cornerClass = this.options.corners ? " ui-corner-all" : "",
miniClass = this.options.mini ? " ui-mini" : "",
left, width, data, tol,
pxStep, percent,
control, isInput, optionElements, min, max, step,
newval, valModStep, alignValue, percentPerStep,
handlePercent, aPercent, bPercent,
valueChanged;
self.slider[0].className = [ this.isToggleSwitch ? "ui-slider ui-slider-switch ui-slider-track ui-shadow-inset" : "ui-slider-track ui-shadow-inset", trackThemeClass, cornerClass, miniClass ].join( "" );
if ( this.options.disabled || this.element.prop( "disabled" ) ) {
this.disable();
}
// set the stored value for comparison later
this.value = this._value();
if ( this.options.highlight && !this.isToggleSwitch && this.slider.find( ".ui-slider-bg" ).length === 0 ) {
this.valuebg = (function() {
var bg = document.createElement( "div" );
bg.className = "ui-slider-bg " + $.mobile.activeBtnClass;
return $( bg ).prependTo( self.slider );
})();
}
this.handle.addClass( "ui-btn" + themeClass + " ui-shadow" );
control = this.element;
isInput = !this.isToggleSwitch;
optionElements = isInput ? [] : control.find( "option" );
min = isInput ? parseFloat( control.attr( "min" ) ) : 0;
max = isInput ? parseFloat( control.attr( "max" ) ) : optionElements.length - 1;
step = ( isInput && parseFloat( control.attr( "step" ) ) > 0 ) ? parseFloat( control.attr( "step" ) ) : 1;
if ( typeof val === "object" ) {
data = val;
// a slight tolerance helped get to the ends of the slider
tol = 8;
left = this.slider.offset().left;
width = this.slider.width();
pxStep = width/((max-min)/step);
if ( !this.dragging ||
data.pageX < left - tol ||
data.pageX > left + width + tol ) {
return;
}
if ( pxStep > 1 ) {
percent = ( ( data.pageX - left ) / width ) * 100;
} else {
percent = Math.round( ( ( data.pageX - left ) / width ) * 100 );
}
} else {
if ( val == null ) {
val = isInput ? parseFloat( control.val() || 0 ) : control[0].selectedIndex;
}
percent = ( parseFloat( val ) - min ) / ( max - min ) * 100;
}
if ( isNaN( percent ) ) {
return;
}
newval = ( percent / 100 ) * ( max - min ) + min;
//from jQuery UI slider, the following source will round to the nearest step
valModStep = ( newval - min ) % step;
alignValue = newval - valModStep;
if ( Math.abs( valModStep ) * 2 >= step ) {
alignValue += ( valModStep > 0 ) ? step : ( -step );
}
percentPerStep = 100/((max-min)/step);
// Since JavaScript has problems with large floats, round
// the final value to 5 digits after the decimal point (see jQueryUI: #4124)
newval = parseFloat( alignValue.toFixed(5) );
if ( typeof pxStep === "undefined" ) {
pxStep = width / ( (max-min) / step );
}
if ( pxStep > 1 && isInput ) {
percent = ( newval - min ) * percentPerStep * ( 1 / step );
}
if ( percent < 0 ) {
percent = 0;
}
if ( percent > 100 ) {
percent = 100;
}
if ( newval < min ) {
newval = min;
}
if ( newval > max ) {
newval = max;
}
this.handle.css( "left", percent + "%" );
this.handle[0].setAttribute( "aria-valuenow", isInput ? newval : optionElements.eq( newval ).attr( "value" ) );
this.handle[0].setAttribute( "aria-valuetext", isInput ? newval : optionElements.eq( newval ).getEncodedText() );
this.handle[0].setAttribute( "title", isInput ? newval : optionElements.eq( newval ).getEncodedText() );
if ( this.valuebg ) {
this.valuebg.css( "width", percent + "%" );
}
// drag the label widths
if ( this._labels ) {
handlePercent = this.handle.width() / this.slider.width() * 100;
aPercent = percent && handlePercent + ( 100 - handlePercent ) * percent / 100;
bPercent = percent === 100 ? 0 : Math.min( handlePercent + 100 - aPercent, 100 );
this._labels.each(function() {
var ab = $( this ).hasClass( "ui-slider-label-a" );
$( this ).width( ( ab ? aPercent : bPercent ) + "%" );
});
}
if ( !preventInputUpdate ) {
valueChanged = false;
// update control"s value
if ( isInput ) {
valueChanged = control.val() !== newval;
control.val( newval );
} else {
valueChanged = control[ 0 ].selectedIndex !== newval;
control[ 0 ].selectedIndex = newval;
}
if ( this._trigger( "beforechange", val ) === false) {
return false;
}
if ( !isfromControl && valueChanged ) {
control.trigger( "change" );
}
}
},
_setHighlight: function( value ) {
value = !!value;
if ( value ) {
this.options.highlight = !!value;
this.refresh();
} else if ( this.valuebg ) {
this.valuebg.remove();
this.valuebg = false;
}
},
_setTheme: function( value ) {
this.handle
.removeClass( "ui-btn-" + this.options.theme )
.addClass( "ui-btn-" + value );
var currentTheme = this.options.theme ? this.options.theme : "inherit",
newTheme = value ? value : "inherit";
this.control
.removeClass( "ui-body-" + currentTheme )
.addClass( "ui-body-" + newTheme );
},
_setTrackTheme: function( value ) {
var currentTrackTheme = this.options.trackTheme ? this.options.trackTheme : "inherit",
newTrackTheme = value ? value : "inherit";
this.slider
.removeClass( "ui-body-" + currentTrackTheme )
.addClass( "ui-body-" + newTrackTheme );
},
_setMini: function( value ) {
value = !!value;
if ( !this.isToggleSwitch && !this.isRangeslider ) {
this.slider.parent().toggleClass( "ui-mini", value );
this.element.toggleClass( "ui-mini", value );
}
this.slider.toggleClass( "ui-mini", value );
},
_setCorners: function( value ) {
this.slider.toggleClass( "ui-corner-all", value );
if ( !this.isToggleSwitch ) {
this.control.toggleClass( "ui-corner-all", value );
}
},
_setDisabled: function( value ) {
value = !!value;
this.element.prop( "disabled", value );
this.slider
.toggleClass( "ui-state-disabled", value )
.attr( "aria-disabled", value );
}
}, $.mobile.behaviors.formReset ) );
})( jQuery );
(function( $, undefined ) {
var popup;
function getPopup() {
if ( !popup ) {
popup = $( "<div></div>", {
"class": "ui-slider-popup ui-shadow ui-corner-all"
});
}
return popup.clone();
}
$.widget( "mobile.slider", $.mobile.slider, {
options: {
popupEnabled: false,
showValue: false
},
_create: function() {
this._super();
$.extend( this, {
_currentValue: null,
_popup: null,
_popupVisible: false
});
this._setOption( "popupEnabled", this.options.popupEnabled );
this._on( this.handle, { "vmousedown" : "_showPopup" } );
this._on( this.slider.add( this.document ), { "vmouseup" : "_hidePopup" } );
this._refresh();
},
// position the popup centered 5px above the handle
_positionPopup: function() {
var dstOffset = this.handle.offset();
this._popup.offset( {
left: dstOffset.left + ( this.handle.width() - this._popup.width() ) / 2,
top: dstOffset.top - this._popup.outerHeight() - 5
});
},
_setOption: function( key, value ) {
this._super( key, value );
if ( key === "showValue" ) {
this.handle.html( value && !this.options.mini ? this._value() : "" );
} else if ( key === "popupEnabled" ) {
if ( value && !this._popup ) {
this._popup = getPopup()
.addClass( "ui-body-" + ( this.options.theme || "a" ) )
.hide()
.insertBefore( this.element );
}
}
},
// show value on the handle and in popup
refresh: function() {
this._super.apply( this, arguments );
this._refresh();
},
_refresh: function() {
var o = this.options, newValue;
if ( o.popupEnabled ) {
// remove the title attribute from the handle (which is
// responsible for the annoying tooltip); NB we have
// to do it here as the jqm slider sets it every time
// the slider's value changes :(
this.handle.removeAttr( "title" );
}
newValue = this._value();
if ( newValue === this._currentValue ) {
return;
}
this._currentValue = newValue;
if ( o.popupEnabled && this._popup ) {
this._positionPopup();
this._popup.html( newValue );
}
if ( o.showValue && !this.options.mini ) {
this.handle.html( newValue );
}
},
_showPopup: function() {
if ( this.options.popupEnabled && !this._popupVisible ) {
this.handle.html( "" );
this._popup.show();
this._positionPopup();
this._popupVisible = true;
}
},
_hidePopup: function() {
var o = this.options;
if ( o.popupEnabled && this._popupVisible ) {
if ( o.showValue && !o.mini ) {
this.handle.html( this._value() );
}
this._popup.hide();
this._popupVisible = false;
}
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.flipswitch", $.extend({
options: {
onText: "On",
offText: "Off",
theme: null,
enhanced: false,
wrapperClass: null,
corners: true,
mini: false
},
_create: function() {
if ( !this.options.enhanced ) {
this._enhance();
} else {
$.extend( this, {
flipswitch: this.element.parent(),
on: this.element.find( ".ui-flipswitch-on" ).eq( 0 ),
off: this.element.find( ".ui-flipswitch-off" ).eq(0),
type: this.element.get( 0 ).tagName
});
}
this._handleFormReset();
// Transfer tabindex to "on" element and make input unfocusable
this._originalTabIndex = this.element.attr( "tabindex" );
if ( this._originalTabIndex != null ) {
this.on.attr( "tabindex", this._originalTabIndex );
}
this.element.attr( "tabindex", "-1" );
this._on({
"focus" : "_handleInputFocus"
});
if ( this.element.is( ":disabled" ) ) {
this._setOptions({
"disabled": true
});
}
this._on( this.flipswitch, {
"click": "_toggle",
"swipeleft": "_left",
"swiperight": "_right"
});
this._on( this.on, {
"keydown": "_keydown"
});
this._on( {
"change": "refresh"
});
},
_handleInputFocus: function() {
this.on.focus();
},
widget: function() {
return this.flipswitch;
},
_left: function() {
this.flipswitch.removeClass( "ui-flipswitch-active" );
if ( this.type === "SELECT" ) {
this.element.get( 0 ).selectedIndex = 0;
} else {
this.element.prop( "checked", false );
}
this.element.trigger( "change" );
},
_right: function() {
this.flipswitch.addClass( "ui-flipswitch-active" );
if ( this.type === "SELECT" ) {
this.element.get( 0 ).selectedIndex = 1;
} else {
this.element.prop( "checked", true );
}
this.element.trigger( "change" );
},
_enhance: function() {
var flipswitch = $( "<div>" ),
options = this.options,
element = this.element,
theme = options.theme ? options.theme : "inherit",
// The "on" button is an anchor so it's focusable
on = $( "<a></a>", {
"href": "#"
}),
off = $( "<span></span>" ),
type = element.get( 0 ).tagName,
onText = ( type === "INPUT" ) ?
options.onText : element.find( "option" ).eq( 1 ).text(),
offText = ( type === "INPUT" ) ?
options.offText : element.find( "option" ).eq( 0 ).text();
on
.addClass( "ui-flipswitch-on ui-btn ui-shadow ui-btn-inherit" )
.text( onText );
off
.addClass( "ui-flipswitch-off" )
.text( offText );
flipswitch
.addClass( "ui-flipswitch ui-shadow-inset " +
"ui-bar-" + theme + " " +
( options.wrapperClass ? options.wrapperClass : "" ) + " " +
( ( element.is( ":checked" ) ||
element
.find( "option" )
.eq( 1 )
.is( ":selected" ) ) ? "ui-flipswitch-active" : "" ) +
( element.is(":disabled") ? " ui-state-disabled": "") +
( options.corners ? " ui-corner-all": "" ) +
( options.mini ? " ui-mini": "" ) )
.append( on, off );
element
.addClass( "ui-flipswitch-input" )
.after( flipswitch )
.appendTo( flipswitch );
$.extend( this, {
flipswitch: flipswitch,
on: on,
off: off,
type: type
});
},
_reset: function() {
this.refresh();
},
refresh: function() {
var direction,
existingDirection = this.flipswitch.hasClass( "ui-flipswitch-active" ) ? "_right" : "_left";
if ( this.type === "SELECT" ) {
direction = ( this.element.get( 0 ).selectedIndex > 0 ) ? "_right": "_left";
} else {
direction = this.element.prop( "checked" ) ? "_right": "_left";
}
if ( direction !== existingDirection ) {
this[ direction ]();
}
},
_toggle: function() {
var direction = this.flipswitch.hasClass( "ui-flipswitch-active" ) ? "_left" : "_right";
this[ direction ]();
},
_keydown: function( e ) {
if ( e.which === $.mobile.keyCode.LEFT ) {
this._left();
} else if ( e.which === $.mobile.keyCode.RIGHT ) {
this._right();
} else if ( e.which === $.mobile.keyCode.SPACE ) {
this._toggle();
e.preventDefault();
}
},
_setOptions: function( options ) {
if ( options.theme !== undefined ) {
var currentTheme = options.theme ? options.theme : "inherit",
newTheme = options.theme ? options.theme : "inherit";
this.widget()
.removeClass( "ui-bar-" + currentTheme )
.addClass( "ui-bar-" + newTheme );
}
if ( options.onText !== undefined ) {
this.on.text( options.onText );
}
if ( options.offText !== undefined ) {
this.off.text( options.offText );
}
if ( options.disabled !== undefined ) {
this.widget().toggleClass( "ui-state-disabled", options.disabled );
}
if ( options.mini !== undefined ) {
this.widget().toggleClass( "ui-mini", options.mini );
}
if ( options.corners !== undefined ) {
this.widget().toggleClass( "ui-corner-all", options.corners );
}
this._super( options );
},
_destroy: function() {
if ( this.options.enhanced ) {
return;
}
if ( this._originalTabIndex != null ) {
this.element.attr( "tabindex", this._originalTabIndex );
} else {
this.element.removeAttr( "tabindex" );
}
this.on.remove();
this.off.remove();
this.element.unwrap();
this.flipswitch.remove();
this.removeClass( "ui-flipswitch-input" );
}
}, $.mobile.behaviors.formReset ) );
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.rangeslider", $.extend( {
options: {
theme: null,
trackTheme: null,
corners: true,
mini: false,
highlight: true
},
_create: function() {
var $el = this.element,
elClass = this.options.mini ? "ui-rangeslider ui-mini" : "ui-rangeslider",
_inputFirst = $el.find( "input" ).first(),
_inputLast = $el.find( "input" ).last(),
_label = $el.find( "label" ).first(),
_sliderWidgetFirst = $.data( _inputFirst.get( 0 ), "mobile-slider" ) ||
$.data( _inputFirst.slider().get( 0 ), "mobile-slider" ),
_sliderWidgetLast = $.data( _inputLast.get(0), "mobile-slider" ) ||
$.data( _inputLast.slider().get( 0 ), "mobile-slider" ),
_sliderFirst = _sliderWidgetFirst.slider,
_sliderLast = _sliderWidgetLast.slider,
firstHandle = _sliderWidgetFirst.handle,
_sliders = $( "<div class='ui-rangeslider-sliders' />" ).appendTo( $el );
_inputFirst.addClass( "ui-rangeslider-first" );
_inputLast.addClass( "ui-rangeslider-last" );
$el.addClass( elClass );
_sliderFirst.appendTo( _sliders );
_sliderLast.appendTo( _sliders );
_label.insertBefore( $el );
firstHandle.prependTo( _sliderLast );
$.extend( this, {
_inputFirst: _inputFirst,
_inputLast: _inputLast,
_sliderFirst: _sliderFirst,
_sliderLast: _sliderLast,
_label: _label,
_targetVal: null,
_sliderTarget: false,
_sliders: _sliders,
_proxy: false
});
this.refresh();
this._on( this.element.find( "input.ui-slider-input" ), {
"slidebeforestart": "_slidebeforestart",
"slidestop": "_slidestop",
"slidedrag": "_slidedrag",
"slidebeforechange": "_change",
"blur": "_change",
"keyup": "_change"
});
this._on({
"mousedown":"_change"
});
this._on( this.element.closest( "form" ), {
"reset":"_handleReset"
});
this._on( firstHandle, {
"vmousedown": "_dragFirstHandle"
});
},
_handleReset: function() {
var self = this;
//we must wait for the stack to unwind before updateing other wise sliders will not have updated yet
setTimeout( function() {
self._updateHighlight();
},0);
},
_dragFirstHandle: function( event ) {
//if the first handle is dragged send the event to the first slider
$.data( this._inputFirst.get(0), "mobile-slider" ).dragging = true;
$.data( this._inputFirst.get(0), "mobile-slider" ).refresh( event );
return false;
},
_slidedrag: function( event ) {
var first = $( event.target ).is( this._inputFirst ),
otherSlider = ( first ) ? this._inputLast : this._inputFirst;
this._sliderTarget = false;
//if the drag was initiated on an extreme and the other handle is focused send the events to
//the closest handle
if ( ( this._proxy === "first" && first ) || ( this._proxy === "last" && !first ) ) {
$.data( otherSlider.get(0), "mobile-slider" ).dragging = true;
$.data( otherSlider.get(0), "mobile-slider" ).refresh( event );
return false;
}
},
_slidestop: function( event ) {
var first = $( event.target ).is( this._inputFirst );
this._proxy = false;
//this stops dragging of the handle and brings the active track to the front
//this makes clicks on the track go the the last handle used
this.element.find( "input" ).trigger( "vmouseup" );
this._sliderFirst.css( "z-index", first ? 1 : "" );
},
_slidebeforestart: function( event ) {
this._sliderTarget = false;
//if the track is the target remember this and the original value
if ( $( event.originalEvent.target ).hasClass( "ui-slider-track" ) ) {
this._sliderTarget = true;
this._targetVal = $( event.target ).val();
}
},
_setOptions: function( options ) {
if ( options.theme !== undefined ) {
this._setTheme( options.theme );
}
if ( options.trackTheme !== undefined ) {
this._setTrackTheme( options.trackTheme );
}
if ( options.mini !== undefined ) {
this._setMini( options.mini );
}
if ( options.highlight !== undefined ) {
this._setHighlight( options.highlight );
}
this._super( options );
this.refresh();
},
refresh: function() {
var $el = this.element,
o = this.options;
if ( this._inputFirst.is( ":disabled" ) || this._inputLast.is( ":disabled" ) ) {
this.options.disabled = true;
}
$el.find( "input" ).slider({
theme: o.theme,
trackTheme: o.trackTheme,
disabled: o.disabled,
corners: o.corners,
mini: o.mini,
highlight: o.highlight
}).slider( "refresh" );
this._updateHighlight();
},
_change: function( event ) {
if ( event.type === "keyup" ) {
this._updateHighlight();
return false;
}
var self = this,
min = parseFloat( this._inputFirst.val(), 10 ),
max = parseFloat( this._inputLast.val(), 10 ),
first = $( event.target ).hasClass( "ui-rangeslider-first" ),
thisSlider = first ? this._inputFirst : this._inputLast,
otherSlider = first ? this._inputLast : this._inputFirst;
if ( ( this._inputFirst.val() > this._inputLast.val() && event.type === "mousedown" && !$(event.target).hasClass("ui-slider-handle")) ) {
thisSlider.blur();
} else if ( event.type === "mousedown" ) {
return;
}
if ( min > max && !this._sliderTarget ) {
//this prevents min from being greater then max
thisSlider.val( first ? max: min ).slider( "refresh" );
this._trigger( "normalize" );
} else if ( min > max ) {
//this makes it so clicks on the target on either extreme go to the closest handle
thisSlider.val( this._targetVal ).slider( "refresh" );
//You must wait for the stack to unwind so first slider is updated before updating second
setTimeout( function() {
otherSlider.val( first ? min: max ).slider( "refresh" );
$.data( otherSlider.get(0), "mobile-slider" ).handle.focus();
self._sliderFirst.css( "z-index", first ? "" : 1 );
self._trigger( "normalize" );
}, 0 );
this._proxy = ( first ) ? "first" : "last";
}
//fixes issue where when both _sliders are at min they cannot be adjusted
if ( min === max ) {
$.data( thisSlider.get(0), "mobile-slider" ).handle.css( "z-index", 1 );
$.data( otherSlider.get(0), "mobile-slider" ).handle.css( "z-index", 0 );
} else {
$.data( otherSlider.get(0), "mobile-slider" ).handle.css( "z-index", "" );
$.data( thisSlider.get(0), "mobile-slider" ).handle.css( "z-index", "" );
}
this._updateHighlight();
if ( min >= max ) {
return false;
}
},
_updateHighlight: function() {
var min = parseInt( $.data( this._inputFirst.get(0), "mobile-slider" ).handle.get(0).style.left, 10 ),
max = parseInt( $.data( this._inputLast.get(0), "mobile-slider" ).handle.get(0).style.left, 10 ),
width = (max - min);
this.element.find( ".ui-slider-bg" ).css({
"margin-left": min + "%",
"width": width + "%"
});
},
_setTheme: function( value ) {
this._inputFirst.slider( "option", "theme", value );
this._inputLast.slider( "option", "theme", value );
},
_setTrackTheme: function( value ) {
this._inputFirst.slider( "option", "trackTheme", value );
this._inputLast.slider( "option", "trackTheme", value );
},
_setMini: function( value ) {
this._inputFirst.slider( "option", "mini", value );
this._inputLast.slider( "option", "mini", value );
this.element.toggleClass( "ui-mini", !!value );
},
_setHighlight: function( value ) {
this._inputFirst.slider( "option", "highlight", value );
this._inputLast.slider( "option", "highlight", value );
},
_destroy: function() {
this._label.prependTo( this.element );
this.element.removeClass( "ui-rangeslider ui-mini" );
this._inputFirst.after( this._sliderFirst );
this._inputLast.after( this._sliderLast );
this._sliders.remove();
this.element.find( "input" ).removeClass( "ui-rangeslider-first ui-rangeslider-last" ).slider( "destroy" );
}
}, $.mobile.behaviors.formReset ) );
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.textinput", $.mobile.textinput, {
options: {
clearBtn: false,
clearBtnText: "Clear text"
},
_create: function() {
this._super();
if ( !!this.options.clearBtn || this.isSearch ) {
this._addClearBtn();
}
},
clearButton: function() {
return $( "<a href='#' class='ui-input-clear ui-btn ui-icon-delete ui-btn-icon-notext ui-corner-all" +
"' title='" + this.options.clearBtnText + "'>" + this.options.clearBtnText + "</a>" );
},
_clearBtnClick: function( event ) {
this.element.val( "" )
.focus()
.trigger( "change" );
this._clearBtn.addClass( "ui-input-clear-hidden" );
event.preventDefault();
},
_addClearBtn: function() {
if ( !this.options.enhanced ) {
this._enhanceClear();
}
$.extend( this, {
_clearBtn: this.widget().find("a.ui-input-clear")
});
this._bindClearEvents();
this._toggleClear();
},
_enhanceClear: function() {
this.clearButton().appendTo( this.widget() );
this.widget().addClass( "ui-input-has-clear" );
},
_bindClearEvents: function() {
this._on( this._clearBtn, {
"click": "_clearBtnClick"
});
this._on({
"keyup": "_toggleClear",
"change": "_toggleClear",
"input": "_toggleClear",
"focus": "_toggleClear",
"blur": "_toggleClear",
"cut": "_toggleClear",
"paste": "_toggleClear"
});
},
_unbindClear: function() {
this._off( this._clearBtn, "click");
this._off( this.element, "keyup change input focus blur cut paste" );
},
_setOptions: function( options ) {
this._super( options );
if ( options.clearBtn !== undefined &&
!this.element.is( "textarea, :jqmData(type='range')" ) ) {
if ( options.clearBtn ) {
this._addClearBtn();
} else {
this._destroyClear();
}
}
if ( options.clearBtnText !== undefined && this._clearBtn !== undefined ) {
this._clearBtn.text( options.clearBtnText )
.attr("title", options.clearBtnText);
}
},
_toggleClear: function() {
this._delay( "_toggleClearClass", 0 );
},
_toggleClearClass: function() {
this._clearBtn.toggleClass( "ui-input-clear-hidden", !this.element.val() );
},
_destroyClear: function() {
this.widget().removeClass( "ui-input-has-clear" );
this._unbindClear();
this._clearBtn.remove();
},
_destroy: function() {
this._super();
this._destroyClear();
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.textinput", $.mobile.textinput, {
options: {
autogrow:true,
keyupTimeoutBuffer: 100
},
_create: function() {
this._super();
if ( this.options.autogrow && this.isTextarea ) {
this._autogrow();
}
},
_autogrow: function() {
this.element.addClass( "ui-textinput-autogrow" );
this._on({
"keyup": "_timeout",
"change": "_timeout",
"input": "_timeout",
"paste": "_timeout"
});
// Attach to the various you-have-become-visible notifications that the
// various framework elements emit.
// TODO: Remove all but the updatelayout handler once #6426 is fixed.
this._on( true, this.document, {
// TODO: Move to non-deprecated event
"pageshow": "_handleShow",
"popupbeforeposition": "_handleShow",
"updatelayout": "_handleShow",
"panelopen": "_handleShow"
});
},
// Synchronously fix the widget height if this widget's parents are such
// that they show/hide content at runtime. We still need to check whether
// the widget is actually visible in case it is contained inside multiple
// such containers. For example: panel contains collapsible contains
// autogrow textinput. The panel may emit "panelopen" indicating that its
// content has become visible, but the collapsible is still collapsed, so
// the autogrow textarea is still not visible.
_handleShow: function( event ) {
if ( $.contains( event.target, this.element[ 0 ] ) &&
this.element.is( ":visible" ) ) {
if ( event.type !== "popupbeforeposition" ) {
this.element
.addClass( "ui-textinput-autogrow-resize" )
.animationComplete(
$.proxy( function() {
this.element.removeClass( "ui-textinput-autogrow-resize" );
}, this ),
"transition" );
}
this._timeout();
}
},
_unbindAutogrow: function() {
this.element.removeClass( "ui-textinput-autogrow" );
this._off( this.element, "keyup change input paste" );
this._off( this.document,
"pageshow popupbeforeposition updatelayout panelopen" );
},
keyupTimeout: null,
_prepareHeightUpdate: function( delay ) {
if ( this.keyupTimeout ) {
clearTimeout( this.keyupTimeout );
}
if ( delay === undefined ) {
this._updateHeight();
} else {
this.keyupTimeout = this._delay( "_updateHeight", delay );
}
},
_timeout: function() {
this._prepareHeightUpdate( this.options.keyupTimeoutBuffer );
},
_updateHeight: function() {
var paddingTop, paddingBottom, paddingHeight, scrollHeight, clientHeight,
borderTop, borderBottom, borderHeight, height,
scrollTop = this.window.scrollTop();
this.keyupTimeout = 0;
// IE8 textareas have the onpage property - others do not
if ( !( "onpage" in this.element[ 0 ] ) ) {
this.element.css({
"height": 0,
"min-height": 0,
"max-height": 0
});
}
scrollHeight = this.element[ 0 ].scrollHeight;
clientHeight = this.element[ 0 ].clientHeight;
borderTop = parseFloat( this.element.css( "border-top-width" ) );
borderBottom = parseFloat( this.element.css( "border-bottom-width" ) );
borderHeight = borderTop + borderBottom;
height = scrollHeight + borderHeight + 15;
// Issue 6179: Padding is not included in scrollHeight and
// clientHeight by Firefox if no scrollbar is visible. Because
// textareas use the border-box box-sizing model, padding should be
// included in the new (assigned) height. Because the height is set
// to 0, clientHeight == 0 in Firefox. Therefore, we can use this to
// check if padding must be added.
if ( clientHeight === 0 ) {
paddingTop = parseFloat( this.element.css( "padding-top" ) );
paddingBottom = parseFloat( this.element.css( "padding-bottom" ) );
paddingHeight = paddingTop + paddingBottom;
height += paddingHeight;
}
this.element.css({
"height": height,
"min-height": "",
"max-height": ""
});
this.window.scrollTop( scrollTop );
},
refresh: function() {
if ( this.options.autogrow && this.isTextarea ) {
this._updateHeight();
}
},
_setOptions: function( options ) {
this._super( options );
if ( options.autogrow !== undefined && this.isTextarea ) {
if ( options.autogrow ) {
this._autogrow();
} else {
this._unbindAutogrow();
}
}
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.selectmenu", $.extend( {
initSelector: "select:not( :jqmData(role='slider')):not( :jqmData(role='flipswitch') )",
options: {
theme: null,
icon: "carat-d",
iconpos: "right",
inline: false,
corners: true,
shadow: true,
iconshadow: false, /* TODO: Deprecated in 1.4, remove in 1.5. */
overlayTheme: null,
dividerTheme: null,
hidePlaceholderMenuItems: true,
closeText: "Close",
nativeMenu: true,
// This option defaults to true on iOS devices.
preventFocusZoom: /iPhone|iPad|iPod/.test( navigator.platform ) && navigator.userAgent.indexOf( "AppleWebKit" ) > -1,
mini: false
},
_button: function() {
return $( "<div/>" );
},
_setDisabled: function( value ) {
this.element.attr( "disabled", value );
this.button.attr( "aria-disabled", value );
return this._setOption( "disabled", value );
},
_focusButton : function() {
var self = this;
setTimeout( function() {
self.button.focus();
}, 40);
},
_selectOptions: function() {
return this.select.find( "option" );
},
// setup items that are generally necessary for select menu extension
_preExtension: function() {
var inline = this.options.inline || this.element.jqmData( "inline" ),
mini = this.options.mini || this.element.jqmData( "mini" ),
classes = "";
// TODO: Post 1.1--once we have time to test thoroughly--any classes manually applied to the original element should be carried over to the enhanced element, with an `-enhanced` suffix. See https://github.com/jquery/jquery-mobile/issues/3577
/* if ( $el[0].className.length ) {
classes = $el[0].className;
} */
if ( !!~this.element[0].className.indexOf( "ui-btn-left" ) ) {
classes = " ui-btn-left";
}
if ( !!~this.element[0].className.indexOf( "ui-btn-right" ) ) {
classes = " ui-btn-right";
}
if ( inline ) {
classes += " ui-btn-inline";
}
if ( mini ) {
classes += " ui-mini";
}
this.select = this.element.removeClass( "ui-btn-left ui-btn-right" ).wrap( "<div class='ui-select" + classes + "'>" );
this.selectId = this.select.attr( "id" ) || ( "select-" + this.uuid );
this.buttonId = this.selectId + "-button";
this.label = $( "label[for='"+ this.selectId +"']" );
this.isMultiple = this.select[ 0 ].multiple;
},
_destroy: function() {
var wrapper = this.element.parents( ".ui-select" );
if ( wrapper.length > 0 ) {
if ( wrapper.is( ".ui-btn-left, .ui-btn-right" ) ) {
this.element.addClass( wrapper.hasClass( "ui-btn-left" ) ? "ui-btn-left" : "ui-btn-right" );
}
this.element.insertAfter( wrapper );
wrapper.remove();
}
},
_create: function() {
this._preExtension();
this.button = this._button();
var self = this,
options = this.options,
iconpos = options.icon ? ( options.iconpos || this.select.jqmData( "iconpos" ) ) : false,
button = this.button
.insertBefore( this.select )
.attr( "id", this.buttonId )
.addClass( "ui-btn" +
( options.icon ? ( " ui-icon-" + options.icon + " ui-btn-icon-" + iconpos +
( options.iconshadow ? " ui-shadow-icon" : "" ) ) : "" ) + /* TODO: Remove in 1.5. */
( options.theme ? " ui-btn-" + options.theme : "" ) +
( options.corners ? " ui-corner-all" : "" ) +
( options.shadow ? " ui-shadow" : "" ) );
this.setButtonText();
// Opera does not properly support opacity on select elements
// In Mini, it hides the element, but not its text
// On the desktop,it seems to do the opposite
// for these reasons, using the nativeMenu option results in a full native select in Opera
if ( options.nativeMenu && window.opera && window.opera.version ) {
button.addClass( "ui-select-nativeonly" );
}
// Add counter for multi selects
if ( this.isMultiple ) {
this.buttonCount = $( "<span>" )
.addClass( "ui-li-count ui-body-inherit" )
.hide()
.appendTo( button.addClass( "ui-li-has-count" ) );
}
// Disable if specified
if ( options.disabled || this.element.attr( "disabled" )) {
this.disable();
}
// Events on native select
this.select.change(function() {
self.refresh();
if ( !!options.nativeMenu ) {
this.blur();
}
});
this._handleFormReset();
this._on( this.button, {
keydown: "_handleKeydown"
});
this.build();
},
build: function() {
var self = this;
this.select
.appendTo( self.button )
.bind( "vmousedown", function() {
// Add active class to button
self.button.addClass( $.mobile.activeBtnClass );
})
.bind( "focus", function() {
self.button.addClass( $.mobile.focusClass );
})
.bind( "blur", function() {
self.button.removeClass( $.mobile.focusClass );
})
.bind( "focus vmouseover", function() {
self.button.trigger( "vmouseover" );
})
.bind( "vmousemove", function() {
// Remove active class on scroll/touchmove
self.button.removeClass( $.mobile.activeBtnClass );
})
.bind( "change blur vmouseout", function() {
self.button.trigger( "vmouseout" )
.removeClass( $.mobile.activeBtnClass );
});
// In many situations, iOS will zoom into the select upon tap, this prevents that from happening
self.button.bind( "vmousedown", function() {
if ( self.options.preventFocusZoom ) {
$.mobile.zoom.disable( true );
}
});
self.label.bind( "click focus", function() {
if ( self.options.preventFocusZoom ) {
$.mobile.zoom.disable( true );
}
});
self.select.bind( "focus", function() {
if ( self.options.preventFocusZoom ) {
$.mobile.zoom.disable( true );
}
});
self.button.bind( "mouseup", function() {
if ( self.options.preventFocusZoom ) {
setTimeout(function() {
$.mobile.zoom.enable( true );
}, 0 );
}
});
self.select.bind( "blur", function() {
if ( self.options.preventFocusZoom ) {
$.mobile.zoom.enable( true );
}
});
},
selected: function() {
return this._selectOptions().filter( ":selected" );
},
selectedIndices: function() {
var self = this;
return this.selected().map(function() {
return self._selectOptions().index( this );
}).get();
},
setButtonText: function() {
var self = this,
selected = this.selected(),
text = this.placeholder,
span = $( document.createElement( "span" ) );
this.button.children( "span" ).not( ".ui-li-count" ).remove().end().end().prepend( (function() {
if ( selected.length ) {
text = selected.map(function() {
return $( this ).text();
}).get().join( ", " );
} else {
text = self.placeholder;
}
if ( text ) {
span.text( text );
} else {
// Set the contents to which we write as   to be XHTML compliant - see gh-6699
span.html( " " );
}
// TODO possibly aggregate multiple select option classes
return span
.addClass( self.select.attr( "class" ) )
.addClass( selected.attr( "class" ) )
.removeClass( "ui-screen-hidden" );
})());
},
setButtonCount: function() {
var selected = this.selected();
// multiple count inside button
if ( this.isMultiple ) {
this.buttonCount[ selected.length > 1 ? "show" : "hide" ]().text( selected.length );
}
},
_handleKeydown: function( /* event */ ) {
this._delay( "_refreshButton" );
},
_reset: function() {
this.refresh();
},
_refreshButton: function() {
this.setButtonText();
this.setButtonCount();
},
refresh: function() {
this._refreshButton();
},
// open and close preserved in native selects
// to simplify users code when looping over selects
open: $.noop,
close: $.noop,
disable: function() {
this._setDisabled( true );
this.button.addClass( "ui-state-disabled" );
},
enable: function() {
this._setDisabled( false );
this.button.removeClass( "ui-state-disabled" );
}
}, $.mobile.behaviors.formReset ) );
})( jQuery );
(function( $, undefined ) {
$.mobile.links = function( target ) {
//links within content areas, tests included with page
$( target )
.find( "a" )
.jqmEnhanceable()
.filter( ":jqmData(rel='popup')[href][href!='']" )
.each( function() {
// Accessibility info for popups
var element = this,
idref = element.getAttribute( "href" ).substring( 1 );
if ( idref ) {
element.setAttribute( "aria-haspopup", true );
element.setAttribute( "aria-owns", idref );
element.setAttribute( "aria-expanded", false );
}
})
.end()
.not( ".ui-btn, :jqmData(role='none'), :jqmData(role='nojs')" )
.addClass( "ui-link" );
};
})( jQuery );
(function( $, undefined ) {
function fitSegmentInsideSegment( windowSize, segmentSize, offset, desired ) {
var returnValue = desired;
if ( windowSize < segmentSize ) {
// Center segment if it's bigger than the window
returnValue = offset + ( windowSize - segmentSize ) / 2;
} else {
// Otherwise center it at the desired coordinate while keeping it completely inside the window
returnValue = Math.min( Math.max( offset, desired - segmentSize / 2 ), offset + windowSize - segmentSize );
}
return returnValue;
}
function getWindowCoordinates( theWindow ) {
return {
x: theWindow.scrollLeft(),
y: theWindow.scrollTop(),
cx: ( theWindow[ 0 ].innerWidth || theWindow.width() ),
cy: ( theWindow[ 0 ].innerHeight || theWindow.height() )
};
}
$.widget( "mobile.popup", {
options: {
wrapperClass: null,
theme: null,
overlayTheme: null,
shadow: true,
corners: true,
transition: "none",
positionTo: "origin",
tolerance: null,
closeLinkSelector: "a:jqmData(rel='back')",
closeLinkEvents: "click.popup",
navigateEvents: "navigate.popup",
closeEvents: "navigate.popup pagebeforechange.popup",
dismissible: true,
enhanced: false,
// NOTE Windows Phone 7 has a scroll position caching issue that
// requires us to disable popup history management by default
// https://github.com/jquery/jquery-mobile/issues/4784
//
// NOTE this option is modified in _create!
history: !$.mobile.browser.oldIE
},
// When the user depresses the mouse/finger on an element inside the popup while the popup is
// open, we ignore resize events for a short while. This prevents #6961.
_handleDocumentVmousedown: function( theEvent ) {
if ( this._isOpen && $.contains( this._ui.container[ 0 ], theEvent.target ) ) {
this._ignoreResizeEvents();
}
},
_create: function() {
var theElement = this.element,
myId = theElement.attr( "id" ),
currentOptions = this.options;
// We need to adjust the history option to be false if there's no AJAX nav.
// We can't do it in the option declarations because those are run before
// it is determined whether there shall be AJAX nav.
currentOptions.history = currentOptions.history && $.mobile.ajaxEnabled && $.mobile.hashListeningEnabled;
this._on( this.document, {
"vmousedown": "_handleDocumentVmousedown"
});
// Define instance variables
$.extend( this, {
_scrollTop: 0,
_page: theElement.closest( ".ui-page" ),
_ui: null,
_fallbackTransition: "",
_currentTransition: false,
_prerequisites: null,
_isOpen: false,
_tolerance: null,
_resizeData: null,
_ignoreResizeTo: 0,
_orientationchangeInProgress: false
});
if ( this._page.length === 0 ) {
this._page = $( "body" );
}
if ( currentOptions.enhanced ) {
this._ui = {
container: theElement.parent(),
screen: theElement.parent().prev(),
placeholder: $( this.document[ 0 ].getElementById( myId + "-placeholder" ) )
};
} else {
this._ui = this._enhance( theElement, myId );
this._applyTransition( currentOptions.transition );
}
this
._setTolerance( currentOptions.tolerance )
._ui.focusElement = this._ui.container;
// Event handlers
this._on( this._ui.screen, { "vclick": "_eatEventAndClose" } );
this._on( this.window, {
orientationchange: $.proxy( this, "_handleWindowOrientationchange" ),
resize: $.proxy( this, "_handleWindowResize" ),
keyup: $.proxy( this, "_handleWindowKeyUp" )
});
this._on( this.document, { "focusin": "_handleDocumentFocusIn" } );
},
_enhance: function( theElement, myId ) {
var currentOptions = this.options,
wrapperClass = currentOptions.wrapperClass,
ui = {
screen: $( "<div class='ui-screen-hidden ui-popup-screen " +
this._themeClassFromOption( "ui-overlay-", currentOptions.overlayTheme ) + "'></div>" ),
placeholder: $( "<div style='display: none;'><!-- placeholder --></div>" ),
container: $( "<div class='ui-popup-container ui-popup-hidden ui-popup-truncate" +
( wrapperClass ? ( " " + wrapperClass ) : "" ) + "'></div>" )
},
fragment = this.document[ 0 ].createDocumentFragment();
fragment.appendChild( ui.screen[ 0 ] );
fragment.appendChild( ui.container[ 0 ] );
if ( myId ) {
ui.screen.attr( "id", myId + "-screen" );
ui.container.attr( "id", myId + "-popup" );
ui.placeholder
.attr( "id", myId + "-placeholder" )
.html( "<!-- placeholder for " + myId + " -->" );
}
// Apply the proto
this._page[ 0 ].appendChild( fragment );
// Leave a placeholder where the element used to be
ui.placeholder.insertAfter( theElement );
theElement
.detach()
.addClass( "ui-popup " +
this._themeClassFromOption( "ui-body-", currentOptions.theme ) + " " +
( currentOptions.shadow ? "ui-overlay-shadow " : "" ) +
( currentOptions.corners ? "ui-corner-all " : "" ) )
.appendTo( ui.container );
return ui;
},
_eatEventAndClose: function( theEvent ) {
theEvent.preventDefault();
theEvent.stopImmediatePropagation();
if ( this.options.dismissible ) {
this.close();
}
return false;
},
// Make sure the screen covers the entire document - CSS is sometimes not
// enough to accomplish this.
_resizeScreen: function() {
var screen = this._ui.screen,
popupHeight = this._ui.container.outerHeight( true ),
screenHeight = screen.removeAttr( "style" ).height(),
// Subtracting 1 here is necessary for an obscure Andrdoid 4.0 bug where
// the browser hangs if the screen covers the entire document :/
documentHeight = this.document.height() - 1;
if ( screenHeight < documentHeight ) {
screen.height( documentHeight );
} else if ( popupHeight > screenHeight ) {
screen.height( popupHeight );
}
},
_handleWindowKeyUp: function( theEvent ) {
if ( this._isOpen && theEvent.keyCode === $.mobile.keyCode.ESCAPE ) {
return this._eatEventAndClose( theEvent );
}
},
_expectResizeEvent: function() {
var windowCoordinates = getWindowCoordinates( this.window );
if ( this._resizeData ) {
if ( windowCoordinates.x === this._resizeData.windowCoordinates.x &&
windowCoordinates.y === this._resizeData.windowCoordinates.y &&
windowCoordinates.cx === this._resizeData.windowCoordinates.cx &&
windowCoordinates.cy === this._resizeData.windowCoordinates.cy ) {
// timeout not refreshed
return false;
} else {
// clear existing timeout - it will be refreshed below
clearTimeout( this._resizeData.timeoutId );
}
}
this._resizeData = {
timeoutId: this._delay( "_resizeTimeout", 200 ),
windowCoordinates: windowCoordinates
};
return true;
},
_resizeTimeout: function() {
if ( this._isOpen ) {
if ( !this._expectResizeEvent() ) {
if ( this._ui.container.hasClass( "ui-popup-hidden" ) ) {
// effectively rapid-open the popup while leaving the screen intact
this._ui.container.removeClass( "ui-popup-hidden ui-popup-truncate" );
this.reposition( { positionTo: "window" } );
this._ignoreResizeEvents();
}
this._resizeScreen();
this._resizeData = null;
this._orientationchangeInProgress = false;
}
} else {
this._resizeData = null;
this._orientationchangeInProgress = false;
}
},
_stopIgnoringResizeEvents: function() {
this._ignoreResizeTo = 0;
},
_ignoreResizeEvents: function() {
if ( this._ignoreResizeTo ) {
clearTimeout( this._ignoreResizeTo );
}
this._ignoreResizeTo = this._delay( "_stopIgnoringResizeEvents", 1000 );
},
_handleWindowResize: function(/* theEvent */) {
if ( this._isOpen && this._ignoreResizeTo === 0 ) {
if ( ( this._expectResizeEvent() || this._orientationchangeInProgress ) &&
!this._ui.container.hasClass( "ui-popup-hidden" ) ) {
// effectively rapid-close the popup while leaving the screen intact
this._ui.container
.addClass( "ui-popup-hidden ui-popup-truncate" )
.removeAttr( "style" );
}
}
},
_handleWindowOrientationchange: function(/* theEvent */) {
if ( !this._orientationchangeInProgress && this._isOpen && this._ignoreResizeTo === 0 ) {
this._expectResizeEvent();
this._orientationchangeInProgress = true;
}
},
// When the popup is open, attempting to focus on an element that is not a
// child of the popup will redirect focus to the popup
_handleDocumentFocusIn: function( theEvent ) {
var target,
targetElement = theEvent.target,
ui = this._ui;
if ( !this._isOpen ) {
return;
}
if ( targetElement !== ui.container[ 0 ] ) {
target = $( targetElement );
if ( 0 === target.parents().filter( ui.container[ 0 ] ).length ) {
$( this.document[ 0 ].activeElement ).one( "focus", function(/* theEvent */) {
target.blur();
});
ui.focusElement.focus();
theEvent.preventDefault();
theEvent.stopImmediatePropagation();
return false;
} else if ( ui.focusElement[ 0 ] === ui.container[ 0 ] ) {
ui.focusElement = target;
}
}
this._ignoreResizeEvents();
},
_themeClassFromOption: function( prefix, value ) {
return ( value ? ( value === "none" ? "" : ( prefix + value ) ) : ( prefix + "inherit" ) );
},
_applyTransition: function( value ) {
if ( value ) {
this._ui.container.removeClass( this._fallbackTransition );
if ( value !== "none" ) {
this._fallbackTransition = $.mobile._maybeDegradeTransition( value );
if ( this._fallbackTransition === "none" ) {
this._fallbackTransition = "";
}
this._ui.container.addClass( this._fallbackTransition );
}
}
return this;
},
_setOptions: function( newOptions ) {
var currentOptions = this.options,
theElement = this.element,
screen = this._ui.screen;
if ( newOptions.wrapperClass !== undefined ) {
this._ui.container
.removeClass( currentOptions.wrapperClass )
.addClass( newOptions.wrapperClass );
}
if ( newOptions.theme !== undefined ) {
theElement
.removeClass( this._themeClassFromOption( "ui-body-", currentOptions.theme ) )
.addClass( this._themeClassFromOption( "ui-body-", newOptions.theme ) );
}
if ( newOptions.overlayTheme !== undefined ) {
screen
.removeClass( this._themeClassFromOption( "ui-overlay-", currentOptions.overlayTheme ) )
.addClass( this._themeClassFromOption( "ui-overlay-", newOptions.overlayTheme ) );
if ( this._isOpen ) {
screen.addClass( "in" );
}
}
if ( newOptions.shadow !== undefined ) {
theElement.toggleClass( "ui-overlay-shadow", newOptions.shadow );
}
if ( newOptions.corners !== undefined ) {
theElement.toggleClass( "ui-corner-all", newOptions.corners );
}
if ( newOptions.transition !== undefined ) {
if ( !this._currentTransition ) {
this._applyTransition( newOptions.transition );
}
}
if ( newOptions.tolerance !== undefined ) {
this._setTolerance( newOptions.tolerance );
}
if ( newOptions.disabled !== undefined ) {
if ( newOptions.disabled ) {
this.close();
}
}
return this._super( newOptions );
},
_setTolerance: function( value ) {
var tol = { t: 30, r: 15, b: 30, l: 15 },
ar;
if ( value !== undefined ) {
ar = String( value ).split( "," );
$.each( ar, function( idx, val ) { ar[ idx ] = parseInt( val, 10 ); } );
switch( ar.length ) {
// All values are to be the same
case 1:
if ( !isNaN( ar[ 0 ] ) ) {
tol.t = tol.r = tol.b = tol.l = ar[ 0 ];
}
break;
// The first value denotes top/bottom tolerance, and the second value denotes left/right tolerance
case 2:
if ( !isNaN( ar[ 0 ] ) ) {
tol.t = tol.b = ar[ 0 ];
}
if ( !isNaN( ar[ 1 ] ) ) {
tol.l = tol.r = ar[ 1 ];
}
break;
// The array contains values in the order top, right, bottom, left
case 4:
if ( !isNaN( ar[ 0 ] ) ) {
tol.t = ar[ 0 ];
}
if ( !isNaN( ar[ 1 ] ) ) {
tol.r = ar[ 1 ];
}
if ( !isNaN( ar[ 2 ] ) ) {
tol.b = ar[ 2 ];
}
if ( !isNaN( ar[ 3 ] ) ) {
tol.l = ar[ 3 ];
}
break;
default:
break;
}
}
this._tolerance = tol;
return this;
},
_clampPopupWidth: function( infoOnly ) {
var menuSize,
windowCoordinates = getWindowCoordinates( this.window ),
// rectangle within which the popup must fit
rectangle = {
x: this._tolerance.l,
y: windowCoordinates.y + this._tolerance.t,
cx: windowCoordinates.cx - this._tolerance.l - this._tolerance.r,
cy: windowCoordinates.cy - this._tolerance.t - this._tolerance.b
};
if ( !infoOnly ) {
// Clamp the width of the menu before grabbing its size
this._ui.container.css( "max-width", rectangle.cx );
}
menuSize = {
cx: this._ui.container.outerWidth( true ),
cy: this._ui.container.outerHeight( true )
};
return { rc: rectangle, menuSize: menuSize };
},
_calculateFinalLocation: function( desired, clampInfo ) {
var returnValue,
rectangle = clampInfo.rc,
menuSize = clampInfo.menuSize;
// Center the menu over the desired coordinates, while not going outside
// the window tolerances. This will center wrt. the window if the popup is
// too large.
returnValue = {
left: fitSegmentInsideSegment( rectangle.cx, menuSize.cx, rectangle.x, desired.x ),
top: fitSegmentInsideSegment( rectangle.cy, menuSize.cy, rectangle.y, desired.y )
};
// Make sure the top of the menu is visible
returnValue.top = Math.max( 0, returnValue.top );
// If the height of the menu is smaller than the height of the document
// align the bottom with the bottom of the document
returnValue.top -= Math.min( returnValue.top,
Math.max( 0, returnValue.top + menuSize.cy - this.document.height() ) );
return returnValue;
},
// Try and center the overlay over the given coordinates
_placementCoords: function( desired ) {
return this._calculateFinalLocation( desired, this._clampPopupWidth() );
},
_createPrerequisites: function( screenPrerequisite, containerPrerequisite, whenDone ) {
var prerequisites,
self = this;
// It is important to maintain both the local variable prerequisites and
// self._prerequisites. The local variable remains in the closure of the
// functions which call the callbacks passed in. The comparison between the
// local variable and self._prerequisites is necessary, because once a
// function has been passed to .animationComplete() it will be called next
// time an animation completes, even if that's not the animation whose end
// the function was supposed to catch (for example, if an abort happens
// during the opening animation, the .animationComplete handler is not
// called for that animation anymore, but the handler remains attached, so
// it is called the next time the popup is opened - making it stale.
// Comparing the local variable prerequisites to the widget-level variable
// self._prerequisites ensures that callbacks triggered by a stale
// .animationComplete will be ignored.
prerequisites = {
screen: $.Deferred(),
container: $.Deferred()
};
prerequisites.screen.then( function() {
if ( prerequisites === self._prerequisites ) {
screenPrerequisite();
}
});
prerequisites.container.then( function() {
if ( prerequisites === self._prerequisites ) {
containerPrerequisite();
}
});
$.when( prerequisites.screen, prerequisites.container ).done( function() {
if ( prerequisites === self._prerequisites ) {
self._prerequisites = null;
whenDone();
}
});
self._prerequisites = prerequisites;
},
_animate: function( args ) {
// NOTE before removing the default animation of the screen
// this had an animate callback that would resolve the deferred
// now the deferred is resolved immediately
// TODO remove the dependency on the screen deferred
this._ui.screen
.removeClass( args.classToRemove )
.addClass( args.screenClassToAdd );
args.prerequisites.screen.resolve();
if ( args.transition && args.transition !== "none" ) {
if ( args.applyTransition ) {
this._applyTransition( args.transition );
}
if ( this._fallbackTransition ) {
this._ui.container
.addClass( args.containerClassToAdd )
.removeClass( args.classToRemove )
.animationComplete( $.proxy( args.prerequisites.container, "resolve" ) );
return;
}
}
this._ui.container.removeClass( args.classToRemove );
args.prerequisites.container.resolve();
},
// The desired coordinates passed in will be returned untouched if no reference element can be identified via
// desiredPosition.positionTo. Nevertheless, this function ensures that its return value always contains valid
// x and y coordinates by specifying the center middle of the window if the coordinates are absent.
// options: { x: coordinate, y: coordinate, positionTo: string: "origin", "window", or jQuery selector
_desiredCoords: function( openOptions ) {
var offset,
dst = null,
windowCoordinates = getWindowCoordinates( this.window ),
x = openOptions.x,
y = openOptions.y,
pTo = openOptions.positionTo;
// Establish which element will serve as the reference
if ( pTo && pTo !== "origin" ) {
if ( pTo === "window" ) {
x = windowCoordinates.cx / 2 + windowCoordinates.x;
y = windowCoordinates.cy / 2 + windowCoordinates.y;
} else {
try {
dst = $( pTo );
} catch( err ) {
dst = null;
}
if ( dst ) {
dst.filter( ":visible" );
if ( dst.length === 0 ) {
dst = null;
}
}
}
}
// If an element was found, center over it
if ( dst ) {
offset = dst.offset();
x = offset.left + dst.outerWidth() / 2;
y = offset.top + dst.outerHeight() / 2;
}
// Make sure x and y are valid numbers - center over the window
if ( $.type( x ) !== "number" || isNaN( x ) ) {
x = windowCoordinates.cx / 2 + windowCoordinates.x;
}
if ( $.type( y ) !== "number" || isNaN( y ) ) {
y = windowCoordinates.cy / 2 + windowCoordinates.y;
}
return { x: x, y: y };
},
_reposition: function( openOptions ) {
// We only care about position-related parameters for repositioning
openOptions = {
x: openOptions.x,
y: openOptions.y,
positionTo: openOptions.positionTo
};
this._trigger( "beforeposition", undefined, openOptions );
this._ui.container.offset( this._placementCoords( this._desiredCoords( openOptions ) ) );
},
reposition: function( openOptions ) {
if ( this._isOpen ) {
this._reposition( openOptions );
}
},
_openPrerequisitesComplete: function() {
var id = this.element.attr( "id" );
this._ui.container.addClass( "ui-popup-active" );
this._isOpen = true;
this._resizeScreen();
this._ui.container.attr( "tabindex", "0" ).focus();
this._ignoreResizeEvents();
if ( id ) {
this.document.find( "[aria-haspopup='true'][aria-owns='" + id + "']" ).attr( "aria-expanded", true );
}
this._trigger( "afteropen" );
},
_open: function( options ) {
var openOptions = $.extend( {}, this.options, options ),
// TODO move blacklist to private method
androidBlacklist = ( function() {
var ua = navigator.userAgent,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match( /AppleWebKit\/([0-9\.]+)/ ),
wkversion = !!wkmatch && wkmatch[ 1 ],
androidmatch = ua.match( /Android (\d+(?:\.\d+))/ ),
andversion = !!androidmatch && androidmatch[ 1 ],
chromematch = ua.indexOf( "Chrome" ) > -1;
// Platform is Android, WebKit version is greater than 534.13 ( Android 3.2.1 ) and not Chrome.
if ( androidmatch !== null && andversion === "4.0" && wkversion && wkversion > 534.13 && !chromematch ) {
return true;
}
return false;
}());
// Count down to triggering "popupafteropen" - we have two prerequisites:
// 1. The popup window animation completes (container())
// 2. The screen opacity animation completes (screen())
this._createPrerequisites(
$.noop,
$.noop,
$.proxy( this, "_openPrerequisitesComplete" ) );
this._currentTransition = openOptions.transition;
this._applyTransition( openOptions.transition );
this._ui.screen.removeClass( "ui-screen-hidden" );
this._ui.container.removeClass( "ui-popup-truncate" );
// Give applications a chance to modify the contents of the container before it appears
this._reposition( openOptions );
this._ui.container.removeClass( "ui-popup-hidden" );
if ( this.options.overlayTheme && androidBlacklist ) {
/* TODO: The native browser on Android 4.0.X ("Ice Cream Sandwich") suffers from an issue where the popup overlay appears to be z-indexed above the popup itself when certain other styles exist on the same page -- namely, any element set to `position: fixed` and certain types of input. These issues are reminiscent of previously uncovered bugs in older versions of Android's native browser: https://github.com/scottjehl/Device-Bugs/issues/3
This fix closes the following bugs ( I use "closes" with reluctance, and stress that this issue should be revisited as soon as possible ):
https://github.com/jquery/jquery-mobile/issues/4816
https://github.com/jquery/jquery-mobile/issues/4844
https://github.com/jquery/jquery-mobile/issues/4874
*/
// TODO sort out why this._page isn't working
this.element.closest( ".ui-page" ).addClass( "ui-popup-open" );
}
this._animate({
additionalCondition: true,
transition: openOptions.transition,
classToRemove: "",
screenClassToAdd: "in",
containerClassToAdd: "in",
applyTransition: false,
prerequisites: this._prerequisites
});
},
_closePrerequisiteScreen: function() {
this._ui.screen
.removeClass( "out" )
.addClass( "ui-screen-hidden" );
},
_closePrerequisiteContainer: function() {
this._ui.container
.removeClass( "reverse out" )
.addClass( "ui-popup-hidden ui-popup-truncate" )
.removeAttr( "style" );
},
_closePrerequisitesDone: function() {
var container = this._ui.container,
id = this.element.attr( "id" );
container.removeAttr( "tabindex" );
// remove the global mutex for popups
$.mobile.popup.active = undefined;
// Blur elements inside the container, including the container
$( ":focus", container[ 0 ] ).add( container[ 0 ] ).blur();
if ( id ) {
this.document.find( "[aria-haspopup='true'][aria-owns='" + id + "']" ).attr( "aria-expanded", false );
}
// alert users that the popup is closed
this._trigger( "afterclose" );
},
_close: function( immediate ) {
this._ui.container.removeClass( "ui-popup-active" );
this._page.removeClass( "ui-popup-open" );
this._isOpen = false;
// Count down to triggering "popupafterclose" - we have two prerequisites:
// 1. The popup window reverse animation completes (container())
// 2. The screen opacity animation completes (screen())
this._createPrerequisites(
$.proxy( this, "_closePrerequisiteScreen" ),
$.proxy( this, "_closePrerequisiteContainer" ),
$.proxy( this, "_closePrerequisitesDone" ) );
this._animate( {
additionalCondition: this._ui.screen.hasClass( "in" ),
transition: ( immediate ? "none" : ( this._currentTransition ) ),
classToRemove: "in",
screenClassToAdd: "out",
containerClassToAdd: "reverse out",
applyTransition: true,
prerequisites: this._prerequisites
});
},
_unenhance: function() {
if ( this.options.enhanced ) {
return;
}
// Put the element back to where the placeholder was and remove the "ui-popup" class
this._setOptions( { theme: $.mobile.popup.prototype.options.theme } );
this.element
// Cannot directly insertAfter() - we need to detach() first, because
// insertAfter() will do nothing if the payload div was not attached
// to the DOM at the time the widget was created, and so the payload
// will remain inside the container even after we call insertAfter().
// If that happens and we remove the container a few lines below, we
// will cause an infinite recursion - #5244
.detach()
.insertAfter( this._ui.placeholder )
.removeClass( "ui-popup ui-overlay-shadow ui-corner-all ui-body-inherit" );
this._ui.screen.remove();
this._ui.container.remove();
this._ui.placeholder.remove();
},
_destroy: function() {
if ( $.mobile.popup.active === this ) {
this.element.one( "popupafterclose", $.proxy( this, "_unenhance" ) );
this.close();
} else {
this._unenhance();
}
return this;
},
_closePopup: function( theEvent, data ) {
var parsedDst, toUrl,
currentOptions = this.options,
immediate = false;
if ( ( theEvent && theEvent.isDefaultPrevented() ) || $.mobile.popup.active !== this ) {
return;
}
// restore location on screen
window.scrollTo( 0, this._scrollTop );
if ( theEvent && theEvent.type === "pagebeforechange" && data ) {
// Determine whether we need to rapid-close the popup, or whether we can
// take the time to run the closing transition
if ( typeof data.toPage === "string" ) {
parsedDst = data.toPage;
} else {
parsedDst = data.toPage.jqmData( "url" );
}
parsedDst = $.mobile.path.parseUrl( parsedDst );
toUrl = parsedDst.pathname + parsedDst.search + parsedDst.hash;
if ( this._myUrl !== $.mobile.path.makeUrlAbsolute( toUrl ) ) {
// Going to a different page - close immediately
immediate = true;
} else {
theEvent.preventDefault();
}
}
// remove nav bindings
this.window.off( currentOptions.closeEvents );
// unbind click handlers added when history is disabled
this.element.undelegate( currentOptions.closeLinkSelector, currentOptions.closeLinkEvents );
this._close( immediate );
},
// any navigation event after a popup is opened should close the popup
// NOTE the pagebeforechange is bound to catch navigation events that don't
// alter the url (eg, dialogs from popups)
_bindContainerClose: function() {
this.window
.on( this.options.closeEvents, $.proxy( this, "_closePopup" ) );
},
widget: function() {
return this._ui.container;
},
// TODO no clear deliniation of what should be here and
// what should be in _open. Seems to be "visual" vs "history" for now
open: function( options ) {
var url, hashkey, activePage, currentIsDialog, hasHash, urlHistory,
self = this,
currentOptions = this.options;
// make sure open is idempotent
if ( $.mobile.popup.active || currentOptions.disabled ) {
return this;
}
// set the global popup mutex
$.mobile.popup.active = this;
this._scrollTop = this.window.scrollTop();
// if history alteration is disabled close on navigate events
// and leave the url as is
if ( !( currentOptions.history ) ) {
self._open( options );
self._bindContainerClose();
// When histoy is disabled we have to grab the data-rel
// back link clicks so we can close the popup instead of
// relying on history to do it for us
self.element
.delegate( currentOptions.closeLinkSelector, currentOptions.closeLinkEvents, function( theEvent ) {
self.close();
theEvent.preventDefault();
});
return this;
}
// cache some values for min/readability
urlHistory = $.mobile.navigate.history;
hashkey = $.mobile.dialogHashKey;
activePage = $.mobile.activePage;
currentIsDialog = ( activePage ? activePage.hasClass( "ui-dialog" ) : false );
this._myUrl = url = urlHistory.getActive().url;
hasHash = ( url.indexOf( hashkey ) > -1 ) && !currentIsDialog && ( urlHistory.activeIndex > 0 );
if ( hasHash ) {
self._open( options );
self._bindContainerClose();
return this;
}
// if the current url has no dialog hash key proceed as normal
// otherwise, if the page is a dialog simply tack on the hash key
if ( url.indexOf( hashkey ) === -1 && !currentIsDialog ) {
url = url + (url.indexOf( "#" ) > -1 ? hashkey : "#" + hashkey);
} else {
url = $.mobile.path.parseLocation().hash + hashkey;
}
// Tack on an extra hashkey if this is the first page and we've just reconstructed the initial hash
if ( urlHistory.activeIndex === 0 && url === urlHistory.initialDst ) {
url += hashkey;
}
// swallow the the initial navigation event, and bind for the next
this.window.one( "beforenavigate", function( theEvent ) {
theEvent.preventDefault();
self._open( options );
self._bindContainerClose();
});
this.urlAltered = true;
$.mobile.navigate( url, { role: "dialog" } );
return this;
},
close: function() {
// make sure close is idempotent
if ( $.mobile.popup.active !== this ) {
return this;
}
this._scrollTop = this.window.scrollTop();
if ( this.options.history && this.urlAltered ) {
$.mobile.back();
this.urlAltered = false;
} else {
// simulate the nav bindings having fired
this._closePopup();
}
return this;
}
});
// TODO this can be moved inside the widget
$.mobile.popup.handleLink = function( $link ) {
var offset,
path = $.mobile.path,
// NOTE make sure to get only the hash from the href because ie7 (wp7)
// returns the absolute href in this case ruining the element selection
popup = $( path.hashToSelector( path.parseUrl( $link.attr( "href" ) ).hash ) ).first();
if ( popup.length > 0 && popup.data( "mobile-popup" ) ) {
offset = $link.offset();
popup.popup( "open", {
x: offset.left + $link.outerWidth() / 2,
y: offset.top + $link.outerHeight() / 2,
transition: $link.jqmData( "transition" ),
positionTo: $link.jqmData( "position-to" )
});
}
//remove after delay
setTimeout( function() {
$link.removeClass( $.mobile.activeBtnClass );
}, 300 );
};
// TODO move inside _create
$.mobile.document.on( "pagebeforechange", function( theEvent, data ) {
if ( data.options.role === "popup" ) {
$.mobile.popup.handleLink( data.options.link );
theEvent.preventDefault();
}
});
})( jQuery );
/*
* custom "selectmenu" plugin
*/
(function( $, undefined ) {
var unfocusableItemSelector = ".ui-disabled,.ui-state-disabled,.ui-li-divider,.ui-screen-hidden,:jqmData(role='placeholder')",
goToAdjacentItem = function( item, target, direction ) {
var adjacent = item[ direction + "All" ]()
.not( unfocusableItemSelector )
.first();
// if there's a previous option, focus it
if ( adjacent.length ) {
target
.blur()
.attr( "tabindex", "-1" );
adjacent.find( "a" ).first().focus();
}
};
$.widget( "mobile.selectmenu", $.mobile.selectmenu, {
_create: function() {
var o = this.options;
// Custom selects cannot exist inside popups, so revert the "nativeMenu"
// option to true if a parent is a popup
o.nativeMenu = o.nativeMenu || ( this.element.parents( ":jqmData(role='popup'),:mobile-popup" ).length > 0 );
return this._super();
},
_handleSelectFocus: function() {
this.element.blur();
this.button.focus();
},
_handleKeydown: function( event ) {
this._super( event );
this._handleButtonVclickKeydown( event );
},
_handleButtonVclickKeydown: function( event ) {
if ( this.options.disabled || this.isOpen || this.options.nativeMenu ) {
return;
}
if (event.type === "vclick" ||
event.keyCode && (event.keyCode === $.mobile.keyCode.ENTER || event.keyCode === $.mobile.keyCode.SPACE)) {
this._decideFormat();
if ( this.menuType === "overlay" ) {
this.button.attr( "href", "#" + this.popupId ).attr( "data-" + ( $.mobile.ns || "" ) + "rel", "popup" );
} else {
this.button.attr( "href", "#" + this.dialogId ).attr( "data-" + ( $.mobile.ns || "" ) + "rel", "dialog" );
}
this.isOpen = true;
// Do not prevent default, so the navigation may have a chance to actually open the chosen format
}
},
_handleListFocus: function( e ) {
var params = ( e.type === "focusin" ) ?
{ tabindex: "0", event: "vmouseover" }:
{ tabindex: "-1", event: "vmouseout" };
$( e.target )
.attr( "tabindex", params.tabindex )
.trigger( params.event );
},
_handleListKeydown: function( event ) {
var target = $( event.target ),
li = target.closest( "li" );
// switch logic based on which key was pressed
switch ( event.keyCode ) {
// up or left arrow keys
case 38:
goToAdjacentItem( li, target, "prev" );
return false;
// down or right arrow keys
case 40:
goToAdjacentItem( li, target, "next" );
return false;
// If enter or space is pressed, trigger click
case 13:
case 32:
target.trigger( "click" );
return false;
}
},
_handleMenuPageHide: function() {
// After the dialog's done, we may want to trigger change if the value has actually changed
this._delayedTrigger();
// TODO centralize page removal binding / handling in the page plugin.
// Suggestion from @jblas to do refcounting
//
// TODO extremely confusing dependency on the open method where the pagehide.remove
// bindings are stripped to prevent the parent page from disappearing. The way
// we're keeping pages in the DOM right now sucks
//
// rebind the page remove that was unbound in the open function
// to allow for the parent page removal from actions other than the use
// of a dialog sized custom select
//
// doing this here provides for the back button on the custom select dialog
this.thisPage.page( "bindRemove" );
},
_handleHeaderCloseClick: function() {
if ( this.menuType === "overlay" ) {
this.close();
return false;
}
},
_handleListItemClick: function( event ) {
var listItem = $( event.target ).closest( "li" ),
// Index of option tag to be selected
oldIndex = this.select[ 0 ].selectedIndex,
newIndex = $.mobile.getAttribute( listItem, "option-index" ),
option = this._selectOptions().eq( newIndex )[ 0 ];
// Toggle selected status on the tag for multi selects
option.selected = this.isMultiple ? !option.selected : true;
// Toggle checkbox class for multiple selects
if ( this.isMultiple ) {
listItem.find( "a" )
.toggleClass( "ui-checkbox-on", option.selected )
.toggleClass( "ui-checkbox-off", !option.selected );
}
// If it's not a multiple select, trigger change after it has finished closing
if ( !this.isMultiple && oldIndex !== newIndex ) {
this._triggerChange = true;
}
// Trigger change if it's a multiple select
// Hide custom select for single selects only - otherwise focus clicked item
// We need to grab the clicked item the hard way, because the list may have been rebuilt
if ( this.isMultiple ) {
this.select.trigger( "change" );
this.list.find( "li:not(.ui-li-divider)" ).eq( newIndex )
.find( "a" ).first().focus();
}
else {
this.close();
}
event.preventDefault();
},
build: function() {
var selectId, popupId, dialogId, label, thisPage, isMultiple, menuId,
themeAttr, overlayTheme, overlayThemeAttr, dividerThemeAttr,
menuPage, listbox, list, header, headerTitle, menuPageContent,
menuPageClose, headerClose,
o = this.options;
if ( o.nativeMenu ) {
return this._super();
}
selectId = this.selectId;
popupId = selectId + "-listbox";
dialogId = selectId + "-dialog";
label = this.label;
thisPage = this.element.closest( ".ui-page" );
isMultiple = this.element[ 0 ].multiple;
menuId = selectId + "-menu";
themeAttr = o.theme ? ( " data-" + $.mobile.ns + "theme='" + o.theme + "'" ) : "";
overlayTheme = o.overlayTheme || o.theme || null;
overlayThemeAttr = overlayTheme ? ( " data-" + $.mobile.ns +
"overlay-theme='" + overlayTheme + "'" ) : "";
dividerThemeAttr = ( o.dividerTheme && isMultiple ) ? ( " data-" + $.mobile.ns + "divider-theme='" + o.dividerTheme + "'" ) : "";
menuPage = $( "<div data-" + $.mobile.ns + "role='dialog' class='ui-selectmenu' id='" + dialogId + "'" + themeAttr + overlayThemeAttr + ">" +
"<div data-" + $.mobile.ns + "role='header'>" +
"<div class='ui-title'></div>"+
"</div>"+
"<div data-" + $.mobile.ns + "role='content'></div>"+
"</div>" );
listbox = $( "<div" + themeAttr + overlayThemeAttr + " id='" + popupId +
"' class='ui-selectmenu'></div>" )
.insertAfter( this.select )
.popup();
list = $( "<ul class='ui-selectmenu-list' id='" + menuId + "' role='listbox' aria-labelledby='" + this.buttonId + "'" + themeAttr + dividerThemeAttr + "></ul>" ).appendTo( listbox );
header = $( "<div class='ui-header ui-bar-" + ( o.theme ? o.theme : "inherit" ) + "'></div>" ).prependTo( listbox );
headerTitle = $( "<h1 class='ui-title'></h1>" ).appendTo( header );
if ( this.isMultiple ) {
headerClose = $( "<a>", {
"role": "button",
"text": o.closeText,
"href": "#",
"class": "ui-btn ui-corner-all ui-btn-left ui-btn-icon-notext ui-icon-delete"
}).appendTo( header );
}
$.extend( this, {
selectId: selectId,
menuId: menuId,
popupId: popupId,
dialogId: dialogId,
thisPage: thisPage,
menuPage: menuPage,
label: label,
isMultiple: isMultiple,
theme: o.theme,
listbox: listbox,
list: list,
header: header,
headerTitle: headerTitle,
headerClose: headerClose,
menuPageContent: menuPageContent,
menuPageClose: menuPageClose,
placeholder: ""
});
// Create list from select, update state
this.refresh();
if ( this._origTabIndex === undefined ) {
// Map undefined to false, because this._origTabIndex === undefined
// indicates that we have not yet checked whether the select has
// originally had a tabindex attribute, whereas false indicates that
// we have checked the select for such an attribute, and have found
// none present.
this._origTabIndex = ( this.select[ 0 ].getAttribute( "tabindex" ) === null ) ? false : this.select.attr( "tabindex" );
}
this.select.attr( "tabindex", "-1" );
this._on( this.select, { focus : "_handleSelectFocus" } );
// Button events
this._on( this.button, {
vclick: "_handleButtonVclickKeydown"
});
// Events for list items
this.list.attr( "role", "listbox" );
this._on( this.list, {
"focusin": "_handleListFocus",
"focusout": "_handleListFocus",
"keydown": "_handleListKeydown",
"click li:not(.ui-disabled,.ui-state-disabled,.ui-li-divider)": "_handleListItemClick"
});
// button refocus ensures proper height calculation
// by removing the inline style and ensuring page inclusion
this._on( this.menuPage, { pagehide: "_handleMenuPageHide" } );
// Events on the popup
this._on( this.listbox, { popupafterclose: "_popupClosed" } );
// Close button on small overlays
if ( this.isMultiple ) {
this._on( this.headerClose, { click: "_handleHeaderCloseClick" } );
}
return this;
},
_popupClosed: function() {
this.close();
this._delayedTrigger();
},
_delayedTrigger: function() {
if ( this._triggerChange ) {
this.element.trigger( "change" );
}
this._triggerChange = false;
},
_isRebuildRequired: function() {
var list = this.list.find( "li" ),
options = this._selectOptions().not( ".ui-screen-hidden" );
// TODO exceedingly naive method to determine difference
// ignores value changes etc in favor of a forcedRebuild
// from the user in the refresh method
return options.text() !== list.text();
},
selected: function() {
return this._selectOptions().filter( ":selected:not( :jqmData(placeholder='true') )" );
},
refresh: function( force ) {
var self, indices;
if ( this.options.nativeMenu ) {
return this._super( force );
}
self = this;
if ( force || this._isRebuildRequired() ) {
self._buildList();
}
indices = this.selectedIndices();
self.setButtonText();
self.setButtonCount();
self.list.find( "li:not(.ui-li-divider)" )
.find( "a" ).removeClass( $.mobile.activeBtnClass ).end()
.attr( "aria-selected", false )
.each(function( i ) {
if ( $.inArray( i, indices ) > -1 ) {
var item = $( this );
// Aria selected attr
item.attr( "aria-selected", true );
// Multiple selects: add the "on" checkbox state to the icon
if ( self.isMultiple ) {
item.find( "a" ).removeClass( "ui-checkbox-off" ).addClass( "ui-checkbox-on" );
} else {
if ( item.hasClass( "ui-screen-hidden" ) ) {
item.next().find( "a" ).addClass( $.mobile.activeBtnClass );
} else {
item.find( "a" ).addClass( $.mobile.activeBtnClass );
}
}
}
});
},
close: function() {
if ( this.options.disabled || !this.isOpen ) {
return;
}
var self = this;
if ( self.menuType === "page" ) {
self.menuPage.dialog( "close" );
self.list.appendTo( self.listbox );
} else {
self.listbox.popup( "close" );
}
self._focusButton();
// allow the dialog to be closed again
self.isOpen = false;
},
open: function() {
this.button.click();
},
_focusMenuItem: function() {
var selector = this.list.find( "a." + $.mobile.activeBtnClass );
if ( selector.length === 0 ) {
selector = this.list.find( "li:not(" + unfocusableItemSelector + ") a.ui-btn" );
}
selector.first().focus();
},
_decideFormat: function() {
var self = this,
$window = this.window,
selfListParent = self.list.parent(),
menuHeight = selfListParent.outerHeight(),
scrollTop = $window.scrollTop(),
btnOffset = self.button.offset().top,
screenHeight = $window.height();
if ( menuHeight > screenHeight - 80 || !$.support.scrollTop ) {
self.menuPage.appendTo( $.mobile.pageContainer ).page();
self.menuPageContent = self.menuPage.find( ".ui-content" );
self.menuPageClose = self.menuPage.find( ".ui-header a" );
// prevent the parent page from being removed from the DOM,
// otherwise the results of selecting a list item in the dialog
// fall into a black hole
self.thisPage.unbind( "pagehide.remove" );
//for WebOS/Opera Mini (set lastscroll using button offset)
if ( scrollTop === 0 && btnOffset > screenHeight ) {
self.thisPage.one( "pagehide", function() {
$( this ).jqmData( "lastScroll", btnOffset );
});
}
self.menuPage.one( {
pageshow: $.proxy( this, "_focusMenuItem" ),
pagehide: $.proxy( this, "close" )
});
self.menuType = "page";
self.menuPageContent.append( self.list );
self.menuPage
.find( "div .ui-title" )
.text( self.label.getEncodedText() || self.placeholder );
} else {
self.menuType = "overlay";
self.listbox.one( { popupafteropen: $.proxy( this, "_focusMenuItem" ) } );
}
},
_buildList: function() {
var self = this,
o = this.options,
placeholder = this.placeholder,
needPlaceholder = true,
dataIcon = "false",
$options, numOptions, select,
dataPrefix = "data-" + $.mobile.ns,
dataIndexAttr = dataPrefix + "option-index",
dataIconAttr = dataPrefix + "icon",
dataRoleAttr = dataPrefix + "role",
dataPlaceholderAttr = dataPrefix + "placeholder",
fragment = document.createDocumentFragment(),
isPlaceholderItem = false,
optGroup,
i,
option, $option, parent, text, anchor, classes,
optLabel, divider, item;
self.list.empty().filter( ".ui-listview" ).listview( "destroy" );
$options = this._selectOptions();
numOptions = $options.length;
select = this.select[ 0 ];
for ( i = 0; i < numOptions;i++, isPlaceholderItem = false) {
option = $options[i];
$option = $( option );
// Do not create options based on ui-screen-hidden select options
if ( $option.hasClass( "ui-screen-hidden" ) ) {
continue;
}
parent = option.parentNode;
text = $option.getEncodedText();
anchor = document.createElement( "a" );
classes = [];
anchor.setAttribute( "href", "#" );
anchor.appendChild( document.createTextNode( text ) );
// Are we inside an optgroup?
if ( parent !== select && parent.nodeName.toLowerCase() === "optgroup" ) {
optLabel = parent.getAttribute( "label" );
if ( optLabel !== optGroup ) {
divider = document.createElement( "li" );
divider.setAttribute( dataRoleAttr, "list-divider" );
divider.setAttribute( "role", "option" );
divider.setAttribute( "tabindex", "-1" );
divider.appendChild( document.createTextNode( optLabel ) );
fragment.appendChild( divider );
optGroup = optLabel;
}
}
if ( needPlaceholder && ( !option.getAttribute( "value" ) || text.length === 0 || $option.jqmData( "placeholder" ) ) ) {
needPlaceholder = false;
isPlaceholderItem = true;
// If we have identified a placeholder, record the fact that it was
// us who have added the placeholder to the option and mark it
// retroactively in the select as well
if ( null === option.getAttribute( dataPlaceholderAttr ) ) {
this._removePlaceholderAttr = true;
}
option.setAttribute( dataPlaceholderAttr, true );
if ( o.hidePlaceholderMenuItems ) {
classes.push( "ui-screen-hidden" );
}
if ( placeholder !== text ) {
placeholder = self.placeholder = text;
}
}
item = document.createElement( "li" );
if ( option.disabled ) {
classes.push( "ui-state-disabled" );
item.setAttribute( "aria-disabled", true );
}
item.setAttribute( dataIndexAttr, i );
item.setAttribute( dataIconAttr, dataIcon );
if ( isPlaceholderItem ) {
item.setAttribute( dataPlaceholderAttr, true );
}
item.className = classes.join( " " );
item.setAttribute( "role", "option" );
anchor.setAttribute( "tabindex", "-1" );
if ( this.isMultiple ) {
$( anchor ).addClass( "ui-btn ui-checkbox-off ui-btn-icon-right" );
}
item.appendChild( anchor );
fragment.appendChild( item );
}
self.list[0].appendChild( fragment );
// Hide header if it's not a multiselect and there's no placeholder
if ( !this.isMultiple && !placeholder.length ) {
this.header.addClass( "ui-screen-hidden" );
} else {
this.headerTitle.text( this.placeholder );
}
// Now populated, create listview
self.list.listview();
},
_button: function() {
return this.options.nativeMenu ?
this._super() :
$( "<a>", {
"href": "#",
"role": "button",
// TODO value is undefined at creation
"id": this.buttonId,
"aria-haspopup": "true",
// TODO value is undefined at creation
"aria-owns": this.menuId
});
},
_destroy: function() {
if ( !this.options.nativeMenu ) {
this.close();
// Restore the tabindex attribute to its original value
if ( this._origTabIndex !== undefined ) {
if ( this._origTabIndex !== false ) {
this.select.attr( "tabindex", this._origTabIndex );
} else {
this.select.removeAttr( "tabindex" );
}
}
// Remove the placeholder attribute if we were the ones to add it
if ( this._removePlaceholderAttr ) {
this._selectOptions().removeAttr( "data-" + $.mobile.ns + "placeholder" );
}
// Remove the popup
this.listbox.remove();
// Remove the dialog
this.menuPage.remove();
}
// Chain up
this._super();
}
});
})( jQuery );
// buttonMarkup is deprecated as of 1.4.0 and will be removed in 1.5.0.
(function( $, undefined ) {
// General policy: Do not access data-* attributes except during enhancement.
// In all other cases we determine the state of the button exclusively from its
// className. That's why optionsToClasses expects a full complement of options,
// and the jQuery plugin completes the set of options from the default values.
// Map classes to buttonMarkup boolean options - used in classNameToOptions()
var reverseBoolOptionMap = {
"ui-shadow" : "shadow",
"ui-corner-all" : "corners",
"ui-btn-inline" : "inline",
"ui-shadow-icon" : "iconshadow", /* TODO: Remove in 1.5 */
"ui-mini" : "mini"
},
getAttrFixed = function() {
var ret = $.mobile.getAttribute.apply( this, arguments );
return ( ret == null ? undefined : ret );
},
capitalLettersRE = /[A-Z]/g;
// optionsToClasses:
// @options: A complete set of options to convert to class names.
// @existingClasses: extra classes to add to the result
//
// Converts @options to buttonMarkup classes and returns the result as an array
// that can be converted to an element's className with .join( " " ). All
// possible options must be set inside @options. Use $.fn.buttonMarkup.defaults
// to get a complete set and use $.extend to override your choice of options
// from that set.
function optionsToClasses( options, existingClasses ) {
var classes = existingClasses ? existingClasses : [];
// Add classes to the array - first ui-btn
classes.push( "ui-btn" );
// If there is a theme
if ( options.theme ) {
classes.push( "ui-btn-" + options.theme );
}
// If there's an icon, add the icon-related classes
if ( options.icon ) {
classes = classes.concat([
"ui-icon-" + options.icon,
"ui-btn-icon-" + options.iconpos
]);
if ( options.iconshadow ) {
classes.push( "ui-shadow-icon" ); /* TODO: Remove in 1.5 */
}
}
// Add the appropriate class for each boolean option
if ( options.inline ) {
classes.push( "ui-btn-inline" );
}
if ( options.shadow ) {
classes.push( "ui-shadow" );
}
if ( options.corners ) {
classes.push( "ui-corner-all" );
}
if ( options.mini ) {
classes.push( "ui-mini" );
}
// Create a string from the array and return it
return classes;
}
// classNameToOptions:
// @classes: A string containing a .className-style space-separated class list
//
// Loops over @classes and calculates an options object based on the
// buttonMarkup-related classes it finds. It records unrecognized classes in an
// array.
//
// Returns: An object containing the following items:
//
// "options": buttonMarkup options found to be present because of the
// presence/absence of corresponding classes
//
// "unknownClasses": a string containing all the non-buttonMarkup-related
// classes found in @classes
//
// "alreadyEnhanced": A boolean indicating whether the ui-btn class was among
// those found to be present
function classNameToOptions( classes ) {
var idx, map, unknownClass,
alreadyEnhanced = false,
noIcon = true,
o = {
icon: "",
inline: false,
shadow: false,
corners: false,
iconshadow: false,
mini: false
},
unknownClasses = [];
classes = classes.split( " " );
// Loop over the classes
for ( idx = 0 ; idx < classes.length ; idx++ ) {
// Assume it's an unrecognized class
unknownClass = true;
// Recognize boolean options from the presence of classes
map = reverseBoolOptionMap[ classes[ idx ] ];
if ( map !== undefined ) {
unknownClass = false;
o[ map ] = true;
// Recognize the presence of an icon and establish the icon position
} else if ( classes[ idx ].indexOf( "ui-btn-icon-" ) === 0 ) {
unknownClass = false;
noIcon = false;
o.iconpos = classes[ idx ].substring( 12 );
// Establish which icon is present
} else if ( classes[ idx ].indexOf( "ui-icon-" ) === 0 ) {
unknownClass = false;
o.icon = classes[ idx ].substring( 8 );
// Establish the theme - this recognizes one-letter theme swatch names
} else if ( classes[ idx ].indexOf( "ui-btn-" ) === 0 && classes[ idx ].length === 8 ) {
unknownClass = false;
o.theme = classes[ idx ].substring( 7 );
// Recognize that this element has already been buttonMarkup-enhanced
} else if ( classes[ idx ] === "ui-btn" ) {
unknownClass = false;
alreadyEnhanced = true;
}
// If this class has not been recognized, add it to the list
if ( unknownClass ) {
unknownClasses.push( classes[ idx ] );
}
}
// If a "ui-btn-icon-*" icon position class is absent there cannot be an icon
if ( noIcon ) {
o.icon = "";
}
return {
options: o,
unknownClasses: unknownClasses,
alreadyEnhanced: alreadyEnhanced
};
}
function camelCase2Hyphenated( c ) {
return "-" + c.toLowerCase();
}
// $.fn.buttonMarkup:
// DOM: gets/sets .className
//
// @options: options to apply to the elements in the jQuery object
// @overwriteClasses: boolean indicating whether to honour existing classes
//
// Calculates the classes to apply to the elements in the jQuery object based on
// the options passed in. If @overwriteClasses is true, it sets the className
// property of each element in the jQuery object to the buttonMarkup classes
// it calculates based on the options passed in.
//
// If you wish to preserve any classes that are already present on the elements
// inside the jQuery object, including buttonMarkup-related classes that were
// added by a previous call to $.fn.buttonMarkup() or during page enhancement
// then you should omit @overwriteClasses or set it to false.
$.fn.buttonMarkup = function( options, overwriteClasses ) {
var idx, data, el, retrievedOptions, optionKey,
defaults = $.fn.buttonMarkup.defaults;
for ( idx = 0 ; idx < this.length ; idx++ ) {
el = this[ idx ];
data = overwriteClasses ?
// Assume this element is not enhanced and ignore its classes
{ alreadyEnhanced: false, unknownClasses: [] } :
// Otherwise analyze existing classes to establish existing options and
// classes
classNameToOptions( el.className );
retrievedOptions = $.extend( {},
// If the element already has the class ui-btn, then we assume that
// it has passed through buttonMarkup before - otherwise, the options
// returned by classNameToOptions do not correctly reflect the state of
// the element
( data.alreadyEnhanced ? data.options : {} ),
// Finally, apply the options passed in
options );
// If this is the first call on this element, retrieve remaining options
// from the data-attributes
if ( !data.alreadyEnhanced ) {
for ( optionKey in defaults ) {
if ( retrievedOptions[ optionKey ] === undefined ) {
retrievedOptions[ optionKey ] = getAttrFixed( el,
optionKey.replace( capitalLettersRE, camelCase2Hyphenated )
);
}
}
}
el.className = optionsToClasses(
// Merge all the options and apply them as classes
$.extend( {},
// The defaults form the basis
defaults,
// Add the computed options
retrievedOptions
),
// ... and re-apply any unrecognized classes that were found
data.unknownClasses ).join( " " );
if ( el.tagName.toLowerCase() !== "button" ) {
el.setAttribute( "role", "button" );
}
}
return this;
};
// buttonMarkup defaults. This must be a complete set, i.e., a value must be
// given here for all recognized options
$.fn.buttonMarkup.defaults = {
icon: "",
iconpos: "left",
theme: null,
inline: false,
shadow: true,
corners: true,
iconshadow: false, /* TODO: Remove in 1.5. Option deprecated in 1.4. */
mini: false
};
$.extend( $.fn.buttonMarkup, {
initSelector: "a:jqmData(role='button'), .ui-bar > a, .ui-bar > :jqmData(role='controlgroup') > a, button"
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.controlgroup", $.extend( {
options: {
enhanced: false,
theme: null,
shadow: false,
corners: true,
excludeInvisible: true,
type: "vertical",
mini: false
},
_create: function() {
var elem = this.element,
opts = this.options;
// Run buttonmarkup
if ( $.fn.buttonMarkup ) {
this.element.find( $.fn.buttonMarkup.initSelector ).buttonMarkup();
}
// Enhance child widgets
$.each( this._childWidgets, $.proxy( function( number, widgetName ) {
if ( $.mobile[ widgetName ] ) {
this.element.find( $.mobile[ widgetName ].initSelector ).not( $.mobile.page.prototype.keepNativeSelector() )[ widgetName ]();
}
}, this ));
$.extend( this, {
_ui: null,
_initialRefresh: true
});
if ( opts.enhanced ) {
this._ui = {
groupLegend: elem.children( ".ui-controlgroup-label" ).children(),
childWrapper: elem.children( ".ui-controlgroup-controls" )
};
} else {
this._ui = this._enhance();
}
},
_childWidgets: [ "checkboxradio", "selectmenu", "button" ],
_themeClassFromOption: function( value ) {
return ( value ? ( value === "none" ? "" : "ui-group-theme-" + value ) : "" );
},
_enhance: function() {
var elem = this.element,
opts = this.options,
ui = {
groupLegend: elem.children( "legend" ),
childWrapper: elem
.addClass( "ui-controlgroup " +
"ui-controlgroup-" +
( opts.type === "horizontal" ? "horizontal" : "vertical" ) + " " +
this._themeClassFromOption( opts.theme ) + " " +
( opts.corners ? "ui-corner-all " : "" ) +
( opts.mini ? "ui-mini " : "" ) )
.wrapInner( "<div " +
"class='ui-controlgroup-controls " +
( opts.shadow === true ? "ui-shadow" : "" ) + "'></div>" )
.children()
};
if ( ui.groupLegend.length > 0 ) {
$( "<div role='heading' class='ui-controlgroup-label'></div>" )
.append( ui.groupLegend )
.prependTo( elem );
}
return ui;
},
_init: function() {
this.refresh();
},
_setOptions: function( options ) {
var callRefresh, returnValue,
elem = this.element;
// Must have one of horizontal or vertical
if ( options.type !== undefined ) {
elem
.removeClass( "ui-controlgroup-horizontal ui-controlgroup-vertical" )
.addClass( "ui-controlgroup-" + ( options.type === "horizontal" ? "horizontal" : "vertical" ) );
callRefresh = true;
}
if ( options.theme !== undefined ) {
elem
.removeClass( this._themeClassFromOption( this.options.theme ) )
.addClass( this._themeClassFromOption( options.theme ) );
}
if ( options.corners !== undefined ) {
elem.toggleClass( "ui-corner-all", options.corners );
}
if ( options.mini !== undefined ) {
elem.toggleClass( "ui-mini", options.mini );
}
if ( options.shadow !== undefined ) {
this._ui.childWrapper.toggleClass( "ui-shadow", options.shadow );
}
if ( options.excludeInvisible !== undefined ) {
this.options.excludeInvisible = options.excludeInvisible;
callRefresh = true;
}
returnValue = this._super( options );
if ( callRefresh ) {
this.refresh();
}
return returnValue;
},
container: function() {
return this._ui.childWrapper;
},
refresh: function() {
var $el = this.container(),
els = $el.find( ".ui-btn" ).not( ".ui-slider-handle" ),
create = this._initialRefresh;
if ( $.mobile.checkboxradio ) {
$el.find( ":mobile-checkboxradio" ).checkboxradio( "refresh" );
}
this._addFirstLastClasses( els,
this.options.excludeInvisible ? this._getVisibles( els, create ) : els,
create );
this._initialRefresh = false;
},
// Caveat: If the legend is not the first child of the controlgroup at enhance
// time, it will be after _destroy().
_destroy: function() {
var ui, buttons,
opts = this.options;
if ( opts.enhanced ) {
return this;
}
ui = this._ui;
buttons = this.element
.removeClass( "ui-controlgroup " +
"ui-controlgroup-horizontal ui-controlgroup-vertical ui-corner-all ui-mini " +
this._themeClassFromOption( opts.theme ) )
.find( ".ui-btn" )
.not( ".ui-slider-handle" );
this._removeFirstLastClasses( buttons );
ui.groupLegend.unwrap();
ui.childWrapper.children().unwrap();
}
}, $.mobile.behaviors.addFirstLastClasses ) );
})(jQuery);
(function( $, undefined ) {
$.widget( "mobile.toolbar", {
initSelector: ":jqmData(role='footer'), :jqmData(role='header')",
options: {
theme: null,
addBackBtn: false,
backBtnTheme: null,
backBtnText: "Back"
},
_create: function() {
var leftbtn, rightbtn,
role = this.element.is( ":jqmData(role='header')" ) ? "header" : "footer",
page = this.element.closest( ".ui-page" );
if ( page.length === 0 ) {
page = false;
this._on( this.document, {
"pageshow": "refresh"
});
}
$.extend( this, {
role: role,
page: page,
leftbtn: leftbtn,
rightbtn: rightbtn
});
this.element.attr( "role", role === "header" ? "banner" : "contentinfo" ).addClass( "ui-" + role );
this.refresh();
this._setOptions( this.options );
},
_setOptions: function( o ) {
if ( o.addBackBtn !== undefined ) {
this._updateBackButton();
}
if ( o.backBtnTheme != null ) {
this.element
.find( ".ui-toolbar-back-btn" )
.addClass( "ui-btn ui-btn-" + o.backBtnTheme );
}
if ( o.backBtnText !== undefined ) {
this.element.find( ".ui-toolbar-back-btn .ui-btn-text" ).text( o.backBtnText );
}
if ( o.theme !== undefined ) {
var currentTheme = this.options.theme ? this.options.theme : "inherit",
newTheme = o.theme ? o.theme : "inherit";
this.element.removeClass( "ui-bar-" + currentTheme ).addClass( "ui-bar-" + newTheme );
}
this._super( o );
},
refresh: function() {
if ( this.role === "header" ) {
this._addHeaderButtonClasses();
}
if ( !this.page ) {
this._setRelative();
if ( this.role === "footer" ) {
this.element.appendTo( "body" );
} else if ( this.role === "header" ) {
this._updateBackButton();
}
}
this._addHeadingClasses();
this._btnMarkup();
},
//we only want this to run on non fixed toolbars so make it easy to override
_setRelative: function() {
$( "[data-"+ $.mobile.ns + "role='page']" ).css({ "position": "relative" });
},
// Deprecated in 1.4. As from 1.5 button classes have to be present in the markup.
_btnMarkup: function() {
this.element
.children( "a" )
.filter( ":not([data-" + $.mobile.ns + "role='none'])" )
.attr( "data-" + $.mobile.ns + "role", "button" );
this.element.trigger( "create" );
},
// Deprecated in 1.4. As from 1.5 ui-btn-left/right classes have to be present in the markup.
_addHeaderButtonClasses: function() {
var headerAnchors = this.element.children( "a, button" );
// Do not mistake a back button for a left toolbar button
this.leftbtn = headerAnchors.hasClass( "ui-btn-left" ) &&
!headerAnchors.hasClass( "ui-toolbar-back-btn" );
this.rightbtn = headerAnchors.hasClass( "ui-btn-right" );
// Filter out right buttons and back buttons
this.leftbtn = this.leftbtn ||
headerAnchors.eq( 0 )
.not( ".ui-btn-right,.ui-toolbar-back-btn" )
.addClass( "ui-btn-left" )
.length;
this.rightbtn = this.rightbtn || headerAnchors.eq( 1 ).addClass( "ui-btn-right" ).length;
},
_updateBackButton: function() {
var backButton,
options = this.options,
theme = options.backBtnTheme || options.theme;
// Retrieve the back button or create a new, empty one
backButton = this._backButton = ( this._backButton || {} );
// We add a back button only if the option to do so is on
if ( this.options.addBackBtn &&
// This must also be a header toolbar
this.role === "header" &&
// There must be multiple pages in the DOM
$( ".ui-page" ).length > 1 &&
( this.page ?
// If the toolbar is internal the page's URL must differ from the hash
( this.page[ 0 ].getAttribute( "data-" + $.mobile.ns + "url" ) !==
$.mobile.path.stripHash( location.hash ) ) :
// Otherwise, if the toolbar is external there must be at least one
// history item to which one can go back
( $.mobile.navigate && $.mobile.navigate.history &&
$.mobile.navigate.history.activeIndex > 0 ) ) &&
// The toolbar does not have a left button
!this.leftbtn ) {
// Skip back button creation if one is already present
if ( !backButton.attached ) {
backButton.element = ( backButton.element ||
$( "<a role='button' href='javascript:void(0);' " +
"class='ui-btn ui-corner-all ui-shadow ui-btn-left " +
( theme ? "ui-btn-" + theme + " " : "" ) +
"ui-toolbar-back-btn ui-icon-carat-l ui-btn-icon-left' " +
"data-" + $.mobile.ns + "rel='back'>" + options.backBtnText +
"</a>" ) )
.prependTo( this.element );
backButton.attached = true;
}
// If we are not adding a back button, then remove the one present, if any
} else if ( backButton.element ) {
backButton.element.detach();
backButton.attached = false;
}
},
_addHeadingClasses: function() {
this.element.children( "h1, h2, h3, h4, h5, h6" )
.addClass( "ui-title" )
// Regardless of h element number in src, it becomes h1 for the enhanced page
.attr({
"role": "heading",
"aria-level": "1"
});
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.toolbar", $.mobile.toolbar, {
options: {
position:null,
visibleOnPageShow: true,
disablePageZoom: true,
transition: "slide", //can be none, fade, slide (slide maps to slideup or slidedown)
fullscreen: false,
tapToggle: true,
tapToggleBlacklist: "a, button, input, select, textarea, .ui-header-fixed, .ui-footer-fixed, .ui-flipswitch, .ui-popup, .ui-panel, .ui-panel-dismiss-open",
hideDuringFocus: "input, textarea, select",
updatePagePadding: true,
trackPersistentToolbars: true,
// Browser detection! Weeee, here we go...
// Unfortunately, position:fixed is costly, not to mention probably impossible, to feature-detect accurately.
// Some tests exist, but they currently return false results in critical devices and browsers, which could lead to a broken experience.
// Testing fixed positioning is also pretty obtrusive to page load, requiring injected elements and scrolling the window
// The following function serves to rule out some popular browsers with known fixed-positioning issues
// This is a plugin option like any other, so feel free to improve or overwrite it
supportBlacklist: function() {
return !$.support.fixedPosition;
}
},
_create: function() {
this._super();
if ( this.options.position === "fixed" && !this.options.supportBlacklist() ) {
this._makeFixed();
}
},
_makeFixed: function() {
this.element.addClass( "ui-"+ this.role +"-fixed" );
this.updatePagePadding();
this._addTransitionClass();
this._bindPageEvents();
this._bindToggleHandlers();
},
_setOptions: function( o ) {
if ( o.position === "fixed" && this.options.position !== "fixed" ) {
this._makeFixed();
}
if ( this.options.position === "fixed" && !this.options.supportBlacklist() ) {
var $page = ( !!this.page )? this.page: ( $(".ui-page-active").length > 0 )? $(".ui-page-active"): $(".ui-page").eq(0);
if ( o.fullscreen !== undefined) {
if ( o.fullscreen ) {
this.element.addClass( "ui-"+ this.role +"-fullscreen" );
$page.addClass( "ui-page-" + this.role + "-fullscreen" );
}
// If not fullscreen, add class to page to set top or bottom padding
else {
this.element.removeClass( "ui-"+ this.role +"-fullscreen" );
$page.removeClass( "ui-page-" + this.role + "-fullscreen" ).addClass( "ui-page-" + this.role+ "-fixed" );
}
}
}
this._super(o);
},
_addTransitionClass: function() {
var tclass = this.options.transition;
if ( tclass && tclass !== "none" ) {
// use appropriate slide for header or footer
if ( tclass === "slide" ) {
tclass = this.element.hasClass( "ui-header" ) ? "slidedown" : "slideup";
}
this.element.addClass( tclass );
}
},
_bindPageEvents: function() {
var page = ( !!this.page )? this.element.closest( ".ui-page" ): this.document;
//page event bindings
// Fixed toolbars require page zoom to be disabled, otherwise usability issues crop up
// This method is meant to disable zoom while a fixed-positioned toolbar page is visible
this._on( page , {
"pagebeforeshow": "_handlePageBeforeShow",
"webkitAnimationStart":"_handleAnimationStart",
"animationstart":"_handleAnimationStart",
"updatelayout": "_handleAnimationStart",
"pageshow": "_handlePageShow",
"pagebeforehide": "_handlePageBeforeHide"
});
},
_handlePageBeforeShow: function( ) {
var o = this.options;
if ( o.disablePageZoom ) {
$.mobile.zoom.disable( true );
}
if ( !o.visibleOnPageShow ) {
this.hide( true );
}
},
_handleAnimationStart: function() {
if ( this.options.updatePagePadding ) {
this.updatePagePadding( ( !!this.page )? this.page: ".ui-page-active" );
}
},
_handlePageShow: function() {
this.updatePagePadding( ( !!this.page )? this.page: ".ui-page-active" );
if ( this.options.updatePagePadding ) {
this._on( this.window, { "throttledresize": "updatePagePadding" } );
}
},
_handlePageBeforeHide: function( e, ui ) {
var o = this.options,
thisFooter, thisHeader, nextFooter, nextHeader;
if ( o.disablePageZoom ) {
$.mobile.zoom.enable( true );
}
if ( o.updatePagePadding ) {
this._off( this.window, "throttledresize" );
}
if ( o.trackPersistentToolbars ) {
thisFooter = $( ".ui-footer-fixed:jqmData(id)", this.page );
thisHeader = $( ".ui-header-fixed:jqmData(id)", this.page );
nextFooter = thisFooter.length && ui.nextPage && $( ".ui-footer-fixed:jqmData(id='" + thisFooter.jqmData( "id" ) + "')", ui.nextPage ) || $();
nextHeader = thisHeader.length && ui.nextPage && $( ".ui-header-fixed:jqmData(id='" + thisHeader.jqmData( "id" ) + "')", ui.nextPage ) || $();
if ( nextFooter.length || nextHeader.length ) {
nextFooter.add( nextHeader ).appendTo( $.mobile.pageContainer );
ui.nextPage.one( "pageshow", function() {
nextHeader.prependTo( this );
nextFooter.appendTo( this );
});
}
}
},
_visible: true,
// This will set the content element's top or bottom padding equal to the toolbar's height
updatePagePadding: function( tbPage ) {
var $el = this.element,
header = ( this.role ==="header" ),
pos = parseFloat( $el.css( header ? "top" : "bottom" ) );
// This behavior only applies to "fixed", not "fullscreen"
if ( this.options.fullscreen ) { return; }
// tbPage argument can be a Page object or an event, if coming from throttled resize.
tbPage = ( tbPage && tbPage.type === undefined && tbPage ) || this.page || $el.closest( ".ui-page" );
tbPage = ( !!this.page )? this.page: ".ui-page-active";
$( tbPage ).css( "padding-" + ( header ? "top" : "bottom" ), $el.outerHeight() + pos );
},
_useTransition: function( notransition ) {
var $win = this.window,
$el = this.element,
scroll = $win.scrollTop(),
elHeight = $el.height(),
pHeight = ( !!this.page )? $el.closest( ".ui-page" ).height():$(".ui-page-active").height(),
viewportHeight = $.mobile.getScreenHeight();
return !notransition &&
( this.options.transition && this.options.transition !== "none" &&
(
( this.role === "header" && !this.options.fullscreen && scroll > elHeight ) ||
( this.role === "footer" && !this.options.fullscreen && scroll + viewportHeight < pHeight - elHeight )
) || this.options.fullscreen
);
},
show: function( notransition ) {
var hideClass = "ui-fixed-hidden",
$el = this.element;
if ( this._useTransition( notransition ) ) {
$el
.removeClass( "out " + hideClass )
.addClass( "in" )
.animationComplete(function () {
$el.removeClass( "in" );
});
}
else {
$el.removeClass( hideClass );
}
this._visible = true;
},
hide: function( notransition ) {
var hideClass = "ui-fixed-hidden",
$el = this.element,
// if it's a slide transition, our new transitions need the reverse class as well to slide outward
outclass = "out" + ( this.options.transition === "slide" ? " reverse" : "" );
if ( this._useTransition( notransition ) ) {
$el
.addClass( outclass )
.removeClass( "in" )
.animationComplete(function() {
$el.addClass( hideClass ).removeClass( outclass );
});
}
else {
$el.addClass( hideClass ).removeClass( outclass );
}
this._visible = false;
},
toggle: function() {
this[ this._visible ? "hide" : "show" ]();
},
_bindToggleHandlers: function() {
var self = this,
o = self.options,
delayShow, delayHide,
isVisible = true,
page = ( !!this.page )? this.page: $(".ui-page");
// tap toggle
page
.bind( "vclick", function( e ) {
if ( o.tapToggle && !$( e.target ).closest( o.tapToggleBlacklist ).length ) {
self.toggle();
}
})
.bind( "focusin focusout", function( e ) {
//this hides the toolbars on a keyboard pop to give more screen room and prevent ios bug which
//positions fixed toolbars in the middle of the screen on pop if the input is near the top or
//bottom of the screen addresses issues #4410 Footer navbar moves up when clicking on a textbox in an Android environment
//and issue #4113 Header and footer change their position after keyboard popup - iOS
//and issue #4410 Footer navbar moves up when clicking on a textbox in an Android environment
if ( screen.width < 1025 && $( e.target ).is( o.hideDuringFocus ) && !$( e.target ).closest( ".ui-header-fixed, .ui-footer-fixed" ).length ) {
//Fix for issue #4724 Moving through form in Mobile Safari with "Next" and "Previous" system
//controls causes fixed position, tap-toggle false Header to reveal itself
// isVisible instead of self._visible because the focusin and focusout events fire twice at the same time
// Also use a delay for hiding the toolbars because on Android native browser focusin is direclty followed
// by a focusout when a native selects opens and the other way around when it closes.
if ( e.type === "focusout" && !isVisible ) {
isVisible = true;
//wait for the stack to unwind and see if we have jumped to another input
clearTimeout( delayHide );
delayShow = setTimeout( function() {
self.show();
}, 0 );
} else if ( e.type === "focusin" && !!isVisible ) {
//if we have jumped to another input clear the time out to cancel the show.
clearTimeout( delayShow );
isVisible = false;
delayHide = setTimeout( function() {
self.hide();
}, 0 );
}
}
});
},
_setRelative: function() {
if( this.options.position !== "fixed" ){
$( "[data-"+ $.mobile.ns + "role='page']" ).css({ "position": "relative" });
}
},
_destroy: function() {
var $el = this.element,
header = $el.hasClass( "ui-header" );
$el.closest( ".ui-page" ).css( "padding-" + ( header ? "top" : "bottom" ), "" );
$el.removeClass( "ui-header-fixed ui-footer-fixed ui-header-fullscreen ui-footer-fullscreen in out fade slidedown slideup ui-fixed-hidden" );
$el.closest( ".ui-page" ).removeClass( "ui-page-header-fixed ui-page-footer-fixed ui-page-header-fullscreen ui-page-footer-fullscreen" );
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.toolbar", $.mobile.toolbar, {
_makeFixed: function() {
this._super();
this._workarounds();
},
//check the browser and version and run needed workarounds
_workarounds: function() {
var ua = navigator.userAgent,
platform = navigator.platform,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match( /AppleWebKit\/([0-9]+)/ ),
wkversion = !!wkmatch && wkmatch[ 1 ],
os = null,
self = this;
//set the os we are working in if it dosent match one with workarounds return
if ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1 || platform.indexOf( "iPod" ) > -1 ) {
os = "ios";
} else if ( ua.indexOf( "Android" ) > -1 ) {
os = "android";
} else {
return;
}
//check os version if it dosent match one with workarounds return
if ( os === "ios" ) {
//iOS workarounds
self._bindScrollWorkaround();
} else if ( os === "android" && wkversion && wkversion < 534 ) {
//Android 2.3 run all Android 2.3 workaround
self._bindScrollWorkaround();
self._bindListThumbWorkaround();
} else {
return;
}
},
//Utility class for checking header and footer positions relative to viewport
_viewportOffset: function() {
var $el = this.element,
header = $el.hasClass( "ui-header" ),
offset = Math.abs( $el.offset().top - this.window.scrollTop() );
if ( !header ) {
offset = Math.round( offset - this.window.height() + $el.outerHeight() ) - 60;
}
return offset;
},
//bind events for _triggerRedraw() function
_bindScrollWorkaround: function() {
var self = this;
//bind to scrollstop and check if the toolbars are correctly positioned
this._on( this.window, { scrollstop: function() {
var viewportOffset = self._viewportOffset();
//check if the header is visible and if its in the right place
if ( viewportOffset > 2 && self._visible ) {
self._triggerRedraw();
}
}});
},
//this addresses issue #4250 Persistent footer instability in v1.1 with long select lists in Android 2.3.3
//and issue #3748 Android 2.x: Page transitions broken when fixed toolbars used
//the absolutely positioned thumbnail in a list view causes problems with fixed position buttons above in a nav bar
//setting the li's to -webkit-transform:translate3d(0,0,0); solves this problem to avoide potential issues in other
//platforms we scope this with the class ui-android-2x-fix
_bindListThumbWorkaround: function() {
this.element.closest( ".ui-page" ).addClass( "ui-android-2x-fixed" );
},
//this addresses issues #4337 Fixed header problem after scrolling content on iOS and Android
//and device bugs project issue #1 Form elements can lose click hit area in position: fixed containers.
//this also addresses not on fixed toolbars page in docs
//adding 1px of padding to the bottom then removing it causes a "redraw"
//which positions the toolbars correctly (they will always be visually correct)
_triggerRedraw: function() {
var paddingBottom = parseFloat( $( ".ui-page-active" ).css( "padding-bottom" ) );
//trigger page redraw to fix incorrectly positioned fixed elements
$( ".ui-page-active" ).css( "padding-bottom", ( paddingBottom + 1 ) + "px" );
//if the padding is reset with out a timeout the reposition will not occure.
//this is independant of JQM the browser seems to need the time to react.
setTimeout( function() {
$( ".ui-page-active" ).css( "padding-bottom", paddingBottom + "px" );
}, 0 );
},
destroy: function() {
this._super();
//Remove the class we added to the page previously in android 2.x
this.element.closest( ".ui-page-active" ).removeClass( "ui-android-2x-fix" );
}
});
})( jQuery );
( function( $, undefined ) {
var ieHack = ( $.mobile.browser.oldIE && $.mobile.browser.oldIE <= 8 ),
uiTemplate = $(
"<div class='ui-popup-arrow-guide'></div>" +
"<div class='ui-popup-arrow-container" + ( ieHack ? " ie" : "" ) + "'>" +
"<div class='ui-popup-arrow'></div>" +
"</div>"
);
function getArrow() {
var clone = uiTemplate.clone(),
gd = clone.eq( 0 ),
ct = clone.eq( 1 ),
ar = ct.children();
return { arEls: ct.add( gd ), gd: gd, ct: ct, ar: ar };
}
$.widget( "mobile.popup", $.mobile.popup, {
options: {
arrow: ""
},
_create: function() {
var ar,
ret = this._super();
if ( this.options.arrow ) {
this._ui.arrow = ar = this._addArrow();
}
return ret;
},
_addArrow: function() {
var theme,
opts = this.options,
ar = getArrow();
theme = this._themeClassFromOption( "ui-body-", opts.theme );
ar.ar.addClass( theme + ( opts.shadow ? " ui-overlay-shadow" : "" ) );
ar.arEls.hide().appendTo( this.element );
return ar;
},
_unenhance: function() {
var ar = this._ui.arrow;
if ( ar ) {
ar.arEls.remove();
}
return this._super();
},
// Pretend to show an arrow described by @p and @dir and calculate the
// distance from the desired point. If a best-distance is passed in, return
// the minimum of the one passed in and the one calculated.
_tryAnArrow: function( p, dir, desired, s, best ) {
var result, r, diff, desiredForArrow = {}, tip = {};
// If the arrow has no wiggle room along the edge of the popup, it cannot
// be displayed along the requested edge without it sticking out.
if ( s.arFull[ p.dimKey ] > s.guideDims[ p.dimKey ] ) {
return best;
}
desiredForArrow[ p.fst ] = desired[ p.fst ] +
( s.arHalf[ p.oDimKey ] + s.menuHalf[ p.oDimKey ] ) * p.offsetFactor -
s.contentBox[ p.fst ] + ( s.clampInfo.menuSize[ p.oDimKey ] - s.contentBox[ p.oDimKey ] ) * p.arrowOffsetFactor;
desiredForArrow[ p.snd ] = desired[ p.snd ];
result = s.result || this._calculateFinalLocation( desiredForArrow, s.clampInfo );
r = { x: result.left, y: result.top };
tip[ p.fst ] = r[ p.fst ] + s.contentBox[ p.fst ] + p.tipOffset;
tip[ p.snd ] = Math.max( result[ p.prop ] + s.guideOffset[ p.prop ] + s.arHalf[ p.dimKey ],
Math.min( result[ p.prop ] + s.guideOffset[ p.prop ] + s.guideDims[ p.dimKey ] - s.arHalf[ p.dimKey ],
desired[ p.snd ] ) );
diff = Math.abs( desired.x - tip.x ) + Math.abs( desired.y - tip.y );
if ( !best || diff < best.diff ) {
// Convert tip offset to coordinates inside the popup
tip[ p.snd ] -= s.arHalf[ p.dimKey ] + result[ p.prop ] + s.contentBox[ p.snd ];
best = { dir: dir, diff: diff, result: result, posProp: p.prop, posVal: tip[ p.snd ] };
}
return best;
},
_getPlacementState: function( clamp ) {
var offset, gdOffset,
ar = this._ui.arrow,
state = {
clampInfo: this._clampPopupWidth( !clamp ),
arFull: { cx: ar.ct.width(), cy: ar.ct.height() },
guideDims: { cx: ar.gd.width(), cy: ar.gd.height() },
guideOffset: ar.gd.offset()
};
offset = this.element.offset();
ar.gd.css( { left: 0, top: 0, right: 0, bottom: 0 } );
gdOffset = ar.gd.offset();
state.contentBox = {
x: gdOffset.left - offset.left,
y: gdOffset.top - offset.top,
cx: ar.gd.width(),
cy: ar.gd.height()
};
ar.gd.removeAttr( "style" );
// The arrow box moves between guideOffset and guideOffset + guideDims - arFull
state.guideOffset = { left: state.guideOffset.left - offset.left, top: state.guideOffset.top - offset.top };
state.arHalf = { cx: state.arFull.cx / 2, cy: state.arFull.cy / 2 };
state.menuHalf = { cx: state.clampInfo.menuSize.cx / 2, cy: state.clampInfo.menuSize.cy / 2 };
return state;
},
_placementCoords: function( desired ) {
var state, best, params, elOffset, bgRef,
optionValue = this.options.arrow,
ar = this._ui.arrow;
if ( !ar ) {
return this._super( desired );
}
ar.arEls.show();
bgRef = {};
state = this._getPlacementState( true );
params = {
"l": { fst: "x", snd: "y", prop: "top", dimKey: "cy", oDimKey: "cx", offsetFactor: 1, tipOffset: -state.arHalf.cx, arrowOffsetFactor: 0 },
"r": { fst: "x", snd: "y", prop: "top", dimKey: "cy", oDimKey: "cx", offsetFactor: -1, tipOffset: state.arHalf.cx + state.contentBox.cx, arrowOffsetFactor: 1 },
"b": { fst: "y", snd: "x", prop: "left", dimKey: "cx", oDimKey: "cy", offsetFactor: -1, tipOffset: state.arHalf.cy + state.contentBox.cy, arrowOffsetFactor: 1 },
"t": { fst: "y", snd: "x", prop: "left", dimKey: "cx", oDimKey: "cy", offsetFactor: 1, tipOffset: -state.arHalf.cy, arrowOffsetFactor: 0 }
};
// Try each side specified in the options to see on which one the arrow
// should be placed such that the distance between the tip of the arrow and
// the desired coordinates is the shortest.
$.each( ( optionValue === true ? "l,t,r,b" : optionValue ).split( "," ),
$.proxy( function( key, value ) {
best = this._tryAnArrow( params[ value ], value, desired, state, best );
}, this ) );
// Could not place the arrow along any of the edges - behave as if showing
// the arrow was turned off.
if ( !best ) {
ar.arEls.hide();
return this._super( desired );
}
// Move the arrow into place
ar.ct
.removeClass( "ui-popup-arrow-l ui-popup-arrow-t ui-popup-arrow-r ui-popup-arrow-b" )
.addClass( "ui-popup-arrow-" + best.dir )
.removeAttr( "style" ).css( best.posProp, best.posVal )
.show();
// Do not move/size the background div on IE, because we use the arrow div for background as well.
if ( !ieHack ) {
elOffset = this.element.offset();
bgRef[ params[ best.dir ].fst ] = ar.ct.offset();
bgRef[ params[ best.dir ].snd ] = {
left: elOffset.left + state.contentBox.x,
top: elOffset.top + state.contentBox.y
};
}
return best.result;
},
_setOptions: function( opts ) {
var newTheme,
oldTheme = this.options.theme,
ar = this._ui.arrow,
ret = this._super( opts );
if ( opts.arrow !== undefined ) {
if ( !ar && opts.arrow ) {
this._ui.arrow = this._addArrow();
// Important to return here so we don't set the same options all over
// again below.
return;
} else if ( ar && !opts.arrow ) {
ar.arEls.remove();
this._ui.arrow = null;
}
}
// Reassign with potentially new arrow
ar = this._ui.arrow;
if ( ar ) {
if ( opts.theme !== undefined ) {
oldTheme = this._themeClassFromOption( "ui-body-", oldTheme );
newTheme = this._themeClassFromOption( "ui-body-", opts.theme );
ar.ar.removeClass( oldTheme ).addClass( newTheme );
}
if ( opts.shadow !== undefined ) {
ar.ar.toggleClass( "ui-overlay-shadow", opts.shadow );
}
}
return ret;
},
_destroy: function() {
var ar = this._ui.arrow;
if ( ar ) {
ar.arEls.remove();
}
return this._super();
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.panel", {
options: {
classes: {
panel: "ui-panel",
panelOpen: "ui-panel-open",
panelClosed: "ui-panel-closed",
panelFixed: "ui-panel-fixed",
panelInner: "ui-panel-inner",
modal: "ui-panel-dismiss",
modalOpen: "ui-panel-dismiss-open",
pageContainer: "ui-panel-page-container",
pageWrapper: "ui-panel-wrapper",
pageFixedToolbar: "ui-panel-fixed-toolbar",
pageContentPrefix: "ui-panel-page-content", /* Used for wrapper and fixed toolbars position, display and open classes. */
animate: "ui-panel-animate"
},
animate: true,
theme: null,
position: "left",
dismissible: true,
display: "reveal", //accepts reveal, push, overlay
swipeClose: true,
positionFixed: false
},
_closeLink: null,
_parentPage: null,
_page: null,
_modal: null,
_panelInner: null,
_wrapper: null,
_fixedToolbars: null,
_create: function() {
var el = this.element,
parentPage = el.closest( ".ui-page, :jqmData(role='page')" );
// expose some private props to other methods
$.extend( this, {
_closeLink: el.find( ":jqmData(rel='close')" ),
_parentPage: ( parentPage.length > 0 ) ? parentPage : false,
_openedPage: null,
_page: this._getPage,
_panelInner: this._getPanelInner(),
_fixedToolbars: this._getFixedToolbars
});
if ( this.options.display !== "overlay" ){
this._getWrapper();
}
this._addPanelClasses();
// if animating, add the class to do so
if ( $.support.cssTransform3d && !!this.options.animate ) {
this.element.addClass( this.options.classes.animate );
}
this._bindUpdateLayout();
this._bindCloseEvents();
this._bindLinkListeners();
this._bindPageEvents();
if ( !!this.options.dismissible ) {
this._createModal();
}
this._bindSwipeEvents();
},
_getPanelInner: function() {
var panelInner = this.element.find( "." + this.options.classes.panelInner );
if ( panelInner.length === 0 ) {
panelInner = this.element.children().wrapAll( "<div class='" + this.options.classes.panelInner + "' />" ).parent();
}
return panelInner;
},
_createModal: function() {
var self = this,
target = self._parentPage ? self._parentPage.parent() : self.element.parent();
self._modal = $( "<div class='" + self.options.classes.modal + "'></div>" )
.on( "mousedown", function() {
self.close();
})
.appendTo( target );
},
_getPage: function() {
var page = this._openedPage || this._parentPage || $( "." + $.mobile.activePageClass );
return page;
},
_getWrapper: function() {
var wrapper = this._page().find( "." + this.options.classes.pageWrapper );
if ( wrapper.length === 0 ) {
wrapper = this._page().children( ".ui-header:not(.ui-header-fixed), .ui-content:not(.ui-popup), .ui-footer:not(.ui-footer-fixed)" )
.wrapAll( "<div class='" + this.options.classes.pageWrapper + "'></div>" )
.parent();
}
this._wrapper = wrapper;
},
_getFixedToolbars: function() {
var extFixedToolbars = $( "body" ).children( ".ui-header-fixed, .ui-footer-fixed" ),
intFixedToolbars = this._page().find( ".ui-header-fixed, .ui-footer-fixed" ),
fixedToolbars = extFixedToolbars.add( intFixedToolbars ).addClass( this.options.classes.pageFixedToolbar );
return fixedToolbars;
},
_getPosDisplayClasses: function( prefix ) {
return prefix + "-position-" + this.options.position + " " + prefix + "-display-" + this.options.display;
},
_getPanelClasses: function() {
var panelClasses = this.options.classes.panel +
" " + this._getPosDisplayClasses( this.options.classes.panel ) +
" " + this.options.classes.panelClosed +
" " + "ui-body-" + ( this.options.theme ? this.options.theme : "inherit" );
if ( !!this.options.positionFixed ) {
panelClasses += " " + this.options.classes.panelFixed;
}
return panelClasses;
},
_addPanelClasses: function() {
this.element.addClass( this._getPanelClasses() );
},
_handleCloseClick: function( event ) {
if ( !event.isDefaultPrevented() ) {
this.close();
}
},
_bindCloseEvents: function() {
this._on( this._closeLink, {
"click": "_handleCloseClick"
});
this._on({
"click a:jqmData(ajax='false')": "_handleCloseClick"
});
},
_positionPanel: function( scrollToTop ) {
var self = this,
panelInnerHeight = self._panelInner.outerHeight(),
expand = panelInnerHeight > $.mobile.getScreenHeight();
if ( expand || !self.options.positionFixed ) {
if ( expand ) {
self._unfixPanel();
$.mobile.resetActivePageHeight( panelInnerHeight );
}
if ( scrollToTop ) {
this.window[ 0 ].scrollTo( 0, $.mobile.defaultHomeScroll );
}
} else {
self._fixPanel();
}
},
_bindFixListener: function() {
this._on( $( window ), { "throttledresize": "_positionPanel" });
},
_unbindFixListener: function() {
this._off( $( window ), "throttledresize" );
},
_unfixPanel: function() {
if ( !!this.options.positionFixed && $.support.fixedPosition ) {
this.element.removeClass( this.options.classes.panelFixed );
}
},
_fixPanel: function() {
if ( !!this.options.positionFixed && $.support.fixedPosition ) {
this.element.addClass( this.options.classes.panelFixed );
}
},
_bindUpdateLayout: function() {
var self = this;
self.element.on( "updatelayout", function(/* e */) {
if ( self._open ) {
self._positionPanel();
}
});
},
_bindLinkListeners: function() {
this._on( "body", {
"click a": "_handleClick"
});
},
_handleClick: function( e ) {
var link,
panelId = this.element.attr( "id" );
if ( e.currentTarget.href.split( "#" )[ 1 ] === panelId && panelId !== undefined ) {
e.preventDefault();
link = $( e.target );
if ( link.hasClass( "ui-btn" ) ) {
link.addClass( $.mobile.activeBtnClass );
this.element.one( "panelopen panelclose", function() {
link.removeClass( $.mobile.activeBtnClass );
});
}
this.toggle();
}
},
_bindSwipeEvents: function() {
var self = this,
area = self._modal ? self.element.add( self._modal ) : self.element;
// on swipe, close the panel
if ( !!self.options.swipeClose ) {
if ( self.options.position === "left" ) {
area.on( "swipeleft.panel", function(/* e */) {
self.close();
});
} else {
area.on( "swiperight.panel", function(/* e */) {
self.close();
});
}
}
},
_bindPageEvents: function() {
var self = this;
this.document
// Close the panel if another panel on the page opens
.on( "panelbeforeopen", function( e ) {
if ( self._open && e.target !== self.element[ 0 ] ) {
self.close();
}
})
// On escape, close? might need to have a target check too...
.on( "keyup.panel", function( e ) {
if ( e.keyCode === 27 && self._open ) {
self.close();
}
});
if ( !this._parentPage && this.options.display !== "overlay" ) {
this._on( this.document, {
"pageshow": "_getWrapper"
});
}
// Clean up open panels after page hide
if ( self._parentPage ) {
this.document.on( "pagehide", ":jqmData(role='page')", function() {
if ( self._open ) {
self.close( true );
}
});
} else {
this.document.on( "pagebeforehide", function() {
if ( self._open ) {
self.close( true );
}
});
}
},
// state storage of open or closed
_open: false,
_pageContentOpenClasses: null,
_modalOpenClasses: null,
open: function( immediate ) {
if ( !this._open ) {
var self = this,
o = self.options,
_openPanel = function() {
self._off( self.document , "panelclose" );
self._page().jqmData( "panel", "open" );
if ( $.support.cssTransform3d && !!o.animate && o.display !== "overlay" ) {
self._wrapper.addClass( o.classes.animate );
self._fixedToolbars().addClass( o.classes.animate );
}
if ( !immediate && $.support.cssTransform3d && !!o.animate ) {
( self._wrapper || self.element )
.animationComplete( complete, "transition" );
} else {
setTimeout( complete, 0 );
}
if ( o.theme && o.display !== "overlay" ) {
self._page().parent()
.addClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme );
}
self.element
.removeClass( o.classes.panelClosed )
.addClass( o.classes.panelOpen );
self._positionPanel( true );
self._pageContentOpenClasses = self._getPosDisplayClasses( o.classes.pageContentPrefix );
if ( o.display !== "overlay" ) {
self._page().parent().addClass( o.classes.pageContainer );
self._wrapper.addClass( self._pageContentOpenClasses );
self._fixedToolbars().addClass( self._pageContentOpenClasses );
}
self._modalOpenClasses = self._getPosDisplayClasses( o.classes.modal ) + " " + o.classes.modalOpen;
if ( self._modal ) {
self._modal
.addClass( self._modalOpenClasses )
.height( Math.max( self._modal.height(), self.document.height() ) );
}
},
complete = function() {
// Bail if the panel was closed before the opening animation has completed
if ( !self._open ) {
return;
}
if ( o.display !== "overlay" ) {
self._wrapper.addClass( o.classes.pageContentPrefix + "-open" );
self._fixedToolbars().addClass( o.classes.pageContentPrefix + "-open" );
}
self._bindFixListener();
self._trigger( "open" );
self._openedPage = self._page();
};
self._trigger( "beforeopen" );
if ( self._page().jqmData( "panel" ) === "open" ) {
self._on( self.document, {
"panelclose": _openPanel
});
} else {
_openPanel();
}
self._open = true;
}
},
close: function( immediate ) {
if ( this._open ) {
var self = this,
o = this.options,
_closePanel = function() {
self.element.removeClass( o.classes.panelOpen );
if ( o.display !== "overlay" ) {
self._wrapper.removeClass( self._pageContentOpenClasses );
self._fixedToolbars().removeClass( self._pageContentOpenClasses );
}
if ( !immediate && $.support.cssTransform3d && !!o.animate ) {
( self._wrapper || self.element )
.animationComplete( complete, "transition" );
} else {
setTimeout( complete, 0 );
}
if ( self._modal ) {
self._modal
.removeClass( self._modalOpenClasses )
.height( "" );
}
},
complete = function() {
if ( o.theme && o.display !== "overlay" ) {
self._page().parent().removeClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme );
}
self.element.addClass( o.classes.panelClosed );
if ( o.display !== "overlay" ) {
self._page().parent().removeClass( o.classes.pageContainer );
self._wrapper.removeClass( o.classes.pageContentPrefix + "-open" );
self._fixedToolbars().removeClass( o.classes.pageContentPrefix + "-open" );
}
if ( $.support.cssTransform3d && !!o.animate && o.display !== "overlay" ) {
self._wrapper.removeClass( o.classes.animate );
self._fixedToolbars().removeClass( o.classes.animate );
}
self._fixPanel();
self._unbindFixListener();
$.mobile.resetActivePageHeight();
self._page().jqmRemoveData( "panel" );
self._trigger( "close" );
self._openedPage = null;
};
self._trigger( "beforeclose" );
_closePanel();
self._open = false;
}
},
toggle: function() {
this[ this._open ? "close" : "open" ]();
},
_destroy: function() {
var otherPanels,
o = this.options,
multiplePanels = ( $( "body > :mobile-panel" ).length + $.mobile.activePage.find( ":mobile-panel" ).length ) > 1;
if ( o.display !== "overlay" ) {
// remove the wrapper if not in use by another panel
otherPanels = $( "body > :mobile-panel" ).add( $.mobile.activePage.find( ":mobile-panel" ) );
if ( otherPanels.not( ".ui-panel-display-overlay" ).not( this.element ).length === 0 ) {
this._wrapper.children().unwrap();
}
if ( this._open ) {
this._fixedToolbars().removeClass( o.classes.pageContentPrefix + "-open" );
if ( $.support.cssTransform3d && !!o.animate ) {
this._fixedToolbars().removeClass( o.classes.animate );
}
this._page().parent().removeClass( o.classes.pageContainer );
if ( o.theme ) {
this._page().parent().removeClass( o.classes.pageContainer + "-themed " + o.classes.pageContainer + "-" + o.theme );
}
}
}
if ( !multiplePanels ) {
this.document.off( "panelopen panelclose" );
}
if ( this._open ) {
this._page().jqmRemoveData( "panel" );
}
this._panelInner.children().unwrap();
this.element
.removeClass( [ this._getPanelClasses(), o.classes.panelOpen, o.classes.animate ].join( " " ) )
.off( "swipeleft.panel swiperight.panel" )
.off( "panelbeforeopen" )
.off( "panelhide" )
.off( "keyup.panel" )
.off( "updatelayout" );
if ( this._modal ) {
this._modal.remove();
}
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.table", {
options: {
classes: {
table: "ui-table"
},
enhanced: false
},
_create: function() {
if ( !this.options.enhanced ) {
this.element.addClass( this.options.classes.table );
}
// extend here, assign on refresh > _setHeaders
$.extend( this, {
// Expose headers and allHeaders properties on the widget
// headers references the THs within the first TR in the table
headers: undefined,
// allHeaders references headers, plus all THs in the thead, which may
// include several rows, or not
allHeaders: undefined
});
this._refresh( true );
},
_setHeaders: function() {
var trs = this.element.find( "thead tr" );
this.headers = this.element.find( "tr:eq(0)" ).children();
this.allHeaders = this.headers.add( trs.children() );
},
refresh: function() {
this._refresh();
},
rebuild: $.noop,
_refresh: function( /* create */ ) {
var table = this.element,
trs = table.find( "thead tr" );
// updating headers on refresh (fixes #5880)
this._setHeaders();
// Iterate over the trs
trs.each( function() {
var columnCount = 0;
// Iterate over the children of the tr
$( this ).children().each( function() {
var span = parseInt( this.getAttribute( "colspan" ), 10 ),
selector = ":nth-child(" + ( columnCount + 1 ) + ")",
j;
this.setAttribute( "data-" + $.mobile.ns + "colstart", columnCount + 1 );
if ( span ) {
for( j = 0; j < span - 1; j++ ) {
columnCount++;
selector += ", :nth-child(" + ( columnCount + 1 ) + ")";
}
}
// Store "cells" data on header as a reference to all cells in the
// same column as this TH
$( this ).jqmData( "cells", table.find( "tr" ).not( trs.eq( 0 ) ).not( this ).children( selector ) );
columnCount++;
});
});
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.table", $.mobile.table, {
options: {
mode: "columntoggle",
columnBtnTheme: null,
columnPopupTheme: null,
columnBtnText: "Columns...",
classes: $.extend( $.mobile.table.prototype.options.classes, {
popup: "ui-table-columntoggle-popup",
columnBtn: "ui-table-columntoggle-btn",
priorityPrefix: "ui-table-priority-",
columnToggleTable: "ui-table-columntoggle"
})
},
_create: function() {
this._super();
if ( this.options.mode !== "columntoggle" ) {
return;
}
$.extend( this, {
_menu: null
});
if ( this.options.enhanced ) {
this._menu = $( this.document[ 0 ].getElementById( this._id() + "-popup" ) ).children().first();
this._addToggles( this._menu, true );
} else {
this._menu = this._enhanceColToggle();
this.element.addClass( this.options.classes.columnToggleTable );
}
this._setupEvents();
this._setToggleState();
},
_id: function() {
return ( this.element.attr( "id" ) || ( this.widgetName + this.uuid ) );
},
_setupEvents: function() {
//NOTE: inputs are bound in bindToggles,
// so it can be called on refresh, too
// update column toggles on resize
this._on( this.window, {
throttledresize: "_setToggleState"
});
this._on( this._menu, {
"change input": "_menuInputChange"
});
},
_addToggles: function( menu, keep ) {
var inputs,
checkboxIndex = 0,
opts = this.options,
container = menu.controlgroup( "container" );
// allow update of menu on refresh (fixes #5880)
if ( keep ) {
inputs = menu.find( "input" );
} else {
container.empty();
}
// create the hide/show toggles
this.headers.not( "td" ).each( function() {
var input, cells,
header = $( this ),
priority = $.mobile.getAttribute( this, "priority" );
if ( priority ) {
cells = header.add( header.jqmData( "cells" ) );
cells.addClass( opts.classes.priorityPrefix + priority );
// Make sure the (new?) checkbox is associated with its header via .jqmData() and
// that, vice versa, the header is also associated with the checkbox
input = ( keep ? inputs.eq( checkboxIndex++ ) :
$("<label><input type='checkbox' checked />" +
( header.children( "abbr" ).first().attr( "title" ) ||
header.text() ) +
"</label>" )
.appendTo( container )
.children( 0 )
.checkboxradio( {
theme: opts.columnPopupTheme
}) )
// Associate the header with the checkbox
.jqmData( "header", header )
.jqmData( "cells", cells );
// Associate the checkbox with the header
header.jqmData( "input", input );
}
});
// set bindings here
if ( !keep ) {
menu.controlgroup( "refresh" );
}
},
_menuInputChange: function( evt ) {
var input = $( evt.target ),
checked = input[ 0 ].checked;
input.jqmData( "cells" )
.toggleClass( "ui-table-cell-hidden", !checked )
.toggleClass( "ui-table-cell-visible", checked );
},
_unlockCells: function( cells ) {
// allow hide/show via CSS only = remove all toggle-locks
cells.removeClass( "ui-table-cell-hidden ui-table-cell-visible");
},
_enhanceColToggle: function() {
var id , menuButton, popup, menu,
table = this.element,
opts = this.options,
ns = $.mobile.ns,
fragment = this.document[ 0 ].createDocumentFragment();
id = this._id() + "-popup";
menuButton = $( "<a href='#" + id + "' " +
"class='" + opts.classes.columnBtn + " ui-btn " +
"ui-btn-" + ( opts.columnBtnTheme || "a" ) +
" ui-corner-all ui-shadow ui-mini' " +
"data-" + ns + "rel='popup'>" + opts.columnBtnText + "</a>" );
popup = $( "<div class='" + opts.classes.popup + "' id='" + id + "'></div>" );
menu = $( "<fieldset></fieldset>" ).controlgroup();
// set extension here, send "false" to trigger build/rebuild
this._addToggles( menu, false );
menu.appendTo( popup );
fragment.appendChild( popup[ 0 ] );
fragment.appendChild( menuButton[ 0 ] );
table.before( fragment );
popup.popup();
return menu;
},
rebuild: function() {
this._super();
if ( this.options.mode === "columntoggle" ) {
// NOTE: rebuild passes "false", while refresh passes "undefined"
// both refresh the table, but inside addToggles, !false will be true,
// so a rebuild call can be indentified
this._refresh( false );
}
},
_refresh: function( create ) {
var headers, hiddenColumns, index;
// Calling _super() here updates this.headers
this._super( create );
if ( !create && this.options.mode === "columntoggle" ) {
headers = this.headers;
hiddenColumns = [];
// Find the index of the column header associated with each old checkbox among the
// post-refresh headers and, if the header is still there, make sure the corresponding
// column will be hidden if the pre-refresh checkbox indicates that the column is
// hidden by recording its index in the array of hidden columns.
this._menu.find( "input" ).each( function() {
var input = $( this ),
header = input.jqmData( "header" ),
index = headers.index( header[ 0 ] );
if ( index > -1 && !input.prop( "checked" ) ) {
// The column header associated with /this/ checkbox is still present in the
// post-refresh table and the checkbox is not checked, so the column associated
// with this column header is currently hidden. Let's record that.
hiddenColumns.push( index );
}
});
// columns not being replaced must be cleared from input toggle-locks
this._unlockCells( this.element.find( ".ui-table-cell-hidden, " +
".ui-table-cell-visible" ) );
// update columntoggles and cells
this._addToggles( this._menu, create );
// At this point all columns are visible, so uncheck the checkboxes that correspond to
// those columns we've found to be hidden
for ( index = hiddenColumns.length - 1 ; index > -1 ; index-- ) {
headers.eq( hiddenColumns[ index ] ).jqmData( "input" )
.prop( "checked", false )
.checkboxradio( "refresh" )
.trigger( "change" );
}
}
},
_setToggleState: function() {
this._menu.find( "input" ).each( function() {
var checkbox = $( this );
this.checked = checkbox.jqmData( "cells" ).eq( 0 ).css( "display" ) === "table-cell";
checkbox.checkboxradio( "refresh" );
});
},
_destroy: function() {
this._super();
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.table", $.mobile.table, {
options: {
mode: "reflow",
classes: $.extend( $.mobile.table.prototype.options.classes, {
reflowTable: "ui-table-reflow",
cellLabels: "ui-table-cell-label"
})
},
_create: function() {
this._super();
// If it's not reflow mode, return here.
if ( this.options.mode !== "reflow" ) {
return;
}
if ( !this.options.enhanced ) {
this.element.addClass( this.options.classes.reflowTable );
this._updateReflow();
}
},
rebuild: function() {
this._super();
if ( this.options.mode === "reflow" ) {
this._refresh( false );
}
},
_refresh: function( create ) {
this._super( create );
if ( !create && this.options.mode === "reflow" ) {
this._updateReflow( );
}
},
_updateReflow: function() {
var table = this,
opts = this.options;
// get headers in reverse order so that top-level headers are appended last
$( table.allHeaders.get().reverse() ).each( function() {
var cells = $( this ).jqmData( "cells" ),
colstart = $.mobile.getAttribute( this, "colstart" ),
hierarchyClass = cells.not( this ).filter( "thead th" ).length && " ui-table-cell-label-top",
contents = $( this ).clone().contents(),
iteration, filter;
if ( contents.length > 0 ) {
if ( hierarchyClass ) {
iteration = parseInt( this.getAttribute( "colspan" ), 10 );
filter = "";
if ( iteration ) {
filter = "td:nth-child("+ iteration +"n + " + ( colstart ) +")";
}
table._addLabels( cells.filter( filter ),
opts.classes.cellLabels + hierarchyClass, contents );
} else {
table._addLabels( cells, opts.classes.cellLabels, contents );
}
}
});
},
_addLabels: function( cells, label, contents ) {
// .not fixes #6006
cells
.not( ":has(b." + label + ")" )
.prepend( $( "<b class='" + label + "'></b>" ).append( contents ) );
}
});
})( jQuery );
(function( $, undefined ) {
// TODO rename filterCallback/deprecate and default to the item itself as the first argument
var defaultFilterCallback = function( index, searchValue ) {
return ( ( "" + ( $.mobile.getAttribute( this, "filtertext" ) || $( this ).text() ) )
.toLowerCase().indexOf( searchValue ) === -1 );
};
$.widget( "mobile.filterable", {
initSelector: ":jqmData(filter='true')",
options: {
filterReveal: false,
filterCallback: defaultFilterCallback,
enhanced: false,
input: null,
children: "> li, > option, > optgroup option, > tbody tr, > .ui-controlgroup-controls > .ui-btn, > .ui-controlgroup-controls > .ui-checkbox, > .ui-controlgroup-controls > .ui-radio"
},
_create: function() {
var opts = this.options;
$.extend( this, {
_search: null,
_timer: 0
});
this._setInput( opts.input );
if ( !opts.enhanced ) {
this._filterItems( ( ( this._search && this._search.val() ) || "" ).toLowerCase() );
}
},
_onKeyUp: function() {
var val, lastval,
search = this._search;
if ( search ) {
val = search.val().toLowerCase(),
lastval = $.mobile.getAttribute( search[ 0 ], "lastval" ) + "";
if ( lastval && lastval === val ) {
// Execute the handler only once per value change
return;
}
if ( this._timer ) {
window.clearTimeout( this._timer );
this._timer = 0;
}
this._timer = this._delay( function() {
if ( this._trigger( "beforefilter", null, { input: search } ) === false ) {
return false;
}
// Change val as lastval for next execution
search[ 0 ].setAttribute( "data-" + $.mobile.ns + "lastval", val );
this._filterItems( val );
this._timer = 0;
}, 250 );
}
},
_getFilterableItems: function() {
var elem = this.element,
children = this.options.children,
items = !children ? { length: 0 }:
$.isFunction( children ) ? children():
children.nodeName ? $( children ):
children.jquery ? children:
this.element.find( children );
if ( items.length === 0 ) {
items = elem.children();
}
return items;
},
_filterItems: function( val ) {
var idx, callback, length, dst,
show = [],
hide = [],
opts = this.options,
filterItems = this._getFilterableItems();
if ( val != null ) {
callback = opts.filterCallback || defaultFilterCallback;
length = filterItems.length;
// Partition the items into those to be hidden and those to be shown
for ( idx = 0 ; idx < length ; idx++ ) {
dst = ( callback.call( filterItems[ idx ], idx, val ) ) ? hide : show;
dst.push( filterItems[ idx ] );
}
}
// If nothing is hidden, then the decision whether to hide or show the items
// is based on the "filterReveal" option.
if ( hide.length === 0 ) {
filterItems[ ( opts.filterReveal && val.length === 0 ) ?
"addClass" : "removeClass" ]( "ui-screen-hidden" );
} else {
$( hide ).addClass( "ui-screen-hidden" );
$( show ).removeClass( "ui-screen-hidden" );
}
this._refreshChildWidget();
this._trigger( "filter", null, {
items: filterItems
});
},
// The Default implementation of _refreshChildWidget attempts to call
// refresh on collapsibleset, controlgroup, selectmenu, or listview
_refreshChildWidget: function() {
var widget, idx,
recognizedWidgets = [ "collapsibleset", "selectmenu", "controlgroup", "listview" ];
for ( idx = recognizedWidgets.length - 1 ; idx > -1 ; idx-- ) {
widget = recognizedWidgets[ idx ];
if ( $.mobile[ widget ] ) {
widget = this.element.data( "mobile-" + widget );
if ( widget && $.isFunction( widget.refresh ) ) {
widget.refresh();
}
}
}
},
// TODO: When the input is not internal, do not even store it in this._search
_setInput: function ( selector ) {
var search = this._search;
// Stop a pending filter operation
if ( this._timer ) {
window.clearTimeout( this._timer );
this._timer = 0;
}
if ( search ) {
this._off( search, "keyup change input" );
search = null;
}
if ( selector ) {
search = selector.jquery ? selector:
selector.nodeName ? $( selector ):
this.document.find( selector );
this._on( search, {
keydown: "_onKeyDown",
keypress: "_onKeyPress",
keyup: "_onKeyUp",
change: "_onKeyUp",
input: "_onKeyUp"
});
}
this._search = search;
},
// Prevent form submission
_onKeyDown: function( event ) {
if ( event.keyCode === $.ui.keyCode.ENTER ) {
event.preventDefault();
this._preventKeyPress = true;
}
},
_onKeyPress: function( event ) {
if ( this._preventKeyPress ) {
event.preventDefault();
this._preventKeyPress = false;
}
},
_setOptions: function( options ) {
var refilter = !( ( options.filterReveal === undefined ) &&
( options.filterCallback === undefined ) &&
( options.children === undefined ) );
this._super( options );
if ( options.input !== undefined ) {
this._setInput( options.input );
refilter = true;
}
if ( refilter ) {
this.refresh();
}
},
_destroy: function() {
var opts = this.options,
items = this._getFilterableItems();
if ( opts.enhanced ) {
items.toggleClass( "ui-screen-hidden", opts.filterReveal );
} else {
items.removeClass( "ui-screen-hidden" );
}
},
refresh: function() {
if ( this._timer ) {
window.clearTimeout( this._timer );
this._timer = 0;
}
this._filterItems( ( ( this._search && this._search.val() ) || "" ).toLowerCase() );
}
});
})( jQuery );
(function( $, undefined ) {
// Create a function that will replace the _setOptions function of a widget,
// and will pass the options on to the input of the filterable.
var replaceSetOptions = function( self, orig ) {
return function( options ) {
orig.call( this, options );
self._syncTextInputOptions( options );
};
},
rDividerListItem = /(^|\s)ui-li-divider(\s|$)/,
origDefaultFilterCallback = $.mobile.filterable.prototype.options.filterCallback;
// Override the default filter callback with one that does not hide list dividers
$.mobile.filterable.prototype.options.filterCallback = function( index, searchValue ) {
return !this.className.match( rDividerListItem ) &&
origDefaultFilterCallback.call( this, index, searchValue );
};
$.widget( "mobile.filterable", $.mobile.filterable, {
options: {
filterPlaceholder: "Filter items...",
filterTheme: null
},
_create: function() {
var idx, widgetName,
elem = this.element,
recognizedWidgets = [ "collapsibleset", "selectmenu", "controlgroup", "listview" ],
createHandlers = {};
this._super();
$.extend( this, {
_widget: null
});
for ( idx = recognizedWidgets.length - 1 ; idx > -1 ; idx-- ) {
widgetName = recognizedWidgets[ idx ];
if ( $.mobile[ widgetName ] ) {
if ( this._setWidget( elem.data( "mobile-" + widgetName ) ) ) {
break;
} else {
createHandlers[ widgetName + "create" ] = "_handleCreate";
}
}
}
if ( !this._widget ) {
this._on( elem, createHandlers );
}
},
_handleCreate: function( evt ) {
this._setWidget( this.element.data( "mobile-" + evt.type.substring( 0, evt.type.length - 6 ) ) );
},
_trigger: function( type, event, data ) {
if ( this._widget && this._widget.widgetFullName === "mobile-listview" &&
type === "beforefilter" ) {
// Also trigger listviewbeforefilter if this widget is also a listview
this._widget._trigger( "beforefilter", event, data );
}
// Passing back the response enables calling preventDefault()
return this._super( type, event, data );
},
_setWidget: function( widget ) {
if ( !this._widget && widget ) {
this._widget = widget;
this._widget._setOptions = replaceSetOptions( this, this._widget._setOptions );
}
if ( !!this._widget ) {
this._syncTextInputOptions( this._widget.options );
if ( this._widget.widgetName === "listview" ) {
this._widget.options.hideDividers = true;
this._widget.element.listview( "refresh" );
}
}
return !!this._widget;
},
_isSearchInternal: function() {
return ( this._search && this._search.jqmData( "ui-filterable-" + this.uuid + "-internal" ) );
},
_setInput: function( selector ) {
var opts = this.options,
updatePlaceholder = true,
textinputOpts = {};
if ( !selector ) {
if ( this._isSearchInternal() ) {
// Ignore the call to set a new input if the selector goes to falsy and
// the current textinput is already of the internally generated variety.
return;
} else {
// Generating a new textinput widget. No need to set the placeholder
// further down the function.
updatePlaceholder = false;
selector = $( "<input " +
"data-" + $.mobile.ns + "type='search' " +
"placeholder='" + opts.filterPlaceholder + "'></input>" )
.jqmData( "ui-filterable-" + this.uuid + "-internal", true );
$( "<form class='ui-filterable'></form>" )
.append( selector )
.submit( function( evt ) {
evt.preventDefault();
selector.blur();
})
.insertBefore( this.element );
if ( $.mobile.textinput ) {
if ( this.options.filterTheme != null ) {
textinputOpts[ "theme" ] = opts.filterTheme;
}
selector.textinput( textinputOpts );
}
}
}
this._super( selector );
if ( this._isSearchInternal() && updatePlaceholder ) {
this._search.attr( "placeholder", this.options.filterPlaceholder );
}
},
_setOptions: function( options ) {
var ret = this._super( options );
// Need to set the filterPlaceholder after having established the search input
if ( options.filterPlaceholder !== undefined ) {
if ( this._isSearchInternal() ) {
this._search.attr( "placeholder", options.filterPlaceholder );
}
}
if ( options.filterTheme !== undefined && this._search && $.mobile.textinput ) {
this._search.textinput( "option", "theme", options.filterTheme );
}
return ret;
},
_destroy: function() {
if ( this._isSearchInternal() ) {
this._search.remove();
}
this._super();
},
_syncTextInputOptions: function( options ) {
var idx,
textinputOptions = {};
// We only sync options if the filterable's textinput is of the internally
// generated variety, rather than one specified by the user.
if ( this._isSearchInternal() && $.mobile.textinput ) {
// Apply only the options understood by textinput
for ( idx in $.mobile.textinput.prototype.options ) {
if ( options[ idx ] !== undefined ) {
if ( idx === "theme" && this.options.filterTheme != null ) {
textinputOptions[ idx ] = this.options.filterTheme;
} else {
textinputOptions[ idx ] = options[ idx ];
}
}
}
this._search.textinput( "option", textinputOptions );
}
}
});
// Instantiate a filterable on a listview that has the data-filter="true" attribute
// This is not necessary for static content, because the auto-enhance takes care of instantiating
// the filterable upon encountering data-filter="true". However, because of 1.3.x it is expected
// that a listview with data-filter="true" will be filterable even if you just instantiate a
// listview on it. The extension below ensures that this continues to happen in 1.4.x.
$.widget( "mobile.listview", $.mobile.listview, {
options: {
filter: false
},
_create: function() {
if ( this.options.filter === true &&
!this.element.data( "mobile-filterable" ) ) {
this.element.filterable();
}
return this._super();
},
_afterListviewRefresh: function() {
var filterable = this.element.data( "mobile-filterable" );
if ( this.options.filter === true && filterable ) {
this._preventRefreshLoop = true;
filterable.refresh();
}
},
// Eliminate infinite recursion caused by the fact that we call filterable.refresh() from
// _afterListviewRefresh() above, which, in turn, calls _refreshChildWidget(), which, in
// turn, calls listview refresh(), which would, in turn, calls _afterListviewRefresh()
// above, if we wouldn't prevent that right here.
refresh: function() {
var returnValue;
if ( !this._preventRefreshLoop ) {
returnValue = this._superApply( arguments );
}
this._preventRefreshLoop = false;
return returnValue;
}
});
})( jQuery );
/*!
* jQuery UI Tabs fadf2b312a05040436451c64bbfaf4814bc62c56
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/tabs/
*
* Depends:
* jquery.ui.core.js
* jquery.ui.widget.js
*/
(function( $, undefined ) {
var tabId = 0,
rhash = /#.*$/;
function getNextTabId() {
return ++tabId;
}
function isLocal( anchor ) {
return anchor.hash.length > 1 &&
decodeURIComponent( anchor.href.replace( rhash, "" ) ) ===
decodeURIComponent( location.href.replace( rhash, "" ) );
}
$.widget( "ui.tabs", {
version: "fadf2b312a05040436451c64bbfaf4814bc62c56",
delay: 300,
options: {
active: null,
collapsible: false,
event: "click",
heightStyle: "content",
hide: null,
show: null,
// callbacks
activate: null,
beforeActivate: null,
beforeLoad: null,
load: null
},
_create: function() {
var that = this,
options = this.options;
this.running = false;
this.element
.addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
.toggleClass( "ui-tabs-collapsible", options.collapsible )
// Prevent users from focusing disabled tabs via click
.delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
if ( $( this ).is( ".ui-state-disabled" ) ) {
event.preventDefault();
}
})
// support: IE <9
// Preventing the default action in mousedown doesn't prevent IE
// from focusing the element, so if the anchor gets focused, blur.
// We don't have to worry about focusing the previously focused
// element since clicking on a non-focusable element should focus
// the body anyway.
.delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
this.blur();
}
});
this._processTabs();
options.active = this._initialActive();
// Take disabling tabs via class attribute from HTML
// into account and update option properly.
if ( $.isArray( options.disabled ) ) {
options.disabled = $.unique( options.disabled.concat(
$.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
return that.tabs.index( li );
})
) ).sort();
}
// check for length avoids error when initializing empty list
if ( this.options.active !== false && this.anchors.length ) {
this.active = this._findActive( options.active );
} else {
this.active = $();
}
this._refresh();
if ( this.active.length ) {
this.load( options.active );
}
},
_initialActive: function() {
var active = this.options.active,
collapsible = this.options.collapsible,
locationHash = location.hash.substring( 1 );
if ( active === null ) {
// check the fragment identifier in the URL
if ( locationHash ) {
this.tabs.each(function( i, tab ) {
if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
active = i;
return false;
}
});
}
// check for a tab marked active via a class
if ( active === null ) {
active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
}
// no active tab, set to false
if ( active === null || active === -1 ) {
active = this.tabs.length ? 0 : false;
}
}
// handle numbers: negative, out of range
if ( active !== false ) {
active = this.tabs.index( this.tabs.eq( active ) );
if ( active === -1 ) {
active = collapsible ? false : 0;
}
}
// don't allow collapsible: false and active: false
if ( !collapsible && active === false && this.anchors.length ) {
active = 0;
}
return active;
},
_getCreateEventData: function() {
return {
tab: this.active,
panel: !this.active.length ? $() : this._getPanelForTab( this.active )
};
},
_tabKeydown: function( event ) {
var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
selectedIndex = this.tabs.index( focusedTab ),
goingForward = true;
if ( this._handlePageNav( event ) ) {
return;
}
switch ( event.keyCode ) {
case $.ui.keyCode.RIGHT:
case $.ui.keyCode.DOWN:
selectedIndex++;
break;
case $.ui.keyCode.UP:
case $.ui.keyCode.LEFT:
goingForward = false;
selectedIndex--;
break;
case $.ui.keyCode.END:
selectedIndex = this.anchors.length - 1;
break;
case $.ui.keyCode.HOME:
selectedIndex = 0;
break;
case $.ui.keyCode.SPACE:
// Activate only, no collapsing
event.preventDefault();
clearTimeout( this.activating );
this._activate( selectedIndex );
return;
case $.ui.keyCode.ENTER:
// Toggle (cancel delayed activation, allow collapsing)
event.preventDefault();
clearTimeout( this.activating );
// Determine if we should collapse or activate
this._activate( selectedIndex === this.options.active ? false : selectedIndex );
return;
default:
return;
}
// Focus the appropriate tab, based on which key was pressed
event.preventDefault();
clearTimeout( this.activating );
selectedIndex = this._focusNextTab( selectedIndex, goingForward );
// Navigating with control key will prevent automatic activation
if ( !event.ctrlKey ) {
// Update aria-selected immediately so that AT think the tab is already selected.
// Otherwise AT may confuse the user by stating that they need to activate the tab,
// but the tab will already be activated by the time the announcement finishes.
focusedTab.attr( "aria-selected", "false" );
this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
this.activating = this._delay(function() {
this.option( "active", selectedIndex );
}, this.delay );
}
},
_panelKeydown: function( event ) {
if ( this._handlePageNav( event ) ) {
return;
}
// Ctrl+up moves focus to the current tab
if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
event.preventDefault();
this.active.focus();
}
},
// Alt+page up/down moves focus to the previous/next tab (and activates)
_handlePageNav: function( event ) {
if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
this._activate( this._focusNextTab( this.options.active - 1, false ) );
return true;
}
if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
this._activate( this._focusNextTab( this.options.active + 1, true ) );
return true;
}
},
_findNextTab: function( index, goingForward ) {
var lastTabIndex = this.tabs.length - 1;
function constrain() {
if ( index > lastTabIndex ) {
index = 0;
}
if ( index < 0 ) {
index = lastTabIndex;
}
return index;
}
while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
index = goingForward ? index + 1 : index - 1;
}
return index;
},
_focusNextTab: function( index, goingForward ) {
index = this._findNextTab( index, goingForward );
this.tabs.eq( index ).focus();
return index;
},
_setOption: function( key, value ) {
if ( key === "active" ) {
// _activate() will handle invalid values and update this.options
this._activate( value );
return;
}
if ( key === "disabled" ) {
// don't use the widget factory's disabled handling
this._setupDisabled( value );
return;
}
this._super( key, value);
if ( key === "collapsible" ) {
this.element.toggleClass( "ui-tabs-collapsible", value );
// Setting collapsible: false while collapsed; open first panel
if ( !value && this.options.active === false ) {
this._activate( 0 );
}
}
if ( key === "event" ) {
this._setupEvents( value );
}
if ( key === "heightStyle" ) {
this._setupHeightStyle( value );
}
},
_tabId: function( tab ) {
return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId();
},
_sanitizeSelector: function( hash ) {
return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
},
refresh: function() {
var options = this.options,
lis = this.tablist.children( ":has(a[href])" );
// get disabled tabs from class attribute from HTML
// this will get converted to a boolean if needed in _refresh()
options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
return lis.index( tab );
});
this._processTabs();
// was collapsed or no tabs
if ( options.active === false || !this.anchors.length ) {
options.active = false;
this.active = $();
// was active, but active tab is gone
} else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
// all remaining tabs are disabled
if ( this.tabs.length === options.disabled.length ) {
options.active = false;
this.active = $();
// activate previous tab
} else {
this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
}
// was active, active tab still exists
} else {
// make sure active index is correct
options.active = this.tabs.index( this.active );
}
this._refresh();
},
_refresh: function() {
this._setupDisabled( this.options.disabled );
this._setupEvents( this.options.event );
this._setupHeightStyle( this.options.heightStyle );
this.tabs.not( this.active ).attr({
"aria-selected": "false",
tabIndex: -1
});
this.panels.not( this._getPanelForTab( this.active ) )
.hide()
.attr({
"aria-expanded": "false",
"aria-hidden": "true"
});
// Make sure one tab is in the tab order
if ( !this.active.length ) {
this.tabs.eq( 0 ).attr( "tabIndex", 0 );
} else {
this.active
.addClass( "ui-tabs-active ui-state-active" )
.attr({
"aria-selected": "true",
tabIndex: 0
});
this._getPanelForTab( this.active )
.show()
.attr({
"aria-expanded": "true",
"aria-hidden": "false"
});
}
},
_processTabs: function() {
var that = this;
this.tablist = this._getList()
.addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
.attr( "role", "tablist" );
this.tabs = this.tablist.find( "> li:has(a[href])" )
.addClass( "ui-state-default ui-corner-top" )
.attr({
role: "tab",
tabIndex: -1
});
this.anchors = this.tabs.map(function() {
return $( "a", this )[ 0 ];
})
.addClass( "ui-tabs-anchor" )
.attr({
role: "presentation",
tabIndex: -1
});
this.panels = $();
this.anchors.each(function( i, anchor ) {
var selector, panel, panelId,
anchorId = $( anchor ).uniqueId().attr( "id" ),
tab = $( anchor ).closest( "li" ),
originalAriaControls = tab.attr( "aria-controls" );
// inline tab
if ( isLocal( anchor ) ) {
selector = anchor.hash;
panel = that.element.find( that._sanitizeSelector( selector ) );
// remote tab
} else {
panelId = that._tabId( tab );
selector = "#" + panelId;
panel = that.element.find( selector );
if ( !panel.length ) {
panel = that._createPanel( panelId );
panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
}
panel.attr( "aria-live", "polite" );
}
if ( panel.length) {
that.panels = that.panels.add( panel );
}
if ( originalAriaControls ) {
tab.data( "ui-tabs-aria-controls", originalAriaControls );
}
tab.attr({
"aria-controls": selector.substring( 1 ),
"aria-labelledby": anchorId
});
panel.attr( "aria-labelledby", anchorId );
});
this.panels
.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
.attr( "role", "tabpanel" );
},
// allow overriding how to find the list for rare usage scenarios (#7715)
_getList: function() {
return this.element.find( "ol,ul" ).eq( 0 );
},
_createPanel: function( id ) {
return $( "<div>" )
.attr( "id", id )
.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
.data( "ui-tabs-destroy", true );
},
_setupDisabled: function( disabled ) {
if ( $.isArray( disabled ) ) {
if ( !disabled.length ) {
disabled = false;
} else if ( disabled.length === this.anchors.length ) {
disabled = true;
}
}
// disable tabs
for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
$( li )
.addClass( "ui-state-disabled" )
.attr( "aria-disabled", "true" );
} else {
$( li )
.removeClass( "ui-state-disabled" )
.removeAttr( "aria-disabled" );
}
}
this.options.disabled = disabled;
},
_setupEvents: function( event ) {
var events = {
click: function( event ) {
event.preventDefault();
}
};
if ( event ) {
$.each( event.split(" "), function( index, eventName ) {
events[ eventName ] = "_eventHandler";
});
}
this._off( this.anchors.add( this.tabs ).add( this.panels ) );
this._on( this.anchors, events );
this._on( this.tabs, { keydown: "_tabKeydown" } );
this._on( this.panels, { keydown: "_panelKeydown" } );
this._focusable( this.tabs );
this._hoverable( this.tabs );
},
_setupHeightStyle: function( heightStyle ) {
var maxHeight,
parent = this.element.parent();
if ( heightStyle === "fill" ) {
maxHeight = parent.height();
maxHeight -= this.element.outerHeight() - this.element.height();
this.element.siblings( ":visible" ).each(function() {
var elem = $( this ),
position = elem.css( "position" );
if ( position === "absolute" || position === "fixed" ) {
return;
}
maxHeight -= elem.outerHeight( true );
});
this.element.children().not( this.panels ).each(function() {
maxHeight -= $( this ).outerHeight( true );
});
this.panels.each(function() {
$( this ).height( Math.max( 0, maxHeight -
$( this ).innerHeight() + $( this ).height() ) );
})
.css( "overflow", "auto" );
} else if ( heightStyle === "auto" ) {
maxHeight = 0;
this.panels.each(function() {
maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
}).height( maxHeight );
}
},
_eventHandler: function( event ) {
var options = this.options,
active = this.active,
anchor = $( event.currentTarget ),
tab = anchor.closest( "li" ),
clickedIsActive = tab[ 0 ] === active[ 0 ],
collapsing = clickedIsActive && options.collapsible,
toShow = collapsing ? $() : this._getPanelForTab( tab ),
toHide = !active.length ? $() : this._getPanelForTab( active ),
eventData = {
oldTab: active,
oldPanel: toHide,
newTab: collapsing ? $() : tab,
newPanel: toShow
};
event.preventDefault();
if ( tab.hasClass( "ui-state-disabled" ) ||
// tab is already loading
tab.hasClass( "ui-tabs-loading" ) ||
// can't switch durning an animation
this.running ||
// click on active header, but not collapsible
( clickedIsActive && !options.collapsible ) ||
// allow canceling activation
( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
return;
}
options.active = collapsing ? false : this.tabs.index( tab );
this.active = clickedIsActive ? $() : tab;
if ( this.xhr ) {
this.xhr.abort();
}
if ( !toHide.length && !toShow.length ) {
$.error( "jQuery UI Tabs: Mismatching fragment identifier." );
}
if ( toShow.length ) {
this.load( this.tabs.index( tab ), event );
}
this._toggle( event, eventData );
},
// handles show/hide for selecting tabs
_toggle: function( event, eventData ) {
var that = this,
toShow = eventData.newPanel,
toHide = eventData.oldPanel;
this.running = true;
function complete() {
that.running = false;
that._trigger( "activate", event, eventData );
}
function show() {
eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
if ( toShow.length && that.options.show ) {
that._show( toShow, that.options.show, complete );
} else {
toShow.show();
complete();
}
}
// start out by hiding, then showing, then completing
if ( toHide.length && this.options.hide ) {
this._hide( toHide, this.options.hide, function() {
eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
show();
});
} else {
eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
toHide.hide();
show();
}
toHide.attr({
"aria-expanded": "false",
"aria-hidden": "true"
});
eventData.oldTab.attr( "aria-selected", "false" );
// If we're switching tabs, remove the old tab from the tab order.
// If we're opening from collapsed state, remove the previous tab from the tab order.
// If we're collapsing, then keep the collapsing tab in the tab order.
if ( toShow.length && toHide.length ) {
eventData.oldTab.attr( "tabIndex", -1 );
} else if ( toShow.length ) {
this.tabs.filter(function() {
return $( this ).attr( "tabIndex" ) === 0;
})
.attr( "tabIndex", -1 );
}
toShow.attr({
"aria-expanded": "true",
"aria-hidden": "false"
});
eventData.newTab.attr({
"aria-selected": "true",
tabIndex: 0
});
},
_activate: function( index ) {
var anchor,
active = this._findActive( index );
// trying to activate the already active panel
if ( active[ 0 ] === this.active[ 0 ] ) {
return;
}
// trying to collapse, simulate a click on the current active header
if ( !active.length ) {
active = this.active;
}
anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
this._eventHandler({
target: anchor,
currentTarget: anchor,
preventDefault: $.noop
});
},
_findActive: function( index ) {
return index === false ? $() : this.tabs.eq( index );
},
_getIndex: function( index ) {
// meta-function to give users option to provide a href string instead of a numerical index.
if ( typeof index === "string" ) {
index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
}
return index;
},
_destroy: function() {
if ( this.xhr ) {
this.xhr.abort();
}
this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
this.tablist
.removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
.removeAttr( "role" );
this.anchors
.removeClass( "ui-tabs-anchor" )
.removeAttr( "role" )
.removeAttr( "tabIndex" )
.removeUniqueId();
this.tabs.add( this.panels ).each(function() {
if ( $.data( this, "ui-tabs-destroy" ) ) {
$( this ).remove();
} else {
$( this )
.removeClass( "ui-state-default ui-state-active ui-state-disabled " +
"ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
.removeAttr( "tabIndex" )
.removeAttr( "aria-live" )
.removeAttr( "aria-busy" )
.removeAttr( "aria-selected" )
.removeAttr( "aria-labelledby" )
.removeAttr( "aria-hidden" )
.removeAttr( "aria-expanded" )
.removeAttr( "role" );
}
});
this.tabs.each(function() {
var li = $( this ),
prev = li.data( "ui-tabs-aria-controls" );
if ( prev ) {
li
.attr( "aria-controls", prev )
.removeData( "ui-tabs-aria-controls" );
} else {
li.removeAttr( "aria-controls" );
}
});
this.panels.show();
if ( this.options.heightStyle !== "content" ) {
this.panels.css( "height", "" );
}
},
enable: function( index ) {
var disabled = this.options.disabled;
if ( disabled === false ) {
return;
}
if ( index === undefined ) {
disabled = false;
} else {
index = this._getIndex( index );
if ( $.isArray( disabled ) ) {
disabled = $.map( disabled, function( num ) {
return num !== index ? num : null;
});
} else {
disabled = $.map( this.tabs, function( li, num ) {
return num !== index ? num : null;
});
}
}
this._setupDisabled( disabled );
},
disable: function( index ) {
var disabled = this.options.disabled;
if ( disabled === true ) {
return;
}
if ( index === undefined ) {
disabled = true;
} else {
index = this._getIndex( index );
if ( $.inArray( index, disabled ) !== -1 ) {
return;
}
if ( $.isArray( disabled ) ) {
disabled = $.merge( [ index ], disabled ).sort();
} else {
disabled = [ index ];
}
}
this._setupDisabled( disabled );
},
load: function( index, event ) {
index = this._getIndex( index );
var that = this,
tab = this.tabs.eq( index ),
anchor = tab.find( ".ui-tabs-anchor" ),
panel = this._getPanelForTab( tab ),
eventData = {
tab: tab,
panel: panel
};
// not remote
if ( isLocal( anchor[ 0 ] ) ) {
return;
}
this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
// support: jQuery <1.8
// jQuery <1.8 returns false if the request is canceled in beforeSend,
// but as of 1.8, $.ajax() always returns a jqXHR object.
if ( this.xhr && this.xhr.statusText !== "canceled" ) {
tab.addClass( "ui-tabs-loading" );
panel.attr( "aria-busy", "true" );
this.xhr
.success(function( response ) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function() {
panel.html( response );
that._trigger( "load", event, eventData );
}, 1 );
})
.complete(function( jqXHR, status ) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function() {
if ( status === "abort" ) {
that.panels.stop( false, true );
}
tab.removeClass( "ui-tabs-loading" );
panel.removeAttr( "aria-busy" );
if ( jqXHR === that.xhr ) {
delete that.xhr;
}
}, 1 );
});
}
},
_ajaxSettings: function( anchor, event, eventData ) {
var that = this;
return {
url: anchor.attr( "href" ),
beforeSend: function( jqXHR, settings ) {
return that._trigger( "beforeLoad", event,
$.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) );
}
};
},
_getPanelForTab: function( tab ) {
var id = $( tab ).attr( "aria-controls" );
return this.element.find( this._sanitizeSelector( "#" + id ) );
}
});
})( jQuery );
(function( $, undefined ) {
})( jQuery );
(function( $, window ) {
$.mobile.iosorientationfixEnabled = true;
// This fix addresses an iOS bug, so return early if the UA claims it's something else.
var ua = navigator.userAgent,
zoom,
evt, x, y, z, aig;
if ( !( /iPhone|iPad|iPod/.test( navigator.platform ) && /OS [1-5]_[0-9_]* like Mac OS X/i.test( ua ) && ua.indexOf( "AppleWebKit" ) > -1 ) ) {
$.mobile.iosorientationfixEnabled = false;
return;
}
zoom = $.mobile.zoom;
function checkTilt( e ) {
evt = e.originalEvent;
aig = evt.accelerationIncludingGravity;
x = Math.abs( aig.x );
y = Math.abs( aig.y );
z = Math.abs( aig.z );
// If portrait orientation and in one of the danger zones
if ( !window.orientation && ( x > 7 || ( ( z > 6 && y < 8 || z < 8 && y > 6 ) && x > 5 ) ) ) {
if ( zoom.enabled ) {
zoom.disable();
}
} else if ( !zoom.enabled ) {
zoom.enable();
}
}
$.mobile.document.on( "mobileinit", function() {
if ( $.mobile.iosorientationfixEnabled ) {
$.mobile.window
.bind( "orientationchange.iosorientationfix", zoom.enable )
.bind( "devicemotion.iosorientationfix", checkTilt );
}
});
}( jQuery, this ));
(function( $, window, undefined ) {
var $html = $( "html" ),
$window = $.mobile.window;
//remove initial build class (only present on first pageshow)
function hideRenderingClass() {
$html.removeClass( "ui-mobile-rendering" );
}
// trigger mobileinit event - useful hook for configuring $.mobile settings before they're used
$( window.document ).trigger( "mobileinit" );
// support conditions
// if device support condition(s) aren't met, leave things as they are -> a basic, usable experience,
// otherwise, proceed with the enhancements
if ( !$.mobile.gradeA() ) {
return;
}
// override ajaxEnabled on platforms that have known conflicts with hash history updates
// or generally work better browsing in regular http for full page refreshes (BB5, Opera Mini)
if ( $.mobile.ajaxBlacklist ) {
$.mobile.ajaxEnabled = false;
}
// Add mobile, initial load "rendering" classes to docEl
$html.addClass( "ui-mobile ui-mobile-rendering" );
// This is a fallback. If anything goes wrong (JS errors, etc), or events don't fire,
// this ensures the rendering class is removed after 5 seconds, so content is visible and accessible
setTimeout( hideRenderingClass, 5000 );
$.extend( $.mobile, {
// find and enhance the pages in the dom and transition to the first page.
initializePage: function() {
// find present pages
var path = $.mobile.path,
$pages = $( ":jqmData(role='page'), :jqmData(role='dialog')" ),
hash = path.stripHash( path.stripQueryParams(path.parseLocation().hash) ),
theLocation = $.mobile.path.parseLocation(),
hashPage = document.getElementById( hash );
// if no pages are found, create one with body's inner html
if ( !$pages.length ) {
$pages = $( "body" ).wrapInner( "<div data-" + $.mobile.ns + "role='page'></div>" ).children( 0 );
}
// add dialogs, set data-url attrs
$pages.each(function() {
var $this = $( this );
// unless the data url is already set set it to the pathname
if ( !$this[ 0 ].getAttribute( "data-" + $.mobile.ns + "url" ) ) {
$this.attr( "data-" + $.mobile.ns + "url", $this.attr( "id" ) ||
theLocation.pathname + theLocation.search );
}
});
// define first page in dom case one backs out to the directory root (not always the first page visited, but defined as fallback)
$.mobile.firstPage = $pages.first();
// define page container
$.mobile.pageContainer = $.mobile.firstPage
.parent()
.addClass( "ui-mobile-viewport" )
.pagecontainer();
// initialize navigation events now, after mobileinit has occurred and the page container
// has been created but before the rest of the library is alerted to that fact
$.mobile.navreadyDeferred.resolve();
// alert listeners that the pagecontainer has been determined for binding
// to events triggered on it
$window.trigger( "pagecontainercreate" );
// cue page loading message
$.mobile.loading( "show" );
//remove initial build class (only present on first pageshow)
hideRenderingClass();
// if hashchange listening is disabled, there's no hash deeplink,
// the hash is not valid (contains more than one # or does not start with #)
// or there is no page with that hash, change to the first page in the DOM
// Remember, however, that the hash can also be a path!
if ( ! ( $.mobile.hashListeningEnabled &&
$.mobile.path.isHashValid( location.hash ) &&
( $( hashPage ).is( ":jqmData(role='page')" ) ||
$.mobile.path.isPath( hash ) ||
hash === $.mobile.dialogHashKey ) ) ) {
// Store the initial destination
if ( $.mobile.path.isHashValid( location.hash ) ) {
$.mobile.navigate.history.initialDst = hash.replace( "#", "" );
}
// make sure to set initial popstate state if it exists
// so that navigation back to the initial page works properly
if ( $.event.special.navigate.isPushStateEnabled() ) {
$.mobile.navigate.navigator.squash( path.parseLocation().href );
}
$.mobile.changePage( $.mobile.firstPage, {
transition: "none",
reverse: true,
changeHash: false,
fromHashChange: true
});
} else {
// trigger hashchange or navigate to squash and record the correct
// history entry for an initial hash path
if ( !$.event.special.navigate.isPushStateEnabled() ) {
$window.trigger( "hashchange", [true] );
} else {
// TODO figure out how to simplify this interaction with the initial history entry
// at the bottom js/navigate/navigate.js
$.mobile.navigate.history.stack = [];
$.mobile.navigate( $.mobile.path.isPath( location.hash ) ? location.hash : location.href );
}
}
}
});
$(function() {
//Run inlineSVG support test
$.support.inlineSVG();
// check which scrollTop value should be used by scrolling to 1 immediately at domready
// then check what the scroll top is. Android will report 0... others 1
// note that this initial scroll won't hide the address bar. It's just for the check.
// hide iOS browser chrome on load if hideUrlBar is true this is to try and do it as soon as possible
if ( $.mobile.hideUrlBar ) {
window.scrollTo( 0, 1 );
}
// if defaultHomeScroll hasn't been set yet, see if scrollTop is 1
// it should be 1 in most browsers, but android treats 1 as 0 (for hiding addr bar)
// so if it's 1, use 0 from now on
$.mobile.defaultHomeScroll = ( !$.support.scrollTop || $.mobile.window.scrollTop() === 1 ) ? 0 : 1;
//dom-ready inits
if ( $.mobile.autoInitializePage ) {
$.mobile.initializePage();
}
// window load event
// hide iOS browser chrome on load if hideUrlBar is true this is as fall back incase we were too early before
if ( $.mobile.hideUrlBar ) {
$window.load( $.mobile.silentScroll );
}
if ( !$.support.cssPointerEvents ) {
// IE and Opera don't support CSS pointer-events: none that we use to disable link-based buttons
// by adding the 'ui-disabled' class to them. Using a JavaScript workaround for those browser.
// https://github.com/jquery/jquery-mobile/issues/3558
// DEPRECATED as of 1.4.0 - remove ui-disabled after 1.4.0 release
// only ui-state-disabled should be present thereafter
$.mobile.document.delegate( ".ui-state-disabled,.ui-disabled", "vclick",
function( e ) {
e.preventDefault();
e.stopImmediatePropagation();
}
);
}
});
}( jQuery, this ));
}));
|
var searchData=
[
['msgdescincludeinfo',['msgDescIncludeInfo',['../structmsgDescIncludeInfo.html',1,'']]],
['msgdescpart',['msgDescPart',['../structmsgDescPart.html',1,'']]],
['msgdescription',['msgDescription',['../structmsgDescription.html',1,'']]],
['msgdescriptioninfos',['msgDescriptionInfos',['../structmsgDescriptionInfos.html',1,'']]],
['msgfielddesc',['msgFieldDesc',['../structmsgFieldDesc.html',1,'']]],
['msgfieldsequence',['msgFieldSequence',['../structmsgFieldSequence.html',1,'']]],
['msgfieldval',['msgFieldVal',['../structmsgFieldVal.html',1,'']]],
['msgheader2msgptr',['msgHeader2MsgPtr',['../structmsgHeader2MsgPtr.html',1,'']]],
['msgheaderinfos',['msgHeaderInfos',['../structmsgHeaderInfos.html',1,'']]],
['msgheadervalues',['msgHeaderValues',['../structmsgHeaderValues.html',1,'']]],
['msginfo',['msgInfo',['../structmsgInfo.html',1,'']]],
['msgkeyvaluedesc',['msgKeyValueDesc',['../structmsgKeyValueDesc.html',1,'']]],
['msgkeyvaluedescpart',['msgKeyValueDescPart',['../structmsgKeyValueDescPart.html',1,'']]],
['msgmidpartvalues',['msgMidPartValues',['../structmsgMidPartValues.html',1,'']]],
['msgparts',['msgParts',['../structmsgParts.html',1,'']]],
['msgrequestinfo',['msgRequestInfo',['../structmsgRequestInfo.html',1,'']]],
['msgrequestinfos',['msgRequestInfos',['../structmsgRequestInfos.html',1,'']]],
['msgtrailervalues',['msgTrailerValues',['../structmsgTrailerValues.html',1,'']]],
['msgvalpart',['msgValPart',['../structmsgValPart.html',1,'']]]
];
|
import Component from '@ember/component';
import { notEmpty } from '@ember/object/computed';
export default Component.extend({
isExpanded: true,
tagName: '',
hasMap: notEmpty('model.hasSourceMap'),
actions: {
toggleExpand() {
this.toggleProperty('isExpanded');
}
}
});
|
module.exports = {
assetsPath: '/PROJECT FOLDER/',
front: {
enabled: true,
host: '', //host address
username: 'root',
privateKey: '../../.ssh/id_rsa',
dest: '/var/www/html/PROJECT FOLDER' //destination directory on host
},
wp: {
enabled: false,
host: '',
username: '',
password: '',
dest: ''
}
};
|
/*
* csa.js
*
* Copyright 2011, Masato Bito
* Licensed under the MIT license.
*
*/
(function(Kifu) {
Kifu.Csa = (function(kifu) { return new Kifu.Csa.initialize(kifu); });
Kifu.Csa.extend = Kifu.Csa.prototype.extend = Kifu.extend;
Kifu.Csa.prototype.extend({
output: function() {
var kifu = this.kifu;
if (kifu.info.format == 'csa') {
return kifu.info.source;
}
var result = "' --- generated by jsShogiKifu ---\n";
result += "V2.2\n";
result += this.outputInfo(kifu.info);
result += this.outputSuite(kifu.suite_init, kifu.info);
result += this.outputMoves(kifu.moves);
return result;
},
outputBoard: function(board) {
var result = '';
for (var y = 1; y <= 9; y++) {
result += 'P' + y;
for (var x = 9; 1 <= x; x--) {
var cell = board[x][y];
if (cell) {
result += (cell.is_black ? '+' : '-') + cell.piece;
} else {
result += ' * ';
}
}
result += "\n";
}
return result;
},
outputDate: function(date) {
var yy = date.getFullYear();
var mm = date.getMonth() + 1;
if (mm < 10) {
mm = '0' + mm;
}
var dd = date.getDate();
if (dd < 10) {
dd = '0' + dd;
}
var h = date.getHours();
if (h < 10) {
h = '0' + h;
}
var m = date.getMinutes();
if (m < 10) {
m = '0' + m;
}
var s = date.getSeconds();
if (s < 10) {
s = '0' + s;
}
return yy + '/' + mm + '/' + dd + ' ' + h + ':' + m + ':' + s;
},
outputInfo: function(info) {
var result = '';
for (var key in info) {
var value = info[key];
switch (key) {
case 'event':
case 'opening':
case 'site':
result += '$' + key.toUpperCase() + ':' + value + "\n";
break;
case 'end_time':
case 'start_time':
result += '$' + key.toUpperCase() + ':' + this.outputDate(value) + "\n";
break;
case 'player_black':
case 'player_white':
var player = key == 'player_black' ? '+' : '-';
result += 'N' + player + value + "\n";
break;
case 'time_limit':
result += '$TIME_LIMIT:';
var h = value.allotted / 60;
if (h < 10) {
result += '0';
}
result += h + ':';
var m = value.allotted % 60;
if (m < 10) {
result += '0';
}
result += m + '+';
var s = value.extra || 0;
if (s < 10) {
result += '0';
}
result += s + "\n";
break;
default:
break;
}
}
return result;
},
outputMoves: function(moves) {
var result = '';
var records = moves.records;
var l = records.length;
for (var i = 0; i < l; i++) {
var record = records[i];
switch (record.type) {
case 'move':
var from = record.from;
var to = record.to;
var player = record.is_black ? '+' : '-';
result += player + from.x + from.y + to.x + to.y + to.piece + "\n";
if (record.period) {
result += 'T' + record.period + "\n";
}
break;
case 'init':
break;
default:
result += '%' + record.type.toUpperCase() + "\n";
break;
}
if (record.comment) {
var lines = this.toLines(record.comment);
var m = lines.length;
for (var j = 0; j < m; j++) {
result += "'*" + lines[j] + "\n";
}
}
}
return result;
},
outputStand: function(stand, is_black) {
var result = '';
for (var piece in stand) {
var amount = stand[piece];
for (var i = 0; i < amount; i++) {
result += '00' + piece;
}
}
if (result) {
return 'P' + (is_black ? '+' : '-') + result + "\n";
} else {
return '';
}
},
outputSuite: function(suite, info) {
var result = '';
result += this.outputBoard(suite.board);
result += this.outputStand(suite.stand.black, true);
result += this.outputStand(suite.stand.white, false);
result += (info.player_start == 'black' ? '+' : '-') + "\n";
return result;
},
parse: function() {
var lines = this.toLines(this.kifu.info.source);
var l = lines.length;
for (var i = 0; i < l; i++) {
var line = lines[i];
this.parseByLine(line);
}
return this;
},
parseByLine: function(line) {
var kifu = this.kifu;
if (line == '+') {
kifu.info.player_start = 'black';
return true;
} else if (line == '-') {
kifu.info.player_start = 'white';
return true;
} else if (line.substr(0, 2) == "'*") {
kifu.moves.addComment(line.substr(2));
return true;
}
switch (line.charAt(0)) {
case '$':
var pos = line.indexOf(':');
var key = line.substr(1, pos-1).toLowerCase();
var value = line.substr(pos+1);
switch (key) {
case 'end_time':
case 'start_time':
var date = new Date();
date.setTime(Date.parse(value));
value = date;
break;
case 'time_limit':
var hours = parseInt(value.substr(0, 2));
var minutes = parseInt(value.substr(3, 2));
var extra = parseInt(value.substr(6));
value = {
allotted: hours * 60 + minutes,
extra: extra};
break;
}
kifu.info[key] = value;
return true;
case '%':
var value = line.substr(1);
var options = {};
switch (value.charAt(0)) {
case '+':
case '-':
options.is_black = value.charAt(0) == '+' ? true : false;
value = value.substr(1);
break;
}
kifu.moves.addSpecial(value, options);
return true;
case '+':
case '-':
var params = {};
params.from = {x: line.charAt(1)-'0', y: line.charAt(2)-'0'};
params.to = {x: line.charAt(3)-'0', y: line.charAt(4)-'0'};
params.to.piece = line.substr(5, 2);
params.is_black = line.charAt(0) == '+' ? true : false;
kifu.moves.addMove(params);
return true;
case 'N':
var player = 'player_' + (line.charAt(1) == '+' ? 'black' : 'white');
kifu.info[player] = line.substr(2);
return true;
case 'P':
switch (line.charAt(1)) {
case 'I':
kifu.suite_init.hirate();
for (var i = 0; ; i++) {
var p_info = line.substr(2+i*4, 4);
if (p_info.length < 4) {
break;
}
var x = p_info.charAt(0) - '0';
var y = p_info.charAt(1) - '0';
var piece = p_info.substr(2);
kifu.suite_init.cellRemove(x, y, piece);
}
return true;
case '+':
case '-':
var is_black = line.charAt(1) == '+';
for (var i = 0; ; i++) {
var p_info = line.substr(2+i*4, 4);
if (p_info.length < 4) {
break;
}
var x = p_info.charAt(0) - '0';
var y = p_info.charAt(1) - '0';
var piece = p_info.substr(2);
if (x == 0 && y == 0) {
kifu.suite_init.standDeploy(piece, is_black);
} else {
kifu.suite_init.cellDeploy(x, y, piece, is_black);
}
}
return true;
default:
var y = line.charAt(1) - '0';
if (y < 1 || 9 < y) {
return false;
}
for (var i = 0; i < 9; i++) {
var p_info = line.substr(2+i*3, 3);
switch (p_info.charAt(0)) {
case '+':
var is_black = true;
break;
case '-':
var is_black = false;
break;
default:
continue;
}
var x = 9 - i;
var piece = p_info.substr(1, 2);
kifu.suite_init.cellDeploy(x, y, piece, is_black);
}
return true;
}
return false;
case 'T':
var period = parseInt(line.substr(1));
kifu.moves.addPeriod(period);
return true;
case 'V':
kifu.info.version = line.substr(1);
return true;
}
return false;
},
toLines: function(source) {
var result = [];
var lines = source.replace(/,(\r?\n|\r)/g, '').split(/\r?\n|\r/);
var l = lines.length;
for (var i = 0; i < l; i++) {
var line = lines[i];
if (line) {
result.push(lines[i]);
}
}
return result;
}
});
Kifu.Csa.extend({
initialize: function(kifu) {
this.kifu = kifu;
}
});
Kifu.Csa.initialize.prototype = Kifu.Csa.prototype
})(Kifu);
// Local variables:
// indent-tabs-mode: nil
// js2-basic-offset: 2
// end:
// vim: set expandtab tabstop=2 shiftwidth=2 softtabstop=2:
|
const { RenderMode } = require('./renderer');
module.exports = (function(){
let exports = {};
exports.createQuadMeshConfig = (w, h) => {
return {
vertices: [
w, h, 0.0,
0, h, 0.0,
w, 0, 0.0,
0, 0, 0.0 ],
normals: [
0.0, 0.0, 1.0,
0.0, 0.0, 1.0,
0.0, 0.0, 1.0,
0.0, 0.0, 1.0 ],
textureCoordinates: [
1.0, 1.0,
0.0, 1.0,
1.0, 0.0,
0.0, 0.0 ],
renderMode: RenderMode.TriangleStrip
};
};
return exports;
})(); |
module.exports = {
ngProvider: 'controller',
ngModule: 'controllers',
ngName: 'todolist.header.controller',
dependencies: [
'$rootScope', '$scope'
],
fn: ($rootScope, $scope) => {
$rootScope.$on('user:loggedin', (e, user) => {
$scope.user = user;
});
}
};
|
module.exports = function() {
var test_db = {
db_host: 'localhost',
db_username: 'root',
db_password: 'justdoit',
db_name: 'cms_test'
};
var prod_db = {
db_host: 'localhost',
db_username: 'root',
db_password: 'justdoit',
db_name: 'isda'
};
return {
getProdConfig: function(){
return prod_db;
},
getTestConfig: function(){
return test_db;
}
}
} |
var Code = require('code');
var Lab = require('lab');
var partial = require('lodash.partial');
var lab = exports.lab = Lab.script();
var describe = lab.describe;
var it = lab.it;
var before = lab.before;
var after = lab.after;
var expect = Code.expect;
var bdd = {it: it, expect: expect};
var utilities = require('../lib/utilities');
var Workbook = require('../lib/parts/workbook');
var SharedStrings = require('../lib/parts/sharedStrings');
function readOnlyTest(obj, name, test) {
it('has a read-only property: ' + name, function (done) {
if (test) test();
expect(function () { obj[name] = 'foo'; }).to.throw(Error, new RegExp("Cannot set " + name + " directly\."));
done()
});
}
describe('Workbook', function () {
var workbook = new Workbook();
var readOnlyTest = partial(utilities.readOnlyTest, bdd, workbook);
var constantTest = partial(utilities.constantTest, bdd, workbook);
constantTest('filename', function () {
expect(workbook.filename).to.be.a.string();
expect(workbook.filename).to.equal('workbook.xml');
});
constantTest('type', function () {
expect(workbook.type).to.be.a.string();
expect(workbook.type).to.equal('officeDocument');
});
readOnlyTest('data', function () {
expect(workbook.data).to.be.an.object();
expect(workbook.data).to.deep.equal({sheets: [], hasDefinedNames: false, definedNames: {}});
});
readOnlyTest('definedNames', function () {
expect(workbook.definedNames).to.be.an.object();
expect(workbook.definedNames).to.deep.equal({});
});
readOnlyTest('path', function () {
expect(workbook.path).to.be.a.string();
expect(workbook.path).to.include('xl', workbook.filename);
});
readOnlyTest('sharedStrings', function () {
expect(workbook.sharedStrings).to.be.an.instanceof(SharedStrings);
});
readOnlyTest('sheets', function () {
expect(workbook.sheets).to.be.an.array();
expect(workbook.sheets).to.have.length(0);
});
readOnlyTest('sheetNames', function () {
expect(workbook.sheetNames).to.be.an.array();
expect(workbook.sheetNames).to.have.length(0);
});
});
|
/**!
* $.p3.request
*
* Query string parser, returns the url and an object
* containing the GET parameters in key: value format
*
* Required in most $.p3 libraries
*
* @author <a href="mailto:hello@raywalker.it">Ray Walker</a>
* @source https://github.com/greenpeace/p3_styleguide
* @version 0.1.1
* @requires <a href="http://jquery.com/">jQuery</a>
* @usage $.p3.request('http://fish.com?type=salmon');
* @returns {object} { url: 'http://fish.com', parameters: { type: 'salmon' } }
*/
(function($) {
'use strict';
var _p3 = $.p3 || {};
_p3.request = function(url) {
var request = {
url: false,
parameters: false
},
parts = [],
getRequestParams = function() {
var params = {};
parts.shift();
if (parts[0]) {
parts.join('?').split(/[&;]/g).forEach(function(param) {
var q = param.split(/\=/);
if (q.length > 0 && q[0].length) {
params[q[0]] = q[1];
}
});
}
return params;
},
getRequestURL = function() {
return (parts[0].length) ? parts[0] : url;
};
if (url) {
parts = url.split('?');
} else {
return request;
}
request.url = getRequestURL();
request.parameters = getRequestParams();
return request;
};
$.p3 = _p3;
}(jQuery));
|
/**
* Utility class for fubus.
*/
(function(module){
/**
* Parse ubus parameters from JSON-RPC call.
* @param args Arguments to parse.
* @returns Object Parsed ubus parameters.
*/
var parseUbusParameters = function(args){
var ubusParams = {
session: args[0],
object: args[1],
method: args[2],
arguments: args[3]
};
return ubusParams;
};
/**
* Module exports.
*/
module.exports = {
parseUbusParameters: parseUbusParameters
}
})(module); |
/**
* Created by tec on 27/04/15.
* Extending Organisations so that a organisation can be Startup, Consulting company, or whatever tag is needed.
* A modified version of LinkTag.js
*/
var keystone = require('keystone'),
Types = keystone.Field.Types;
/**
* Organisation Tags Model
* ===============
*/
var OrganisationTag = new keystone.List('OrganisationTag', {
autokey: { from: 'name', path: 'key', unique: true }
});
OrganisationTag.add({
name: { type: String, required: true }
});
/**
* Relationships
* =============
*/
OrganisationTag.relationship({ ref: 'Organisation', refPath: 'tags', path: 'organisations' });
/**
* Registration
* ============
*/
OrganisationTag.register();
|
module.exports = function(passport){
var express = require('express');
var router = express.Router();
/* USER LOGIN */
router.get('/login', function(req, res) {
res.render('login', { message: req.flash('loginMessage')});
});
router.post('/login', passport.authenticate('local-login',{
successRedirect: '/dashboard/index',
failureRedirect: '/auth/login',
failureFlash: true
//session:true
}));
/* USER LOGOUT */
router.get('/logout', function(req, res){
req.logout();
res.redirect('/auth/login');
});
// /* USER REGISTRATION */
// router.get('/register', function(req, res, next) {
// res.render('register', { message: req.flash('registerMessage')});
// });
// router.post('/register', passport.authenticate('local-register', {
// successRedirect: '/auth/login',
// failureRedirect: '/auth/register',
// failureFlash: true
// //session:true
// }));
return router;
//TODO: encrypt the passwords on database?
}; |
import React, { PropTypes } from 'react';
import styled from 'styled-components';
import Sidebar from './sidebar';
import Header from './header';
const Content = styled.div`
margin-left: 200px;
height: 100vh;
display: flex;
flex-direction: column;
align-items: stretch;
align-content: stretch;
`;
const Layout = ({ children }) => (
<div>
<Sidebar />
<Content>
<Header title="Title" />
{children}
</Content>
</div>
);
Layout.propTypes = {
children: PropTypes.node.isRequired,
};
export default Layout;
|
import { omit } from 'lodash'
function tagList(
state = {
isFetching: false,
names: []
},
action
) {
switch (action.type) {
case 'GET_TAGS_FULFILLED':
return {
...state,
names: action.payload.data.result
}
case 'ADD_TAG_FULFILLED':
return {
...state,
names: [...state.names, action.payload.data.tag.name]
}
case 'REMOVE_TAG_FROM_LIST':
return {
...state,
names: state.names.filter(name => name !== action.name)
}
case 'ADD_TAG_TO_LIST':
return {
...state,
names: [...state.names, action.name]
}
default:
return state
}
}
export default function tagLists(state = {}, action) {
switch (action.type) {
case 'GET_TAGS_FULFILLED':
return {
...state,
[action.tagType]: tagList(state[action.tagType], action)
}
case 'ADD_TAG_FULFILLED':
return {
...state,
[action.payload.data.tag.type]: tagList(
state[action.payload.data.tag.type],
action
)
}
case 'REMOVE_TAG_FROM_LIST':
return {
...state,
[action.tagType]: tagList(state[action.tagType], action)
}
case 'ADD_TAG_TO_LIST':
return {
...state,
[action.tagType]: tagList(state[action.tagType], action)
}
case 'RESET_TAG_LIST':
return omit(state, action.tagType)
default:
return state
}
}
|
rock.namespace('rock.geometry');
/**
* Represents a 3D vector
*
* @constructor
* @author Luis Alberto Jiménez
*/
rock.geometry.Vector3 = function (x, y, z) {
this.x = x;
this.y = y;
this.z = z;
};
/**
* Normalize this vector
*/
rock.geometry.Vector3.prototype.normalize = function () {
var module = this.module();
this.x = this.x / module;
this.y = this.y / module;
this.z = this.z / module;
};
/**
* Get the module
*/
rock.geometry.Vector3.prototype.module = function () {
return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z * this.z));
};
/**
* Get the x
*
* @returns the value
*/
rock.geometry.Vector3.prototype.getX = function () {
return this.x;
};
/**
* Set the x
*
* @param x
* the value to set
*/
rock.geometry.Vector3.prototype.setX = function (x) {
this.x = x;
};
/**
* Get the y
*
* @returns the value
*/
rock.geometry.Vector3.prototype.getY = function () {
return this.y;
};
/**
* Set the y
*
* @param y
* the value to set
*/
rock.geometry.Vector3.prototype.setY = function (y) {
this.y = y;
};
/**
* Get the z
*
* @returns the value
*/
rock.geometry.Vector3.prototype.getZ = function () {
return this.z;
};
/**
* Set the z
*
* @param z
* the value to set
*/
rock.geometry.Vector3.prototype.setZ = function (z) {
this.z = z;
};
rock.geometry.Vector3.prototype.clone = function () {
return new rock.geometry.Vector3(this.x, this.y, this.z);
}; |
(function(Prism) {
var javascript = Prism.util.clone(Prism.languages.javascript);
Prism.languages.jsx = Prism.languages.extend('markup', javascript);
Prism.languages.jsx.tag.pattern= /<\/?[\w.:-]+\s*(?:\s+(?:[\w.:-]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s{'">=]+|\{(?:\{(?:\{[^}]*\}|[^{}])*\}|[^{}])+\}))?|\{\.{3}[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\}))*\s*\/?>/i;
Prism.languages.jsx.tag.inside['attr-value'].pattern = /=(?!\{)(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">]+)/i;
Prism.languages.insertBefore('inside', 'attr-name', {
'spread': {
pattern: /\{\.{3}[a-z_$][\w$]*(?:\.[a-z_$][\w$]*)*\}/,
inside: {
'punctuation': /\.{3}|[{}.]/,
'attr-value': /\w+/
}
}
}, Prism.languages.jsx.tag);
Prism.languages.insertBefore('inside', 'attr-value',{
'script': {
// Allow for two levels of nesting
pattern: /=(\{(?:\{(?:\{[^}]*\}|[^}])*\}|[^}])+\})/i,
inside: {
'script-punctuation': {
pattern: /^=(?={)/,
alias: 'punctuation'
},
rest: Prism.languages.jsx
},
'alias': 'language-javascript'
}
}, Prism.languages.jsx.tag);
// The following will handle plain text inside tags
var stringifyToken = function (token) {
if (typeof token === 'string') {
return token;
}
if (typeof token.content === 'string') {
return token.content;
}
return token.content.map(stringifyToken).join('');
};
var walkTokens = function (tokens) {
var openedTags = [];
for (var i = 0; i < tokens.length; i++) {
var token = tokens[i];
var notTagNorBrace = false;
if (typeof token !== 'string') {
if (token.type === 'tag' && token.content[0] && token.content[0].type === 'tag') {
// We found a tag, now find its kind
if (token.content[0].content[0].content === '</') {
// Closing tag
if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
// Pop matching opening tag
openedTags.pop();
}
} else {
if (token.content[token.content.length - 1].content === '/>') {
// Autoclosed tag, ignore
} else {
// Opening tag
openedTags.push({
tagName: stringifyToken(token.content[0].content[1]),
openedBraces: 0
});
}
}
} else if (openedTags.length > 0 && token.type === 'punctuation' && token.content === '{') {
// Here we might have entered a JSX context inside a tag
openedTags[openedTags.length - 1].openedBraces++;
} else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === 'punctuation' && token.content === '}') {
// Here we might have left a JSX context inside a tag
openedTags[openedTags.length - 1].openedBraces--;
} else {
notTagNorBrace = true
}
}
if (notTagNorBrace || typeof token === 'string') {
if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
// Here we are inside a tag, and not inside a JSX context.
// That's plain text: drop any tokens matched.
var plainText = stringifyToken(token);
// And merge text with adjacent text
if (i < tokens.length - 1 && (typeof tokens[i + 1] === 'string' || tokens[i + 1].type === 'plain-text')) {
plainText += stringifyToken(tokens[i + 1]);
tokens.splice(i + 1, 1);
}
if (i > 0 && (typeof tokens[i - 1] === 'string' || tokens[i - 1].type === 'plain-text')) {
plainText = stringifyToken(tokens[i - 1]) + plainText;
tokens.splice(i - 1, 1);
i--;
}
tokens[i] = new Prism.Token('plain-text', plainText, null, plainText);
}
}
if (token.content && typeof token.content !== 'string') {
walkTokens(token.content);
}
}
};
Prism.hooks.add('after-tokenize', function (env) {
if (env.language !== 'jsx' && env.language !== 'tsx') {
return;
}
walkTokens(env.tokens);
});
}(Prism));
|
'use strict';
const {round} = Math;
module.exports = {
toLinear(v) {
return v > 0.04045 ? (((v + 0.055) / 1.055) ** 2.4) : (v / 12.92);
},
toGamma(v) {
return v > 0.0031308 ? (v ** (1.0 / 2.4) * 1.055 - 0.055) : v * 12.92;
},
toLuma(r, g, b) {
return (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
},
clampTo8bit(v) {
if (v < 0) {
return 0;
} else if (v > 255) {
return 255;
}
return round(v);
},
}
|
/**
* Calculates value-over-replacement for players by position
*
* Inputs:
* player names & estimated points
* position slots per fantasy team roster
* number of fantasy teams in the league
* Output:
* Decorated input object with VORP added to each player
*/
(function(document, window, undefined) {
'use strict';
/**
* Calculates demand for starters @ a position. Assign equal demand for all
* positions in a flex slot.
*/
window.getTeamDemand = function(position, draftRoster) {
var demand = 0;
$.each(draftRoster, function(_, slot) {
var flexOptions = slot.split("/").length
;
if (slot.indexOf(position) != -1) {
demand += (1 / flexOptions);
}
});
return demand;
};
window.vorp = function(pointEstimates, draftRoster, numTeams) {
var POSITIONS = ["QB", "RB", "WR", "TE", "K", "DST"]
, REPLACEMENT_RANGE = 3
/**
* Calculates replacement value by estimating demand for each
* position, and then averaging the projected value of the
* next three available players at the position
*/
, getReplacementValue = function(position, inputEstimates) {
var teamDemand = window.getTeamDemand(position, draftRoster)
, totalDemand = teamDemand * numTeams
, players = inputEstimates[position] || []
, replacementStart = Math.min(Math.ceil(totalDemand),
players.length - 1)
, replacementStop = replacementStart + REPLACEMENT_RANGE
, replacementPlayers = players.slice(replacementStart, replacementStop)
, replacementValue = averagePoints(replacementPlayers)
;
log(position + " replacement range " + replacementStart + " - " + replacementStop);
return replacementValue.toFixed(2);
}
/**
* Returns a map of position -> replacement value
*/
, calculateReplacementValues = function(inputEstimates) {
var replacementValues = {};
$.each(POSITIONS, function(_, pos) {
replacementValues[pos] = getReplacementValue(pos, inputEstimates);
});
return replacementValues;
}
, sortInput = function(estimates) {
// sort all the lists (positions) by point total, descending
$.each(estimates, function(position, playerList) {
playerList.sort(function(a,b) { return b.points - a.points; });
});
return estimates;
}
//
// Now do the real work. Clean the input, calculate replacement values
// and return a decorated version of the input object with vorp
//
, inputEstimates = sortInput(pointEstimates)
, replacementValues = calculateReplacementValues(inputEstimates)
;
log("running VORP for " + numTeams + " teams, roster: " + draftRoster);
log("replacementValues: " + JSON.stringify(replacementValues));
forEveryPlayer(inputEstimates, function(player, pos_rank) {
player.vorp = (player.points - replacementValues[player.pos]);
player.pos_rank = pos_rank + 1;
});
return inputEstimates;
};
})(document, window);
|
switch (process.env.NODE_ENV) {
case 'production':
module.exports = require('./webpack.prod')({env: 'production'});
break;
case 'development':
module.exports = require('./webpack.dev')({env: 'development'});
break;
case 'client':
module.exports = require('./webpack.client')({env: 'production'});
break;
default:
module.exports = require('./webpack.dev')({env: 'development'});
}
|
import RecipientLeft from './RecipientLeft';
import RecipientsModified from './RecipientsModified';
export default (app) => {
app.postComponents.recipientsModified = RecipientsModified;
app.postComponents.recipientLeft = RecipientLeft;
};
|
class GraphicsManager {
constructor(canvas) {
this.canvas = canvas;
this.context = canvas.getContext("2d");
this.memoryCanvas = document.createElement("canvas");
this.memoryContext = canvas.getContext("2d");
this.drawables = [];
this.rotation = 0; // in radians
this.drawRotation = 0;
this.isDrawing = false;
this.wrapValue = Math.PI * 2;
}
startDrawing() {
this.isDrawing = true;
window.requestAnimationFrame(this._draw.bind(this));
}
stopDrawing() {
this.isDrawing = false;
}
addDrawable(drawable) {
this.drawables.push(drawable);
}
addDrawables(drawables) {
for (var i = 0; i < drawables.length; i++) {
this.drawables.push(drawables[i]);
};
}
setRotation(rotation) {
this.rotation = rotation;
}
_draw() {
if (!this.isDrawing) return;
const angleDiff = ((((this.rotation - this.drawRotation) % this.wrapValue) + this.wrapValue*1.5) % this.wrapValue) - this.wrapValue/2;
this.drawRotation += angleDiff * 0.05;
this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
this.context.translate(this.canvas.width/2, this.canvas.height/2);
this.context.rotate(this.drawRotation);
this.context.translate(-this.canvas.width/2, -this.canvas.height/2);
for (let i = 0; i < this.drawables.length; ++i) {
this.drawables[i].render(this.context);
}
this.context.setTransform(1, 0, 0, 1, 0, 0);
window.requestAnimationFrame(this._draw.bind(this));
}
} |
/* =========================================================
* bootstrap-datepicker.js
* http://www.eyecon.ro/bootstrap-datepicker
* =========================================================
* Copyright 2012 Stefan Petre
* Improvements by Andrew Rowls
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ========================================================= */
!function( $ ) {
function UTCDate(){
return new Date(Date.UTC.apply(Date, arguments));
}
function UTCToday(){
var today = new Date();
return UTCDate(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
}
// Picker object
var Datepicker = function(element, options) {
var that = this;
this.element = $(element);
this.language = options.language||this.element.data('date-language')||"fa";
this.language = this.language in dates ? this.language : this.language.split('-')[0]; //Check if "de-DE" style date is available, if not language should fallback to 2 letter code eg "de"
this.language = this.language in dates ? this.language : "fa";
this.isRTL = dates[this.language].rtl||false;
this.format = DPGlobal.parseFormat(options.format||this.element.data('date-format')||dates[this.language].format||'mm/dd/yyyy');
this.isInline = false;
this.isInput = this.element.is('input');
this.component = this.element.is('.date') ? this.element.find('.add-on, .btn') : false;
this.hasInput = this.component && this.element.find('input').length;
if(this.component && this.component.length === 0)
this.component = false;
this.forceParse = true;
if ('forceParse' in options) {
this.forceParse = options.forceParse;
} else if ('dateForceParse' in this.element.data()) {
this.forceParse = this.element.data('date-force-parse');
}
this.picker = $(DPGlobal.template);
this._buildEvents();
this._attachEvents();
if(this.isInline) {
this.picker.addClass('datepicker-inline').appendTo(this.element);
} else {
this.picker.addClass('datepicker-dropdown dropdown-menu');
}
if (this.isRTL){
this.picker.addClass('datepicker-rtl');
this.picker.find('.prev i, .next i')
.toggleClass('fa fa-chevron-right fa fa-chevron-left');
}
this.autoclose = false;
if ('autoclose' in options) {
this.autoclose = options.autoclose;
} else if ('dateAutoclose' in this.element.data()) {
this.autoclose = this.element.data('date-autoclose');
}
this.keyboardNavigation = true;
if ('keyboardNavigation' in options) {
this.keyboardNavigation = options.keyboardNavigation;
} else if ('dateKeyboardNavigation' in this.element.data()) {
this.keyboardNavigation = this.element.data('date-keyboard-navigation');
}
this.viewMode = this.startViewMode = 0;
switch(options.startView || this.element.data('date-start-view')){
case 2:
case 'decade':
this.viewMode = this.startViewMode = 2;
break;
case 1:
case 'year':
this.viewMode = this.startViewMode = 1;
break;
}
this.minViewMode = options.minViewMode||this.element.data('date-min-view-mode')||0;
if (typeof this.minViewMode === 'string') {
switch (this.minViewMode) {
case 'months':
this.minViewMode = 1;
break;
case 'years':
this.minViewMode = 2;
break;
default:
this.minViewMode = 0;
break;
}
}
this.viewMode = this.startViewMode = Math.max(this.startViewMode, this.minViewMode);
this.todayBtn = (options.todayBtn||this.element.data('date-today-btn')||false);
this.todayHighlight = (options.todayHighlight||this.element.data('date-today-highlight')||false);
this.calendarWeeks = false;
if ('calendarWeeks' in options) {
this.calendarWeeks = options.calendarWeeks;
} else if ('dateCalendarWeeks' in this.element.data()) {
this.calendarWeeks = this.element.data('date-calendar-weeks');
}
if (this.calendarWeeks)
this.picker.find('tfoot th.today')
.attr('colspan', function(i, val){
return parseInt(val) + 1;
});
this._allow_update = false;
this.weekStart = ((options.weekStart||this.element.data('date-weekstart')||dates[this.language].weekStart||6) % 7);
this.weekEnd = ((this.weekStart + 6) % 7);
this.startDate = -Infinity;
this.endDate = Infinity;
this.daysOfWeekDisabled = [];
this.setStartDate(options.startDate||this.element.data('date-startdate'));
this.setEndDate(options.endDate||this.element.data('date-enddate'));
this.setDaysOfWeekDisabled(options.daysOfWeekDisabled||this.element.data('date-days-of-week-disabled'));
this.fillDow();
this.fillMonths();
this._allow_update = true;
this.update();
this.showMode();
if(this.isInline) {
this.show();
}
};
Datepicker.prototype = {
constructor: Datepicker,
_events: [],
_secondaryEvents: [],
_applyEvents: function(evs){
for (var i=0, el, ev; i<evs.length; i++){
el = evs[i][0];
ev = evs[i][1];
el.on(ev);
}
},
_unapplyEvents: function(evs){
for (var i=0, el, ev; i<evs.length; i++){
el = evs[i][0];
ev = evs[i][1];
el.off(ev);
}
},
_buildEvents: function(){
if (this.isInput) { // single input
this._events = [
[this.element, {
focus: $.proxy(this.show, this),
keyup: $.proxy(this.update, this),
keydown: $.proxy(this.keydown, this)
}]
];
}
else if (this.component && this.hasInput){ // component: input + button
this._events = [
// For components that are not readonly, allow keyboard nav
[this.element.find('input'), {
focus: $.proxy(this.show, this),
keyup: $.proxy(this.update, this),
keydown: $.proxy(this.keydown, this)
}],
[this.component, {
click: $.proxy(this.show, this)
}]
];
}
else if (this.element.is('div')) { // inline datepicker
this.isInline = true;
}
else {
this._events = [
[this.element, {
click: $.proxy(this.show, this)
}]
];
}
this._secondaryEvents = [
[this.picker, {
click: $.proxy(this.click, this)
}],
[$(window), {
resize: $.proxy(this.place, this)
}],
[$(document), {
mousedown: $.proxy(function (e) {
// Clicked outside the datepicker, hide it
if ($(e.target).closest('.datepicker.datepicker-inline, .datepicker.datepicker-dropdown').length === 0) {
this.hide();
}
}, this)
}]
];
},
_attachEvents: function(){
this._detachEvents();
this._applyEvents(this._events);
},
_detachEvents: function(){
this._unapplyEvents(this._events);
},
_attachSecondaryEvents: function(){
this._detachSecondaryEvents();
this._applyEvents(this._secondaryEvents);
},
_detachSecondaryEvents: function(){
this._unapplyEvents(this._secondaryEvents);
},
show: function(e) {
if (!this.isInline)
this.picker.appendTo('body');
this.picker.show();
this.height = this.component ? this.component.outerHeight() : this.element.outerHeight();
this.place();
this._attachSecondaryEvents();
if (e) {
e.preventDefault();
}
this.element.trigger({
type: 'show',
date: this.date
});
},
hide: function(e){
if(this.isInline) return;
if (!this.picker.is(':visible')) return;
this.picker.hide().detach();
this._detachSecondaryEvents();
this.viewMode = this.startViewMode;
this.showMode();
if (
this.forceParse &&
(
this.isInput && this.element.val() ||
this.hasInput && this.element.find('input').val()
)
)
this.setValue();
this.element.trigger({
type: 'hide',
date: this.date
});
},
remove: function() {
this.hide();
this._detachEvents();
this._detachSecondaryEvents();
this.picker.remove();
delete this.element.data().datepicker;
if (!this.isInput) {
delete this.element.data().date;
}
},
getDate: function() {
var d = this.getUTCDate();
return new JalaliDate(d.getTime() + (d.getTimezoneOffset()*60000));
},
getUTCDate: function() {
return this.date;
},
setDate: function(d) {
this.setUTCDate(new JalaliDate(d.getTime() - (d.getTimezoneOffset()*60000)));
},
setUTCDate: function(d) {
this.date = d;
this.setValue();
},
setValue: function() {
var formatted = this.getFormattedDate();
if (!this.isInput) {
if (this.component){
this.element.find('input').val(formatted);
}
this.element.data('date', formatted);
} else {
this.element.val(formatted);
}
},
getFormattedDate: function(format) {
if (format === undefined)
format = this.format;
return DPGlobal.formatDate(this.date, format, this.language);
},
setStartDate: function(startDate){
this.startDate = startDate||-Infinity;
if (this.startDate !== -Infinity) {
this.startDate = DPGlobal.parseDate(this.startDate, this.format, this.language);
}
this.update();
this.updateNavArrows();
},
setEndDate: function(endDate){
this.endDate = endDate||Infinity;
if (this.endDate !== Infinity) {
this.endDate = DPGlobal.parseDate(this.endDate, this.format, this.language);
}
this.update();
this.updateNavArrows();
},
setDaysOfWeekDisabled: function(daysOfWeekDisabled){
this.daysOfWeekDisabled = daysOfWeekDisabled||[];
if (!$.isArray(this.daysOfWeekDisabled)) {
this.daysOfWeekDisabled = this.daysOfWeekDisabled.split(/,\s*/);
}
this.daysOfWeekDisabled = $.map(this.daysOfWeekDisabled, function (d) {
return parseInt(d, 10);
});
this.update();
this.updateNavArrows();
},
place: function(){
if(this.isInline) return;
var zIndex = parseInt(this.element.parents().filter(function() {
return $(this).css('z-index') != 'auto';
}).first().css('z-index'))+10;
var offset = this.component ? this.component.parent().offset() : this.element.offset();
var height = this.component ? this.component.outerHeight(true) : this.element.outerHeight(true);
this.picker.css({
top: offset.top + height,
left: offset.left,
zIndex: zIndex
});
},
_allow_update: true,
update: function(){
if (!this._allow_update) return;
var date, fromArgs = false;
if(arguments && arguments.length && (typeof arguments[0] === 'string' || arguments[0] instanceof Date)) {
date = arguments[0];
fromArgs = true;
} else {
date = this.isInput ? this.element.val() : this.element.data('date') || this.element.find('input').val();
}
this.date = DPGlobal.parseDate(date, this.format, this.language);
if(fromArgs) this.setValue();
if (this.date < this.startDate) {
this.viewDate = new JalaliDate(this.startDate);
} else if (this.date > this.endDate) {
this.viewDate = new JalaliDate(this.endDate);
} else {
this.viewDate = new JalaliDate(this.date);
}
this.fill();
},
fillDow: function(){
var dowCnt = this.weekStart,
html = '<tr>';
if(this.calendarWeeks){
var cell = '<th class="cw"> </th>';
html += cell;
this.picker.find('.datepicker-days thead tr:first-child').prepend(cell);
}
while (dowCnt < this.weekStart + 7) {
html += '<th class="dow">'+dates[this.language].daysMin[(dowCnt++)%7]+'</th>';
}
html += '</tr>';
this.picker.find('.datepicker-days thead').append(html);
},
fillMonths: function(){
var html = '',
i = 0;
while (i < 12) {
html += '<span class="month">'+dates[this.language].monthsShort[i++]+'</span>';
}
this.picker.find('.datepicker-months td').html(html);
},
fill: function() {
var d = new JalaliDate(this.viewDate),
year = d.getUTCFullYear(),
month = d.getUTCMonth(),
startYear = this.startDate !== -Infinity ? this.startDate.getUTCFullYear() : -Infinity,
startMonth = this.startDate !== -Infinity ? this.startDate.getUTCMonth() : -Infinity,
endYear = this.endDate !== Infinity ? this.endDate.getUTCFullYear() : Infinity,
endMonth = this.endDate !== Infinity ? this.endDate.getUTCMonth() : Infinity,
currentDate = this.date.getGregorianDate() && this.date.getGregorianDate().valueOf(),
today = new Date();
this.picker.find('.datepicker-days thead th.switch')
.text(dates[this.language].months[month]+' '+year);
this.picker.find('tfoot th.today')
.text(dates[this.language].today)
.toggle(this.todayBtn !== false);
this.updateNavArrows();
this.fillMonths();
var prevMonth = new JalaliDate(year, month-1, 28,0,0,0,0),
day = DPGlobal.getDaysInMonth(prevMonth.getUTCFullYear(), prevMonth.getUTCMonth());
prevMonth.setUTCDate(day);
prevMonth.setUTCDate(day - (prevMonth.getUTCDay() - this.weekStart + 7)%7);
var nextMonth = new JalaliDate(prevMonth);
nextMonth.setUTCDate(nextMonth.getUTCDate() + 42);
nextMonth = nextMonth.valueOf();
_nextMonth = nextMonth.getGregorianDate().valueOf();
var html = [];
var clsName,
rowCount = 0;
while(prevMonth.getGregorianDate().valueOf() < _nextMonth) {
//if (prevMonth.getUTCDay() == this.weekStart) {
if (rowCount == 0) {
html.push('<tr>');
if(this.calendarWeeks){
// ISO 8601: First week contains first thursday.
// ISO also states week starts on Monday, but we can be more abstract here.
var
// Start of current week: based on weekstart/current date
ws = new JalaliDate(+prevMonth + (this.weekStart - prevMonth.getUTCDay() - 7) % 7 * 864e5),
// Thursday of this week
th = new JalaliDate(+ws + (7 + 4 - ws.getUTCDay()) % 7 * 864e5),
// First Thursday of year, year from thursday
yth = new JalaliDate(+(yth = new JalaliDate(th.getUTCFullYear(), 0, 1)) + (7 + 4 - yth.getUTCDay())%7*864e5),
// Calendar week: ms between thursdays, div ms per day, div 7 days
calWeek = (th - yth) / 864e5 / 7 + 1;
html.push('<td class="cw">'+ calWeek +'</td>');
}
}
clsName = '';
if (prevMonth.getFullYear() < year || (prevMonth.getFullYear() == year && prevMonth.getMonth() < month)) {
clsName += ' old';
} else if (prevMonth.getFullYear() > year || (prevMonth.getFullYear() == year && prevMonth.getMonth() > month)) {
clsName += ' new';
}
// Compare internal UTC date with local today, not UTC today
if (this.todayHighlight &&
prevMonth.getGregorianDate().getUTCFullYear() == today.getFullYear() &&
prevMonth.getGregorianDate().getUTCMonth() == today.getMonth() &&
prevMonth.getGregorianDate().getUTCDate() == today.getDate()) {
clsName += ' today';
}
if (currentDate && prevMonth.getGregorianDate().valueOf() == currentDate) {
clsName += ' active';
}
//convert date to gregorian then compare, and add condition for startDate and endDate if is not Infinity date
if ((this.startDate !== -Infinity && prevMonth.getGregorianDate().valueOf() < this.startDate.getGregorianDate().valueOf())||
(this.endDate !== Infinity && prevMonth.getGregorianDate().valueOf() > this.endDate.getGregorianDate().valueOf()) ||
$.inArray(prevMonth.getUTCDay(), this.daysOfWeekDisabled) !== -1) {
clsName += ' disabled';
}
html.push('<td class="day'+clsName+'">'+prevMonth.getUTCDate() + '</td>');
//if (prevMonth.getGregorianDate().getDay() == this.weekEnd) {
if (rowCount == 6) {
html.push('</tr>');
}
prevMonth.setUTCDate(prevMonth.getUTCDate()+1);
rowCount=(rowCount==6)?0:rowCount+1;
}
this.picker.find('.datepicker-days tbody').empty().append(html.join(''));
var currentYear = this.date && this.date.getUTCFullYear();
var months = this.picker.find('.datepicker-months')
.find('th:eq(1)')
.text(year)
.end()
.find('span').removeClass('active');
if (currentYear && currentYear == year) {
months.eq(this.date.getUTCMonth()).addClass('active');
}
if (year < startYear || year > endYear) {
months.addClass('disabled');
}
if (year == startYear) {
months.slice(0, startMonth).addClass('disabled');
}
if (year == endYear) {
months.slice(endMonth+1).addClass('disabled');
}
html = '';
year = parseInt(year/10, 10) * 10;
var yearCont = this.picker.find('.datepicker-years')
.find('th:eq(1)')
.text(year + '-' + (year + 9))
.end()
.find('td');
year -= 1;
for (var i = -1; i < 11; i++) {
html += '<span class="year'+(i == -1 || i == 10 ? ' old' : '')+(currentYear == year ? ' active' : '')+(year < startYear || year > endYear ? ' disabled' : '')+'">'+year+'</span>';
year += 1;
}
yearCont.html(html);
},
updateNavArrows: function() {
if (!this._allow_update) return;
var d = new JalaliDate(this.viewDate),
year = d.getFullYear(),
month = d.getMonth();
switch (this.viewMode) {
case 0:
if (this.startDate !== -Infinity && year <= this.startDate.getUTCFullYear() && month <= this.startDate.getUTCMonth()) {
this.picker.find('.prev').css({visibility: 'hidden'});
} else {
this.picker.find('.prev').css({visibility: 'visible'});
}
if (this.endDate !== Infinity && year >= this.endDate.getUTCFullYear() && month >= this.endDate.getUTCMonth()) {
this.picker.find('.next').css({visibility: 'hidden'});
} else {
this.picker.find('.next').css({visibility: 'visible'});
}
break;
case 1:
case 2:
if (this.startDate !== -Infinity && year <= this.startDate.getUTCFullYear()) {
this.picker.find('.prev').css({visibility: 'hidden'});
} else {
this.picker.find('.prev').css({visibility: 'visible'});
}
if (this.endDate !== Infinity && year >= this.endDate.getUTCFullYear()) {
this.picker.find('.next').css({visibility: 'hidden'});
} else {
this.picker.find('.next').css({visibility: 'visible'});
}
break;
}
},
click: function(e) {
e.preventDefault();
var target = $(e.target).closest('span, td, th');
if (target.length == 1) {
switch(target[0].nodeName.toLowerCase()) {
case 'th':
switch(target[0].className) {
case 'switch':
this.showMode(1);
break;
case 'prev':
case 'next':
var dir = DPGlobal.modes[this.viewMode].navStep * (target[0].className == 'prev' ? -1 : 1);
switch(this.viewMode){
case 0:
this.viewDate = this.moveMonth(this.viewDate, dir);
break;
case 1:
case 2:
this.viewDate = this.moveYear(this.viewDate, dir);
break;
}
this.fill();
break;
case 'today':
var date = new JalaliDate();
date = new JalaliDate(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0);
this.showMode(-2);
var which = this.todayBtn == 'linked' ? null : 'view';
this._setDate(date, which);
break;
}
break;
case 'span':
if (!target.is('.disabled')) {
this.viewDate.setUTCDate(1);
if (target.is('.month')) {
var day = 1;
var month = target.parent().find('span').index(target);
var year = this.viewDate.getUTCFullYear();
this.viewDate.setUTCMonth(month);
this.element.trigger({
type: 'changeMonth',
date: this.viewDate
});
if ( this.minViewMode == 1 ) {
this._setDate(new JalaliDate(year, month, day,0,0,0,0));
}
} else {
var year = parseInt(target.text(), 10)||0;
var day = 1;
var month = 0;
this.viewDate.setUTCFullYear(year);
this.element.trigger({
type: 'changeYear',
date: this.viewDate
});
if ( this.minViewMode == 2 ) {
this._setDate(new JalaliDate(year, month, day,0,0,0,0));
}
}
this.showMode(-1);
this.fill();
}
break;
case 'td':
if (target.is('.day') && !target.is('.disabled')){
var day = parseInt(target.text(), 10)||1;
var year = this.viewDate.getUTCFullYear(),
month = this.viewDate.getUTCMonth();
if (target.is('.old')) {
if (month === 0) {
month = 11;
year -= 1;
} else {
month -= 1;
}
} else if (target.is('.new')) {
if (month == 11) {
month = 0;
year += 1;
} else {
month += 1;
}
}
this._setDate(new JalaliDate(year, month, day,0,0,0,0));
}
break;
}
}
},
_setDate: function(date, which){
if (!which || which == 'date')
this.date = date;
if (!which || which == 'view')
this.viewDate = date;
this.fill();
this.setValue();
this.element.trigger({
type: 'changeDate',
date: this.date
});
var element;
if (this.isInput) {
element = this.element;
} else if (this.component){
element = this.element.find('input');
}
if (element) {
element.change();
if (this.autoclose && (!which || which == 'date')) {
this.hide();
}
}
},
moveMonth: function(date, dir){
if (!dir) return date;
var new_date = new JalaliDate(date.valueOf()),
day = new_date.getUTCDate(),
month = new_date.getUTCMonth(),
mag = Math.abs(dir),
new_month, test;
dir = dir > 0 ? 1 : -1;
if (mag == 1){
test = dir == -1
// If going back one month, make sure month is not current month
// (eg, Mar 31 -> Feb 31 == Feb 28, not Mar 02)
? function(){ return new_date.getUTCMonth() == month; }
// If going forward one month, make sure month is as expected
// (eg, Jan 31 -> Feb 31 == Feb 28, not Mar 02)
: function(){ return new_date.getUTCMonth() != new_month; };
new_month = month + dir;
new_date.setUTCMonth(new_month);
// Dec -> Jan (12) or Jan -> Dec (-1) -- limit expected date to 0-11
if (new_month < 0 || new_month > 11)
new_month = (new_month + 12) % 12;
} else {
// For magnitudes >1, move one month at a time...
for (var i=0; i<mag; i++)
// ...which might decrease the day (eg, Jan 31 to Feb 28, etc)...
new_date = this.moveMonth(new_date, dir);
// ...then reset the day, keeping it in the new month
new_month = new_date.getUTCMonth();
new_date.setUTCDate(day);
test = function(){ return new_month != new_date.getUTCMonth(); };
}
// Common date-resetting loop -- if date is beyond end of month, make it
// end of month
while (test()){
new_date.setUTCDate(--day);
new_date.setUTCMonth(new_month);
}
return new_date;
},
moveYear: function(date, dir){
return this.moveMonth(date, dir*12);
},
dateWithinRange: function(date){
return date >= this.startDate && date <= this.endDate;
},
keydown: function(e){
if (this.picker.is(':not(:visible)')){
if (e.keyCode == 27) // allow escape to hide and re-show picker
this.show();
return;
}
var dateChanged = false,
dir, day, month,
newDate, newViewDate;
switch(e.keyCode){
case 27: // escape
this.hide();
e.preventDefault();
break;
case 37: // left
case 39: // right
if (!this.keyboardNavigation) break;
dir = e.keyCode == 37 ? -1 : 1;
if (e.ctrlKey){
newDate = this.moveYear(this.date, dir);
newViewDate = this.moveYear(this.viewDate, dir);
} else if (e.shiftKey){
newDate = this.moveMonth(this.date, dir);
newViewDate = this.moveMonth(this.viewDate, dir);
} else {
newDate = new JalaliDate(this.date);
newDate.setUTCDate(this.date.getUTCDate() + dir);
newViewDate = new JalaliDate(this.viewDate);
newViewDate.setUTCDate(this.viewDate.getUTCDate() + dir);
}
if (this.dateWithinRange(newDate)){
this.date = newDate;
this.viewDate = newViewDate;
this.setValue();
this.update();
e.preventDefault();
dateChanged = true;
}
break;
case 38: // up
case 40: // down
if (!this.keyboardNavigation) break;
dir = e.keyCode == 38 ? -1 : 1;
if (e.ctrlKey){
newDate = this.moveYear(this.date, dir);
newViewDate = this.moveYear(this.viewDate, dir);
} else if (e.shiftKey){
newDate = this.moveMonth(this.date, dir);
newViewDate = this.moveMonth(this.viewDate, dir);
} else {
newDate = new JalaliDate(this.date);
newDate.setUTCDate(this.date.getUTCDate() + dir * 7);
newViewDate = new JalaliDate(this.viewDate);
newViewDate.setUTCDate(this.viewDate.getUTCDate() + dir * 7);
}
if (this.dateWithinRange(newDate)){
this.date = newDate;
this.viewDate = newViewDate;
this.setValue();
this.update();
e.preventDefault();
dateChanged = true;
}
break;
case 13: // enter
this.hide();
e.preventDefault();
break;
case 9: // tab
this.hide();
break;
}
if (dateChanged){
this.element.trigger({
type: 'changeDate',
date: this.date
});
var element;
if (this.isInput) {
element = this.element;
} else if (this.component){
element = this.element.find('input');
}
if (element) {
element.change();
}
}
},
showMode: function(dir) {
if (dir) {
this.viewMode = Math.max(this.minViewMode, Math.min(2, this.viewMode + dir));
}
/*
vitalets: fixing bug of very special conditions:
jquery 1.7.1 + webkit + show inline datepicker in bootstrap popover.
Method show() does not set display css correctly and datepicker is not shown.
Changed to .css('display', 'block') solve the problem.
See https://github.com/vitalets/x-editable/issues/37
In jquery 1.7.2+ everything works fine.
*/
//this.picker.find('>div').hide().filter('.datepicker-'+DPGlobal.modes[this.viewMode].clsName).show();
this.picker.find('>div').hide().filter('.datepicker-'+DPGlobal.modes[this.viewMode].clsName).css('display', 'block');
this.updateNavArrows();
}
};
$.fn.datepicker = function ( option ) {
var args = Array.apply(null, arguments);
args.shift();
return this.each(function () {
var $this = $(this),
data = $this.data('datepicker'),
options = typeof option == 'object' && option;
if (!data) {
$this.data('datepicker', (data = new Datepicker(this, $.extend({}, $.fn.datepicker.defaults,options))));
}
if (typeof option == 'string' && typeof data[option] == 'function') {
data[option].apply(data, args);
}
});
};
$.fn.datepicker.defaults = {
};
$.fn.datepicker.Constructor = Datepicker;
var dates = $.fn.datepicker.dates = {
en: {
days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"],
daysShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
daysMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"],
months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
monthsShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
today: "Today"
},
fa: {
days: ["یکشنبه", "دوشنبه", "سه شنبه", "چهارشنبه", "پنج شنبه", "جمعه", "شنبه", "یکشنبه"],
daysShort: ["شنبه", "یک", "دو", "سه", "چهار", "پنج", "جمعه", "شنبه"],
daysMin: ["ی", "د", "س", "چ", "پ", "ج", "ش", "ی"],
months: ["فروردین", "اردیبهشت", "خرداد", "تیر", "مرداد", "شهریور", "مهر", "آبان", "آذر", "دی", "بهمن", "اسفند"],
monthsShort: ["فروردین", "اردیبهشت", "خرداد", "تیر", "مرداد", "شهریور", "مهر", "آبان", "آذر", "دی", "بهمن", "اسفند"],
today: "امروز",
rtl: true,
}
};
var DPGlobal = {
modes: [
{
clsName: 'days',
navFnc: 'Month',
navStep: 1
},
{
clsName: 'months',
navFnc: 'FullYear',
navStep: 1
},
{
clsName: 'years',
navFnc: 'FullYear',
navStep: 10
}],
isLeapYear: function (year) {
//return (((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0));
return ((((((year - ((year > 0) ? 474 : 473)) % 2820) + 474) + 38) * 682) % 2816) < 682;
},
getDaysInMonth: function (year, month) {
//return [31, (DPGlobal.isLeapYear(year) ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];
return [31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29][month]
},
validParts: /dd?|DD?|mm?|MM?|yy(?:yy)?/g,
nonpunctuation: /[^ -\/:-@\[\u3400-\u9fff-`{-~\t\n\r]+/g,
parseFormat: function(format){
// IE treats \0 as a string end in inputs (truncating the value),
// so it's a bad format delimiter, anyway
var separators = format.replace(this.validParts, '\0').split('\0'),
parts = format.match(this.validParts);
if (!separators || !separators.length || !parts || parts.length === 0){
throw new Error("Invalid date format.");
}
return {separators: separators, parts: parts};
},
parseDate: function(date, format, language) {
if (date instanceof Date) return date;
if (/^[\-+]\d+[dmwy]([\s,]+[\-+]\d+[dmwy])*$/.test(date)) {
var part_re = /([\-+]\d+)([dmwy])/,
parts = date.match(/([\-+]\d+)([dmwy])/g),
part, dir;
date = new JalaliDate();
for (var i=0; i<parts.length; i++) {
part = part_re.exec(parts[i]);
dir = parseInt(part[1]);
switch(part[2]){
case 'd':
date.setUTCDate(date.getUTCDate() + dir);
break;
case 'm':
date = Datepicker.prototype.moveMonth.call(Datepicker.prototype, date, dir);
break;
case 'w':
date.setUTCDate(date.getUTCDate() + dir * 7);
break;
case 'y':
date = Datepicker.prototype.moveYear.call(Datepicker.prototype, date, dir);
break;
}
}
return new JalaliDate(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 0, 0, 0);
}
var parts = date && date.match(this.nonpunctuation) || [],
date = new JalaliDate(),
parsed = {},
setters_order = ['yyyy', 'yy', 'M', 'MM', 'm', 'mm', 'd', 'dd'],
setters_map = {
yyyy: function(d,v){ return d.setUTCFullYear(v); },
yy: function(d,v){ return d.setUTCFullYear(2000+v); },
m: function(d,v){
v -= 1;
while (v<0) v += 12;
v %= 12;
d.setUTCMonth(v);
while (d.getUTCMonth() != v)
d.setUTCDate(d.getUTCDate()-1);
return d;
},
d: function(d,v){ return d.setUTCDate(v); }
},
val, filtered, part;
setters_map['M'] = setters_map['MM'] = setters_map['mm'] = setters_map['m'];
setters_map['dd'] = setters_map['d'];
date = new JalaliDate(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0);
var fparts = format.parts.slice();
// Remove noop parts
if (parts.length != fparts.length) {
fparts = $(fparts).filter(function(i,p){
return $.inArray(p, setters_order) !== -1;
}).toArray();
}
// Process remainder
if (parts.length == fparts.length) {
for (var i=0, cnt = fparts.length; i < cnt; i++) {
val = parseInt(parts[i], 10);
part = fparts[i];
if (isNaN(val)) {
switch(part) {
case 'MM':
filtered = $(dates[language].months).filter(function(){
var m = this.slice(0, parts[i].length),
p = parts[i].slice(0, m.length);
return m == p;
});
val = $.inArray(filtered[0], dates[language].months) + 1;
break;
case 'M':
filtered = $(dates[language].monthsShort).filter(function(){
var m = this.slice(0, parts[i].length),
p = parts[i].slice(0, m.length);
return m == p;
});
val = $.inArray(filtered[0], dates[language].monthsShort) + 1;
break;
}
}
parsed[part] = val;
}
for (var i=0, s; i<setters_order.length; i++){
s = setters_order[i];
if (s in parsed && !isNaN(parsed[s]))
setters_map[s](date, parsed[s]);
}
}
return date;
},
formatDate: function(date, format, language){
var val = {
d: date.getUTCDate(),
D: dates[language].daysShort[date.getUTCDay()],
DD: dates[language].days[date.getUTCDay()],
m: date.getUTCMonth() + 1,
M: dates[language].monthsShort[date.getUTCMonth()],
MM: dates[language].months[date.getUTCMonth()],
yy: date.getUTCFullYear().toString().substring(2),
yyyy: date.getUTCFullYear()
};
val.dd = (val.d < 10 ? '0' : '') + val.d;
val.mm = (val.m < 10 ? '0' : '') + val.m;
var date = [],
seps = $.extend([], format.separators);
for (var i=0, cnt = format.parts.length; i < cnt; i++) {
if (seps.length)
date.push(seps.shift());
date.push(val[format.parts[i]]);
}
return date.join('');
},
headTemplate: '<thead>'+
'<tr>'+
'<th class="prev"><i class="fa fa-chevron-left"/></th>'+
'<th colspan="5" class="switch"></th>'+
'<th class="next"><i class="fa fa-chevron-right"/></th>'+
'</tr>'+
'</thead>',
contTemplate: '<tbody><tr><td colspan="7"></td></tr></tbody>',
footTemplate: '<tfoot><tr><th colspan="7" class="today"></th></tr></tfoot>'
};
DPGlobal.template = '<div class="datepicker">'+
'<div class="datepicker-days">'+
'<table class=" table-condensed">'+
DPGlobal.headTemplate+
'<tbody></tbody>'+
DPGlobal.footTemplate+
'</table>'+
'</div>'+
'<div class="datepicker-months">'+
'<table class="table-condensed">'+
DPGlobal.headTemplate+
DPGlobal.contTemplate+
DPGlobal.footTemplate+
'</table>'+
'</div>'+
'<div class="datepicker-years">'+
'<table class="table-condensed">'+
DPGlobal.headTemplate+
DPGlobal.contTemplate+
DPGlobal.footTemplate+
'</table>'+
'</div>'+
'</div>';
$.fn.datepicker.DPGlobal = DPGlobal;
}( window.jQuery );
function JalaliDate(p0, p1, p2) {
var gregorianDate;
var jalaliDate;
if (!isNaN(parseInt(p0)) && !isNaN(parseInt(p1)) && !isNaN(parseInt(p2))) {
var g = jalali_to_gregorian([parseInt(p0, 10), parseInt(p1, 10), parseInt(p2, 10)]);
setFullDate(new Date(g[0], g[1], g[2]));
} else {
setFullDate(p0);
}
function jalali_to_gregorian(d) {
var adjustDay = 0;
if(d[1]<0){
adjustDay = leap_persian(d[0]-1)? 30: 29;
d[1]++;
}
var gregorian = jd_to_gregorian(persian_to_jd(d[0], d[1] + 1, d[2])-adjustDay);
gregorian[1]--;
return gregorian;
}
function gregorian_to_jalali(d) {
var jalali = jd_to_persian(gregorian_to_jd(d[0], d[1] + 1, d[2]));
jalali[1]--;
return jalali;
}
function setFullDate(date) {
if (date && date.getGregorianDate) date = date.getGregorianDate();
gregorianDate = new Date(date);
gregorianDate.setHours(gregorianDate.getHours() > 12 ? gregorianDate.getHours() + 2 : 0)
if (!gregorianDate || gregorianDate == 'Invalid Date' || isNaN(gregorianDate || !gregorianDate.getDate())) {
gregorianDate = new Date();
}
jalaliDate = gregorian_to_jalali([
gregorianDate.getFullYear(),
gregorianDate.getMonth(),
gregorianDate.getDate()]);
return this;
}
this.getGregorianDate = function() { return gregorianDate; }
this.setFullDate = setFullDate;
this.setMonth = function(e) {
jalaliDate[1] = e;
var g = jalali_to_gregorian(jalaliDate);
gregorianDate = new Date(g[0], g[1], g[2]);
jalaliDate = gregorian_to_jalali([g[0], g[1], g[2]]);
}
this.setUTCMonth = function(e) {
jalaliDate[1] = e;
var g = jalali_to_gregorian(jalaliDate);
gregorianDate = new Date(g[0], g[1], g[2]);
jalaliDate = gregorian_to_jalali([g[0], g[1], g[2]]);
}
this.setFullYear = function(e) {
jalaliDate[0] = e;
var g = jalali_to_gregorian(jalaliDate);
gregorianDate = new Date(g[0], g[1], g[2]);
jalaliDate = gregorian_to_jalali([g[0], g[1], g[2]]);
}
this.setUTCFullYear = function(e) {
jalaliDate[0] = e;
var g = jalali_to_gregorian(jalaliDate);
gregorianDate = new Date(g[0], g[1], g[2]);
jalaliDate = gregorian_to_jalali([g[0], g[1], g[2]]);
}
this.setDate = function(e) {
jalaliDate[2] = e;
var g = jalali_to_gregorian(jalaliDate);
gregorianDate = new Date(g[0], g[1], g[2]);
jalaliDate = gregorian_to_jalali([g[0], g[1], g[2]]);
};
this.setUTCDate = function(e) {
jalaliDate[2] = e;
var g = jalali_to_gregorian(jalaliDate);
gregorianDate = new Date(g[0], g[1], g[2]);
jalaliDate = gregorian_to_jalali([g[0], g[1], g[2]]);
};
this.checkDate = function(j_y, j_m, j_d){
return !(j_y < 0 || j_y > 32767 || j_m < 1 || j_m > 12 || j_d < 1 || j_d >
(JalaliDate.j_days_in_month[j_m-1] + (j_m == 12 && !((j_y-979)%33%4))));
}
this.getFullYear = function() { return jalaliDate[0]; };
this.getUTCFullYear = function() { return jalaliDate[0]; };
this.getMonth = function() { return jalaliDate[1]; };
this.getUTCMonth = function() { return jalaliDate[1]; };
this.getDate = function() { return jalaliDate[2]; };
this.getUTCDate = function() { return jalaliDate[2]; };
this.toString = function() { return jalaliDate.join(',').toString(); };
this.getDay = function() { return gregorianDate.getDay(); };
this.getUTCDay = function() { return gregorianDate.getDay(); };
this.getHours = function() { return gregorianDate.getHours(); };
this.getMinutes = function() { return gregorianDate.getMinutes(); };
this.getSeconds = function() { return gregorianDate.getSeconds(); };
this.getTime = function() { return gregorianDate.getTime(); };
this.getTimeZoneOffset = function() { return gregorianDate.getTimeZoneOffset(); };
this.getYear = function() { return jalaliDate[0] % 100; };
this.setHours = function(e) { gregorianDate.setHours(e) };
this.setMinutes = function(e) { gregorianDate.setMinutes(e) };
this.setSeconds = function(e) { gregorianDate.setSeconds(e) };
this.setMilliseconds = function(e) { gregorianDate.setMilliseconds(e) };
}
|
import buble from 'rollup-plugin-buble';
export default {
entry: 'index.js',
format: 'cjs',
dest: 'dist/rollup-plugin-sass-modules.js',
external: [
'fs',
'path',
'resolve',
'node-sass',
'rollup-pluginutils',
],
plugins: [
buble(),
],
};
|
Vector2 = function(x, y){
this.x = x;
this.y = y;
};
Vector2.prototype.add = function(v){
this.x += v.x;
this.y += v.y;
};
Vector2.prototype.sub = function(v) {
this.x -= v.x;
this.y -= v.y;
};
Vector2.prototype.mult = function(s) {
this.x *= s;
this.y *= s;
};
Vector2.prototype.div = function(s) {
this.x /= s;
this.y /= s;
};
Vector2.prototype.mag = function() {
return Math.sqrt(this.x*this.x + this.y*this.y);
};
Vector2.prototype.setMag = function(m){
s = m / this.mag();
this.x /= s;
this.y /= s;
}
Vector2.prototype.normalize = function(){
this.x = this.x / this.mag();
this.y = this.y / this.mag();
}
Vector2.prototype.heading = function() {
return Math.atan2(this.y, this.x);
};
Vector2.prototype.rotate = function(a) {
this.x = this.mag() * Math.cos(this.heading() + a);
this.y = this.mag() * Math.sin(this.heading() + a);
};
Vector2.prototype.dot = function(v) {
return this.x * v.x + this.y * v.y;
};
Vector2.prototype.limit = function(max) {
if(this.mag() > max){
this.setMag(max);
}
};
Vector2.prototype.get = function() {
return new Vector2(this.x, this.y);
};
Vector2.random2D = function(){
randA = (Math.random() * (2 * Math.PI));
randX = Math.cos(randA);
randY = Math.sin(randA)
return new Vector2(randX, randY);
} |
var gulp = require('gulp');
gulp.task('production', ['images', 'shaders', 'minifyCss', 'uglifyJs']);
|
angular.module('billsync')
// .constant('$baseUrl', 'http://10.0.3.2:3000') // Genymotion
// .constant('$baseUrl', 'http://192.168.1.208:3000') // iOS
// .constant('$baseUrl', 'http://localhost:3000') // local Web app
//.constant('$baseUrl', 'https://billsync-staging.herokuapp.com') // Staging
.constant('$baseUrl', 'https://www.bill-sync.com') // Production
.config(function($stateProvider, $urlRouterProvider, AuthProvider, $httpProvider, $baseUrl) {
$stateProvider
.state('app', {
url: "/app",
abstract: true,
templateUrl: "templates/menu.html",
controller: 'AppCtrl'
})
.state('app.tabs', {
url: "/tabs",
abstract: true,
templateUrl: "templates/tabs.html",
controller: 'TabsCtrl'
})
.state('app.tabs.profile', {
url: "/profile",
views: {
'home-tab': {
templateUrl: "templates/profile.html",
controller: 'ProfileCtrl'
}
}
})
.state('app.tabs.settings', {
url: "/settings",
views: {
'home-tab': {
templateUrl: "templates/settings.html"
}
}
})
.state('app.tabs.users', {
url: "/users",
views: {
'home-tab': {
templateUrl: "templates/users.html",
controller: 'UsersCtrl'
}
}
})
.state('app.tabs.accounting', {
url: "/accounting",
views: {
'home-tab': {
templateUrl: "templates/accounting.html"
}
}
})
/*.state('app.usersAdd', {
url: "/users",
templateUrl: "templates/users-add.html",
controller: 'UsersCtrl'
})*/
.state('app.userEdit', {
url: "/user/:id/edit",
templateUrl: "templates/user-edit.html",
controller: 'UserEditCtrl'
})
.state('app.tabs.home', {
url: "/home",
views: {
'home-tab': {
templateUrl: "templates/home.html",
controller: 'HomeCtrl'
}
}
})
/* .state('app.vendors', {
url: "/vendors",
templateUrl: "templates/vendors.html",
controller: 'VendorsCtrl'
})*/
.state('app.tabs.vendors', {
url: "/vendors",
views: {
'home-tab': {
templateUrl: "templates/vendors.html",
controller: 'VendorsCtrl'
}
}
})
.state('app.tabs.vendorView', {
url: "/vendor/:id/view",
//templateUrl: "templates/vendor-view.html",
//controller: 'VendorEditCtrl'
views: {
'home-tab': {
templateUrl: "templates/vendor-view.html",
controller: 'VendorEditCtrl'
}
}
})
.state('app.tabs.vendorEdit', {
url: "/vendor/:id/edit",
views: {
'home-tab': {
templateUrl: "templates/vendor-edit.html",
controller: 'VendorEditCtrl'
}
}
})
/*.state('app.vendorEdit', {
url: "/vendor/:id/edit",
templateUrl: "templates/vendor-edit.html",
controller: 'VendorEditCtrl'
})*/
.state('app.tabs.vendorBasicInfo', {
url: "/vendor/:id/edit/basic-info",
views: {
'home-tab': {
templateUrl: "templates/vendor-tabs/basic-info.html",
controller: 'VendorEditCtrl'
}
}
})
/*.state('app.vendorBasicInfo', {
url: "/vendor/:id/edit/basic-info",
templateUrl: "templates/vendor-tabs/basic-info.html",
controller: 'VendorEditCtrl'
views: {
'vendors-tab': {
}
}
})*/
/*.state('app.vendorPaymentTerms', {
url: "/vendor/:id/edit/payment-terms",
templateUrl: "templates/vendor-tabs/payment-terms.html",
controller: 'VendorEditCtrl'
})*/
.state('app.tabs.vendorPaymentTerms', {
url: "/vendor/:id/edit/payment-terms",
views: {
'home-tab': {
templateUrl: "templates/vendor-tabs/payment-terms.html",
controller: 'VendorEditCtrl'
}
}
})
/*.state('app.vendorAlerts', {
url: "/vendor/:id/edit/alerts",
templateUrl: "templates/vendor-tabs/alerts.html",
controller: 'VendorEditCtrl'
})*/
.state('app.tabs.vendorAlerts', {
url: "/vendor/:id/edit/alerts",
views: {
'home-tab': {
templateUrl: "templates/vendor-tabs/alerts.html",
controller: 'VendorEditCtrl'
}
}
})
/*.state('app.vendorAccounting', {
url: "/vendor/:id/edit/accounting",
templateUrl: "templates/vendor-tabs/accounting.html",
controller: 'VendorEditCtrl'
})*/
.state('app.tabs.vendorAccounting', {
url: "/vendor/:id/edit/accounting",
views: {
'home-tab': {
templateUrl: "templates/vendor-tabs/accounting.html",
controller: 'VendorEditCtrl'
}
}
})
/*.state('app.vendorLineItems', {
url: "/vendor/:id/edit/line-items",
templateUrl: "templates/vendor-tabs/line-items.html",
controller: 'VendorEditCtrl'
})*/
.state('app.tabs.vendorLineItems', {
url: "/vendor/:id/edit/line-items",
views: {
'home-tab': {
templateUrl: "templates/vendor-tabs/line-items.html",
controller: 'VendorEditCtrl'
}
}
})
/*.state('app.vendorBills', {
url: "/vendor/:id/edit/bills",
templateUrl: "templates/vendor-tabs/bills.html",
controller: 'VendorEditCtrl'
})*/
.state('app.tabs.vendorBills', {
url: "/vendor/:id/edit/bills",
views: {
'home-tab': {
templateUrl: "templates/vendor-tabs/bills.html",
controller: 'VendorEditCtrl'
}
}
})
/*.state('app.vendorCombineVendors', {
url: "/vendor/:id/edit/combine-vendors",
templateUrl: "templates/vendor-tabs/combine-vendors.html",
controller: 'VendorEditCtrl'
})*/
.state('app.tabs.vendorCombineVendors', {
url: "/vendor/:id/edit/combine-vendors",
views: {
'home-tab': {
templateUrl: "templates/vendor-tabs/combine-vendors.html",
controller: 'VendorEditCtrl'
}
}
})
.state('app.tabs.invoice', {
url: "/invoice/:id",
views: {
'home-tab' :{
templateUrl: "templates/invoice.html",
controller: 'InvoiceCtrl'
}
}
})
.state('app.tabs.invoiceEdit', {
url: "/invoice/:id/edit?from",
views: {
'home-tab' :{
templateUrl: "templates/invoice-edit.html",
controller: 'InvoiceEditCtrl'
}
}
})
.state('app.capture', {
url: "/capture",
templateUrl: "templates/capture.html",
controller: 'CaptureCtrl'
})
.state('app.tabs.payments', {
url: "/payments",
views :{
'payments-tab' :{
templateUrl: "templates/payments.html",
controller: 'ReportsCtrl'
}
}
});
$urlRouterProvider.otherwise('/app/tabs/home');
AuthProvider.loginPath($baseUrl + '/auth/sign_in.json');
AuthProvider.logoutPath($baseUrl + '/auth/sign_out.json');
AuthProvider.registerPath($baseUrl + '/auth/sign_up.json');
AuthProvider.resourceName('individual');
AuthProvider.logoutMethod('GET');
$httpProvider.defaults.withCredentials = true;
});
|
window.Rendxx = window.Rendxx || {};
window.Rendxx.Game = window.Rendxx.Game || {};
window.Rendxx.Game.Ghost = window.Rendxx.Game.Ghost || {};
window.Rendxx.Game.Ghost.System = window.Rendxx.Game.Ghost.System || {};
/**
* Item: Basic
* Items on MapObject
*/
(function (SYSTEM) {
// Data ----------------------------------------------------------
var Data = SYSTEM.Data;
// Construct -----------------------------------------------------
var Basic = function (id, mapObjectId, name, entity) {
this.entity = entity;
this.id = id;
this.mapObjectId = mapObjectId;
this.characterId = -1;
this.name = name;
// callback
this.onChange = null;
};
Basic.prototype = Object.create(null);
Basic.prototype.constructor = Basic;
// Method --------------------------------------------------------
Basic.prototype.reset = function (_recoverData) {
if (_recoverData === undefined || _recoverData === null) return;
if ('mapObjectId' in _recoverData) this.mapObjectId = _recoverData.mapObjectId;
if ('characterId' in _recoverData) this.characterId = _recoverData.characterId;
};
Basic.prototype.toJSON = function () {
return {
mapObjectId: this.mapObjectId,
characterId: this.characterId
}
};
Basic.prototype.take = function (characterId) {
this.mapObjectId = -1;
this.characterId = characterId;
this.updateData();
};
Basic.prototype.place = function (mapObjectId) {
this.mapObjectId = mapObjectId;
this.characterId = -1;
this.updateData();
};
Basic.prototype.updateData = function () {
if (this.onChange === null) return;
this.onChange(this.id, this.toJSON());
};
Basic.prototype.touch = function (x, y) {
};
// ----------------------------------------------------------------
SYSTEM.Item = SYSTEM.Item || {};
SYSTEM.Item.Basic = Basic;
})(window.Rendxx.Game.Ghost.System); |
'use strict';
//Instructors service used for instructors REST endpoint
angular.module('mean.instructors').factory('Instructors', ['$resource',
function($resource) {
return $resource('api/instructors/:instructorId', {
instructorId: '@_id'
}, {
update: {
method: 'PUT'
}
});
}
]);
|
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @providesModule GraphQLSchemaUtils
*
* @format
*/
'use strict';
var _require = require('graphql'),
assertAbstractType = _require.assertAbstractType,
getNamedType = _require.getNamedType,
getNullableType = _require.getNullableType,
isType = _require.isType,
print = _require.print,
typeFromAST = _require.typeFromAST,
GraphQLInterfaceType = _require.GraphQLInterfaceType,
GraphQLList = _require.GraphQLList,
GraphQLObjectType = _require.GraphQLObjectType,
GraphQLSchema = _require.GraphQLSchema,
GraphQLUnionType = _require.GraphQLUnionType;
var ID = 'id';
var ID_TYPE = 'ID';
/**
* Determine if the given type may implement the named type:
* - it is the named type
* - it implements the named interface
* - it is an abstract type and *some* of its concrete types may
* implement the named type
*/
function mayImplement(schema, type, typeName) {
var unmodifiedType = getRawType(type);
return unmodifiedType.toString() === typeName || implementsInterface(unmodifiedType, typeName) || isAbstractType(unmodifiedType) && hasConcreteTypeThatImplements(schema, unmodifiedType, typeName);
}
function canHaveSelections(type) {
return type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType;
}
/**
* Implements duck typing that checks whether a type has an id field of the ID
* type. This is approximating what we can hopefully do with the __id proposal
* a bit more cleanly.
*
* https://github.com/graphql/graphql-future/blob/master/01%20-%20__id.md
*/
function hasID(schema, type) {
var unmodifiedType = getRawType(type);
require('fbjs/lib/invariant')(unmodifiedType instanceof GraphQLObjectType || unmodifiedType instanceof GraphQLInterfaceType, 'GraphQLSchemaUtils.hasID(): Expected a concrete type or interface, ' + 'got type `%s`.', type);
var idType = schema.getType(ID_TYPE);
var idField = unmodifiedType.getFields()[ID];
return idField && getRawType(idField.type) === idType;
}
/**
* Determine if a type is abstract (not concrete).
*
* Note: This is used in place of the `graphql` version of the function in order
* to not break `instanceof` checks with Jest. This version also unwraps
* non-null/list wrapper types.
*/
function isAbstractType(type) {
var rawType = getRawType(type);
return rawType instanceof GraphQLInterfaceType || rawType instanceof GraphQLUnionType;
}
function isUnionType(type) {
return type instanceof GraphQLUnionType;
}
/**
* Get the unmodified type, with list/null wrappers removed.
*/
function getRawType(type) {
return require('./nullthrowsOSS')(getNamedType(type));
}
/**
* Gets the non-list type, removing the list wrapper if present.
*/
function getSingularType(type) {
var unmodifiedType = type;
while (unmodifiedType instanceof GraphQLList) {
unmodifiedType = unmodifiedType.ofType;
}
return unmodifiedType;
}
/**
* @public
*/
function implementsInterface(type, interfaceName) {
return getInterfaces(type).some(function (interfaceType) {
return interfaceType.toString() === interfaceName;
});
}
/**
* @private
*/
function hasConcreteTypeThatImplements(schema, type, interfaceName) {
return isAbstractType(type) && getConcreteTypes(schema, type).some(function (concreteType) {
return implementsInterface(concreteType, interfaceName);
});
}
/**
* @private
*/
function getConcreteTypes(schema, type) {
return schema.getPossibleTypes(assertAbstractType(type));
}
/**
* @private
*/
function getInterfaces(type) {
if (type instanceof GraphQLObjectType) {
return type.getInterfaces();
}
return [];
}
/**
* @public
*
* Determine if an AST node contains a fragment/operation definition.
*/
function isOperationDefinitionAST(ast) {
return ast.kind === 'FragmentDefinition' || ast.kind === 'OperationDefinition';
}
/**
* @public
*
* Determine if an AST node contains a schema definition.
*/
function isSchemaDefinitionAST(ast) {
return ast.kind === 'DirectiveDefinition' || ast.kind === 'EnumTypeDefinition' || ast.kind === 'InputObjectTypeDefinition' || ast.kind === 'InterfaceTypeDefinition' || ast.kind === 'ObjectTypeDefinition' || ast.kind === 'ScalarTypeDefinition' || ast.kind === 'TypeExtensionDefinition' || ast.kind === 'UnionTypeDefinition';
}
function assertTypeWithFields(type) {
require('fbjs/lib/invariant')(type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType, 'GraphQLSchemaUtils: Expected type `%s` to be an object or interface type.', type);
return type;
}
/**
* Helper for calling `typeFromAST()` with a clear warning when the type does
* not exist. This enables the pattern `assertXXXType(getTypeFromAST(...))`,
* emitting distinct errors for unknown types vs types of the wrong category.
*/
function getTypeFromAST(schema, ast) {
var type = typeFromAST(schema, ast);
require('fbjs/lib/invariant')(isType(type), 'GraphQLSchemaUtils: Unknown type `%s`.', print(ast));
return type;
}
/**
* Given a defitinition AST node, gives us a unique name for that node.
* Note: this can be tricky for type extensions: while types always have one
* name, type extensions are defined by everything inside them.
*
* TODO @mmahoney: t16495627 write tests or remove uses of this
*/
function definitionName(definition) {
switch (definition.kind) {
case 'DirectiveDefinition':
case 'EnumTypeDefinition':
case 'FragmentDefinition':
case 'InputObjectTypeDefinition':
case 'InterfaceTypeDefinition':
case 'ObjectTypeDefinition':
case 'ScalarTypeDefinition':
case 'UnionTypeDefinition':
return definition.name.value;
case 'OperationDefinition':
return definition.name ? definition.name.value : '';
case 'TypeExtensionDefinition':
return definition.toString();
case 'SchemaDefinition':
return 'schema';
}
throw new Error('Unkown definition kind: ' + definition.kind);
}
module.exports = {
assertTypeWithFields: assertTypeWithFields,
definitionName: definitionName,
canHaveSelections: canHaveSelections,
getNullableType: getNullableType,
getRawType: getRawType,
getSingularType: getSingularType,
getTypeFromAST: getTypeFromAST,
hasID: hasID,
implementsInterface: implementsInterface,
isAbstractType: isAbstractType,
isUnionType: isUnionType,
isOperationDefinitionAST: isOperationDefinitionAST,
isSchemaDefinitionAST: isSchemaDefinitionAST,
mayImplement: mayImplement
}; |
/*************************************************************
*
* MathJax/localization/da/MathML.js
*
* Copyright (c) 2009-2018 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
MathJax.Localization.addTranslation("da","MathML",{
version: "2.7.3",
isLoaded: true,
strings: {
BadMglyph: "D\u00E5rlig mglyph: %1",
BadMglyphFont: "D\u00E5rlig skrifttype: %1",
MathPlayer: "MathJax var ikke i stand til at konfigurere MathPlayer.\n\nHvis MathPlayer ikke er installeret, skal du installere det f\u00F8rst.\nEllers, kan dine sikkerhedsindstillinger forhindrer ActiveX\nkontrolelementer i at k\u00F8re. Bruge dine Internetindstillinger under\ni menuen Funktioner og v\u00E6lg fanen Sikkerhed, og tryk derefter p\u00E5\nknappen Brugerdefineret niveau. Kontroller, at indstillingerne for\n'K\u00F8r ActiveX-objekter' og 'bin\u00E6r- og script-opf\u00F8rsel' er aktiveret.\n\nI \u00F8jeblikket vil du se fejlmeddelelser i stedet for\nformateret matematik",
CantCreateXMLParser: "MathJax kan ikke oprette en XML-parser til MathML. Kontroller, at\n'Script ActiveX-objekter markeret sikre til scripting' sikkerhed\ner aktiveret (bruge elementet Internetindstillinger i menuen \nv\u00E6rkt\u00F8jer, og v\u00E6lg sikkerhedspanel, tryk derefter p\u00E5 \nBrugerdefineret niveau knappen for at unders\u00F8ge det).\n\nMathML ligninger vil ikke kunne behandles af MathJax",
UnknownNodeType: "Ukendt nodetype: %1",
UnexpectedTextNode: "Uventet tekst node: %1",
ErrorParsingMathML: "Fejl under parsing af MathML",
ParsingError: "Fejl under parsing af MathML: %1",
MathMLSingleElement: "MathML skal v\u00E6re dannet af en enkelt element",
MathMLRootElement: "MathML skal v\u00E6re dannet af et \u003Cmath\u003E element, ikke %1"
}
});
MathJax.Ajax.loadComplete("[MathJax]/localization/da/MathML.js");
|
const DOMAttributeNames = {
acceptCharset: 'accept-charset',
className: 'class',
htmlFor: 'for',
httpEquiv: 'http-equiv'
}
let updatePromise
export function updateHead (head) {
const promise = updatePromise = Promise.resolve().then(() => {
if (promise !== updatePromise) return
updatePromise = null
const tags = {}
head.forEach((h) => {
const components = tags[h.type] || []
components.push(h)
tags[h.type] = components
})
updateTitle(tags.title && tags.title[0])
;['meta', 'base', 'link', 'style', 'script'].forEach((type) => {
updateElements(type, tags[type] || [])
})
})
}
function updateTitle (component) {
let title
if (component) {
const { children } = component.props
title = typeof children === 'string' ? children : children.join('')
} else {
title = ''
}
if (title !== document.title) document.title = title
}
function updateElements (type, components) {
const headEl = document.getElementsByTagName('head')[0]
const oldTags = Array.prototype.slice.call(headEl.querySelectorAll(type + '.next-head'))
const newTags = components.map(reactElementToDOM).filter((newTag) => {
for (let i = 0, len = oldTags.length; i < len; i++) {
const oldTag = oldTags[i]
if (oldTag.isEqualNode(newTag)) {
oldTags.splice(i, 1)
return false
}
}
return true
})
oldTags.forEach((t) => t.parentNode.removeChild(t))
newTags.forEach((t) => headEl.appendChild(t))
}
function reactElementToDOM ({ type, props }) {
const el = document.createElement(type)
for (const p in props) {
if (!props.hasOwnProperty(p)) continue
if (p === 'children' || p === 'dangerouslySetInnerHTML') continue
const attr = DOMAttributeNames[p] || p.toLowerCase()
el.setAttribute(attr, props[p])
}
const { children, dangerouslySetInnerHTML } = props
if (dangerouslySetInnerHTML) {
el.innerHTML = dangerouslySetInnerHTML.__html || ''
} else if (children) {
el.textContent = typeof children === 'string' ? children : children.join('')
}
return el
}
|
__history = [{"date":"Mon, 06 Jul 2015 01:38:04 GMT","sloc":164,"lloc":90,"functions":12,"deliveredBugs":1.083129029148451,"maintainability":66.34553435547375,"lintErrors":[],"difficulty":21.032608695652176}] |
import {requestAnimFrame, cancelAnimFrame} from 'Common';
import assign from 'lodash/object/assign';
const FPS = 60;
const DELTA_SAMPLE_SIZE = FPS;
const DELTA = 1000 / FPS;
const Runner = {};
Runner.create = function(state, tick, preTick = runner => runner) {
let counterTimestamp = 0;
let frameCounter = 0;
let deltaHistory = [];
let timePrev;
let timeScalePrev = 1;
const runner = assign({
fps: FPS,
timestamp: 0,
delta: DELTA,
correction: 1,
deltaMin: 1000 / FPS,
deltaMax: 1000 / (FPS * 0.5),
timeScale: 1,
isFixed: false,
frameRequestId: 0,
enabled: true,
frameCount: 0
}, state);
function step(time) {
let delta;
let correction = 1;
runner.frameRequestId = requestAnimFrame(step);
if (!runner.enabled) {
return;
}
preTick(runner);
if (runner.isFixed) {
// fixed timestep
delta = runner.delta;
} else {
// dynamic timestep based on wall clock between calls
delta = (time - timePrev) || runner.delta;
timePrev = time;
// optimistically filter delta over a few frames, to improve stability
deltaHistory.push(delta);
deltaHistory = deltaHistory.slice(-DELTA_SAMPLE_SIZE);
delta = Math.min.apply(null, deltaHistory);
// limit delta
delta = delta < runner.deltaMin ? runner.deltaMin : delta;
delta = delta > runner.deltaMax ? runner.deltaMax : delta;
// time correction for delta
correction = delta / runner.delta;
// update engine timing object
runner.delta = delta;
}
// time correction for time scaling
if (timeScalePrev !== 0) {
correction *= runner.timeScale / timeScalePrev;
}
if (runner.timeScale === 0) {
correction = 0;
}
timeScalePrev = runner.timeScale;
// fps counter
frameCounter += 1;
if (time - counterTimestamp >= 1000) {
runner.fps = frameCounter * ((time - counterTimestamp) / 1000);
counterTimestamp = time;
frameCounter = 0;
}
runner.frameCount += 1;
tick(delta, correction, runner);
}
runner.frameRequestId = requestAnimFrame(step);
return runner;
};
Runner.destroy = function(runner) {
cancelAnimFrame(runner.frameRequestId);
};
export default Runner; |
import React from 'react';
import cssModules from 'react-css-modules';
import styles from './index.module.scss';
import { EventsContainer } from 'containers';
const EventsPage = () => (
<div className={styles.container}>
<EventsContainer />
</div>
);
export default cssModules(EventsPage, styles);
|
var fs = require('fs')
, starx = require('starx')
, resolve = require('path').resolve
, readFile = starx.yieldable(require('fs').readFile)
, defaultImg = new Buffer('AAABAAEAEBAQAAEABAAoAQAAFgAAACgAAAAQAAAAIAAAAAEABAAAAAAAgAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAA/4QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAAAAAQABAAEAAAAAEAEAEAAAAAABAQEAAAAAAAAREAAAAAEREREREREAAAAAERAAAAAAAAEBAQAAAAAAEAEAEAAAAAEAAQABAAAAAAABAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAD//wAA/38AAP9/AAD3dwAA+28AAP1fAAD+PwAAwAEAAP4/AAD9XwAA+28AAPd3AAD/fwAA/38AAP//AAD//wAA', 'base64')
exports = module.exports = favicon
function favicon(path) {
return function *(next) {
if (this.path !== '/favicon.ico') return yield next
var img = path
? yield readFile(resolve(path))
: defaultImg
this.type = 'image/x-icon'
this.body = img
}
} |
import React, { Component } from 'react';
import ReactDOM from 'react-dom';
import { createStore, combineReducers } from 'redux';
import { Provider } from 'react-redux';
import { Router, Route } from 'react-router';
import { createHistory } from 'history';
import votesReducer from './reducers';
import VotingPage from './components/voting-page';
import VotingSummary from './components/voting-summary';
const history = createHistory();
const store = createStore(
combineReducers({
votes: votesReducer,
})
);
class App extends Component {
render() {
return (
<Provider store={store}>
<Router history={history}>
<Route component={VotingPage} path="/vote"/>
<Route component={VotingSummary} path="/summary"/>
</Router>
</Provider>
);
}
}
ReactDOM.render(<App/>, document.getElementById('content'));
|
/**
*
*/
requirejs(['../common/config2'], function () {
requirejs(['widget/msg', 'note', './widget/along', 'outside'], function (msg, note, along, outside) {
$(function () {
$("h1").after('<p>' + msg.getName() + ';' + note.getName() + ';' + along.getName() + ';' + outside.getName() + '</p>');
});
});
});
|
const chai = require('chai');
const expect = chai.expect;
const fs = require('fs');
const path = require('path');
const CASE_PATH = './tests/files/cases';
const cases = fs.readdirSync(CASE_PATH).map(filename => {
if (!filename.endsWith('.js')) {
throw new Error(`Invalid case ${filename} in ./tests/files/cases`);
}
let name = filename.substr(0, filename.length - 3);
let names = name.split('_').map(n => n[0].toUpperCase() + n.substr(1));
return {
name: [names[0], `(${names[1]})`].concat(names.slice(2)).join(' '),
valid: names[1] === 'Valid',
pathname: filename,
buffer: fs.readFileSync(path.join(CASE_PATH, filename))
}
});
describe('LibDoc', () => {
const FunctionParser = require('../index.js').FunctionParser;
const parser = new FunctionParser();
const types = require('../index.js').types;
describe('Function Validation', () => {
cases.forEach(functionCase => {
it(`Should check ${functionCase.name}`, () => {
let err;
try {
parser.parseDefinition(functionCase.pathname, functionCase.buffer);
} catch (e) {
err = e;
}
functionCase.valid ?
expect(err).to.not.exist :
expect(err).to.exist;
});
});
});
describe('Comprehensive Test', () => {
let definitions = parser.load('./tests/files/comprehensive');
let ignoredDefinitions = parser.load('./tests/files/ignore', null, ['ignoreme.js']);
it('Should read all functions correctly', () => {
expect(Object.keys(definitions).length).to.equal(18);
expect(definitions).to.haveOwnProperty('');
expect(definitions).to.haveOwnProperty('test');
expect(definitions).to.haveOwnProperty('returns');
expect(definitions).to.haveOwnProperty('default');
expect(definitions).to.haveOwnProperty('multiline_description');
expect(definitions).to.haveOwnProperty('dir/test');
expect(definitions).to.haveOwnProperty('dir/sub');
expect(definitions).to.haveOwnProperty('dir/sub/test');
expect(definitions).to.haveOwnProperty('schema/basic');
expect(definitions).to.haveOwnProperty('schema/optional');
expect(definitions).to.haveOwnProperty('schema/nested');
expect(definitions).to.haveOwnProperty('schema/array');
expect(definitions).to.haveOwnProperty('enum');
expect(definitions).to.haveOwnProperty('enum_return');
});
it('Should read all functions correctly with ignore parameter set', () => {
expect(Object.keys(ignoredDefinitions).length).to.equal(1);
expect(ignoredDefinitions).to.haveOwnProperty('');
});
it('Should have correct filenames', () => {
expect(definitions[''].pathname).to.equal('__main__.js');
expect(definitions['test'].pathname).to.equal('test.js');
expect(definitions['returns'].pathname).to.equal('returns.js');
expect(definitions['default'].pathname).to.equal('default.js');
expect(definitions['multiline_description'].pathname).to.equal('multiline_description.js');
expect(definitions['dir/test'].pathname).to.equal('dir/test.js');
expect(definitions['dir/sub'].pathname).to.equal('dir/sub/__main__.js');
expect(definitions['dir/sub/test'].pathname).to.equal('dir/sub/test.js');
expect(definitions['schema/basic'].pathname).to.equal('schema/basic.js');
expect(definitions['schema/optional'].pathname).to.equal('schema/optional.js');
expect(definitions['schema/nested'].pathname).to.equal('schema/nested.js');
expect(definitions['schema/array'].pathname).to.equal('schema/array.js');
expect(definitions['enum'].pathname).to.equal('enum.js');
expect(definitions['enum_return'].pathname).to.equal('enum_return.js');
});
it('Should have correct descriptions', () => {
expect(definitions[''].description).to.equal('');
expect(definitions['test'].description).to.equal('Test function');
expect(definitions['returns'].description).to.equal('');
expect(definitions['default'].description).to.equal('Test default parameters');
expect(definitions['multiline_description'].description).to.equal('Test multi line descriptions\nThis is a second line\nThis is a third line\n\nThis is a fourth line\n');
expect(definitions['dir/test'].description).to.equal('');
expect(definitions['dir/sub'].description).to.equal('Test function');
expect(definitions['dir/sub/test'].description).to.equal('');
expect(definitions['schema/basic'].description).to.equal('Test Schema Input');
expect(definitions['schema/optional'].description).to.equal('Test Optional Schema Input');
expect(definitions['schema/nested'].description).to.equal('Test Nested Schema Input');
expect(definitions['schema/array'].description).to.equal('Test Array Schema Input');
expect(definitions['enum'].description).to.equal('Test Enum');
expect(definitions['enum_return'].description).to.equal('Test Enum Returns');
});
it('Should have correct context', () => {
expect(definitions[''].context).to.equal(null);
expect(definitions['test'].context).to.exist;
expect(definitions['returns'].context).to.equal(null);
expect(definitions['default'].context).to.exist;
expect(definitions['multiline_description'].context).to.equal(null);
expect(definitions['dir/test'].context).to.exist;
expect(definitions['dir/sub'].context).to.equal(null);
expect(definitions['dir/sub/test'].context).to.exist;
expect(definitions['schema/basic'].context).to.equal(null);
expect(definitions['schema/optional'].context).to.equal(null);
expect(definitions['schema/nested'].context).to.equal(null);
expect(definitions['schema/array'].context).to.equal(null);
expect(definitions['enum'].context).to.equal(null);
expect(definitions['enum_return'].context).to.exist;
});
it('Should have correct returns descriptions', () => {
expect(definitions[''].returns.description).to.equal('');
expect(definitions['test'].returns.description).to.equal('');
expect(definitions['returns'].returns.description).to.equal('hello');
expect(definitions['default'].returns.description).to.equal('');
expect(definitions['dir/test'].returns.description).to.equal('');
expect(definitions['dir/sub'].returns.description).to.equal('A return description!');
expect(definitions['dir/sub/test'].returns.description).to.equal('');
expect(definitions['schema/basic'].returns.description).to.equal('');
expect(definitions['schema/optional'].returns.description).to.equal('');
expect(definitions['schema/nested'].returns.description).to.equal('');
expect(definitions['schema/array'].returns.description).to.equal('');
expect(definitions['enum'].returns.description).to.equal('');
expect(definitions['enum_return'].returns.description).to.equal('a or b');
});
it('Should have correct returns types', () => {
expect(definitions[''].returns.type).to.equal('any');
expect(definitions['test'].returns.type).to.equal('boolean');
expect(definitions['returns'].returns.type).to.equal('number');
expect(definitions['default'].returns.type).to.equal('string');
expect(definitions['dir/test'].returns.type).to.equal('any');
expect(definitions['dir/sub'].returns.type).to.equal('boolean');
expect(definitions['dir/sub/test'].returns.type).to.equal('any');
expect(definitions['schema/basic'].returns.type).to.equal('string');
expect(definitions['schema/optional'].returns.type).to.equal('string');
expect(definitions['schema/nested'].returns.type).to.equal('string');
expect(definitions['schema/array'].returns.type).to.equal('string');
expect(definitions['enum'].returns.type).to.equal('any');
expect(definitions['enum_return'].returns.type).to.equal('enum');
});
it('Should have correct charge value', () => {
expect(definitions[''].charge).to.equal(1);
expect(definitions['test'].charge).to.equal(0);
expect(definitions['returns'].charge).to.equal(1);
expect(definitions['default'].charge).to.equal(1);
expect(definitions['multiline_description'].charge).to.equal(1);
expect(definitions['dir/test'].charge).to.equal(1);
expect(definitions['dir/sub'].charge).to.equal(19);
expect(definitions['dir/sub/test'].charge).to.equal(1);
expect(definitions['schema/basic'].charge).to.equal(1);
expect(definitions['schema/optional'].charge).to.equal(1);
expect(definitions['schema/nested'].charge).to.equal(1);
expect(definitions['schema/array'].charge).to.equal(1);
expect(definitions['enum'].charge).to.equal(1);
expect(definitions['enum_return'].charge).to.equal(1);
});
it('Should have correct keys', () => {
expect(definitions[''].keys).to.be.an('Array');
expect(definitions[''].keys).to.have.length(0);
expect(definitions['test'].keys).to.be.an('Array');
expect(definitions['test'].keys).to.have.length(0);
expect(definitions['returns'].keys).to.be.an('Array');
expect(definitions['returns'].keys).to.have.length(0);
expect(definitions['default'].keys).to.be.an('Array');
expect(definitions['default'].keys).to.have.length(0);
expect(definitions['multiline_description'].keys).to.be.an('Array');
expect(definitions['multiline_description'].keys).to.have.length(0);
expect(definitions['dir/test'].keys).to.be.an('Array');
expect(definitions['dir/test'].keys).to.have.length(0);
expect(definitions['dir/sub'].keys).to.be.an('Array');
expect(definitions['dir/sub'].keys).to.have.length(2);
expect(definitions['dir/sub'].keys[0]).to.equal('TEST_KEY');
expect(definitions['dir/sub'].keys[1]).to.equal('TEST_KEY2');
expect(definitions['dir/sub/test'].keys).to.be.an('Array');
expect(definitions['dir/sub/test'].keys).to.have.length(0);
expect(definitions['schema/basic'].keys).to.be.an('Array');
expect(definitions['schema/basic'].keys).to.have.length(0);
expect(definitions['schema/optional'].keys).to.be.an('Array');
expect(definitions['schema/optional'].keys).to.have.length(0);
expect(definitions['schema/nested'].keys).to.be.an('Array');
expect(definitions['schema/nested'].keys).to.have.length(0);
expect(definitions['schema/array'].keys).to.be.an('Array');
expect(definitions['schema/array'].keys).to.have.length(0);
expect(definitions['enum'].keys).to.be.an('Array');
expect(definitions['enum'].keys).to.have.length(0);
expect(definitions['enum_return'].keys).to.be.an('Array');
expect(definitions['enum_return'].keys).to.have.length(0);
});
it('Should read "" (default) parameters', () => {
let params = definitions[''].params;
expect(params.length).to.equal(0);
});
it('Should read "test" parameters', () => {
let params = definitions['test'].params;
expect(params.length).to.equal(1);
expect(params[0].name).to.equal('a');
expect(params[0].type).to.equal('boolean');
expect(params[0].description).to.equal('alpha');
});
it('Should read "default" parameters', () => {
let params = definitions['default'].params;
expect(params.length).to.equal(2);
expect(params[0].name).to.equal('name');
expect(params[0].type).to.equal('string');
expect(params[0].description).to.equal('A name');
expect(params[0].defaultValue).to.equal('hello');
expect(params[1].name).to.equal('obj');
expect(params[1].type).to.equal('object');
expect(params[1].description).to.equal('An object');
expect(params[1].defaultValue).to.exist;
expect(params[1].defaultValue).to.haveOwnProperty('result');
expect(params[1].defaultValue.result).to.haveOwnProperty('a-string-key');
expect(params[1].defaultValue.result['a-string-key']).to.equal(1);
expect(params[1].defaultValue.result[1]).to.equal('one');
});
it('Should read "dir/test" parameters', () => {
let params = definitions['dir/test'].params;
expect(params.length).to.equal(6);
expect(params[0].name).to.equal('a');
expect(params[0].type).to.equal('boolean');
expect(params[0].description).to.equal('');
expect(params[1].name).to.equal('b');
expect(params[1].type).to.equal('string');
expect(params[1].description).to.equal('');
expect(params[2].name).to.equal('c');
expect(params[2].type).to.equal('number');
expect(params[2].description).to.equal('');
expect(params[3].name).to.equal('d');
expect(params[3].type).to.equal('any');
expect(params[3].description).to.equal('');
expect(params[4].name).to.equal('e');
expect(params[4].type).to.equal('array');
expect(params[4].description).to.equal('');
expect(params[5].name).to.equal('f');
expect(params[5].type).to.equal('object');
expect(params[5].description).to.equal('');
});
it('Should read "dir/test" default values', () => {
let params = definitions['dir/test'].params;
expect(params.length).to.equal(6);
expect(params[0].defaultValue).to.equal(true);
expect(params[1].defaultValue).to.equal('false');
expect(params[2].defaultValue).to.equal(1);
expect(params[3].defaultValue).to.equal(null);
expect(params[4].defaultValue).to.be.an('array');
expect(params[4].defaultValue).to.deep.equal([]);
expect(params[5].defaultValue).to.be.an('object');
expect(params[5].defaultValue).to.deep.equal({});
});
it('Should read "dir/sub" parameters', () => {
let params = definitions['dir/sub'].params;
expect(params.length).to.equal(6);
expect(params[0].name).to.equal('a');
expect(params[0].type).to.equal('boolean');
expect(params[0].description).to.equal('alpha');
expect(params[1].name).to.equal('b');
expect(params[1].type).to.equal('string');
expect(params[1].description).to.equal('beta');
expect(params[2].name).to.equal('c');
expect(params[2].type).to.equal('number');
expect(params[2].description).to.equal('gamma');
expect(params[3].name).to.equal('d');
expect(params[3].type).to.equal('any');
expect(params[3].description).to.equal('delta');
expect(params[4].name).to.equal('e');
expect(params[4].type).to.equal('array');
expect(params[4].description).to.equal('epsilon');
expect(params[5].name).to.equal('f');
expect(params[5].type).to.equal('object');
expect(params[5].description).to.equal('zeta');
});
it('Should read "dir/sub" default values', () => {
let params = definitions['dir/sub'].params;
expect(params.length).to.equal(6);
expect(params[0].defaultValue).to.equal(true);
expect(params[1].defaultValue).to.equal('false');
expect(params[2].defaultValue).to.equal(1);
expect(params[3].defaultValue).to.equal(null);
expect(params[4].defaultValue).to.be.an('array');
expect(params[4].defaultValue).to.deep.equal([1, 2, 3, {four: 'five'}]);
expect(params[5].defaultValue).to.be.an('object');
expect(params[5].defaultValue).to.deep.equal({one: 'two', three: [4, 5]});
});
it('Should read "dir/sub/test" parameters', () => {
let params = definitions['dir/sub/test'].params;
expect(params.length).to.equal(0);
});
it('Should read "schema/basic" parameters', () => {
let params = definitions['schema/basic'].params;
expect(params.length).to.equal(3);
expect(params[0].name).to.equal('before');
expect(params[0].type).to.equal('string');
expect(params[0].description).to.equal('');
expect(params[2].name).to.equal('after');
expect(params[2].type).to.equal('string');
expect(params[2].description).to.equal('');
expect(params[1].name).to.equal('obj');
expect(params[1].type).to.equal('object');
expect(params[1].description).to.equal('');
expect(params[1].schema).to.exist;
expect(params[1].schema[0].name).to.equal('name');
expect(params[1].schema[0].type).to.equal('string');
expect(params[1].schema[1].name).to.equal('enabled');
expect(params[1].schema[1].type).to.equal('boolean');
expect(params[1].schema[2].name).to.equal('data');
expect(params[1].schema[2].type).to.equal('object');
expect(params[1].schema[2].schema[0].name).to.equal('a');
expect(params[1].schema[2].schema[0].type).to.equal('string');
expect(params[1].schema[2].schema[1].name).to.equal('b');
expect(params[1].schema[2].schema[1].type).to.equal('string');
expect(params[1].schema[3].name).to.equal('timestamp');
expect(params[1].schema[3].type).to.equal('number');
});
it('Should read "schema/optional" parameters', () => {
let params = definitions['schema/optional'].params;
expect(params.length).to.equal(3);
expect(params[0].name).to.equal('before');
expect(params[0].defaultValue).to.equal(null);
expect(params[0].type).to.equal('string');
expect(params[0].description).to.equal('');
expect(params[1].name).to.equal('obj');
expect(params[1].type).to.equal('object');
expect(params[1].description).to.equal('');
expect(params[1].schema).to.exist;
expect(params[1].schema[0].name).to.equal('name');
expect(params[1].schema[0].defaultValue).to.equal(null);
expect(params[1].schema[0].type).to.equal('string');
expect(params[1].schema[1].name).to.equal('enabled');
expect(params[1].schema[1].defaultValue).to.equal(null);
expect(params[1].schema[1].type).to.equal('boolean');
expect(params[1].schema[2].name).to.equal('data');
expect(params[1].schema[2].type).to.equal('object');
expect(params[1].schema[2].schema[0].name).to.equal('a');
expect(params[1].schema[2].schema[0].defaultValue).to.equal(null);
expect(params[1].schema[2].schema[0].type).to.equal('string');
expect(params[1].schema[2].schema[1].name).to.equal('b');
expect(params[1].schema[2].schema[1].type).to.equal('string');
expect(params[1].schema[3].name).to.equal('timestamp');
expect(params[1].schema[3].type).to.equal('number');
expect(params[2].name).to.equal('after');
expect(params[2].type).to.equal('string');
expect(params[2].description).to.equal('');
});
it('Should read "schema/nested" parameters', () => {
let params = definitions['schema/nested'].params;
expect(params).to.deep.equal([
{
name: 'before',
type: 'string',
description: ''
},
{
name: 'obj',
type: 'object',
description: '',
schema: [
{
name: 'str',
type: 'string',
description: ''
},
{
name: 'bool',
type: 'boolean',
description: ''
},
{
name: 'obj',
type: 'object',
description: '',
schema: [
{
name: 'str',
type: 'string',
description: ''
},
{
name: 'obj',
type: 'object',
description: '',
schema: [
{
name: 'str',
type: 'string',
description: ''
}
]
}
]
},
{
name: 'num',
type: 'number',
description: ''
}
]
},
{
name: 'after',
type: 'string',
description: ''
}
]);
});
it('Should read "schema/array" parameters', () => {
let params = definitions['schema/array'].params;
expect(params).to.deep.equal([
{
name: 'arr1',
type: 'array',
description: '',
schema: [
{
name: 'str',
type: 'string',
description: ''
}
]
},
{
name: 'arr2',
type: 'array',
description: '',
schema: [
{
name: 'obj',
type: 'object',
description: '',
schema: [
{
name: 'str',
type: 'string',
description: ''
},
{
name: 'obj',
type: 'object',
description: '',
schema: [
{
name: 'str',
type: 'string',
description: ''
},
]
}
]
}
]
}
]);
});
it('Should read "enum_schema" parameters', () => {
let params = definitions['enum_schema'].params;
expect(params).to.deep.equal([
{
name: 'before',
type: 'string',
description: 'a param'
},
{
name: 'valueRange',
type: 'object',
description: 'The data to be inserted',
schema: [
{
type: 'string',
name: 'range',
description: ''
},
{
type: 'enum',
name: 'majorDimension',
description: '',
members: [
['ROWS', "ROWS"],
['COLUMNS', "COLUMNS"]
]
},
{
type: 'array',
name: 'values',
description: 'An array of arrays, the outer array representing all the data and each inner array representing a major dimension. Each item in the inner array corresponds with one cell'
}
]
},
{
name: 'after',
type: 'string',
description: 'a param'
}
]);
});
it('Should had a named return value and description', () => {
let definition = definitions['named_return'];
expect(definition.returns.name).to.equal('returnName');
expect(definition.returns.description).to.equal('And a return description');
});
it('Should had a nullable return value', () => {
let definition = definitions['nullable_return'];
expect(definition.returns.description).to.equal('not sure');
expect(definition.returns.type).to.equal('string');
expect(definition.returns.name).to.equal('maybestring');
expect(definition.returns.defaultValue).to.equal(null);
});
it('Should read "enum" parameters', () => {
let params = definitions['enum'].params;
expect(params).to.deep.equal([
{
name: 'before',
type: 'any',
defaultValue: null,
description: ''
},
{
name: 'basic',
type: 'enum',
description: 'some basic types',
members: [['num', 0], ['double', '1'], ['float', 1.2], ['numstr', '123']]
},
{
name: 'after',
type: 'any',
defaultValue: null,
description: ''
}
]);
});
});
describe('Types', () => {
it('should validate "string"', () => {
expect(types.validate('string', 'abc')).to.equal(true);
expect(types.validate('string', 1)).to.equal(false);
expect(types.validate('string', 1.1)).to.equal(false);
expect(types.validate('string', 1e300)).to.equal(false);
expect(types.validate('string', true)).to.equal(false);
expect(types.validate('string', {})).to.equal(false);
expect(types.validate('string', [])).to.equal(false);
expect(types.validate('string', new Buffer(0))).to.equal(false);
expect(types.validate('string', null)).to.equal(false);
expect(types.validate('string', null, true)).to.equal(true);
});
it('should validate "number"', () => {
expect(types.validate('number', 'abc')).to.equal(false);
expect(types.validate('number', 1)).to.equal(true);
expect(types.validate('number', 1.1)).to.equal(true);
expect(types.validate('number', 1e300)).to.equal(true);
expect(types.validate('number', true)).to.equal(false);
expect(types.validate('number', {})).to.equal(false);
expect(types.validate('number', [])).to.equal(false);
expect(types.validate('number', new Buffer(0))).to.equal(false);
expect(types.validate('number', null)).to.equal(false);
expect(types.validate('number', null, true)).to.equal(true);
});
it('should validate "float"', () => {
expect(types.validate('float', 'abc')).to.equal(false);
expect(types.validate('float', 1)).to.equal(true);
expect(types.validate('float', 1.1)).to.equal(true);
expect(types.validate('float', 1e300)).to.equal(true);
expect(types.validate('float', true)).to.equal(false);
expect(types.validate('float', {})).to.equal(false);
expect(types.validate('float', [])).to.equal(false);
expect(types.validate('float', new Buffer(0))).to.equal(false);
expect(types.validate('float', null)).to.equal(false);
expect(types.validate('float', null, true)).to.equal(true);
});
it('should validate "integer"', () => {
expect(types.validate('integer', 'abc')).to.equal(false);
expect(types.validate('integer', 1)).to.equal(true);
expect(types.validate('integer', 1.1)).to.equal(false);
expect(types.validate('integer', 1e300)).to.equal(false);
expect(types.validate('integer', true)).to.equal(false);
expect(types.validate('integer', {})).to.equal(false);
expect(types.validate('integer', [])).to.equal(false);
expect(types.validate('integer', new Buffer(0))).to.equal(false);
expect(types.validate('integer', null)).to.equal(false);
expect(types.validate('integer', null, true)).to.equal(true);
});
it('should validate "boolean"', () => {
expect(types.validate('boolean', 'abc')).to.equal(false);
expect(types.validate('boolean', 1)).to.equal(false);
expect(types.validate('boolean', 1.1)).to.equal(false);
expect(types.validate('boolean', 1e300)).to.equal(false);
expect(types.validate('boolean', true)).to.equal(true);
expect(types.validate('boolean', {})).to.equal(false);
expect(types.validate('boolean', [])).to.equal(false);
expect(types.validate('boolean', new Buffer(0))).to.equal(false);
expect(types.validate('boolean', null)).to.equal(false);
expect(types.validate('boolean', null, true)).to.equal(true);
});
it('should validate "object"', () => {
expect(types.validate('object', 'abc')).to.equal(false);
expect(types.validate('object', 1)).to.equal(false);
expect(types.validate('object', 1.1)).to.equal(false);
expect(types.validate('object', 1e300)).to.equal(false);
expect(types.validate('object', true)).to.equal(false);
expect(types.validate('object', {})).to.equal(true);
expect(types.validate('object', [])).to.equal(false);
expect(types.validate('object', new Buffer(0))).to.equal(false);
expect(types.validate('object', null)).to.equal(false);
expect(types.validate('object', null, true)).to.equal(true);
});
it('should validate "array"', () => {
expect(types.validate('array', 'abc')).to.equal(false);
expect(types.validate('array', 1)).to.equal(false);
expect(types.validate('array', 1.1)).to.equal(false);
expect(types.validate('array', 1e300)).to.equal(false);
expect(types.validate('array', true)).to.equal(false);
expect(types.validate('array', {})).to.equal(false);
expect(types.validate('array', [])).to.equal(true);
expect(types.validate('array', new Buffer(0))).to.equal(false);
expect(types.validate('array', null)).to.equal(false);
expect(types.validate('array', null, true)).to.equal(true);
});
it('should validate "buffer"', () => {
expect(types.validate('buffer', 'abc')).to.equal(false);
expect(types.validate('buffer', 1)).to.equal(false);
expect(types.validate('buffer', 1.1)).to.equal(false);
expect(types.validate('buffer', 1e300)).to.equal(false);
expect(types.validate('buffer', true)).to.equal(false);
expect(types.validate('buffer', {})).to.equal(false);
expect(types.validate('buffer', [])).to.equal(false);
expect(types.validate('buffer', new Buffer(0))).to.equal(true);
expect(types.validate('buffer', null)).to.equal(false);
expect(types.validate('buffer', null, true)).to.equal(true);
});
it('should validate "any"', () => {
expect(types.validate('any', 'abc')).to.equal(true);
expect(types.validate('any', 1)).to.equal(true);
expect(types.validate('any', 1.1)).to.equal(true);
expect(types.validate('any', 1e300)).to.equal(true);
expect(types.validate('any', true)).to.equal(true);
expect(types.validate('any', {})).to.equal(true);
expect(types.validate('any', [])).to.equal(true);
expect(types.validate('any', new Buffer(0))).to.equal(true);
expect(types.validate('any', null)).to.equal(true);
expect(types.validate('any', null, true)).to.equal(true);
});
it('Should validate "enum"', () => {
let members = [
['sunday', 0],
['1', 1],
['1.1', 2],
['1e300', 3],
['true', 4],
['{}', 5],
['[]', 6],
['new Buffer(0)', 7],
['null', 8]
];
expect(types.validate('enum', 'sunday', false, members)).to.equal(true);
expect(types.validate('enum', '1', false, members)).to.equal(true);
expect(types.validate('enum', '1.1', false, members)).to.equal(true);
expect(types.validate('enum', '1e300', false, members)).to.equal(true);
expect(types.validate('enum', 'true', false, members)).to.equal(true);
expect(types.validate('enum', '{}', false, members)).to.equal(true);
expect(types.validate('enum', '[]', false, members)).to.equal(true);
expect(types.validate('enum', 'new Buffer(0)', false, members)).to.equal(true);
expect(types.validate('enum', 'null', false, members)).to.equal(true);
expect(types.validate('enum', null, true, members)).to.equal(true);
expect(types.validate('enum', 'abc', false, members)).to.equal(false);
expect(types.validate('enum', 1, false, members)).to.equal(false);
expect(types.validate('enum', 1.1, false, members)).to.equal(false);
expect(types.validate('enum', 1e300, false, members)).to.equal(false);
expect(types.validate('enum', true, false, members)).to.equal(false);
expect(types.validate('enum', {}, false, members)).to.equal(false);
expect(types.validate('enum', [], false, members)).to.equal(false);
expect(types.validate('enum', new Buffer(0), false, members)).to.equal(false);
expect(types.validate('enum', null, false, members)).to.equal(false);
});
it('Should validate an "object" with a schema that has a "enum" member', () => {
expect(
types.validate('object', { offset: '0 minutes' }, false, [
{
name: 'offset',
type: 'enum',
description: `How many minutes past the start of each hour you would like your API to execute`,
members: [
['0 minutes', 0],
['15 minutes', 60 * 15],
['30 minutes', 60 * 30],
['45 minutes', 60 * 45]
]
}
])
).to.equal(true);
expect(
types.validate('object', { offset: '0 min' }, false, [
{
name: 'offset',
type: 'enum',
description: `How many minutes past the start of each hour you would like your API to execute`,
members: [
['0 minutes', 0],
['15 minutes', 60 * 15],
['30 minutes', 60 * 30],
['45 minutes', 60 * 45]
]
}
])
).to.equal(false);
});
it('Should validate an "array" with a schema that has a "enum" member', () => {
expect(
types.validate('array', ['0 minutes'], false, [
{
name: 'offset',
type: 'enum',
description: `How many minutes past the start of each hour you would like your API to execute`,
members: [
['0 minutes', 0],
['15 minutes', 60 * 15],
['30 minutes', 60 * 30],
['45 minutes', 60 * 45]
]
}
])
).to.equal(true);
expect(
types.validate('array', ['0 min'], false, [
{
name: 'offset',
type: 'enum',
description: `How many minutes past the start of each hour you would like your API to execute`,
members: [
['0 minutes', 0],
['15 minutes', 60 * 15],
['30 minutes', 60 * 30],
['45 minutes', 60 * 45]
]
}
])
).to.equal(false);
});
it('should validate "object" with schema', () => {
expect(types.validate('object', {})).to.equal(true);
expect(
types.validate(
'object',
{},
false,
[
{name: 'hello', type: 'string'}
]
)
).to.equal(false);
expect(
types.validate(
'object',
{
hello: 'what'
},
false,
[
{name: 'hello', type: 'string'}
]
)
).to.equal(true);
let testSchema = [
{name: 'hello', type: 'string'},
{name: 'data', type: 'object', schema: [
{name: 'a', type: 'string'},
{name: 'b', type: 'string'}
]},
{name: 'tf', type: 'boolean'}
];
expect(
types.validate(
'object',
{},
false,
testSchema
)
).to.equal(false);
expect(
types.validate(
'object',
{
hello: 'hey',
},
false,
testSchema
)
).to.equal(false);
expect(
types.validate(
'object',
{
hello: 'hey',
data: {a: 'a', b: 'b'},
tf: true
},
false,
testSchema
)
).to.equal(true);
expect(
types.validate(
'object',
{
hello: 'hey',
data: {a: 1, b: 'b'},
tf: true
},
false,
testSchema
)
).to.equal(false);
expect(types.validate('object', null)).to.equal(false);
expect(types.validate('object', null, true)).to.equal(true);
});
it('should convert types from strings', () => {
expect(types.convert('number', '1e300')).to.equal(1e300);
expect(types.convert('float', '100.1')).to.equal(100.1);
expect(types.convert('integer', '100')).to.equal(100);
expect(types.convert('boolean', 'f')).to.equal(false);
expect(types.convert('boolean', 'false')).to.equal(false);
expect(types.convert('boolean', 't')).to.equal(true);
expect(types.convert('boolean', 'true')).to.equal(true);
expect(types.convert('object', '{"a":1}')).to.deep.equal({a: 1});
expect(types.convert('array', '[1,2,3]')).to.deep.equal([1, 2, 3]);
expect(types.convert('buffer', '{"_bytes":[1,2]}')).to.be.instanceof(Buffer);
expect(types.convert('buffer', '{"_base64":"Y2FyZWVyc0BzdGRsaWIuY29t"}')).to.be.instanceof(Buffer);
});
it('should check types', () => {
expect(types.check()).to.equal('any');
expect(types.check(null)).to.equal('any');
expect(types.check('hello')).to.equal('string');
expect(types.check(1e300)).to.equal('number');
expect(types.check(100.1)).to.equal('number');
expect(types.check(100)).to.equal('number');
expect(types.check(true)).to.equal('boolean');
expect(types.check(false)).to.equal('boolean');
expect(types.check({})).to.equal('object');
expect(types.check([])).to.equal('array');
expect(types.check(new Buffer(0))).to.equal('buffer');
});
it('should introspect basic types', () => {
expect(types.introspect(null)).to.deep.equal({
type: 'any',
defaultValue: null
});
expect(types.introspect(4)).to.deep.equal({
type: 'number'
});
expect(types.introspect('hello')).to.deep.equal({
type: 'string'
});
expect(types.introspect(new Buffer(99))).to.deep.equal({
type: 'buffer'
});
expect(types.introspect({a: 'a', b: 'b', c: null, d: 4})).to.deep.equal({
type: 'object',
schema: [{
name: 'a',
type: 'string',
sampleValue: 'a'
}, {
name: 'b',
type: 'string',
sampleValue: 'b'
}, {
name: 'c',
type: 'any',
defaultValue: null
}, {
name: 'd',
type: 'number',
sampleValue: 4
}]
});
expect(types.introspect([1, 2, 3])).to.deep.equal({
type: 'array',
schema: [{
type: 'number'
}]
});
expect(types.introspect([['one', 'two', 'three'], ['four'], ['five', 'six']])).to.deep.equal({
type: 'array',
schema: [{
type: 'array',
schema: [{
type: 'string'
}]
}]
});
});
it('Should introspect a nested object', () => {
expect(
types.introspect({
hello: 'hey',
data: {a: 'a', b: 'b'},
nestedArray: [{c: 'c', d: 'd'}, {c: 'c', e: 'e'}],
deeplyNestedArray: [
[{f: 'f', g: 'g'}, {f: 'f', g: 'g'}, {g: 'g', h: 'h'}],
[{f: 'f', g: 'g'}, {g: 'g', h: 'h'}, {g: 'g', h: 'h'}]
],
tf: true
})
).to.deep.equal({
type: 'object',
schema: [{
name: 'hello',
type: 'string',
sampleValue: 'hey'
}, {
name: 'data',
type: 'object',
schema: [{
name: 'a',
type: 'string',
sampleValue: 'a'
}, {
name: 'b',
type: 'string',
sampleValue: 'b'
}]
}, {
name: 'nestedArray',
type: 'array',
schema: [{
type: 'object',
schema: [{
type: 'string',
name: 'c',
sampleValue: 'c'
}]
}]
}, {
name: 'deeplyNestedArray',
type: 'array',
schema: [{
type: 'array',
schema: [{
type: 'object',
schema: [{
type: 'string',
name: 'g',
sampleValue: 'g'
}]
}]
}]
}, {
name: 'tf',
type: 'boolean',
sampleValue: true
}]
});
});
it('Should introspect heterogenous arrays', () => {
expect(types.introspect(['one', 2, 3, 4])).to.deep.equal({
type: 'array',
schema: [{
type: 'any'
}]
});
expect(types.introspect({
nested: ['one', 2, 3, 4],
a: new Buffer(0)
})).to.deep.equal({
type: 'object',
schema: [{
type: 'array',
name: 'nested',
schema: [{
type: 'any'
}]
}, {
type: 'buffer',
name: 'a',
sampleValue: new Buffer(0)
}]
});
});
it('Should introspect more complex nullable values properly', () => {
expect(types.introspect([1, 2, null, 4])).to.deep.equal({
type: 'array',
schema: [{
type: 'number',
defaultValue: null
}]
});
expect(types.introspect([null, null, 1, null, 2, 3])).to.deep.equal({
type: 'array',
schema: [{
type: 'number',
defaultValue: null
}]
});
expect(types.introspect([null])).to.deep.equal({
type: 'array',
schema: [{
type: 'any',
defaultValue: null
}]
});
expect(types.introspect([1, 'two', null, 4])).to.deep.equal({
type: 'array',
schema: [{
type: 'any',
defaultValue: null
}]
});
expect(types.introspect({
nested: ['one', 2, 3, null],
nestedObjects: [{
one: 'one',
two: 2,
three: 3,
four: 4,
five: 'five'
}, {
one: null,
two: null,
three: null,
four: 44,
five: '5ive'
}, {
one: 'uno',
two: 2,
three: 'three',
four: 444
}]
})).to.deep.equal({
type: 'object',
schema: [{
type: 'array',
name: 'nested',
schema: [{
type: 'any',
defaultValue: null
}]
}, {
type: 'array',
name: 'nestedObjects',
schema: [{
type: 'object',
schema: [{
name: 'one',
type: 'any',
defaultValue: null,
sampleValue: 'one'
}, {
name: 'two',
type: 'any',
defaultValue: null,
sampleValue: 2
}, {
name: 'three',
type: 'any',
defaultValue: null,
sampleValue: 3
},
{
name: 'four',
type: 'number',
sampleValue: 4
}]
}]
}]
});
});
});
describe('Gateway', () => {
require('./gateway/tests.js')(expect);
});
});
|
// asynchronously load fonts
WebFontConfig = {
google: {
families: ['PT Serif:400,400italic,700', 'PT Sans Narrow:400,700']
}
};
// if( cookie( fullCSSKey ) ){
// (function(d) {
// var wf = d.createElement('script'), s = d.scripts[0];
// wf.src = 'https://ajax.googleapis.com/ajax/libs/webfont/1.6.26/webfont.js';
// s.parentNode.insertBefore(wf, s);
// })(document);
// };
$(document).ready(function(){
$("body").addClass("js");
// FitVids init
$(".page__content").fitVids();
// smooth scroll init
$("a").smoothScroll({offset: -20});
// add lightbox class to all image links
$("a[href$='.jpg'], a[href$='.png'], a[href$='.gif']").attr("data-lity", "");
// lazy load settings
$("img.load").show().lazyload({
effect: "fadeIn",
skip_invisible: false
});
// Bigfoot footnotes
var bigfoot = $.bigfoot(
// {
// actionOriginalFN: "ignore"
// }
);
});
// Static comments
(function ($) {
var $comments = $('.js-comments');
$('#comment-form').submit(function () {
var form = this;
$(form).addClass('disabled');
$('#comment-form-submit').html('<svg class="icon spin"><use xlink:href="#icon-loading"></use></svg> Loading...');
$.ajax({
type: $(this).attr('method'),
url: $(this).attr('action'),
data: $(this).serialize(),
contentType: 'application/x-www-form-urlencoded',
success: function (data) {
$('#comment-form-submit').html('Submitted').addClass('btn--disabled');
$('#comment-form .js-notice').removeClass('notice--danger').addClass('notice--success');
showAlert('<strong>Thanks for your comment!</strong> It is <a href="https://github.com/mmistakes/made-mistakes-jekyll/pulls">currently pending</a> and will show on the site once approved.');
},
error: function (err) {
console.log(err);
$('#comment-form-submit').html('Submit Comment');
$('#comment-form .js-notice').removeClass('notice--success').addClass('notice--danger');
showAlert('<strong>Sorry, there was an error with your submission.</strong> Please make sure all required fields have been completed and try again.');
$(form).removeClass('disabled');
}
});
return false;
});
function showAlert(message) {
$('#comment-form .js-notice').removeClass('hidden');
$('#comment-form .js-notice-text').html(message);
}
})(jQuery);
// Staticman comment replies
// modified from Wordpress https://core.svn.wordpress.org/trunk/wp-includes/js/comment-reply.js
// Released under the GNU General Public License - https://wordpress.org/about/gpl/
var addComment = {
moveForm: function( commId, parentId, respondId, postId ) {
var div, element, style, cssHidden,
t = this,
comm = t.I( commId ),
respond = t.I( respondId ),
cancel = t.I( 'cancel-comment-reply-link' ),
parent = t.I( 'comment-parent' ),
post = t.I( 'comment-post-slug' ),
commentForm = respond.getElementsByTagName( 'form' )[0];
if ( ! comm || ! respond || ! cancel || ! parent || ! commentForm ) {
return;
}
t.respondId = respondId;
postId = postId || false;
if ( ! t.I( 'sm-temp-form-div' ) ) {
div = document.createElement( 'div' );
div.id = 'sm-temp-form-div';
div.style.display = 'none';
respond.parentNode.insertBefore( div, respond );
}
comm.parentNode.insertBefore( respond, comm.nextSibling );
if ( post && postId ) {
post.value = postId;
}
parent.value = parentId;
cancel.style.display = '';
cancel.onclick = function() {
var t = addComment,
temp = t.I( 'sm-temp-form-div' ),
respond = t.I( t.respondId );
if ( ! temp || ! respond ) {
return;
}
t.I( 'comment-parent' ).value = '0';
temp.parentNode.insertBefore( respond, temp );
temp.parentNode.removeChild( temp );
this.style.display = 'none';
this.onclick = null;
return false;
};
/*
* Set initial focus to the first form focusable element.
* Try/catch used just to avoid errors in IE 7- which return visibility
* 'inherit' when the visibility value is inherited from an ancestor.
*/
try {
for ( var i = 0; i < commentForm.elements.length; i++ ) {
element = commentForm.elements[i];
cssHidden = false;
// Modern browsers.
if ( 'getComputedStyle' in window ) {
style = window.getComputedStyle( element );
// IE 8.
} else if ( document.documentElement.currentStyle ) {
style = element.currentStyle;
}
/*
* For display none, do the same thing jQuery does. For visibility,
* check the element computed style since browsers are already doing
* the job for us. In fact, the visibility computed style is the actual
* computed value and already takes into account the element ancestors.
*/
if ( ( element.offsetWidth <= 0 && element.offsetHeight <= 0 ) || style.visibility === 'hidden' ) {
cssHidden = true;
}
// Skip form elements that are hidden or disabled.
if ( 'hidden' === element.type || element.disabled || cssHidden ) {
continue;
}
element.focus();
// Stop after the first focusable element.
break;
}
} catch( er ) {}
return false;
},
I: function( id ) {
return document.getElementById( id );
}
};
|
const Koa = require('koa');
const bodyParser = require('koa-bodyparser');
const getRawBody = require('raw-body');
const app = new Koa();
app.use(bodyParser());
var co = require('co')
var parse = require('co-body')
// for raw data
app.use((ctx, next) => {
if (ctx.is('text/*')) {
return new Promise((resolve, reject) => {
yield parse.text(ctx.request);
});
} else {
// before
return next().then(() => {
// after
})
}
});
// response
app.use(ctx => {
// the parsed body will store in this.request.body
// if nothing was parsed, body will be an empty object {}
console.dir(ctx.text)
return ctx.body = ctx.text
});
app.listen(3000); |
var _ = require("lodash");
var tipe = require("tipe");
var plg = {};
var refDocletClones = {};
plg.handlers = {
/***
* Called when processing starts. This method
* resets any globals.
* @param {object} e
*/
parseBegin: function ( e ) {
refDocletClones = {};
},
/**
* Called when processing is finished. We will create our
* cloned doclets here to ensure that we have full doclet information
* (some doclet properties have not been computed yet when the @aka
* tag is first identified).
*
* @param {object} e
*/
processingComplete: function( e ) {
// Locals
var clonesToAdd = [];
// We'll check each doclet to see if any are supposed to be cloned
_.each( e.doclets, function( v, k ) {
// If a doclet has an @aka tag then it will exist
// in the refDocletClones object.
if( refDocletClones[ v.longname ] !== undefined ) {
// Each doclet will have one entry for each occurrence
// of the @aka tag, so we will iterate over each occurrence.
_.each( refDocletClones[ v.longname ], function( name ) {
// Use a helper method to apply the doclet name change..
var cln = cloneAndRenameDoclet( v, name );
// Add the new doclet to a temporary array
// that will be iterated later..
clonesToAdd.push( cln );
});
}
});
// Do we have any clones to add?
if( clonesToAdd.length > 0 ) {
// Yes.. iterate over each..
_.each( clonesToAdd, function( cln ) {
// Add each clone to the main doclet array
e.doclets.push( cln );
});
}
}
};
/**
* This method adds the @aka tag to the jsdoc tag dictionary
*
* @param {object} dictionary
*/
plg.defineTags = function(dictionary) {
// Add the tag
dictionary.defineTag("aka", {
// Here we require a value
// e.g.
// @aka someOtherName < valid
// @aka < invalid
mustHaveValue: true,
// This method is fired each time jsdoc
// encounters the @aka tag.
// (actually, oddly, its fired twice for each)
onTagged: function( doclet, tag ) {
// Pass to the helper method (below)
return onAkaTag( doclet, tag );
}
});
};
/**
* This helper function clones a doclet and gives it a new name
* (but preserves everything else, including the `memberOf` info).
* This method is called exclusively by the `processingComplete`
* listener above.
*
* @param {object} objDoclet
* @param {string} newName
* @returns {void}
*/
function cloneAndRenameDoclet( objDoclet, newName ) {
// Create the doclet clone
var nd = _.cloneDeep( objDoclet );
// Here we use a bit of hackery so that we don't
// need to know all of the available symbols (., #, ~)
// in jsdoc. We'll just use whatever symbol proceeds
// the memberOf string in the longname.
var memOfLength = nd.memberof.length;
var localName = nd.longname.substr( memOfLength );
var sym = localName.substr( 0, 1 );
// Change the short name in the doclet
nd.name = newName;
// Change the long name in the doclet
nd.longname = nd.memberof + sym + newName;
// Automatically set the access level of the alias
if( nd.name.substr(0,1) === "_" ) {
nd.access = "private";
} else {
nd.access = "public";
}
// Return our modified clone for inclusion.
return nd;
}
/**
* This method is fired each time the @aka tag is encountered.
* All this method does is keep track of the doclets that have
* one or more @aka tags for use by the `processingComplete`
* listener above. (it doesn't actually clone anything)
*
* @param {object} doclet
* @param {object} tag
* @returns {void}
*/
function onAkaTag( doclet, tag ) {
// Paranoia check: Ensure the doclet is "aka-able"
if( doclet.name === undefined || doclet.name === '' || doclet.name === null ) {
return;
}
// Locals
var dName = doclet.name;
var tValue = tag.value;
// Track the clone
createDocletCloneRef( dName, tValue );
}
/**
* Helper function for creating doclet clone references
*
* @param {string} docletName
* @param {string} akaValue
*/
function createDocletCloneRef( docletName, akaValue ) {
var rgxValidMemberChrs = /[^A-Za-z0-9_]/g;
var allAkaValues = akaValue.split( rgxValidMemberChrs );
_.each( allAkaValues, function( finalAkaValue ) {
if( finalAkaValue !== "" ) {
// Create the ref property for this doclet
// (if it does not exist)
if( refDocletClones[ docletName ] === undefined ) {
refDocletClones[ docletName ] = {};
}
// Add this tag to the reference object
// for doclet cloning later on...
refDocletClones[ docletName ][ finalAkaValue ] = finalAkaValue;
}
});
}
// Export our plugin
module.exports = plg;
|
var mongoose = require('mongoose');
var express = require('express');
var app = express();
// Databse Querying
mongoose.connect('mongodb://localhost/test');
var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
console.log('Connected!');
});
var collection : db.collection("result");
// Mongoose Schema definition
/*var Schema = mongoose.Schema;
var UserSchema = new Schema({
// Server IP
server_ip: String,
// Onion ID
onion: String,
// Check Date
date_check: String,
// Server ip
server_ip: String,
// Shodan
shodan_result: String,
// Cymon
cymon_result: String,
// Lang
lang: String,
// Category
category: String
});*/
// Mongoose Model definition
var User = mongoose.model('users', UserSchema);
app.use(express.static('public'));
app.get('/index.html', function (req, res) {
res.sendFile( __dirname + "/" + "index.html" );
})
// Send JSON files to clients
app.get('/server.js', function (req, res) {
User.find({ email: req.params.email }, function (err, docs) {
docs=(true)
res.json(docs);
});
})
var server = app.listen(8080, function () {
var host = server.address().address
var port = server.address().port
console.log("Server litenning on http://%s:%s", host, port)
})
|
'use strict';
const postcss = require('postcss');
module.exports = postcss.plugin('postcss-class-rename', classRename);
function classRename(callback, options) {
options = options || {};
return root => {
root.walkRules(rule => {
if (!rule.selectors){
return rule;
}
rule.selectors = rule.selectors.map(selector => {
if (
(!options.isID && !/[\.]/g.test(selector)) ||
(options.isID && !/[\.#]/g.test(selector))
) {
return selector;
}
let re;
if (!options.isID) {
re = /[^\.]*(\.)[A-Za-z0-9_\-]+[^\.]*/gi;
}
else {
re = /[^\.]*(\.|#)[A-Za-z0-9_\-]+[^\.#]*/gi;
}
let classes = selector.match(re);
return classes.map(cls => {
let _re;
if (!options.isID) {
_re = /([^\.]*)(\.)([A-Za-z0-9_\-]+)([^\.]*)/gi;
}
else {
_re = /([^\.#]*)(\.|#)([A-Za-z0-9_\-]+)([^\.]*)/gi;
}
let ar = cls.split(_re);
if (classMatchesTest(ar[3], options.ignore)|| ar[3].trim().length === 0) {
return ar[1] + ar[2] + ar[3] + ar[4];
}
return ar[1] + ar[2] + callback(ar[3]) + ar[4]
}).join('');
});
});
};
}
/**
* Determine if class passes test
*
* @param {string} clss
* @param {string} test
*/
function classMatchesTest(cls, test) {
if (!test) {
return false;
}
cls = cls.trim();
if (test instanceof RegExp) {
return test.exec(cls);
}
if (Array.isArray(test)) {
// Reassign arguments
let tests = test;
test = undefined;
return tests.some(test => {
if (test instanceof RegExp) {
return test.exec(cls);
} else {
return cls === test;
}
});
}
return cls === test;
}
|
var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var routes = require('./routes/index');
var users = require('./routes/users');
var app = express();
app.use(favicon(__dirname + '/dist/favicon.ico'));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded());
app.use(cookieParser());
/// error handlers
/**
* Development Settings
*/
if (app.get('env') === 'development') {
// This will change in production since we'll be using the dist folder
// This covers serving up the index page
app.use(express.static(path.join(__dirname, '../client/.tmp')));
app.use(express.static(path.join(__dirname, '../client/app')));
// Error Handling
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err
});
});
}
/**
* Production Settings
*/
if (app.get('env') === 'production') {
// changes it to use the optimized version for production
app.use(express.static(path.join(__dirname, '/dist')));
// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {}
});
});
}
module.exports = app;
|
// TinyColor v0.11.2
// https://github.com/bgrins/TinyColor
// 2014-06-13, Brian Grinstead, MIT License
(function() {
var trimLeft = /^[\s,#]+/,
trimRight = /\s+$/,
tinyCounter = 0,
math = Math,
mathRound = math.round,
mathMin = math.min,
mathMax = math.max,
mathRandom = math.random;
var tinycolor = function tinycolor (color, opts) {
color = (color) ? color : '';
opts = opts || { };
// If input is already a tinycolor, return itself
if (color instanceof tinycolor) {
return color;
}
// If we are called as a function, call using new instead
if (!(this instanceof tinycolor)) {
return new tinycolor(color, opts);
}
var rgb = inputToRGB(color);
this._r = rgb.r,
this._g = rgb.g,
this._b = rgb.b,
this._a = rgb.a,
this._roundA = mathRound(100*this._a) / 100,
this._format = opts.format || rgb.format;
this._gradientType = opts.gradientType;
// Don't let the range of [0,255] come back in [0,1].
// Potentially lose a little bit of precision here, but will fix issues where
// .5 gets interpreted as half of the total, instead of half of 1
// If it was supposed to be 128, this was already taken care of by `inputToRgb`
if (this._r < 1) { this._r = mathRound(this._r); }
if (this._g < 1) { this._g = mathRound(this._g); }
if (this._b < 1) { this._b = mathRound(this._b); }
this._ok = rgb.ok;
this._tc_id = tinyCounter++;
};
tinycolor.prototype = {
isDark: function() {
return this.getBrightness() < 128;
},
isLight: function() {
return !this.isDark();
},
isValid: function() {
return this._ok;
},
getFormat: function() {
return this._format;
},
getAlpha: function() {
return this._a;
},
getBrightness: function() {
var rgb = this.toRgb();
return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
},
setAlpha: function(value) {
this._a = boundAlpha(value);
this._roundA = mathRound(100*this._a) / 100;
return this;
},
toHsv: function() {
var hsv = rgbToHsv(this._r, this._g, this._b);
return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
},
toHsvString: function() {
var hsv = rgbToHsv(this._r, this._g, this._b);
var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
return (this._a == 1) ?
"hsv(" + h + ", " + s + "%, " + v + "%)" :
"hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")";
},
toHsl: function() {
var hsl = rgbToHsl(this._r, this._g, this._b);
return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
},
toHslString: function() {
var hsl = rgbToHsl(this._r, this._g, this._b);
var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
return (this._a == 1) ?
"hsl(" + h + ", " + s + "%, " + l + "%)" :
"hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")";
},
toHex: function(allow3Char) {
return rgbToHex(this._r, this._g, this._b, allow3Char);
},
toHexString: function(allow3Char) {
return '#' + this.toHex(allow3Char);
},
toHex8: function() {
return rgbaToHex(this._r, this._g, this._b, this._a);
},
toHex8String: function() {
return '#' + this.toHex8();
},
toRgb: function() {
return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
},
toRgbString: function() {
return (this._a == 1) ?
"rgb(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" :
"rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")";
},
toPercentageRgb: function() {
return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a };
},
toPercentageRgbString: function() {
return (this._a == 1) ?
"rgb(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" :
"rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
},
toName: function() {
if (this._a === 0) {
return "transparent";
}
if (this._a < 1) {
return false;
}
return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
},
toFilter: function(secondColor) {
var hex8String = '#' + rgbaToHex(this._r, this._g, this._b, this._a);
var secondHex8String = hex8String;
var gradientType = this._gradientType ? "GradientType = 1, " : "";
if (secondColor) {
var s = tinycolor(secondColor);
secondHex8String = s.toHex8String();
}
return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")";
},
toString: function(format) {
var formatSet = !!format;
format = format || this._format;
var formattedString = false;
var hasAlpha = this._a < 1 && this._a >= 0;
var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "name");
if (needsAlphaFormat) {
// Special case for "transparent", all other non-alpha formats
// will return rgba when there is transparency.
if (format === "name" && this._a === 0) {
return this.toName();
}
return this.toRgbString();
}
if (format === "rgb") {
formattedString = this.toRgbString();
}
if (format === "prgb") {
formattedString = this.toPercentageRgbString();
}
if (format === "hex" || format === "hex6") {
formattedString = this.toHexString();
}
if (format === "hex3") {
formattedString = this.toHexString(true);
}
if (format === "hex8") {
formattedString = this.toHex8String();
}
if (format === "name") {
formattedString = this.toName();
}
if (format === "hsl") {
formattedString = this.toHslString();
}
if (format === "hsv") {
formattedString = this.toHsvString();
}
return formattedString || this.toHexString();
}
};
// If input is an object, force 1 into "1.0" to handle ratios properly
// String input requires "1.0" as input, so 1 will be treated as 1
tinycolor.fromRatio = function(color, opts) {
if (typeof color == "object") {
var newColor = {};
for (var i in color) {
if (color.hasOwnProperty(i)) {
if (i === "a") {
newColor[i] = color[i];
}
else {
newColor[i] = convertToPercentage(color[i]);
}
}
}
color = newColor;
}
return tinycolor(color, opts);
};
// Given a string or object, convert that input to RGB
// Possible string inputs:
//
// "red"
// "#f00" or "f00"
// "#ff0000" or "ff0000"
// "#ff000000" or "ff000000"
// "rgb 255 0 0" or "rgb (255, 0, 0)"
// "rgb 1.0 0 0" or "rgb (1, 0, 0)"
// "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
// "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
// "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
// "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
// "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
//
function inputToRGB(color) {
var rgb = { r: 0, g: 0, b: 0 };
var a = 1;
var ok = false;
var format = false;
if (typeof color == "string") {
color = stringInputToObject(color);
}
if (typeof color == "object") {
if (color.hasOwnProperty("r") && color.hasOwnProperty("g") && color.hasOwnProperty("b")) {
rgb = rgbToRgb(color.r, color.g, color.b);
ok = true;
format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
}
else if (color.hasOwnProperty("h") && color.hasOwnProperty("s") && color.hasOwnProperty("v")) {
color.s = convertToPercentage(color.s);
color.v = convertToPercentage(color.v);
rgb = hsvToRgb(color.h, color.s, color.v);
ok = true;
format = "hsv";
}
else if (color.hasOwnProperty("h") && color.hasOwnProperty("s") && color.hasOwnProperty("l")) {
color.s = convertToPercentage(color.s);
color.l = convertToPercentage(color.l);
rgb = hslToRgb(color.h, color.s, color.l);
ok = true;
format = "hsl";
}
if (color.hasOwnProperty("a")) {
a = color.a;
}
}
a = boundAlpha(a);
return {
ok: ok,
format: color.format || format,
r: mathMin(255, mathMax(rgb.r, 0)),
g: mathMin(255, mathMax(rgb.g, 0)),
b: mathMin(255, mathMax(rgb.b, 0)),
a: a
};
}
// Conversion Functions
// --------------------
// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
// `rgbToRgb`
// Handle bounds / percentage checking to conform to CSS color spec
// <http://www.w3.org/TR/css3-color/>
// *Assumes:* r, g, b in [0, 255] or [0, 1]
// *Returns:* { r, g, b } in [0, 255]
function rgbToRgb(r, g, b){
return {
r: bound01(r, 255) * 255,
g: bound01(g, 255) * 255,
b: bound01(b, 255) * 255
};
}
// `rgbToHsl`
// Converts an RGB color value to HSL.
// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
// *Returns:* { h, s, l } in [0,1]
function rgbToHsl(r, g, b) {
r = bound01(r, 255);
g = bound01(g, 255);
b = bound01(b, 255);
var max = mathMax(r, g, b), min = mathMin(r, g, b);
var h, s, l = (max + min) / 2;
if(max == min) {
h = s = 0; // achromatic
}
else {
var d = max - min;
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
switch(max) {
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
case g: h = (b - r) / d + 2; break;
case b: h = (r - g) / d + 4; break;
}
h /= 6;
}
return { h: h, s: s, l: l };
}
// `hslToRgb`
// Converts an HSL color value to RGB.
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
// *Returns:* { r, g, b } in the set [0, 255]
function hslToRgb(h, s, l) {
var r, g, b;
h = bound01(h, 360);
s = bound01(s, 100);
l = bound01(l, 100);
function hue2rgb(p, q, t) {
if(t < 0) t += 1;
if(t > 1) t -= 1;
if(t < 1/6) return p + (q - p) * 6 * t;
if(t < 1/2) return q;
if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
return p;
}
if(s === 0) {
r = g = b = l; // achromatic
}
else {
var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
var p = 2 * l - q;
r = hue2rgb(p, q, h + 1/3);
g = hue2rgb(p, q, h);
b = hue2rgb(p, q, h - 1/3);
}
return { r: r * 255, g: g * 255, b: b * 255 };
}
// `rgbToHsv`
// Converts an RGB color value to HSV
// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
// *Returns:* { h, s, v } in [0,1]
function rgbToHsv(r, g, b) {
r = bound01(r, 255);
g = bound01(g, 255);
b = bound01(b, 255);
var max = mathMax(r, g, b), min = mathMin(r, g, b);
var h, s, v = max;
var d = max - min;
s = max === 0 ? 0 : d / max;
if(max == min) {
h = 0; // achromatic
}
else {
switch(max) {
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
case g: h = (b - r) / d + 2; break;
case b: h = (r - g) / d + 4; break;
}
h /= 6;
}
return { h: h, s: s, v: v };
}
// `hsvToRgb`
// Converts an HSV color value to RGB.
// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
// *Returns:* { r, g, b } in the set [0, 255]
function hsvToRgb(h, s, v) {
h = bound01(h, 360) * 6;
s = bound01(s, 100);
v = bound01(v, 100);
var i = math.floor(h),
f = h - i,
p = v * (1 - s),
q = v * (1 - f * s),
t = v * (1 - (1 - f) * s),
mod = i % 6,
r = [v, q, p, p, t, v][mod],
g = [t, v, v, q, p, p][mod],
b = [p, p, t, v, v, q][mod];
return { r: r * 255, g: g * 255, b: b * 255 };
}
// `rgbToHex`
// Converts an RGB color to hex
// Assumes r, g, and b are contained in the set [0, 255]
// Returns a 3 or 6 character hex
function rgbToHex(r, g, b, allow3Char) {
var hex = [
pad2(mathRound(r).toString(16)),
pad2(mathRound(g).toString(16)),
pad2(mathRound(b).toString(16))
];
// Return a 3 character hex if possible
if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
}
return hex.join("");
}
// `rgbaToHex`
// Converts an RGBA color plus alpha transparency to hex
// Assumes r, g, b and a are contained in the set [0, 255]
// Returns an 8 character hex
function rgbaToHex(r, g, b, a) {
var hex = [
pad2(convertDecimalToHex(a)),
pad2(mathRound(r).toString(16)),
pad2(mathRound(g).toString(16)),
pad2(mathRound(b).toString(16))
];
return hex.join("");
}
// `equals`
// Can be called with any tinycolor input
tinycolor.equals = function (color1, color2) {
if (!color1 || !color2) { return false; }
return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
};
tinycolor.random = function() {
return tinycolor.fromRatio({
r: mathRandom(),
g: mathRandom(),
b: mathRandom()
});
};
// Modification Functions
// ----------------------
// Thanks to less.js for some of the basics here
// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>
tinycolor.desaturate = function (color, amount) {
amount = (amount === 0) ? 0 : (amount || 10);
var hsl = tinycolor(color).toHsl();
hsl.s -= amount / 100;
hsl.s = clamp01(hsl.s);
return tinycolor(hsl);
};
tinycolor.saturate = function (color, amount) {
amount = (amount === 0) ? 0 : (amount || 10);
var hsl = tinycolor(color).toHsl();
hsl.s += amount / 100;
hsl.s = clamp01(hsl.s);
return tinycolor(hsl);
};
tinycolor.greyscale = function(color) {
return tinycolor.desaturate(color, 100);
};
tinycolor.lighten = function(color, amount) {
amount = (amount === 0) ? 0 : (amount || 10);
var hsl = tinycolor(color).toHsl();
hsl.l += amount / 100;
hsl.l = clamp01(hsl.l);
return tinycolor(hsl);
};
tinycolor.brighten = function(color, amount) {
amount = (amount === 0) ? 0 : (amount || 10);
var rgb = tinycolor(color).toRgb();
rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));
rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));
rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));
return tinycolor(rgb);
};
tinycolor.darken = function (color, amount) {
amount = (amount === 0) ? 0 : (amount || 10);
var hsl = tinycolor(color).toHsl();
hsl.l -= amount / 100;
hsl.l = clamp01(hsl.l);
return tinycolor(hsl);
};
tinycolor.complement = function(color) {
var hsl = tinycolor(color).toHsl();
hsl.h = (hsl.h + 180) % 360;
return tinycolor(hsl);
};
// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
// Values outside of this range will be wrapped into this range.
tinycolor.spin = function(color, amount) {
var hsl = tinycolor(color).toHsl();
var hue = (mathRound(hsl.h) + amount) % 360;
hsl.h = hue < 0 ? 360 + hue : hue;
return tinycolor(hsl);
};
tinycolor.mix = function(color1, color2, amount) {
amount = (amount === 0) ? 0 : (amount || 50);
var rgb1 = tinycolor(color1).toRgb();
var rgb2 = tinycolor(color2).toRgb();
var p = amount / 100;
var w = p * 2 - 1;
var a = rgb2.a - rgb1.a;
var w1;
if (w * a == -1) {
w1 = w;
} else {
w1 = (w + a) / (1 + w * a);
}
w1 = (w1 + 1) / 2;
var w2 = 1 - w1;
var rgba = {
r: rgb2.r * w1 + rgb1.r * w2,
g: rgb2.g * w1 + rgb1.g * w2,
b: rgb2.b * w1 + rgb1.b * w2,
a: rgb2.a * p + rgb1.a * (1 - p)
};
return tinycolor(rgba);
};
// Combination Functions
// ---------------------
// Thanks to jQuery xColor for some of the ideas behind these
// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>
tinycolor.triad = function(color) {
var hsl = tinycolor(color).toHsl();
var h = hsl.h;
return [
tinycolor(color),
tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),
tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })
];
};
tinycolor.tetrad = function(color) {
var hsl = tinycolor(color).toHsl();
var h = hsl.h;
return [
tinycolor(color),
tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),
tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),
tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })
];
};
tinycolor.splitcomplement = function(color) {
var hsl = tinycolor(color).toHsl();
var h = hsl.h;
return [
tinycolor(color),
tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),
tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})
];
};
tinycolor.analogous = function(color, results, slices) {
results = results || 6;
slices = slices || 30;
var hsl = tinycolor(color).toHsl();
var part = 360 / slices;
var ret = [tinycolor(color)];
for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {
hsl.h = (hsl.h + part) % 360;
ret.push(tinycolor(hsl));
}
return ret;
};
tinycolor.monochromatic = function(color, results) {
results = results || 6;
var hsv = tinycolor(color).toHsv();
var h = hsv.h, s = hsv.s, v = hsv.v;
var ret = [];
var modification = 1 / results;
while (results--) {
ret.push(tinycolor({ h: h, s: s, v: v}));
v = (v + modification) % 1;
}
return ret;
};
// Readability Functions
// ---------------------
// <http://www.w3.org/TR/AERT#color-contrast>
// `readability`
// Analyze the 2 colors and returns an object with the following properties:
// `brightness`: difference in brightness between the two colors
// `color`: difference in color/hue between the two colors
tinycolor.readability = function(color1, color2) {
var c1 = tinycolor(color1);
var c2 = tinycolor(color2);
var rgb1 = c1.toRgb();
var rgb2 = c2.toRgb();
var brightnessA = c1.getBrightness();
var brightnessB = c2.getBrightness();
var colorDiff = (
Math.max(rgb1.r, rgb2.r) - Math.min(rgb1.r, rgb2.r) +
Math.max(rgb1.g, rgb2.g) - Math.min(rgb1.g, rgb2.g) +
Math.max(rgb1.b, rgb2.b) - Math.min(rgb1.b, rgb2.b)
);
return {
brightness: Math.abs(brightnessA - brightnessB),
color: colorDiff
};
};
// `readable`
// http://www.w3.org/TR/AERT#color-contrast
// Ensure that foreground and background color combinations provide sufficient contrast.
// *Example*
// tinycolor.readable("#000", "#111") => false
tinycolor.readable = function(color1, color2) {
var readability = tinycolor.readability(color1, color2);
return readability.brightness > 125 && readability.color > 500;
};
// `mostReadable`
// Given a base color and a list of possible foreground or background
// colors for that base, returns the most readable color.
// *Example*
// tinycolor.mostReadable("#123", ["#fff", "#000"]) => "#000"
tinycolor.mostReadable = function(baseColor, colorList) {
var bestColor = null;
var bestScore = 0;
var bestIsReadable = false;
for (var i=0; i < colorList.length; i++) {
// We normalize both around the "acceptable" breaking point,
// but rank brightness constrast higher than hue.
var readability = tinycolor.readability(baseColor, colorList[i]);
var readable = readability.brightness > 125 && readability.color > 500;
var score = 3 * (readability.brightness / 125) + (readability.color / 500);
if ((readable && ! bestIsReadable) ||
(readable && bestIsReadable && score > bestScore) ||
((! readable) && (! bestIsReadable) && score > bestScore)) {
bestIsReadable = readable;
bestScore = score;
bestColor = tinycolor(colorList[i]);
}
}
return bestColor;
};
// Big List of Colors
// ------------------
// <http://www.w3.org/TR/css3-color/#svg-color>
var names = tinycolor.names = {
aliceblue: "f0f8ff",
antiquewhite: "faebd7",
aqua: "0ff",
aquamarine: "7fffd4",
azure: "f0ffff",
beige: "f5f5dc",
bisque: "ffe4c4",
black: "000",
blanchedalmond: "ffebcd",
blue: "00f",
blueviolet: "8a2be2",
brown: "a52a2a",
burlywood: "deb887",
burntsienna: "ea7e5d",
cadetblue: "5f9ea0",
chartreuse: "7fff00",
chocolate: "d2691e",
coral: "ff7f50",
cornflowerblue: "6495ed",
cornsilk: "fff8dc",
crimson: "dc143c",
cyan: "0ff",
darkblue: "00008b",
darkcyan: "008b8b",
darkgoldenrod: "b8860b",
darkgray: "a9a9a9",
darkgreen: "006400",
darkgrey: "a9a9a9",
darkkhaki: "bdb76b",
darkmagenta: "8b008b",
darkolivegreen: "556b2f",
darkorange: "ff8c00",
darkorchid: "9932cc",
darkred: "8b0000",
darksalmon: "e9967a",
darkseagreen: "8fbc8f",
darkslateblue: "483d8b",
darkslategray: "2f4f4f",
darkslategrey: "2f4f4f",
darkturquoise: "00ced1",
darkviolet: "9400d3",
deeppink: "ff1493",
deepskyblue: "00bfff",
dimgray: "696969",
dimgrey: "696969",
dodgerblue: "1e90ff",
firebrick: "b22222",
floralwhite: "fffaf0",
forestgreen: "228b22",
fuchsia: "f0f",
gainsboro: "dcdcdc",
ghostwhite: "f8f8ff",
gold: "ffd700",
goldenrod: "daa520",
gray: "808080",
green: "008000",
greenyellow: "adff2f",
grey: "808080",
honeydew: "f0fff0",
hotpink: "ff69b4",
indianred: "cd5c5c",
indigo: "4b0082",
ivory: "fffff0",
khaki: "f0e68c",
lavender: "e6e6fa",
lavenderblush: "fff0f5",
lawngreen: "7cfc00",
lemonchiffon: "fffacd",
lightblue: "add8e6",
lightcoral: "f08080",
lightcyan: "e0ffff",
lightgoldenrodyellow: "fafad2",
lightgray: "d3d3d3",
lightgreen: "90ee90",
lightgrey: "d3d3d3",
lightpink: "ffb6c1",
lightsalmon: "ffa07a",
lightseagreen: "20b2aa",
lightskyblue: "87cefa",
lightslategray: "789",
lightslategrey: "789",
lightsteelblue: "b0c4de",
lightyellow: "ffffe0",
lime: "0f0",
limegreen: "32cd32",
linen: "faf0e6",
magenta: "f0f",
maroon: "800000",
mediumaquamarine: "66cdaa",
mediumblue: "0000cd",
mediumorchid: "ba55d3",
mediumpurple: "9370db",
mediumseagreen: "3cb371",
mediumslateblue: "7b68ee",
mediumspringgreen: "00fa9a",
mediumturquoise: "48d1cc",
mediumvioletred: "c71585",
midnightblue: "191970",
mintcream: "f5fffa",
mistyrose: "ffe4e1",
moccasin: "ffe4b5",
navajowhite: "ffdead",
navy: "000080",
oldlace: "fdf5e6",
olive: "808000",
olivedrab: "6b8e23",
orange: "ffa500",
orangered: "ff4500",
orchid: "da70d6",
palegoldenrod: "eee8aa",
palegreen: "98fb98",
paleturquoise: "afeeee",
palevioletred: "db7093",
papayawhip: "ffefd5",
peachpuff: "ffdab9",
peru: "cd853f",
pink: "ffc0cb",
plum: "dda0dd",
powderblue: "b0e0e6",
purple: "800080",
red: "f00",
rosybrown: "bc8f8f",
royalblue: "4169e1",
saddlebrown: "8b4513",
salmon: "fa8072",
sandybrown: "f4a460",
seagreen: "2e8b57",
seashell: "fff5ee",
sienna: "a0522d",
silver: "c0c0c0",
skyblue: "87ceeb",
slateblue: "6a5acd",
slategray: "708090",
slategrey: "708090",
snow: "fffafa",
springgreen: "00ff7f",
steelblue: "4682b4",
tan: "d2b48c",
teal: "008080",
thistle: "d8bfd8",
tomato: "ff6347",
turquoise: "40e0d0",
violet: "ee82ee",
wheat: "f5deb3",
white: "fff",
whitesmoke: "f5f5f5",
yellow: "ff0",
yellowgreen: "9acd32"
};
// Make it easy to access colors via `hexNames[hex]`
var hexNames = tinycolor.hexNames = flip(names);
// Utilities
// ---------
// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
function flip(o) {
var flipped = { };
for (var i in o) {
if (o.hasOwnProperty(i)) {
flipped[o[i]] = i;
}
}
return flipped;
}
// Return a valid alpha value [0,1] with all invalid values being set to 1
function boundAlpha(a) {
a = parseFloat(a);
if (isNaN(a) || a < 0 || a > 1) {
a = 1;
}
return a;
}
// Take input from [0, n] and return it as [0, 1]
function bound01(n, max) {
if (isOnePointZero(n)) { n = "100%"; }
var processPercent = isPercentage(n);
n = mathMin(max, mathMax(0, parseFloat(n)));
// Automatically convert percentage into number
if (processPercent) {
n = parseInt(n * max, 10) / 100;
}
// Handle floating point rounding errors
if ((math.abs(n - max) < 0.000001)) {
return 1;
}
// Convert into [0, 1] range if it isn't already
return (n % max) / parseFloat(max);
}
// Force a number between 0 and 1
function clamp01(val) {
return mathMin(1, mathMax(0, val));
}
// Parse a base-16 hex value into a base-10 integer
function parseIntFromHex(val) {
return parseInt(val, 16);
}
// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
function isOnePointZero(n) {
return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1;
}
// Check to see if string passed in is a percentage
function isPercentage(n) {
return typeof n === "string" && n.indexOf('%') != -1;
}
// Force a hex value to have 2 characters
function pad2(c) {
return c.length == 1 ? '0' + c : '' + c;
}
// Replace a decimal with it's percentage value
function convertToPercentage(n) {
if (n <= 1) {
n = (n * 100) + "%";
}
return n;
}
// Converts a decimal to a hex value
function convertDecimalToHex(d) {
return Math.round(parseFloat(d) * 255).toString(16);
}
// Converts a hex value to a decimal
function convertHexToDecimal(h) {
return (parseIntFromHex(h) / 255);
}
var matchers = (function() {
// <http://www.w3.org/TR/css3-values/#integers>
var CSS_INTEGER = "[-\\+]?\\d+%?";
// <http://www.w3.org/TR/css3-values/#number-value>
var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
// Allow positive/negative integer/number. Don't capture the either/or, just the entire outcome.
var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
// Actual matching.
// Parentheses and commas are optional, but not required.
// Whitespace can take the place of commas or opening paren
var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
return {
rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
hex3: /^([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
hex6: /^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
hex8: /^([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
};
})();
// `stringInputToObject`
// Permissive string parsing. Take in a number of formats, and output an object
// based on detected format. Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
function stringInputToObject(color) {
color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();
var named = false;
if (names[color]) {
color = names[color];
named = true;
}
else if (color == 'transparent') {
return { r: 0, g: 0, b: 0, a: 0, format: "name" };
}
// Try to match string input using regular expressions.
// Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
// Just return an object and let the conversion functions handle that.
// This way the result will be the same whether the tinycolor is initialized with string or object.
var match;
if ((match = matchers.rgb.exec(color))) {
return { r: match[1], g: match[2], b: match[3] };
}
if ((match = matchers.rgba.exec(color))) {
return { r: match[1], g: match[2], b: match[3], a: match[4] };
}
if ((match = matchers.hsl.exec(color))) {
return { h: match[1], s: match[2], l: match[3] };
}
if ((match = matchers.hsla.exec(color))) {
return { h: match[1], s: match[2], l: match[3], a: match[4] };
}
if ((match = matchers.hsv.exec(color))) {
return { h: match[1], s: match[2], v: match[3] };
}
if ((match = matchers.hex8.exec(color))) {
return {
a: convertHexToDecimal(match[1]),
r: parseIntFromHex(match[2]),
g: parseIntFromHex(match[3]),
b: parseIntFromHex(match[4]),
format: named ? "name" : "hex8"
};
}
if ((match = matchers.hex6.exec(color))) {
return {
r: parseIntFromHex(match[1]),
g: parseIntFromHex(match[2]),
b: parseIntFromHex(match[3]),
format: named ? "name" : "hex"
};
}
if ((match = matchers.hex3.exec(color))) {
return {
r: parseIntFromHex(match[1] + '' + match[1]),
g: parseIntFromHex(match[2] + '' + match[2]),
b: parseIntFromHex(match[3] + '' + match[3]),
format: named ? "name" : "hex"
};
}
return false;
}
// Node: Export function
if (typeof module !== "undefined" && module.exports) {
module.exports = tinycolor;
}
// AMD/requirejs: Define the module
else if (typeof define === 'function' && define.amd) {
define(function () {return tinycolor;});
}
// Browser: Expose to window
else {
window.tinycolor = tinycolor;
}
})(); |
import {AJAX_CALL_ERROR,AJAX_CALL_SUCESS,BEGIN_AJAX_CALL} from '../actions/';
import initialState from './initialState';
export default function ajaxGlobalReducer(state = initialState.ajaxGlobal, action) {
switch (action.type) {
case BEGIN_AJAX_CALL:
{
return Object.assign({}, {...state, started: true});
}
case AJAX_CALL_ERROR:
case AJAX_CALL_SUCESS:
{
return Object.assign({}, {...state, started: false, done: true});
}
default:
return state;
}
}
|
angular.module('ResourceApp', [
'ngRoute',
'ngResource',
'ngStorage',
'ngAnimate',
'appRoutes',
'enterStroke',
'MainController',
'UserController',
'RecursoController',
'AulaController',
'SolicitudController',
'MensajeController',
'RecursoService',
'UserService',
'AulaService',
'SolicitudService',
'MensajeService',
'ui.bootstrap',
'ModalInstanceController',
'ModalInstanceController2'
]);
|
// Nicolas Ribot,
requirejs.config({
'baseUrl': '../lib',
'paths': {
'leaflet.wms': '../leaflet.wms',
'iconLayers': '/leafleticonlayers/src/iconLayers'
}
});
define(['leaflet', 'leaflet.wms'],
function(L, wms) {
var autowmsMap = '';
var tiledMap = '';
var overlayMap = '';
//autowmsMap = createMap('autowms-map', false, true);
overlayMap = createMap('overlay-map', false, false);
//tiledMap = createMap('tiled-map', true, false);
function createMap(div, tiled, autowms) {
// Map configuration
var map = L.map(div);
// map.setView([45, -93.2], 6);
map.setView([44.0, 4.4], 8);
var basemaps = {
'Basemap': basemap().addTo(map),
'Blank': blank()
};
if (autowms) {
// Test autowms mode: Adds only a WMS service URL
// Add WMS source/layers
var source = wms.source(
"http://localhost/qgis/qgis_mapserv.fcgi?map=/Users/nicolas/Projets/smage/demo/web/QGIS-Web-Client-master/projets_qgis/appli_smage.qgs",
{
'autowms': true,
'format': 'image/png'
}
);
source.loadFromWMS(function() {
L.control.iconLayers(this.getLayersForControl()).addTo(map);
});
source.addTo(map);
// Add WMS source/layers
var source = wms.source(
"http://ows.terrestris.de/osm/service",
{
"format": "image/png",
"transparent": "true",
"attribution": "<a href='http://ows.terrestris.de/'>terrestris</a>",
"info_format": "text/html",
"tiled": tiled
}
);
var layers = {
'Topographic': source.getLayer("TOPO-WMS").addTo(map),
'OSM Overlay': source.getLayer("OSM-Overlay-WMS").addTo(map)
};
} else {
var source = wms.source(
// "http://webservices.nationalatlas.gov/wms",
"http://localhost/qgis/qgis_mapserv.fcgi?map=/Users/nicolas/Projets/smage/demo/web/QGIS-Web-Client-master/projets_qgis/appli_smage.qgs",
{
"format": "image/png",
"transparent": "true",
"attribution": "<a href='#'>Nico wms</a>",
"tiled": tiled
}
);
var layers = {
'Sous Bassins': source.getLayer("Sous Bassins"),
'Parcs Nationaux': source.getLayer("Parcs Nationaux")
// ,'Lakes & Rivers': source.getLayer("lakesrivers"),
// 'Airports': source.getLayer("airports"),
// 'State Capitals': source.getLayer("statecap")
};
for (var name in layers) {
layers[name].addTo(map);
}
// Create layer control
L.control.orderlayers(basemaps, layers).addTo(map);
// L.control.iconLayers(
// IconLayersConfigBuilder.buildFromWMSSource(source)
// ).addTo(map);
// L.control.iconLayers(source.getLayersForControl()
// ).addTo(map);
// Opacity slider
var slider = L.DomUtil.get('range-' + div);
L.DomEvent.addListener(slider, 'change', function() {
source.setOpacity(this.value);
});
// legend/info radio
var r1 = L.DomUtil.get('info-' + div);
L.DomEvent.addListener(r1, 'click', radioClick);
var r2 = L.DomUtil.get('legend-' + div);
L.DomEvent.addListener(r2, 'click', radioClick);
function radioClick(evt) {
if (this.value === '1') {
source.options.identify = true;
source.options.legend = false;
L.DomUtil.get('imglegend').src = '';
} else if (this.value === '2') {
source.options.identify = false;
source.options.legend = true;
console.log(source.options);
L.DomUtil.get('imglegend').src = source.getLayerLegendURL('Sous Bassins');
}
source.getEvents();
};
}
return map;
}
function basemap() {
// maps.stamen.com
var attr = 'Map tiles by <a href="http://stamen.com">Stamen Design</a>, under <a href="http://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>. Data by <a href="http://openstreetmap.org">OpenStreetMap</a>, under <a href="http://www.openstreetmap.org/copyright">ODbL</a>.';
return L.tileLayer("http://tile.stamen.com/toner-background/{z}/{x}/{y}.png", {
opacity: 0.1,
attribution: attr
});
// return L.tileLayer('http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
// maxZoom: 19,
// attribution: '© <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
// });
}
function blank() {
var layer = new L.Layer();
layer.onAdd = layer.onRemove = function() {};
return layer;
}
// Export maps for console experimentation
return {
'maps': {
'overlay': overlayMap,
'tiled': tiledMap,
'autowms': autowmsMap
}
};
});
|
/**
Jasmine Reporter that outputs test results to the browser console.
Useful for running in a headless environment such as PhantomJs, ZombieJs etc.
Usage:
// From your html file that loads jasmine:
jasmine.getEnv().addReporter(new jasmine.ConsoleReporter());
jasmine.getEnv().execute();
*/
(function (jasmine, console) {
if (!jasmine) {
throw "jasmine library isn't loaded!";
}
var ANSI = {}
ANSI.color_map = {
"green": 32,
"red": 31
}
ANSI.colorize_text = function (text, color) {
var color_code = this.color_map[color];
return "\033[" + color_code + "m" + text + "\033[0m";
}
var ConsoleReporter = function () {
if (!console || !console.log) { throw "console isn't present!"; }
this.status = this.statuses.stopped;
};
var proto = ConsoleReporter.prototype;
proto.statuses = {
stopped: "stopped",
running: "running",
fail: "fail",
success: "success"
};
proto.reportRunnerStarting = function (runner) {
this.status = this.statuses.running;
this.start_time = (new Date()).getTime();
this.executed_specs = 0;
this.passed_specs = 0;
this.log("Starting...");
};
proto.reportRunnerResults = function (runner) {
var failed = this.executed_specs - this.passed_specs;
var spec_str = this.executed_specs + (this.executed_specs === 1 ? " spec, " : " specs, ");
var fail_str = failed + (failed === 1 ? " failure in " : " failures in ");
var color = (failed > 0) ? "red" : "green";
var dur = (new Date()).getTime() - this.start_time;
this.log("");
this.log("Finished");
this.log("-----------------");
this.log(spec_str + fail_str + (dur / 1000) + "s.", color);
this.status = (failed > 0) ? this.statuses.fail : this.statuses.success;
/* Print something that signals that testing is over so that headless browsers
like PhantomJs know when to terminate. */
this.log("");
this.log("ConsoleReporter finished");
};
proto.reportSpecStarting = function (spec) {
this.executed_specs++;
};
proto.reportSpecResults = function (spec) {
if (spec.results().passed()) {
this.passed_specs++;
return;
}
var resultText = spec.suite.description + " : " + spec.description;
this.log(resultText, "red");
var items = spec.results().getItems()
for (var i = 0; i < items.length; i++) {
var trace = items[i].trace.stack || items[i].trace;
this.log(trace, "red");
}
};
proto.reportSuiteResults = function (suite) {
if (!suite.parentSuite) { return; }
var results = suite.results();
var failed = results.totalCount - results.passedCount;
var color = (failed > 0) ? "red" : "green";
this.log(suite.description + ": " + results.passedCount + " of " + results.totalCount + " passed.", color);
};
proto.log = function (str, color) {
var text = (color != undefined) ? ANSI.colorize_text(str, color) : str;
console.log(text)
};
jasmine.ConsoleReporter = ConsoleReporter;
})(jasmine, console); |
/**
* RGB Shift Shader
* Shifts red and blue channels from center in opposite directions
* Ported from http://kriss.cx/tom/2009/05/rgb-shift/
* by Tom Butterworth / http://kriss.cx/tom/
*
* amount: shift distance (1 is width of input)
* angle: shift angle in radians
*/
var RGBShiftShader = {
uniforms: {
"tDiffuse": { value: null },
"amount": { value: 0.005 },
"angle": { value: 0.0 }
},
vertexShader: [
"varying vec2 vUv;",
"void main() {",
" vUv = uv;",
" gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
"}"
].join( "\n" ),
fragmentShader: [
"uniform sampler2D tDiffuse;",
"uniform float amount;",
"uniform float angle;",
"varying vec2 vUv;",
"void main() {",
" vec2 offset = amount * vec2( cos(angle), sin(angle));",
" vec4 cr = texture2D(tDiffuse, vUv + offset);",
" vec4 cga = texture2D(tDiffuse, vUv);",
" vec4 cb = texture2D(tDiffuse, vUv - offset);",
" gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);",
"}"
].join( "\n" )
};
export { RGBShiftShader };
|
exports.config = {
specs: ['tests/e2e/*.spec.js'],
multiCapabilities: [
{
browserName: 'firefox'
}
],
onPrepare: function () {
global.collector = new (require('istanbul').Collector)();
},
onComplete: function () {
var fs = require('fs');
var mkp = require('mkdirp');
var val = global.collector.getFinalCoverage();
if (Object.keys(val).length) {
var f = 'reports/e2e-coverage';
mkp(f, function () {
fs.writeFileSync(f + '/e2e-coverage.json', JSON.stringify(val));
global.collector.dispose();
});
}
}
};
|
//this is our multi-dimensional array.
//access first array by: playList[0] ..
//access first song by: playList[0][0] -- I did it my way
//access first artist by: playList[0][1] - Frank Sinatra
var playList = [
['I Did It My Way', 'Frank Sinatra'],
['Respect', 'Aretha Franklin'],
['Imagine', 'John Lennon'],
['Born to Run', 'Bruce Springsteen'],
['Louie Louie', 'The Kingsmen'],
['Maybellene', 'Chuck Berry']
];
function print(message) {
document.write(message);
}
function printSongs( songs ) {
var listHTML = '<ol>';
for ( var i = 0; i < songs.length; i += 1) {
//here we are printing songs and artist.
//songs are at 0 element in each array.. where artists are at 1 element in each array.
listHTML += '<li>' + songs[i][0] + ' by ' + songs[i][1] + '</li>';
}
listHTML += '</ol>';
print(listHTML);
}
printSongs(playList);
|
exports.regex = /(culia(a|o|do|da)?|ql[ao]?|ch[uú]?pala|c[aá]?llate|csm)/;
// exports.example = 'micah <chuchada>: Le cuenta tu <secreto> al grupo.'
exports.onMsg = function(bot, msg, match) {
const chatId = msg.chat.id;
const replies = [
'u.u perdón',
'y tu mamá?',
'y a vo quién te habló?',
'mas weón que pelear con un bot'
];
bot.sendMessage(chatId, replies[Math.floor(Math.random()*replies.length)]);
};
|
import ISignalMapper from './isignal-mapper'
import Utils from './utils'
export default class RandomSignalMapper extends ISignalMapper {
constructor(auralizer, library) {
super(auralizer, library)
const rand1 = Utils.prng.randomInt()
const rand2 = Utils.prng.randomInt()
const rand3 = Utils.prng.randomInt()
auralizer.eventSignals.forEach((signal, i, signals) => {
this.maps.event[signal] = [
library.eventSounds[(rand1 + i) % library.eventSounds.length]
]
})
auralizer.heartbeatSignals.forEach((signal, i, signals) => {
this.maps.heartbeat[signal] = [
library.heartbeatSounds[(rand2 + i) % library.heartbeatSounds.length]
]
})
auralizer.stateSignals.forEach((signal, i, signals) => {
this.maps.state[signal] = [
library.stateSounds[(rand3 + i) % library.stateSounds.length]
]
})
}
}
|
8.0-alpha3:37b605a580b522d9d0113a52d2f3b8b426a05f4b9d2ee8de10ec64b7e6f815c0
8.0-alpha4:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha5:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha6:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha7:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha8:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha9:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha10:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha11:67429462e694fe791eb195fb23ec82e446d6da428c174708dbea10dc9dda8cd9
8.0-alpha12:248b4646d313a18153f8e929e0bf74aa16406e2d95c304dad3ce0e8a2da77e0a
8.0-alpha13:248b4646d313a18153f8e929e0bf74aa16406e2d95c304dad3ce0e8a2da77e0a
8.0.0-alpha14:248b4646d313a18153f8e929e0bf74aa16406e2d95c304dad3ce0e8a2da77e0a
8.0.0-alpha15:4f000eacbdf5508fa908822c8558e182f70eed44778f311acd177d454542a675
8.0.0-beta1:9007eba4fe0555e1190ad98b4d21fa41fac24dcb3cf34aaf80ea2334a4b6bbc5
8.0.0-beta2:9007eba4fe0555e1190ad98b4d21fa41fac24dcb3cf34aaf80ea2334a4b6bbc5
8.0.0-beta3:9007eba4fe0555e1190ad98b4d21fa41fac24dcb3cf34aaf80ea2334a4b6bbc5
8.0.0-beta4:c117064ae438ba0b1562578bba5ac76bea66e1deb3414db4e6f1b1ea9cb1512a
8.0.0-beta6:c117064ae438ba0b1562578bba5ac76bea66e1deb3414db4e6f1b1ea9cb1512a
8.0.0-beta7:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta9:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta10:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta11:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta12:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta13:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta14:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta15:65bbc8b98a1245c5bca6ced331c12c9466759ff947259724caa13c9ed8a29e32
8.0.0-beta16:5ee47cdd24fb470c98c14026a5a3f498403f797f7b04352c345323639f3b7067
8.0.0-rc1:5ee47cdd24fb470c98c14026a5a3f498403f797f7b04352c345323639f3b7067
8.0.0-rc2:5ee47cdd24fb470c98c14026a5a3f498403f797f7b04352c345323639f3b7067
8.0.0-rc3:73a40b18bd8c80c34dd18d91e19aa6272afcfd5dd9596339c3069fac162245ef
8.0.0-rc4:73a40b18bd8c80c34dd18d91e19aa6272afcfd5dd9596339c3069fac162245ef
8.0.1:8f817908aa199eabcd7c2c49f9b860fc92179120a4067180df3d33be644ca4d9
8.0.2:8f817908aa199eabcd7c2c49f9b860fc92179120a4067180df3d33be644ca4d9
8.0.3:8f817908aa199eabcd7c2c49f9b860fc92179120a4067180df3d33be644ca4d9
8.0.4:8f817908aa199eabcd7c2c49f9b860fc92179120a4067180df3d33be644ca4d9
8.0.5:8f817908aa199eabcd7c2c49f9b860fc92179120a4067180df3d33be644ca4d9
8.0.6:8f817908aa199eabcd7c2c49f9b860fc92179120a4067180df3d33be644ca4d9
8.1.0-beta1:bf80d1f30afb9afeff3efacbbb1205227d387b84523e480aa1c0598744de9269
8.1.0-beta2:bf5751fc21817b6f20b932f77e941f9353d38d2406fcda964183a3aa09656021
8.1.0-rc1:bf5751fc21817b6f20b932f77e941f9353d38d2406fcda964183a3aa09656021
8.1.1:817d48b7266b289a04c58471eda63229e66e2313442137360cb5023adf4c384c
8.1.2:f6468f98d8284765ce96d68a38d846dae6bb278ca15922cd52072d98d545c638
8.1.3:f6468f98d8284765ce96d68a38d846dae6bb278ca15922cd52072d98d545c638
8.1.4:f6468f98d8284765ce96d68a38d846dae6bb278ca15922cd52072d98d545c638
8.1.5:f6468f98d8284765ce96d68a38d846dae6bb278ca15922cd52072d98d545c638
8.1.6:f6468f98d8284765ce96d68a38d846dae6bb278ca15922cd52072d98d545c638
8.1.7:f6468f98d8284765ce96d68a38d846dae6bb278ca15922cd52072d98d545c638
8.1.8:3b2b361d004269c961d4fe08d031bbdd66160fe6218321aa574e3b4288ea43f2
8.1.9:3b2b361d004269c961d4fe08d031bbdd66160fe6218321aa574e3b4288ea43f2
8.1.10:3b2b361d004269c961d4fe08d031bbdd66160fe6218321aa574e3b4288ea43f2
8.2.0-beta1:3b2b361d004269c961d4fe08d031bbdd66160fe6218321aa574e3b4288ea43f2
8.2.0-beta2:3b2b361d004269c961d4fe08d031bbdd66160fe6218321aa574e3b4288ea43f2
8.2.0-beta3:3b2b361d004269c961d4fe08d031bbdd66160fe6218321aa574e3b4288ea43f2
8.2.0-rc1:3b2b361d004269c961d4fe08d031bbdd66160fe6218321aa574e3b4288ea43f2
8.2.0-rc2:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.2.1:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.2.2:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.2.3:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.2.4:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.2.5:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.2.6:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.3.0-alpha1:4c7f0ff5fcfc417cd876da59a46bf342a2f5cabf7fc43bec0b628d523b2bcbf7
8.3.0-beta1:c5cbddff04410dbd15f833b5846cdd4e11cc92a3fedbac6d197fd818c2546c5e
8.3.0-rc1:c5cbddff04410dbd15f833b5846cdd4e11cc92a3fedbac6d197fd818c2546c5e
8.2.7:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.3.0-rc2:c5cbddff04410dbd15f833b5846cdd4e11cc92a3fedbac6d197fd818c2546c5e
8.0.0:73a40b18bd8c80c34dd18d91e19aa6272afcfd5dd9596339c3069fac162245ef
8.1.0:817d48b7266b289a04c58471eda63229e66e2313442137360cb5023adf4c384c
8.2.0:e3963e7edb283be6949bf78ad71bc14043af12c3186b4cebe59998cba1b6dec4
8.3.0:c5cbddff04410dbd15f833b5846cdd4e11cc92a3fedbac6d197fd818c2546c5e
|
/**
* Copyright © 2015 Magento. All rights reserved.
* See COPYING.txt for license details.
*/
define(
[
'ko',
'jquery',
],
function (ko, $) {
'use strict';
return {
/**
*
* @param installments
* @param grandTotal
* @param precision
* @param currencyCode
* @returns {Array}
*/
getInstallmentsWithPrices: function (installments, grandTotal, precision, currencyCode) {
let numberOfInstallments = [];
let dividedAmount = 0;
let dividedString = "";
$.each(installments, function (amount, installment) {
if (grandTotal >= amount) {
dividedAmount = (grandTotal / installment).toFixed(precision);
dividedString = installment + " x " + dividedAmount + " " + currencyCode;
numberOfInstallments.push({
key: [dividedString],
value: installment
});
}
});
return numberOfInstallments;
}
};
}
);
|
var fs = require('fs');
var path = require('path');
var verify = require('../../mmverify');
exports.problem = fs.createReadStream(__dirname + '/problem.txt');
exports.solution = fs.createReadStream(__dirname + '/solution.txt');
function lessthen(str, n) {
return str.length < n;
}
exports.verify = verify({ modeReset: true, name:'ex-3' }, function (args, t) {
var f = require(path.resolve(args[0]));
var input = 'dudee a \n\t12345@#^= .:-;';
var output = input.toUpperCase();
t.equal(typeof f, 'function', 'you need to export a function');
t.equal(f(input) === output, true, '');
var s = require('fs').readFileSync(args[0], 'utf8');
t.equal(s.indexOf('toUpperCase'), -1, 'cannot use toUpperCase word!' );
t.end();
});
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Currency = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _backbone = require('backbone.radio');
var _backbone2 = _interopRequireDefault(_backbone);
var _numbro = require('numbro');
var _numbro2 = _interopRequireDefault(_numbro);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var channel = _backbone2.default.channel('global');
var CurrencyHelper = function () {
function CurrencyHelper() {
_classCallCheck(this, CurrencyHelper);
}
_createClass(CurrencyHelper, [{
key: 'addLocale',
value: function addLocale(code, language) {
_numbro2.default.culture(code, language);
}
}, {
key: 'format',
value: function format(amount) {
var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var currencyLocale = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
var lang = currencyLocale || channel.request('currencyLocale');
var formatStr = '$0,0';
if (lang) {
_numbro2.default.culture(lang);
var language = _numbro2.default.cultureData();
if (language.format) {
formatStr = language.format;
}
}
for (var i = 0; i < decimals; i++) {
if (i === 0) {
formatStr += '.';
}
formatStr += '0';
}
return (0, _numbro2.default)(amount).format(formatStr);
}
}]);
return CurrencyHelper;
}();
var Currency = exports.Currency = new CurrencyHelper();
//# sourceMappingURL=currency.js.map
|
import React, { PropTypes } from 'react';
import { formatDate } from '../../../utils';
import EditProject from './editProject';
class ProjectCard extends React.Component {
constructor(props, context){
super(props, context);
}
handleClick(e){
if(e.target.getAttribute('data-target') == '#editProject' || e.target.getAttribute('data-target') == '#deleteProject'){
return;
}
this.context.router.push(`/project/${this.props.project._id}/taskboard`);
}
render(){
const { projectName, description, createTime, owner } = this.props.project;
return(
<div className="col-sm-6 col-md-4">
<div className="thumbnail" onClick={this.handleClick.bind(this)} >
<EditProject project={this.props.project} />
<img src="/static/imgs/cover-media.jpg" alt="project img" />
<div className="caption">
<h3 title={projectName}>{projectName}</h3>
<p title={description}>{description}</p>
</div>
<div className="panel-footer" style={{display: 'flex', justifyContent: 'space-between'}}>
<p title={owner} className="text-muted project-info">{`创建者:${owner}`}</p>
<p className="text-muted">{`创建时间：${formatDate(createTime)}`}</p>
</div>
</div>
</div>
);
}
}
ProjectCard.contextTypes = {
router: PropTypes.object.isRequired
}
export default ProjectCard; |
var gulp = require('gulp');
var browserify = require('browserify');
var watchify = require('watchify');
var source = require('vinyl-source-stream');
var notify = require('gulp-notify');
function handleErrors() {
notify.onError({
title : 'Compile Error',
message : '<%= error.message %>'
}).apply(this, arguments);
this.emit('end'); //keeps gulp from hanging on this task
}
function buildScript(file) {
var props = {
entries : ['./client/src/' + file],
debug : true,
transform : [
['babelify', { presets: ['es2015', 'react'] }]
]
};
//watchify if watch set to true. otherwise browserify once
var bundler = watchify(browserify(props));
function rebundle(){
var stream = bundler.bundle();
return stream
.on('error', handleErrors)
.pipe(source('bundle.js'))
.pipe(gulp.dest('./build/'));
}
bundler.on('update', function() {
var updateStart = Date.now();
rebundle();
console.log('Updated!', (Date.now() - updateStart) + 'ms');
})
// run it once the first time buildScript is called
return rebundle();
}
// run 'scripts' task first, then watch for future changes
gulp.task('default', ['scripts']);
gulp.task('scripts', buildScript.bind(this, 'app.jsx'));
|
import Ember from "ember";
var TypeMapping = Ember.Object.extend({
init: function(){
this.typesMap = {};
},
addTypeMapping: function(typeCode, className) {
this.typesMap[typeCode.toLowerCase()] = className;
},
classForType: function(typeCode) {
typeCode = typeCode.toLowerCase();
var mappedType = this.typesMap[typeCode];
if (!mappedType) {
Ember.Logger.warn("Couldn't map typeCode %@".fmt(typeCode));
}
return this.typeClass(mappedType);
},
typeClass: function(type) {
if (_.isString(type)) {
return this.classForType(type);
}
else {
return type;
}
}
});
var TypeMappings = TypeMapping.create();
export default TypeMappings;
|
function Cell(x, y, filled) {
this.position = {
x: x,
y: y
}
this.filled = filled,
this.selected = false,
this.enabled = true
}
Cell.prototype.equals = function(cell) {
return this.position.x == cell.position.x
&& this.position.y == cell.position.y;
}
function Grid(puzzle) {
var cells = new Array();
for(var i = 0; i < puzzle.length; i++) {
cells[i] = new Array(puzzle[i].length);
for(var j = 0; j < puzzle[i].length; j++) {
cells[i][j] = new Cell(j, i, puzzle[i][j] == 1);
}
}
this.cells = cells;
this.height = cells.length;
this.width = cells[0].length;
}
Grid.prototype.getCell = function(x, y) {
if(this.cells[y] && this.cells[y][x]) {
return this.cells[y][x];
}
return false;
}
Grid.prototype.selectCell = function(x, y) {
if(this.cells[y] && this.cells[y][x] && this.cells[y][x].enabled) {
this.cells[y][x].selected = true;
}
}
Grid.prototype.deselectCell = function(x, y) {
if(this.cells[y] && this.cells[y][x]) {
this.cells[y][x].selected = false;
}
}
Grid.prototype.enableCell = function(x, y) {
if(this.cells[y] && this.cells[y][x]) {
this.cells[y][x].enabled = true;
}
}
Grid.prototype.disableCell = function(x, y) {
if(this.cells[y] && this.cells[y][x] && !this.cells[y][x].selected) {
this.cells[y][x].enabled = false;
}
} |
import { Navigation } from 'react-native-navigation'
import SafariView from 'react-native-safari-view'
import * as Pocket from '../api/PocketAdapter'
import * as ChaseDriver from '../api/ChaseDriver'
export function ready() {
return async function(dispatch, getState) {
await _initialize(dispatch)
}
}
async function _initialize(dispatch) {
console.tron.start('allActions#_initialize')
try {
await _loadUserInfo(dispatch)
} catch (e) {
showLoginScreen(dispatch)
return
}
try {
await _loadMainCatalog(dispatch)
await _bumpAllTags(dispatch)
_loadSceneCatalogA(dispatch)
_loadSceneCatalogB(dispatch)
_loadSceneCatalogC(dispatch)
_loadSceneText(dispatch)
} catch (e) {
console.tron.warn('allActions#_initialize', e)
}
console.tron.end('allActions#_initialize')
}
async function _loadUserInfo(dispatch) {
console.info('allActions#_loadUserInfo')
await global.storage.load({ key: 'loginState' }).then(user => {
console.tron.info('user', user )
Pocket.setAccessToken(user.accessToken)
dispatch({ type: 'LOGIN_SUCCESS', data: user })
return
}).catch(e => {
console.tron.info('allActions#_loadUserInfo', 'NEEDS_AUTH')
throw e
})
}
async function _loadMainCatalog(dispatch) {
_refreshInboxCatalog(dispatch)
}
export function loginFromStorage() {
return function(dispatch, getState) {
return new Promise((resolve, reject) => {
global.storage.load({
key: 'loginState',
}).then(ret => {
dispatch({ type: 'LOGIN_SUCCESS', data: ret })
resolve()
}).catch(err => {
showLoginScreen(dispatch)
console.warn('[Error Message from Storage]', err);
switch (err.name) {
case 'NotFoundError':
break
case 'ExpiredError':
break
}
})
})
}
}
function showLoginScreen(dispatch) {
dispatch({ type: 'NEEDS_AUTH' })
Navigation.showModal({
screen: 'Chase.LoginScreen',
animationType: 'slide-up',
navigatorStyle: {
navBarHidden: true,
},
})
}
export function getPocketAuthUrl() {
return function(dispatch) {
return new Promise((resolve, reject) => {
Pocket.getRequestToken()
.then(token => {
// Request token will be used on Pocket.checkPocketApiAuth
dispatch({ type: 'GOT_REQUEST_TOKEN', requestToken: token })
return Pocket.getAuthorizePageUrl(token)
})
.then(authUrl => resolve(authUrl))
})
}
}
export function doAfterRedirect(eventUrl) {
return function(dispatch, getState) {
console.tron.start('#doAfterRedirect', eventUrl)
if (eventUrl.match(/authorizationFinished/)) {
SafariView.dismiss()
const rt = getState().login.requestToken
Pocket.checkPocketApiAuth(rt)
.then(res => {
const loginData = { username: res.username, accessToken: res.access_token }
updateLoginData(loginData)
_initialize(dispatch)
}).catch(err => {
console.tron.warn('#doAfterRedirect - Declined', err)
})
} else {
console.tron.error('#doAfterRedirect - Unexpected', eventUrl)
}
}
}
function updateLoginData(loginData) {
global.storage.save({
key: 'loginState',
data: {
username: loginData.username,
accessToken: loginData.accessToken,
},
expires: null
})
}
export function disconnectFromPocket() {
return function(dispatch, getState) {
global.storage.remove({ key: 'loginState' })
global.storage.remove({ key: 'scenes' })
updateLoginData({})
dispatch({ type: 'LOGOUT_DONE' })
showLoginScreen(dispatch)
}
}
export function clearCatalogCache() {
return function(dispatch, getState) {
global.storage.remove({ key: 'entries' })
global.storage.remove({ key: 'thumbs' })
dispatch({ type: 'CLEAR_ENTRIES' })
dispatch({ type: 'CLEAR_ALL_CATALOGS' })
}
}
export function setScenes(scenes) {
return function(dispatch) {
dispatch({ type: 'SET_SCENES', scenes })
global.storage.save({ key: 'scenes', data: scenes, expires: null })
}
}
function _loadSceneText(dispatch) {
global.storage.load({
key: 'scenes',
}).then(scenes => {
dispatch({ type: 'SET_SCENES', scenes })
}).catch(e => {
switch (e.name) {
case 'NotFoundError':
break
default:
}
})
}
export function refreshCatalog(catalogId) {
return function(dispatch, getState) {
_refreshInboxCatalog(dispatch)
}
}
function _refreshInboxCatalog(dispatch) {
return new Promise((resolve, reject) => {
console.tron.info('allActions#_refreshInboxCatalog')
dispatch({ type: 'REFRESH_WORK' })
Pocket.getAllUntaggedItems().then((result) => {
const { catalog, rawItems } = ChaseDriver.makeCatalog(result.list)
dispatch({ type: 'REFRESH_CATALOG_MAIN', catalog })
ChaseDriver.saveCatalogItemsAsEntryToStorage(rawItems)
.then(entries => {
dispatch({ type: 'REFRESH_ENTRIES', entries })
})
resolve(catalog)
}).catch(e => {
console.tron.error('allActions#_refreshInboxCatalog', e)
})
})
}
export function refreshSceneCatalogs() {
return function(dispatch, getState) {
return new Promise((resolve, reject) => {
console.tron.info('allActions#refreshSceneCatalogs', getState)
_loadSceneCatalogA(dispatch)
_loadSceneCatalogB(dispatch)
_loadSceneCatalogC(dispatch)
resolve()
})
}
}
function _loadSceneCatalogA(dispatch) {
Pocket.getItemsTaggedBy('chase:a').then((result) => {
const { catalog, rawItems } = ChaseDriver.makeSceneCatalog(result.list)
// console.tron.info('allActions#_loadSceneCatalogA', catalog)
dispatch({ type: 'REFRESH_WORK' })
dispatch({ type: 'REFRESH_CATALOG_SCENE_A', catalog })
ChaseDriver.saveCatalogItemsAsEntryToStorage(rawItems)
.then(entries => {
dispatch({ type: 'REFRESH_ENTRIES', entries })
})
})
}
function _loadSceneCatalogB(dispatch) {
Pocket.getItemsTaggedBy('chase:b').then((result) => {
const { catalog, rawItems } = ChaseDriver.makeSceneCatalog(result.list)
// console.tron.info('allActions#_loadSceneCatalogB', catalog)
dispatch({ type: 'REFRESH_WORK' })
dispatch({ type: 'REFRESH_CATALOG_SCENE_B', catalog })
ChaseDriver.saveCatalogItemsAsEntryToStorage(rawItems)
.then(entries => {
dispatch({ type: 'REFRESH_ENTRIES', entries })
})
})
}
function _loadSceneCatalogC(dispatch) {
Pocket.getItemsTaggedBy('chase:c').then((result) => {
const { catalog, rawItems } = ChaseDriver.makeSceneCatalog(result.list)
// console.tron.info('allActions#_loadSceneCatalogC', catalog)
dispatch({ type: 'REFRESH_WORK' })
dispatch({ type: 'REFRESH_CATALOG_SCENE_C', catalog })
ChaseDriver.saveCatalogItemsAsEntryToStorage(rawItems)
.then(entries => {
dispatch({ type: 'REFRESH_ENTRIES', entries })
})
})
}
export function refreshTagCatalog(tagNm) {
return function(dispatch, getState) {
return new Promise((resolve, reject) => {
console.tron.info('allActions#refreshTagCatalog -- start')
dispatch({ type: 'REFRESH_WORK' })
dispatch({ type: 'REFRESH_CATALOG_TAG', catalog: null })
Pocket.getItemsTaggedBy(tagNm).then((result) => {
const { catalog, rawItems } = ChaseDriver.makeCatalog(result.list)
dispatch({ type: 'REFRESH_CATALOG_TAG', catalog })
console.tron.info('allActions#refreshTagCatalog -- catalog:', catalog)
ChaseDriver.saveCatalogItemsAsEntryToStorage(rawItems)
.then(entries => {
dispatch({ type: 'REFRESH_ENTRIES', entries })
console.tron.info('allActions#refreshTagCatalog -- done', entries)
})
})
resolve()
})
}
}
export function makeNewThumb(entry) {
return function(dispatch) {
return new Promise((resolve, reject) => {
const url = entry.url
const pocket_id = entry.eid
const suggested = entry.suggested
ChaseDriver.callLambdaThumb(url, pocket_id, suggested).then(() => {
resolve()
})
})
}
}
export function applyScene(itemId, abc) {
return async function(dispatch, getState) {
await Pocket.addTag(itemId, `chase:${abc}`)
dispatch({ type: 'SET_WORK_SCENE', itemId, abc })
/* update one entry with new tag */
const tagName = `chase:${abc}`
let entries = Object.assign({}, getState().entries)
let entry = Object.assign({}, entries[itemId])
entry.tags = Object.assign({}, entry.tags, { [tagName]: {tag: tagName} })
entries[itemId] = entry
dispatch({ type: 'REFRESH_ENTRIES', entries })
}
}
export function addTag({ itemId, tagNm }) {
return async function(dispatch, getState) {
await Pocket.addTag(itemId, tagNm)
return tagNm
}
}
export function archive(itemId) {
return async function(dispatch, getState) {
dispatch({ type: 'SET_WORK_ARCHIVE', itemId })
await Pocket.archive(itemId)
return itemId
}
}
export function changeScene(idx) {
return function(dispatch, getState) {
dispatch({ type: 'CHANGE_SCENE', sceneIdx: idx })
}
}
export function refreshAllTags() {
return async function(dispatch, getState) {
await _bumpAllTags(dispatch)
}
}
async function _bumpAllTags(dispatch) {
const tags = await Pocket.getAllTags()
dispatch({ type: 'REFRESH_TAGS', tags })
}
export function debugInfo() {
return async function(dispatch, getState) {
console.tron.log('== DEBUG INFO ===============================')
await _dumpReducers(getState())
console.tron.log('- - - - - - - - - - - - - - - - - - - - - - -')
await _dumpStorages()
console.tron.log('=============================================')
}
}
async function _dumpReducers(allState) {
Object.keys(allState).forEach(key => {
console.tron.info(`Reducers[${key}]:`, allState[key])
})
}
async function _dumpStorages() {
await global.storage.load({ key: 'loginState' }).then(data => {
console.tron.info('Storages -- loginState:', data)
}).catch(e => { console.tron.info('Storage Load Error:', 'loginState') })
await global.storage.load({ key: 'entries' }).then(data => {
console.tron.info('Storages -- entries:', data)
}).catch(e => { console.tron.info('Storage Load Error:', 'entries') })
await global.storage.load({ key: 'scenes' }).then(data => {
console.tron.info('Storages -- scenes:', data)
}).catch(e => { console.tron.info('Storage Load Error:', 'scenes') })
}
|
var argscheck = require('cordova/argscheck'),
utils = require('cordova/utils'),
exec = require('cordova/exec');
var gps = function() {
};
gps.prototype.getStatus = function (successCallback, errorCallback) {
exec(successCallback, errorCallback, "GPS", "getStatus", []);
}
gps.prototype.isEnabled = function (successCallback, errorCallback) {
exec(successCallback, errorCallback, "GPS", "isEnabled", []);
}
gps.prototype.getCurrentLocation = function (successCallback, errorCallback) {
exec(successCallback, errorCallback, "GPS", "getCurrentLocation", []);
}
var gpsPlugin = new gps();
module.exports = gpsPlugin;
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _index = require('../../differenceInSeconds/index.js');
var _index2 = _interopRequireDefault(_index);
var _index3 = require('../_lib/convertToFP/index.js');
var _index4 = _interopRequireDefault(_index3);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// This file is generated automatically by `scripts/build/fp.js`. Please, don't change it.
var differenceInSeconds = (0, _index4.default)(_index2.default, 2);
exports.default = differenceInSeconds;
module.exports = exports['default']; |
var x = function (){};
var y = function (){};
var z = function () {
};
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.