Bundled payments, DMEPOS, regulatory reform, and ESRD
By Jonathan Blum, Acting Principal Deputy Administrator and Director, Center for Medicare
In the past few days, the Centers for Medicare and Medicaid (CMS) announced four critical initiatives that are designed to enhance health care delivery for millions of Medicare beneficiaries by improving care or lowering costs, or both. Taken together the announcements illustrate the breadth and diversity of efforts underway to ensure a better, stronger, more patient-centered Medicare program.
Last week, we announced a new health care delivery system reform, made possible by the Affordable Care Act, to test how bundling of payments for episodes of care, for example a heart attack or stroke, instead of paying for each test or procedure or physician’s visit, can result in more coordinated, higher quality care for beneficiaries. By bundling payments for services that beneficiaries receive during an episode of care, CMS hopes to encourage doctors, hospitals, and others to work together to improve care and health outcomes, while also lowering Medicare costs. Over 500 organizations, nationwide, have already signed-on to participate.
We also announced a major expansion of the Durable Medical Equipment, Prosthetics, Orthotics, and Supplies (DMEPOS) Competitive Bidding Program. In its first year of operation, competitive bidding, where prices are based on suppliers’ bids, saved the Medicare program, and taxpayers, over $202 million, while maintaining access to quality products for Medicare beneficiaries in the nine areas of the country where the program launched. It’s a great example of the Administration’s determination to put the brakes on runaway healthcare costs. With this expansion in the program, Medicare beneficiaries in 91 major metropolitan areas will save an average of 45 percent on certain DMEPOS items beginning in July. Between 2013 and 2022, we estimate that the expansion of the DMEPOS program will save Medicare $25.7 billion, while saving beneficiaries, who pay a percentage for medical equipment and supplies, $17.1 billion through lower prices.
This week, we issued a proposed rule which will help health care providers and hospitals to operate more efficiently by getting rid of regulations that are outdated, obsolete, or excessively burdensome. Many of the rule’s provisions streamline requirements that health care providers must meet in order to participate in the Medicare and Medicaid programs, without jeopardizing patient safety, and they will save providers nearly $676 million annually. Just as important, by eliminating burdensome requirements, health care providers can improve the quality of health care delivery for Medicare beneficiaries by spending more time focusing on patient care and less time filling out forms.
Finally this week, we announced the Comprehensive End-Stage Renal Disease (ESRD) Care Initiative. It will help identify, test and evaluate new ways to improve care for Medicare beneficiaries living with ESRD. We’ll be working with the health care provider community to care for a population that significant and complex health care needs. Through better care coordination, beneficiaries can more easily navigate the multiple providers involved in their care, ultimately improving their health outcomes.
These four initiatives demonstrate that CMS is employing new and novel tools and programs, thinking outside the box and beyond the usual way of doing things, in order to improve health care delivery for people with Medicare and, in the process, strengthen the Medicare program for current and future beneficiaries.


'Event Horizon'
A movie review by Walter Frith
As the medium of film grows larger with each passing year, movie audiences are left with fewer original movies but as long as a film can still entertain, it can still be called good. In the case of 'Event Horizon', this is a movie that isn't necessarily a copycat of past science fiction/horror films but rather it has been influenced by them. There are shades of 'Alien', 'The Exorcist', 'The Shining', '2001' and '2010' all mixed together in one very collective blend to shock and electrify you and is not for the faint of heart. There are extreme moments of graphic violence mixed in with a very loud and thunderous soundtrack and the special effects and art direction/set decoration are eye catching to say the least.
Set 50 years in the future in the year 2047, 'Event Horizon' deals with a group of space explorers led by Laurence Fishburne who travel to the far reaches of Neptune to investigate a space ship launched from Earth 7 years earlier which disappeared without a trace. It is found and a doctor along for the ride (Sam Neill) is the one who helped build and design the ship and scientific technology has allowed him to create the outer space atmosphere around it. The exploration team discovers that the ship itself is now possessed by a lifeforce of its own and it feeds on the fears and secrets of humans who encounter it. Sound like a 'B' movie plot? Perhaps, but read on.
To understand and appreciate this movie you have to stretch the boundaries of your imagination to a limit that perhaps may be a little too illogical and there is no doubt that director Paul Anderson has gone over the top at times but I still found the movie frightening, compelling and it has been a very long time since I jumped up in my seat while watching a film. Its religious overtones may offend some and its tone is sharp but the film is evenly paced, solidly edited (perhaps a bit too much at times) and technically efficient. If you enjoyed the movies I mentioned in the first paragraph of this review, then 'Event Horizon' will satisfy your craving for this kind of entertainment. Don't see this one if you feel faint at the sight of blood and it is not recommended for anyone that's ever covered their eyes during a movie.
OUT OF 5> * * * 1/2
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


CG Albums¶
Adding a CG Album¶
Albums Associated a Character¶
For this tutorial, this example shows how to add a character named Emma to the game. You can view Emma’s character definition and more in Adding a New Character to Chatrooms.
Albums are defined in gallery_album_definitions.rpy
. There are two images to define and one album variable.
Note
Prior to v3.3.0, the game required two album definitions, a variable and a persistent version. The current version combines both of these into one. If you were using the previous version, your album images should automatically update on game launch, and then you can switch over to the current way of defining albums.
First, under the heading Album Cover Images, you will see images that look like cg_label_ja
. This is the background of the small label that contains the name of the album. For Emma, you will define an image like:
image cg_label_em = "CGs/label_bg_em.webp"
The important thing is that it is called cg_label_em
where em
is the character’s file_id. You can look at the existing images to see what they look like. The CG label is typically 241x64 px.
Below that is a set of images like ja_album_cover
. This is the image that will be displayed as a button to click and open the album. It typically has an image of the associated character and is 157x137 px. Emma’s image definition will look like:
image em_album_cover = "CGs/em_album_cover.webp"
The important part is that it’s called em_album_cover
where em
is the character’s file_id.
Next, you need to define the album:
define em_album = GalleryAlbum([])
The album should be the character’s file_id + album, so in this case it’s em_album
.
At the bottom of the file, you will also see a definition for the variable all_albums
. You need to add Emma’s file_id here so that her album shows up in the Album screen:
default all_albums = [
'ju', 'z', 's', 'y', 'ja', 'v', 'u', 'r', 'common', 'em'
]
You can reorganize this list as you see fit. Albums are organized in rows of three on the Album screen. So, the following definition would be equally correct, depending on which characters you wanted to have albums:
default all_albums = [
'ju', 'z', 's', 'y', 'ja', 'em', 'common'
]
Tip
If a player has already unlocked an image inside an album, it will be automatically added to all_albums
. If you’re making a new route and don’t want some characters’ albums to appear, you must both 1) remove them from all_albums
and 2) Use Reset Persistent
from the Ren’Py launcher to cause Ren’Py to forget which CGs you unlocked over other routes.
Albums not Associated With a Character¶
If you want an album that isn’t associated with any particular character, such as a “Common” album, the program expects you to follow certain naming conventions so it can find the correct album cover, label, and variables.
For example, if you wanted to add a “New Year’s” album, you must do the following:
Add “new year’s” to the
all_albums
definition. If a string is all lowercase, the first letter will be capitalized when it is displayed on the Album screen, but otherwise capitalization is preserved. Also note the use of double quotes (“) instead of single so you don’t have to escape the apostrophe.
default all_albums = [
'ju', 'z', 's', 'y', 'ja', 'v', 'u', 'r', 'common', "New Year's"
]
Determine what the program will expect the variables to be called.
The program uses a specific naming scheme to process strings into file and variable names:
Spaces are turned into underscores (e.g. “bonus images” -> “bonus_images”)
Apostrophes are removed (e.g. “valentine’s day -> “valentines_day”)
Entire word is in lowercase (e.g. “RFA Bonus” -> “rfa_bonus”)
So, using the rules above, “New Year’s” in the all_albums
definition will become “new_years”. You can then define the two images and album definition like you did for Emma above:
image cg_label_new_years = "Image for your label.png"
image new_years_album_cover = "Image for your album cover.png"
define new_years_album = []
Defining a CG¶
For any CG you would like to show in-game, you must first go to gallery_album_definitions.rpy
and define an image under the CGs header. For this example, a fourth CG in the Common album will be added. CG images should take up the entire screen, which is 750x1334 px. CGs of other sizes may not display correctly.
First, define the image:
image cg common_4 = "CGs/common_album/cg-4.webp"
The name of the cg must be cg
+ the name of the album it is found in, minus “album”, plus an underscore and some identifier for the image such as a number (4
), or a descriptor of the CG. Other possible CG definitions might be:
image cg common_flower = "CGs/common_album/cg-flower.webp"
image cg ju_meeting = "CGs/ju_album/ju-meeting-office.webp"
After defining your image, you must add it to the correct album. See Adding a CG Album for more on creating new albums as well.
define common_album = GalleryAlbum([
GalleryImage("cg common_1"),
GalleryImage("cg common_2"),
GalleryImage("cg common_3"),
GalleryImage("cg common_4")
])
In this example, no unique thumbnail was specified. If the program can find an image with the suffix -thumb
before the file extension, it will use that as the thumbnail. So, since the image is found at “CGs/common_album/cg-4.webp”, the program will look for a thumbnail image at “CGs/common_album/cg-4-thumb.webp”.
Otherwise, you can also manually specify a thumbnail as the third argument to GalleryImage or just by specifying it using thumbnail=
in the definition:
GalleryImage("cg common_4", thumbnail="CGs/thumbnails/common_4_thumbnail.webp")
Typically thumbnails are 150x150 px. If one is not provided, the given CG is cropped and resized to the appropriate size.
The full list of arguments to the GalleryImage definition is below:
- name
A string. Typically this ends up being the same as
img
below if you define your CGs as described above, but you could also do something like:GalleryImage("cg common_5", "CGs/Common/special.webp")
This would have the same effect as if you’d defined
cg common_5
using theimage
declaration.- img
A Displayable, typically a string with the name of the image for this CG as it should appear in the album. Can be omitted if it is the same as
name
. If this is the file path to the image, you should use thename
property to give the CG a “script-friendly” name, as that’s the one you’ll use to unlock it in-game.- thumbnail
Optional. An image path or displayable for the thumbnail as it should appear in the Gallery. Should be 155x155 pixels. If not provided, the CG is scaled and cropped to fit the thumbnail size.
- locked_img
Optional. The file path to the image that will be used as the “locked” thumbnail icon in the gallery. Should be 155x155 pixels. Typically has a “?” or a locked symbol somewhere to indicate this gallery image hasn’t been unlocked yet.
This is often used to indicate, for example, that an image comes from a particular DLC.
- chat_img
Optional. A Displayable (typically an image path or string containing the name of a defined image) which will be shown to the player at full-size in the chatroom only. The supplied
img
field will be used when viewing this image full-size in the gallery instead.Use this to do things like supply blurry or edited CGs in the chatroom, but provide their regular unedited version in the gallery.
- chat_preview
Optional. A Displayable (typically an image path or string containing the name of a defined image) which will be shown to the player in the chatroom only. Clicking this image will show either
chat_img
(if available) orimg
(if not) full-screen. Typically this is about 35% of the full screen size, or 263x467 pixels, but can be whatever dimensions you like.Use this to customize the image preview in the chatroom, such as blurring the thumbnail for “spoilers” or to put the thumbnail focus on a particular part of the image.
Note
The equivalent property was called
chat_thumb
in theAlbum
object prior to v3.3.0.
So, for example, you could define a GalleryImage object like so:
GalleryImage("cg common_1",
thumbnail="common_1_thumb",
chat_img="cg common_1_edit",
chat_preview="CGs/spoiler_img.png"
)
(Note that this assumes you have image cg common_1 = "..."
, image common_1_thumb = "..."
, image cg common_1_edit = "..."
etc.)
You would then still be able to use the CG in the usual manner described below to show in chatrooms or text messages.
Large Thumbnails¶
Recall our additional CG image:
image cg common_4 = "CGs/common_album/cg-4.webp"
For better compatibility with the new profile picture system, you may also want to provide a “larger” version of a thumbnail for use in profile pictures on the profile screen. The program will search for an image with the name of the thumbnail + the suffix -b
before the file extension. So, if “cg common_4” isn’t given a different thumbnail, it will look for the large version of the thumbnail at “CGs/common_album/cg-4-thumb-b.webp”.
If you provided a different thumbnail, as in GalleryImage("cg common_4", thumbnail="CGs/thumbnails/common_4_thumbnail.webp")
, then the large version is expected to be called “CGs/thumbnails/common_4_thumbnail-b.webp”.
Adding a CG After Starting the Game¶
In some cases, you may not want a CG to appear in a character’s album unless some condition is met, such as a particular DLC being unlocked. In such a case, you can make use of the condition
property of a GalleryImage
object.
For example, say you have a variable, persistent.new_years_dlc
, which tracks whether the player has the New Year’s DLC or not. You only want to show “missing” New Year’s DLC images in their album if they already have the DLC. In such a case, you can do:
image ja_ny1 = "CGs/Jaehee/ny1.webp"
define ja_album = GalleryAlbum([ GalleryImage(
"ja_ny1",
locked_img="CGs/new_years_locked.webp",
condition="persistent.new_years_dlc"
)
])
This will define a gallery image named “ja_ny1” with the locked thumbnail at “CGs/new_years_locked.webp” and the condition of "persistent.new_years_dlc"
. The fact that persistent.new_years_dlc
is in quotes is important - the program uses this to evaluate the condition when it’s going to show the gallery (as opposed to right at the start of the game).
You can use this for more complex conditions as well, so long as they are enclosed in quotes. Some examples:
"'jaehee' in persistent.new_years_dlc_endings"
"persistent.new_years_dlc_endings >= 1 and persistent.new_years_dlc and 'jaehee' in persistent.new_years_dlc"
Typically you should use persistent variables for the conditions, because the player can view their album from the main menu as well so any save file-specific values won’t necessarily be used.
Warning
The following code will only work if you use the old definition format for albums (namely, the one with a default
album and a persistent
version). The updated version of this code (as of v3.3.0) can be found above, and should be used in preference to the version below. The following version is maintained for compatibility purposes only.
While in most cases you should define your CGs in gallery_album_definitions.rpy
, you can also add new CGs to an album after the game has already started with the function add_to_album
. This function takes two parameters:
- album
The album variable that should contain this new CG.
e.g.
ja_album
- photo_list
An
Album
or list ofAlbum
objects which should be added to the given album variable above.e.g. [ Album(“cg s_4”), Album(“cg s_5”) ]
Typically you would use this function at the beginning of a route, particularly if the route is DLC since this will allow you to add images to the album without having to directly modify the gallery_album_definitions.rpy
file. An example may look like:
label new_year_prologue():
$ new_route_setup(route=new_years_route, chatroom_label='new_year_prologue',
participants=[ja])
$ paraphrase_choices = True
# Album definitions for this new route
$ add_to_album(ja_album, Album('cg ja_ny_1'))
$ add_to_album(ju_album, Album("cg ju_ny_1"))
$ add_to_album(s_album, [ Album("cg s_ny_1"), Album("cg s_ny_2") ])
$ character_list = [ju, z, s, y, ja, m]
$ heart_point_chars = [ju, z, s, y, ja]
# Route prologue begins here
Hiding Albums Until Unlocked¶
In some situations, you may want an album to not show up in the player’s photo album until they have unlocked an image contained in it. For example, if you include a New Year’s scenario, you may want to put related CGs in a New Year’s album, but if the player hasn’t unlocked or played through the New Year’s scenario, you don’t want the New Year’s album to show up in their photo album screen.
In this case, you can use the line
$ hide_albums(["new year's"])
to hide this album unless the player has unlocked a photo in it. The best place to put this is just before setting up a new route e.g.
$ hide_albums(["new year's"])
$ new_route_setup(route=my_new_route)
If the player has already unlocked images in this album, it will continue to be shown. Otherwise, this album will only appear in the player’s photo album once they have unlocked an image in it (this is taken care of automatically).
Note that since you are passing a list, you can pass multiple albums to be hidden e.g.
$ hide_albums(["new year's", "christmas", "b"])
Showing a CG in a Chatroom or Text Message¶
In chatrooms or text messages, sometimes characters will post images that the player can click on the view full-size. These images will automatically be unlocked in the appropriate Album once the player has seen them.
To show a CG in the chatroom, put the name of the CG in the character’s dialogue e.g.
s "cg common_4" (img=True)
# or with the msg CDS
msg s "cg common_4" img
You can also omit cg
at the beginning, so long as you remember to mark it as an image:
y "common_4" (img=True)
msg z "common_4" img
The program will take care of resizing the CG for the chatroom and allowing the player to view it full-size. It will also unlock the CG in the appropriate album and notify the player if they have not yet seen the image in the album. If this is the first time the player has seen this image, it will also become available for use as a bonus profile picture (see Bonus Profile Pictures).
You can see an example of a CG posted in a text message in tutorial_3b_VN.rpy
, and an example of a CG posted during a chatroom in tutorial_5_coffee.rpy
.
Showing a CG during Story Mode¶
All you need to do to have an image unlock after showing it in a Story Mode section is to show it to the player. This can be done through the scene
or show
statements. scene
will clear the screen of any existing character sprites/backgrounds etc before showing the image. It’s highly recommended that if you are showing a CG outside of a chatroom that you use the image
statement to declare a “short” name for the CG (e.g. image cg common_4 = "CGs/Common/com4.webp"
).
You can display it in script with scene
or show
, as mentioned:
ju "I wanted to show you how the lounge has been decorated."
scene cg common_4
show jumin front neutral
ju "Do you like it?"
or
ja "Oh, no, I've spilled the flour everywhere."
show cg common_4
ja "Could you get something to clean this up with?"
In most cases, you will probably use scene
to show a CG image to the player instead of show
.
The CG can be cleared from the screen either by replacing it with another scene
statement or by explicitly hiding it with hide cg
:
u "I wanted to show you how the lounge has been decorated."
scene cg common_4
show jumin front neutral
ju "Do you like it?"
scene bg meeting_room # This clears the CG from the screen
ju "I think it turned out rather well."
or
ja "Oh, no, I've spilled the flour everywhere."
show cg common_4
ja "Could you get something to clean this up with?"
hide cg # This clears the CG from the screen
show jaehee happy
ja "I'm sorry for the trouble."
You can see an example of a CG posted during a Story Mode section in tutorial_8_plot_branches.rpy
.


{% extends "base.html" %} {% block refunding %}
The job has been completed. Click here to download the logs.
Start another refund job.


May 29
Don't Hesitate
He that wavereth is like a wave of the sea driven with the wind and tossed. For let not that man think that he shall receive any thing of the Lord. A double minded man is unstable in all his ways.
James 1:6-8
What happens when you hesitate to do something God has told you to do? Your adversary takes the first step.
If you want to live by faith, hesitation is one of the most hazardous habits you could ever have. It comes from being indecisive. The Bible says a man like that is "unstable and unreliable and uncertain about everything he thinks, feels, decides" (The Amplified Bible).
If you are double-minded, the decisions you make are split. You try to live by faith and protect your fear at the same time. You make faith statements like "I believe God is going to heal me." Then your fear whispers, "But I wouldn't want to say I'm well just yet." You're so busy going back and forth between faith and fear, you can't make any progress at all.
Kick the habit of hesitation today. Make a solid decision to trust in and act on the Word of God. Settle it forever. Resolve never to entertain doubts again. When doubt comes to your mind, cast it out quickly.
When God speaks, don't waste a moment. Step right out in faith. That way, you can always keep the devil a step behind you!
Scripture Reading: James 1:1-8


Dog Survey
Tell us all about your dog!
Name :
Email :
How many days per week do you walk your dog? :
Is your dog an indoor or outdoor dog? :
Select One
Indoor
Outdoor
Indoor/Outdoor
Dog Size :
Small
Medium
Large
What does your dog enjoy? (Check all that apply) :
Parks
Beaches
Hiking
Pet Stores
Kayaking
Walks
Additional Comments :
Anything else you'd like to tell us about your dog?
Submit


Please enter the parameters below for setting up the virtual environment
Organizations e.g. 40
Lower Limt of Machines e.g. 1
Higher Limit of Machines e.g. 10
Random Seeding Phrase e.g. Dime Lab


I'm running Vista x64 sp1. I've had IE 7 and then IE 8 (b2) installed. I tried uploading via ftp from a)Windows Explorer, b)Visual Studio ftp, c)FireZilla, d)SmartFTP. Small files uploaded perfectly but even 150KB files kept timing out and retrying. Active/passive didn't help. Nothing helped. I tried for 28 hours to upload a 340KB file. It was infuriating. I tried from another ISP's connection. I tried from XP. Nothing worked. God knows why. I contacted tech support, they said it was a problem on my ISP and that my connection was poor. While I agree a 100kbps upload isn't good at all, I do expect to upload 100KB in a few minutes and not failing for hours. I can't be too sure about their response as people using my ISP DO upload via ftp. I sent my files to a friend in the US and he graciously uploaded for me. He mentioned it was slow. And then I needed changes on my site. Enter frustration.
Well...just now I found a brilliant solution that's just plain mind boggling. I learned of FireFTP, an ftp plugin for FireFox. Now, (this may surprise a lot of folks), I don't like FireFox much. On my dev machine, it's painfully slow loading pages from the VS dev server compared to IE7 / IE8 / Chrome. But this is one thing I'll always be using for ftp from now on. You see, FireFTP is slick, fast and it uploaded my 350KB file in 25 seconds flat(!) - something the bigger players failed to do.
I'm guessing this is coz of some OS configuration or firewall or whatever. I tried turing off vista auto tuning. Nothing helped. I faced the same problem from XP though. I wonder if it's my good buddy Kaspersky that's causing me the pain. I did try turning off the firewall, but that didn't help either.
Anyhow, I'm glad I found fireftp. I noticed some people on the forums were complaining about slow ftp too. I hope fireftp can help them too.
EDIT: As Josh points out...I really should have posted this link here:
FireFTP: The BEST and SIMPLEST FTP software I've EVER used - and one that just "works".
There you go :D


| group_split {dplyr} | R Documentation |
group_split()
works like base::split()
but
it uses the grouping structure from group_by()
and therefore is subject to the data mask
it does not name the elements of the list based on the grouping as this typically loses information and is confusing.
group_keys()
explains the grouping structure, by returning a data frame that has one row
per group and one column per grouping variable.
group_split(.tbl, ..., .keep = TRUE)
.tbl |
A tbl |
... |
Grouping specification, forwarded to |
.keep |
Should the grouping columns be kept |
group_split()
returns a list of tibbles. Each tibble contains the rows of .tbl
for the associated group and
all the columns, including the grouping variables.
group_keys()
returns a tibble with one row per group, and one column per grouping variable
The primary use case for group_split()
is with already grouped data frames,
typically a result of group_by()
. In this case group_split()
only uses
the first argument, the grouped tibble, and warns when ...
is used.
Because some of these groups may be empty, it is best paired with group_keys()
which identifies the representatives of each grouping variable for the group.
When used on ungrouped data frames, group_split()
and group_keys()
forwards the ...
to
group_by()
before the split, therefore the ...
are subject to the data mask.
Using these functions on an ungrouped data frame only makes sense if you need only one or the other, because otherwise the grouping algorithm is performed each time.
group_split()
returns a list of one-row tibbles is returned, and the ...
are ignored and warned against
Other grouping functions:
group_by()
,
group_map()
,
group_nest()
,
group_trim()
# ----- use case 1 : on an already grouped tibble ir <- iris %>% group_by(Species) group_split(ir) group_keys(ir) # this can be useful if the grouped data has been altered before the split ir <- iris %>% group_by(Species) %>% filter(Sepal.Length > mean(Sepal.Length)) group_split(ir) group_keys(ir) # ----- use case 2: using a group_by() grouping specification # both group_split() and group_keys() have to perform the grouping # so it only makes sense to do this if you only need one or the other iris %>% group_split(Species) iris %>% group_keys(Species)


Trials Module
- Source:
Methods
(static) BuildExperiment(printTrials)
BuildExperiment must be called to generate the trial array from the supplied IVs,
prior to running the experiment.
Parameters:
| Name | Type | Description |
|---|---|---|
printTrials |
bool | flag to print the trials as they are built. |
- Source:
(static) forceOutputResponses()
Download participant's responses as a csv. This can be called at any time during the experiment
to obtain participant data before all trials are complete.
- Source:
(static) getPptInfo()
Get participant number and name.
- Source:
(static) getTrials() → {array}
Returns a deep copy of the trials array
- Source:
Returns:
- Type
- array
(static) OutputResponses(uri_csv_string)
Function to output URI encoded csv.
This function can be overridden to support different
functionality (e.g. sending the CSV to a server).
Parameters:
| Name | Type | Description |
|---|---|---|
uri_csv_string |
string |
- Source:
Example
Trials.OutputResponses = function(uri_csv_string){
$.post("/custom_uploader.php", {data: uri_csv_string});
};
(static) runNextTrial(options)
Call `ExperimentJS.Trials.runNextTrial()` both to start the experiment and to progress to the next trial.
To store participant's response, an object should be passed in as the first arg.
This object should contain the key "dv_value", with its value being the participant's response
to the trial that was just run.
Parameters:
| Name | Type | Description |
|---|---|---|
options |
object | must contain field "dv_value" |
- Source:
Example
ExperimentJS.Trials.runNextTrial(); // To start the experiment
ExperimentJS.Trials.runNextTrial({ dv_value: "participant's response" }); // To store participant's response and progress to next trial
(static) setDVName(dvName)
Set the name of the dependent variable (DV)
Parameters:
| Name | Type | Description |
|---|---|---|
dvName |
string |
- Source:
(static) setEndCallback(end_callback)
Set a custom behaviour to be run at the end of the experiment, after responses are output.
Parameters:
| Name | Type | Description |
|---|---|---|
end_callback |
function | A function implementing this behaviour |
- Source:
(static) setIVLevels(ivname, levels)
`setIVLevels` AND `setIVsetFunc` must both be called once per IV. They are linked by a common `ivname`.\n
Call `setIVLevels` to assign data to the setter function (passed to `setIVsetFunc`).
Data should be an array of arrays.
Each sub array is the arguments passed to the setter function:
Parameters:
| Name | Type | Description |
|---|---|---|
ivname |
string | The name of the IV. |
levels |
array | Array of arrays of arguments passed to the set function. |
- Source:
Example
ExperimentJS.Trials.setIVsetFunc("iv name", function(arg1, arg2, arg3){ ... });
ExperimentJS.Trials.setIVLevels("iv name", [ [arg1_a, arg2_a, arg3_a], [arg1_b, arg2_b, arg3_b], ...]);
(static) setIVPhases(phase_num, array_of_iv_names, transition_func_or_delay)
Present IVs sequentially by assigning each independent variable (IV) name to an ordinally numbered phase.
To transition between phases, a function or a delay (in milliseconds) must be provided.
If a function is provided, it must receive a callback as its first argument.
This callback should be called to transition to the next phase.
Parameters:
| Name | Type | Description |
|---|---|---|
phase_num |
int | ordinal number of the phase |
array_of_iv_names |
array | array of IV names for this phase |
transition_func_or_delay |
function | number | function to handle transition between phases, or duration until next phase |
- Source:
Example
// Using a function
ExperimentJS.Trials.setIVPhases(0, ["Name of an IV to run in phase 0", "Another one"], function(continue_to_next_phase){
if(some_condition_is_satisified){
continue_to_next_phase();
}
});
// Using a number (i.e. a timeout delay)
ExperimentJS.Trials.setIVPhases(0, ["Name of an IV to run in phase 0", "Another one"], 2000); // after two seconds go to the next phase
ExperimentJS.Trials.setIVPhases(1, ["An IV in the second phase"]); // after two seconds go to the next phase
(static) setIVResponseParserFunc(ivname, parserFunc) → {string|object}
In some cases, the arguments that you pass into your independent variable (IV) setter function will not be useful
to include in the output at the end of the experiment.
`setIVResponseParserFunc` allows you to set a function that parses the arguments passed to the setter function
into one (or more) output values (with more descriptive value). See example for more detail on output..
Parameters:
| Name | Type | Description |
|---|---|---|
ivname |
string | The name of the independent variable (IV). |
parserFunc |
function | Function to parse responses. Must conform to the interface in the example.. |
- Source:
Returns:
One (string) or more (object) columns of parsed output data
- Type
- string | object
Example
Trials.setIVResponseParserFunc("iv name",
function ( r, g, b..., index){
// Here R, G & B are the arguments passed to the setter function
// Parse the arguments for this independent variable...
// eg. three numbers representing an RGB triplet could be condensed into a color name:
var output;
if (r === 255 && g === 0 && b === 0){
output = "red";
} else {
output = "not red";
}
// return either a:
string - output a single column of parsed data, in string form
object - output multiple columns of parsed data, where each key is the column header
}
);
(static) setIVsetFunc(ivname, setFunc)
Generating every IV requires 2 steps: creating the levels and creating a set function.
`setIVsetFunc` is called to set the function that will be used to set that IV in the display.
The levels it receives are set by `setIVLevels`.
The arguments this function receives must correspond to the elements in the sub-arrays passed to `setIVLevels`.
Parameters:
| Name | Type | Description |
|---|---|---|
ivname |
string | The name of the IV. |
setFunc |
function | Function used to set levels in the display. |
- Source:
Example
ExperimentJS.Trials.setIVsetFunc("iv name", function(arg1, arg2, arg3){ ... });
ExperimentJS.Trials.setIVLevels("iv name", [ [arg1_a, arg2_a, arg3_a], [arg1_b, arg2_b, arg3_b], ...]);
(static) setMidpointCallback(midpoint_callback)
Set a custom behaviour to be run at the midpoint of the experiment.
Parameters:
| Name | Type | Description |
|---|---|---|
midpoint_callback |
function | A callback function implementing this behaviour |
- Source:
(static) setRepeats(nRepeats)
Set the number of repeats in the experiment.
Parameters:
| Name | Type | Description |
|---|---|---|
nRepeats |
int |
- Source:
(static) setShouldTrackResponseTime(shouldTrackResponseTime)
Turn tracking of response time on or off.
Parameters:
| Name | Type | Description |
|---|---|---|
shouldTrackResponseTime |
bool |
- Source:
(static) setShuffle(shouldShuffle)
Determine whether the trials should be shuffled.
Parameters:
| Name | Type | Description |
|---|---|---|
shouldShuffle |
bool |
- Source:
(static) setStartCallback(start_callback)
Set a custom behaviour to be run at the start of the experiment.
Parameters:
| Name | Type | Description |
|---|---|---|
start_callback |
function | callback function implementing this behaviour |
- Source:
(static) shuffleTrials(trials)
Shuffles trials using the Fisher Yates algorithm.
If you wish to alter the shuffling behaviour, this function can be overridden (see example below).
Parameters:
| Name | Type | Description |
|---|---|---|
trials |
array | an array of unshuffled trials |
- Source:
Example
Trials.shuffleTrials = function(all_trials){
// shuffle all_trials in some way...
return all_trials
}


Jambalaya
12 minutes ago
20 comments
An easy Jambalaya recipe is pure comfort food filled to the brim with flavour. The aromatic trinity of Cajun/Creole cooking. Yum Yum
Macaroni & Cheese
10 minutes ago
0 comments
If you’ve got a pulse, I assume you love creamy mac and cheese. The question of ‘Why we love it’ is a real nature vs nurture debate
Collard Greens
5 hours ago
2 comments
This member of the cabbage family has an earthy flavor and a meaty, tender texture unlike any other cooked green you’ve had before. It’s the perfect side dish!
Candied Yams Dessert
1 hours ago
2 comments
Candied yams are a southern staple and soul food classic. They are the perfect combination of sweet potato, butter, sugar, and spices.


Classes
lvector.AGS ArcGIS Server
This class creates a layer that processes and displays features from an ArcGIS Server. You can also use this class to create a layer from any services that implement Esri's Geo REST specification, like Arc2Earth.
Usage Example
var myAGSLayer = new lvector.AGS({ url: "http://maps.rtd-denver.com/ArcGIS/rest/services/BusLocations/MapServer/0", fields: "*", uniqueField: "OBJECTID", scaleRange: [13, 20], popupTemplate: "
Bus #{BUS_NUMBER}

Speed: {SPEED} mph
" });
Constructor
| Constructor | Description |
|---|---|
lvector.AGS( <AGS options> options ) | Instantiates an AGS layer with an object literal with AGS options described below. |
Options
| Option | Type | Default Value | Description |
|---|---|---|---|
url | String | null | Required - A url for a specific layer in an ArcGIS Server service. |
map | Object L.Map object | null | The Leaflet Map object where the layer will be added. The layer can be added to the map later with the setMap method. |
scaleRange | Array | null | An array with two number values that represent the minimum and maximum scales the layer is visible. For example: [14, 17] |
dynamic | Boolean | false | Whether or not the layer contains dynamic data. If true, feature geometry and attributes will be checked for changes after extent change and/or after a defined interval. For details check the dynamic data documentation. |
autoUpdate | Boolean | false | Whether or not to auto-update a dynamic layer. If true, feature geometry and attributes will be updated at an interval set by the autoUpdateInterval option. For details check the dynamic data documentation. |
autoUpdateInterval | Integer | null | The interval (in milliseconds) between checks for updated feature geometry and attributes when the autoUpdate option is set to true . For details check the dynamic data documentation. |
popupTemplate | String|Function | null | A template for creating the content of a Leaflet Popup when a feature is clicked. For details check the Popup Template documentation. |
singlePopup | Boolean | false | Whether or not to show a single Popup for a layer when features are clicked. This keeps the map from getting cluttered when multiple features are clicked. |
popupOptions | Object Leaflet Popup options | null | Controls the width of and the presence of a close button for the Popup and whether the map should be panned when the Popup is opened. |
symbology | Object symbology options | null | The symbology options for the layer. Features can be rendered with a single symbology or can also be symbolized based on an attribute using unique values or a value range. For details check the symbology options documentation. |
showAll | Boolean | false | If true, all features will be fetched and shown once, not after a map extent change. This is helpful for layers with only a handful of features. |
fields | String | null | A list of comma separated fields to be returned with the features. For example "OBJECTID,OWNER_NAME" returns two fields and "*" returns all fields. |
uniqueField | String | null | A field in the returned data that can be considered unique. This isn't required but is very helpful in determining which features are already on the map when the map extent changes. |
clickEvent | Function | null | A user defined click event. For details check the Custom clickEvent options documentation. |
Methods
| Method | Description |
|---|---|
setMap( <L.Map> Map ) | Adds the layer to a map. Remove the layer by passing null . |
getMap() | Gets the map (if any) that the layer has been added to. |
lvector.A2E Arc2Earth
This class creates a layer that processes and displays features from an Arc2Earth Sync instance.
Usage Example
var myA2ELayer = new lvector.A2E({ url: "http://sync.arc2earth.com/6442491/ArcGIS/rest/services/tfs/2447544/FeatureServer/0", esriOptions: true, uniqueField: "global_fid", popupTemplate: '

{Name}

', singlePopup: true, dynamic: true, autoUpdate: true });
Constructor
| Constructor | Description |
|---|---|
lvector.A2E( <A2E options> options ) | Instantiates an A2E layer with an object literal with A2E options described below. |
Options
| Option | Type | Default Value | Description |
|---|---|---|---|
url | String | null | Required - A url for a specific layer in an ArcGIS Server service. |
map | Object L.Map object | null | The Leaflet Map object where the layer will be added. The layer can be added to the map later with the setMap method. |
scaleRange | Array | null | An array with two number values that represent the minimum and maximum scales the layer is visible. For example: [14, 17] |
dynamic | Boolean | false | Whether or not the layer contains dynamic data. If true, feature geometry and attributes will be checked for changes after extent change and/or when a PubNub message is sent to the client. |
autoUpdate | Boolean | false | Whether or not to auto-update a dynamic layer. If true, feature geometry and attributes will be updated in near real-time by subscribing to PubNub events. |
popupTemplate | String|Function | null | A template for creating the content of a Leaflet Popup when a feature is clicked. For details check the Popup Template documentation. |
singlePopup | Boolean | false | Whether or not to show a single Popup for a layer when features are clicked. This keeps the map from getting cluttered when multiple features are clicked. |
popupOptions | Object Leaflet Popup options | null | Controls the width of and the presence of a close button for the Popup and whether the map should be panned when the Popup is opened. |
symbology | Object symbology options | null | The symbology options for the layer. Features can be rendered with a single symbology or can also be symbolized based on an attribute using unique values or a value range. For details check the symbology options documentation. |
showAll | Boolean | false | If true, all features will be fetched and shown once, not after a map extent change. This is helpful for layers with only a handful of features. |
fields | String | null | A list of comma separated fields to be returned with the features. For example "OBJECTID,OWNER_NAME" returns two fields and "*" returns all fields. |
uniqueField | String | null | A field in the returned data that can be considered unique. This isn't required but is very helpful in determining which features are already on the map when the map extent changes. |
esriOptions | Boolean | false | Whether or not to request scaleRange and symbology settings from the Arc2Earth Sync back-end. Layers loaded from ArcGIS Desktop into Arc2Earth Sync will retain scaleRange and symbology settings from ArcGIS Desktop. |
clickEvent | Function | null | A user defined click event. For details check the Custom clickEvent options documentation. |
Methods
| Method | Description |
|---|---|
setMap( <L.Map> Map ) | Adds the layer to a map. Remove the layer by passing null . |
getMap() | Gets the map (if any) that the layer has been added to. |
lvector.GeoIQ GeoIQ - Geocommons
This class creates a layer that processes and displays features from a GeoIQ dataset.
Usage Example
var myGeoIQLayer = new lvector.GeoIQ({ dataset: 164880, uniqueField: "NAME", scaleRange: [6, 20], popupTemplate: '

{NAME}

', singlePopup: true, symbology: { type: "single", vectorOptions: { icon: new customIcon({ iconUrl: "../../docs-demo/img/markers/ski-lift.png" }) } } });
Constructor
| Constructor | Description |
|---|---|
lvector.GeoIQ( <GeoIQ options> options ) | Instantiates a GeoIQ layer with an object literal with GeoIQ options described below. |
Options
| Option | Type | Default Value | Description |
|---|---|---|---|
dataset | Number | null | Required - A dataset id for a GeoIQ/Geocommons dataset. |
map | Object L.Map object | null | The Leaflet Map object where the layer will be added. The layer can be added to the map later with the setMap method. |
scaleRange | Array | null | An array with two number values that represent the minimum and maximum scales the layer is visible. For example: [14, 17] |
dynamic | Boolean | false | Whether or not the layer contains dynamic data. If true, feature geometry and attributes will be checked for changes after extent change and/or after a defined interval. For details check the dynamic data documentation. |
autoUpdate | Boolean | false | Whether or not to auto-update a dynamic layer. If true, feature geometry and attributes will be updated at an interval set by the autoUpdateInterval option. For details check the dynamic data documentation. |
autoUpdateInterval | Integer | null | The interval (in milliseconds) between checks for updated feature geometry and attributes when the autoUpdate option is set to true . For details check the dynamic data documentation. |
popupTemplate | String|Function | null | A template for creating the content of a Leaflet Popup when a feature is clicked. For details check the Popup Template documentation. |
singlePopup | Boolean | false | Whether or not to show a single Popup for a layer when features are clicked. This keeps the map from getting cluttered when multiple features are clicked. |
popupOptions | Object Leaflet Popup options | null | Controls the width of and the presence of a close button for the Popup and whether the map should be panned when the Popup is opened. |
symbology | Object symbology options | null | The symbology options for the layer. Features can be rendered with a single symbology or can also be symbolized based on an attribute using unique values or a value range. For details check the symbology options documentation. |
showAll | Boolean | false | If true, all features will be fetched and shown once, not after a map extent change. This is helpful for layers with only a handful of features. |
uniqueField | String | null | A field in the returned data that can be considered unique. This isn't required but is very helpful in determining which features are already on the map when the map extent changes. |
clickEvent | Function | null | A user defined click event. For details check the Custom clickEvent options documentation. |
Methods
| Method | Description |
|---|---|
setMap( <L.Map> Map ) | Adds the layer to a map. Remove the layer by passing null . |
getMap() | Gets the map (if any) that the layer has been added to. |
lvector.CartoDB CartoDB
This class creates a layer that processes and displays features from a CartoDB table.
Usage Example
var myCartoDBLayer = new lvector.CartoDB({ user: "geojason", table: "man_hole", scaleRange: [16, 20], symbology: { type: "single", vectorOptions: { icon: new customIcon({ iconUrl: "../../docs-demo/img/markers/manhole.png" }) } }, popupTemplate: '
Man Hole</h3
Depth: {mh_depth}
', singlePopup: true });
Constructor
| Constructor | Description |
|---|---|
lvector.CartoDB( <CartoDB options> options ) | Instantiates a CartoDB layer with an object literal with CartoDB options described below. |
Options
| Option | Type | Default Value | Description |
|---|---|---|---|
user | String | null | Required - The CartoDB user that owns the table to be displayed. For example a CartoDB map viewed via a URL like http://geojason.cartodb.com/map , "geojason" is the CartoDB user. |
table | String | null | Required - The CartoDB table name for the data to be displayed. |
map | Object L.Map object | null | The Leaflet Map object where the layer will be added. The layer can be added to the map later with the setMap method. |
scaleRange | Array | null | An array with two number values that represent the minimum and maximum scales the layer is visible. For example: [14, 17] |
dynamic | Boolean | false | Whether or not the layer contains dynamic data. If true, feature geometry and attributes will be checked for changes after extent change and/or after a defined interval. For details check the dynamic data documentation. |
autoUpdate | Boolean | false | Whether or not to auto-update a dynamic layer. If true, feature geometry and attributes will be updated at an interval set by the autoUpdateInterval option. For details check the dynamic data documentation. |
autoUpdateInterval | Integer | null | The interval (in milliseconds) between checks for updated feature geometry and attributes when the autoUpdate option is set to true . For details check the dynamic data documentation. |
popupTemplate | String|Function | null | A template for creating the content of a Leaflet Popup when a feature is clicked. For details check the Popup Template documentation. |
singlePopup | Boolean | false | Whether or not to show a single Popup for a layer when features are clicked. This keeps the map from getting cluttered when multiple features are clicked. |
popupOptions | Object Leaflet Popup options | null | Controls the width of and the presence of a close button for the Popup and whether the map should be panned when the Popup is opened. |
symbology | Object symbology options | null | The symbology options for the layer. Features can be rendered with a single symbology or can also be symbolized based on an attribute using unique values or a value range. For details check the symbology options documentation. |
showAll | Boolean | false | If true, all features will be fetched and shown once, not after a map extent change. This is helpful for layers with only a handful of features. |
fields | String | "*" | A list of comma separated fields to be returned with the features. By default all fields are returned. |
clickEvent | Function | null | A user defined click event. For details check the Custom clickEvent options documentation. |
Methods
| Method | Description |
|---|---|
setMap( <L.Map> Map ) | Adds the layer to a map. Remove the layer by passing null . |
getMap() | Gets the map (if any) that the layer has been added to. |
lvector.PRWSF PostGIS RESTful Web Service Framework
This class creates a layer that processes and displays features from a PostGIS RESTful Web Service Framework geotable.
The PostGIS RESTful Web Service Framework is an open source project written in PHP that creates a set of web services that allow you to query geo data in a PostGIS database. These web services are extemely flexible allowing you to project, aggregate, order and serialize your data in many different ways. Below are some implementations I've found:
- Union County GeoData API (A .Net port)
- Mecklenburg County GeoPortal
- Denver Regional Council of Governments
Usage Example
var myPrwsfLayer = new lvector.PRWSF({ url: "http://gis.drcog.org/REST", geotable: "mountain_backdrop_preservation_area", fields: "gid", uniqueField: "gid", geomPrecision: 6, srid: 2232, showAll: true, symbology: { type: "single", vectorOptions: { fillColor: "#2f4a00", fillOpacity: 0.4, strokeWeight: 1.8, strokeColor: "#2f4a00", strokeOpacity: 1, clickable: false } } });
Constructor
| Constructor | Description |
|---|---|
lvector.PRWSF( <PRWSF options> options ) | Instantiates a PRWSF layer with an object literal with PRWSF options described below. |
Options
| Option | Type | Default Value | Description |
|---|---|---|---|
url | String | null | Required - The root URL for the PostGIS RESTful Web Service Framework instance. |
geotable | String | null | Required - The geotable for which we want data to be displayed. |
fields | String | null | A list of comma separated fields to be returned with the features. By default only the geometry field is returned. You'd likely want to also return a unique id and some other attribute information. |
geomFieldName | String | "the_geom" | The geometry field name for this geotable. Most commonly found as the_geom |
geomPrecision | Integer | null | Used to reduce the maximum number of decimal places in the PostGIS ST_AsGeoJSON output (PostGIS defaults to 15). |
srid | Integer | null | The SRID of the geometry in this geotable. This isn't required but increases performance drastically as the bounding box geometry can be projected to match your features' projection, which makes use of spatial indexes (that you've hopefully built). |
where | String | null | Any additional SQL query(ies) to further filter the returned features. |
limit | Integer | null | Limit the number of returned features. |
map | Object L.Map object | null | The Leaflet Map object where the layer will be added. The layer can be added to the map later with the setMap method. |
scaleRange | Array | null | An array with two number values that represent the minimum and maximum scales the layer is visible. For example: [14, 17] |
dynamic | Boolean | false | Whether or not the layer contains dynamic data. If true, feature geometry and attributes will be checked for changes after extent change and/or after a defined interval. For details check the dynamic data documentation. |
autoUpdate | Boolean | false | Whether or not to auto-update a dynamic layer. If true, feature geometry and attributes will be updated at an interval set by the autoUpdateInterval option. For details check the dynamic data documentation. |
autoUpdateInterval | Integer | null | The interval (in milliseconds) between checks for updated feature geometry and attributes when the autoUpdate option is set to true . For details check the dynamic data documentation. |
popupTemplate | String|Function | null | A template for creating the content of a Leaflet Popup when a feature is clicked. For details check the Popup Template documentation. |
singlePopup | Boolean | false | Whether or not to show a single Popup for a layer when features are clicked. This keeps the map from getting cluttered when multiple features are clicked. |
popupOptions | Object Leaflet Popup options | null | Controls the width of and the presence of a close button for the Popup and whether the map should be panned when the Popup is opened. |
symbology | Object symbology options | null | The symbology options for the layer. Features can be rendered with a single symbology or can also be symbolized based on an attribute using unique values or a value range. For details check the symbology options documentation. |
showAll | Boolean | false | If true, all features will be fetched and shown once, not after a map extent change. This is helpful for layers with only a handful of features. |
clickEvent | Function | null | A user defined click event. For details check the Custom clickEvent options documentation. |
Methods
| Method | Description |
|---|---|
setMap( <L.Map> Map ) | Adds the layer to a map. Remove the layer by passing null . |
getMap() | Gets the map (if any) that the layer has been added to. |
lvector.GISCloud GIS Cloud
This class creates a layer that processes and displays features from a GIS Cloud map layer.
Usage Example
var myGisCloudLayer = new lvector.GISCloud({ mapID: 27322, layerID: 117755, symbology: { type: "single", vectorOptions: { weight: 4, color: "#46461f", opacity: 0.8 } }, scaleRange: [13, 18] });
Constructor
| Constructor | Description |
|---|---|
lvector.GISCloud( <GISCloud options> options ) | Instantiates a GISCloud layer with an object literal with GISCloud options described below. |
Options
| Option | Type | Default Value | Description |
|---|---|---|---|
mapID | String|Number | null | Required - The GIS Cloud Map ID where your layer can be found. |
layerID | String|Number | null | Required - The GIS Cloud Layer ID for your layer. |
where | String | null | Any additional SQL query(ies) to further filter the returned features. |
map | Object L.Map object | null | The Leaflet Map object where the layer will be added. The layer can be added to the map later with the setMap method. |
scaleRange | Array | null | An array with two number values that represent the minimum and maximum scales the layer is visible. For example: [14, 17] |
dynamic | Boolean | false | Whether or not the layer contains dynamic data. If true, feature geometry and attributes will be checked for changes after extent change and/or after a defined interval. For details check the dynamic data documentation. |
autoUpdate | Boolean | false | Whether or not to auto-update a dynamic layer. If true, feature geometry and attributes will be updated at an interval set by the autoUpdateInterval option. For details check the dynamic data documentation. |
autoUpdateInterval | Integer | null | The interval (in milliseconds) between checks for updated feature geometry and attributes when the autoUpdate option is set to true . For details check the dynamic data documentation. |
popupTemplate | String|Function | null | A template for creating the content of a Leaflet Popup when a feature is clicked. For details check the Popup Template documentation. |
singlePopup | Boolean | false | Whether or not to show a single Popup for a layer when features are clicked. This keeps the map from getting cluttered when multiple features are clicked. |
popupOptions | Object Leaflet Popup options | null | Controls the width of and the presence of a close button for the Popup and whether the map should be panned when the Popup is opened. |
symbology | Object symbology options | null | The symbology options for the layer. Features can be rendered with a single symbology or can also be symbolized based on an attribute using unique values or a value range. For details check the symbology options documentation. |
showAll | Boolean | false | If true, all features will be fetched and shown once, not after a map extent change. This is helpful for layers with only a handful of features. |
clickEvent | Function | null | A user defined click event. For details check the Custom clickEvent options documentation. |
Methods
| Method | Description |
|---|---|
setMap( <google.maps.Map> Map ) | Adds the layer to a map. Remove the layer by passing null . |
getMap() | Gets the map (if any) that the layer has been added to. |
lvector.GitSpatial GitSpatial
This class creates a layer that processes and displays features from a GitSpatial feature set.
Usage Example
my_gitspatial_layer = new lvector.GitSpatial({ user: 'JasonSanford', repo: 'mecklenburg-gis-opendata', feature_set: 'parks', popupTemplate: '

{name}
Address: {address}
' });
Constructor
| Constructor | Description |
|---|---|
lvector.GitSpatial( <GitSpatial options> options ) | Instantiates a GitSpatial layer with an object literal with GitSpatial options described below. |
Options
| Option | Type | Default Value | Description |
|---|---|---|---|
user | String | null | Required - The GitHub user id for a GitSpatial feature set. |
repo | String | null | Required - The GitHub repo name for a GitSpatial feature set. |
featureSet | String | null | Required - The GitSpatial feature set name. |
map | Object L.Map object | null | The Leaflet Map object where the layer will be added. The layer can be added to the map later with the setMap method. |
scaleRange | Array | null | An array with two number values that represent the minimum and maximum scales the layer is visible. For example: [14, 17] |
dynamic | Boolean | false | Whether or not the layer contains dynamic data. If true, feature geometry and attributes will be checked for changes after extent change and/or after a defined interval. For details check the dynamic data documentation. |
autoUpdate | Boolean | false | Whether or not to auto-update a dynamic layer. If true, feature geometry and attributes will be updated at an interval set by the autoUpdateInterval option. For details check the dynamic data documentation. |
autoUpdateInterval | Integer | null | The interval (in milliseconds) between checks for updated feature geometry and attributes when the autoUpdate option is set to true . For details check the dynamic data documentation. |
popupTemplate | String|Function | null | A template for creating the content of a Leaflet Popup when a feature is clicked. For details check the Popup Template documentation. |
singlePopup | Boolean | false | Whether or not to show a single Popup for a layer when features are clicked. This keeps the map from getting cluttered when multiple features are clicked. |
popupOptions | Object Leaflet Popup options | null | Controls the width of and the presence of a close button for the Popup and whether the map should be panned when the Popup is opened. |
symbology | Object symbology options | null | The symbology options for the layer. Features can be rendered with a single symbology or can also be symbolized based on an attribute using unique values or a value range. For details check the symbology options documentation. |
showAll | Boolean | false | If true, all features will be fetched and shown once, not after a map extent change. This is helpful for layers with only a handful of features. |
Methods
| Method | Description |
|---|---|
setMap( <google.maps.Map> Map ) | Adds the layer to a map. Remove the layer by passing null . |
getMap() | Gets the map (if any) that the layer has been added to. |
Other Reference
Symbology
Symbology for a layer can be defined a few different ways including single
, unique
and range
. If no symbology is defined the default Leaflet vector styles will be used.
When instantiating a new layer, use one of the options below when setting the symbology
option value.
Note that marker icons may also have a title
option for defining a tooltip on mouseover.
single
The single
type displays all features with the same symbology.
{ type: "single", // Defines the symbology as a single type of representation for all features vectorOptions: { // Leaflet Path options for all features fillColor: "#46461f", fillOpacity: 0.5, weight: 4, color: "#ff7800" } }
unique
The unique
type displays features with the same attibute values with the same symbology. This is helpful when you have a handful of discrete values for which you want to define symbology.
Check the districts example on the ArcGIS Server demo page and view source to see it in action.
{ type: "unique", // Defines the symbology as a unique type where features with an attribute of a specific value are symbolized the same way property: "DISTRICT", // The property (field, attribute) to use for defining unique values and styles values: [ // An array of values to set symbology. Each value has a specific symbology { value: "A", // If feature.properties.DISTRICT == "A" vectorOptions: { // Use these Leaflet Path options for features matching fillColor: "#6600FF", fillOpacity: 0.6, color: "#666666", opacity: 0.8, weight: 1 } }, { value: "B", vectorOptions: { fillColor: "#660066", fillOpacity: 0.6, color: "#666666", opacity: 0.8, weight: 1 } }, { value: "C", vectorOptions: { fillColor: "#FF9900", fillOpacity: 0.6, color: "#666666", opacity: 0.8, weight: 1 } } ] }
range
The range
type tests values to see if they are within a specified range and symbolizes them accordingly. This is helpful for datasets that have values with lots of individual values like population counts per county in the US or in this example, vehicle speeds.
{ type: "range", // Defines the symbology as a range type where values above a minimum and below a maximum value are symbolized the same way property: "SPEED", // The property (field, attribute) to use for defining range values and styles ranges: [ // An array of value ranges to set symbology. Each value range has a specific symbology. { range: [1, 20], // if feature.properties.SPEED >= 1 AND feature.properties.SPEED <= 20 vectorOptions: { // Use these Leaflet Path options for features with values in this range icon: new customIcon({ iconUrl: "../../docs-demo/img/markers/bus-brown.png" }), title: "{SPEED} mph" } },{ range: [21, 100], vectorOptions: { icon: new customIcon({ iconUrl: "../../docs-demo/img/markers/bus-green.png" }), title: "{SPEED} mph" } } ] }
Popup Templates
To create content to show Popups when features are clicked we can use the popupTemplate
option. A popupTemplate can be set two ways:
- A string with property names wrapped in curly brackets (
{road_name}
) to act as placeholders for the values - A function that returns a string that will be used as the Popup content. This function is passed the feature properties so that these properties can be used any number of ways to create Popup content. You could do things like create a chart with Google's Chart API or format ALL CAPS text to Proper Case.
String Based
A simple popupTemplate might look like:
"
{road_name}

Speed Limit: {speed_limit} mph
"
which gets transformed to:
"
S Bemis St

Speed Limit: 25 mph
"
Function Based
For more flexibility we can use a function to do some more complex operations with our feature properties for customized output. A function for a popupTemplate might look like:
function(properties) { /* Assuming "properties" is an object like: { ROAD_NAME: "S Bemis St", SPEED_LIMIT: 25 } */ var output = "
State Road
"; for (var prop in properties) { output += prop.replace(/_/gi, " ").replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();}) + ": " + properties[prop] + "
"; } return output; }
This function iterates through each property in properties and formats each to Proper Case for better looking output.
"
State Road
Road Name: S Bemis St
Speed Limit: 25
"
Custom clickEvent
In addition to opening popups, you may want to define your own click events. This is useful for appending data to a div or opening a modal dialog. To create a custom click event, we can use the clickEvent
option and pass a function with feature
and event
arguments.
Example
The following example will pop up an alert box with the 'name' attribute when the marker is clicked:
prwsf_libraries = new lvector.PRWSF({ url: "http://maps.co.mecklenburg.nc.us/rest", geotable: "libraries", fields: "gid,name,address,city", uniqueField: "gid", srid: 2264, scaleRange: [7, 20], showAll: true, symbology: { type: "single", vectorOptions: { icon: new customMarker() } }, clickEvent: function (feature, event) { alert(feature.properties.name); } });
Dynamic Data
To create a dynamic layer simply set the dynamic
option to true
. Using this option alone (without autoUpdate
and autoUpdateInterval
) will check for feature geometry and property changes when the map extent changes. If geometry changes are found the feature is altered on the map. If properties changes are found any Popups associated with this feature are updated to reflect this change.
Auto-update
Using the autoUpdate
and autoUpdateInterval
options we can set a layer to automatically fetch new features every x seconds, even when the map extent hasn't changed. Set the autoUpdate
option to true
and autoUpdateInterval
to the amount of time (in milliseconds) for how often you want features fetched. To create a dynamic layer that auto-updates every 5 seconds you might create your layer like:
var myAGSLayer = new lvector.AGS({ url: "http://maps.rtd-denver.com/ArcGIS/rest/services/BusLocations/MapServer/0", fields: "*", uniqueField: "OBJECTID", dynamic: true, autoUpdate: true, autoUpdateInterval: 5000 });
Arc2Earth
Auto-updating works slightly different with Arc2Earth layers. Since update messages are almost immediately sent to the client using PubNub, only the dynamic
and autoUpdate
parameters must be set (both to true
). This eliminates the need for constant polling, thus reducing the load on the server.
An auto-updating Arc2Earth layer might look something like:
myA2ELayer = new lvector.A2E({ url: "http://sync.arc2earth.com/6442491/ArcGIS/rest/services/tfs/2447544/FeatureServer/0", esriOptions: true, uniqueField: "global_fid", popupTemplate: '

{Name}

', singlePopup: true, dynamic: true, autoUpdate: true });


1. (one off) Fork a Repo, making a 'downstream' Remote Repo on github
http://help.github.com/fork-a-repo/
2. (one off) Clone the 'forked' Repo from github, making a Local master Repo
git clone git@github.com:samthetechie/emoncms.git
(or git remote add origin git@github.com:openenergymonitor/WIZnet-Ethernet-Shield-emoncms-example.git)
3. Make changes to Local Master: change, edit, improve code, add files etc.
//open terminal in correct foldergit add <file>//makes github track new files
git commit -m 'your commit message here'
git push
or (git push -u origin master)
5. Define the Upstream which Repository is upsteam of your Remote 'forked' Repo.
git remote add upstream git://github.com/openenergymonitor/emoncms.git
6. Fetch Changes from Remote Upstream (downloaded to a different local branch i.e. you cannot see the new files in the project folder untill you merge in the next step)
git fetch upstream
7. Merge Changes from remote upstream with local Repo.
git merge upstream/master
8. Push the merged copy to your 'forked' repo on github
git push
9. Have changed pulled back up the upstream server: Submit a pull request from the github website. This has to be accepted by the admin before it becomes the new upstream
N.B. conflict resolution is really really simple. Open the conflicted file and manually merge the two versions. Email/google chat with the other programmer/coder to ask what stuff does if necessary.
Delete all the random <<<<<<< and ========= and >>>>>>>>> tags that get added.
Delete all the random *.base *.local files that get made too!
Continue as normal.


---
layout: post
title: Memolane Aggregates Your Online Life Into a Timeline/Story
categories: []
tags: []
status: publish
type: post
published: true
meta:
_original_post_id: ''
_original_import_author: John Duprey
author:
---
Memolane is a new service that will pull your online together into a timeline/story. Give it a try, but watch your privacy settings!


Front End Development Part 1
The HTML form
element represents a document section that contains interactive controls for submitting information to a web server.
The HTTP method that the browser uses to submit the form.
post
- Corresponds to the HTTP POST method ; form data are included in the body of the form and sent to the server.
get
- Corresponds to the HTTP GET method; form data are appended to the action attribute URI with a '?' as separator, and the resulting URI is sent to the server. Use this method when the form has no side-effects and contains only ASCII characters.
The HTML fieldset
element is used to group several controls as well as labels within a web form.
As the example above shows, the fieldset
element provides a grouping for a part of an HTML form, with a nested legend
element providing a caption for the fieldset
. It takes few attributes, the most notable of which are form, which can contain the id of a form
on the same page, allowing you to make the fieldset
part of that form
even if it is not nested inside it, and disabled, which allows you to disable the fieldset
and all its contents in one go.
The HTML label
element represents a caption for an item in a user interface.
To associate the label
with an input
element in the way shown in the example above, you need to give the input
an id attribute. The label
then needs a for attribute whose value is the same as the input's id.
In the examples above you can see two form input examples — both with a corresponding label
. This offers some major advantages:
These services are under the same umbrella these days. You may know that Chris worked for Wufoo before it was acquired by Survey Monkey. Wufoo is an advertiser here on CSS-Tricks but has not paid for inclusion to this post. We included these services because they just plain work. Wufoo is for any type of web form while SurveyMonkey is likely a better tool specifically for web form surveys.
Polldaddy is from Automattic, the force behind WordPress. Like Wufoo, it's a hosted service and is suited for complex forms, such as surveys. One thing I personally like about (aside from it's clean interface) is that is offers a nice iOS app for collecting form data in other places than a website. That's perfect something like a conference, book signing or some other live event where collecting information in person would be a benefit.
Google Forms is unique in this group as it's entirely free. It's part of the Google Docs world along with Slides and Sheets (you can export form data to Sheets). Being a part of that world means inviting collaborators to the forms you build there.
Typeform builds forms with a unique interface: each question is asked one at at time, more like a real life conversation.
This is a premium plugin (i.e. costs money) that puts a real form builder in the admin of your site. Gravity Forms allows you to create an unlimited number of forms directly from the WordPress dashboard, includes a slick drag-and-drop interface, and offers all the advanced options you might expect to see in something like Wufoo, such as conditional logic, style customizations and integrations with popular services.


{% load static %}
Your Complaint will be forwared to the official and your problem will be solved as soon as possible.
You can refuse to pass along cyberbullying messages. Tell friends to stop cyberbullying, block communication with cyberbullies, and report cyberbullying to a trusted adult. To stay cyber-safe, never post or share your personal information online or your friends’ personal information (this includes your full name, address, telephone number, school name, parents’ names or credit card number). Never share your Internet passwords with anyone and never meet face-to-face with someone you only met online.
The parent can start by teaching the child about social responsibility. Have the child imagine the situation in reverse. Cyberbullying can spiral to a massive level, even though cyberbullies may have just sent a post or text that initially started off as a joke. It is also important to teach this same lesson to cyberbullying victims, because many victims in turn can become cyberbullies themselves.
You will be completely anonymous for another users.only admin can see your details.
After completing the form filling process you will recive a email regarding your Ticket ID and that ticket will be used to check where your complaint has reached.
Your complaint will be processed in four stages.
Accepted
Under Investigation
Reviewed
Resolved
People should make themselves aware of every aspects of cyberbullying and make sure that they take as much of preventions they can take.
NO,they won't know that you have registered a complain againts them.Feel free to share your problems regarding Cyberbul.
No,they won't until something is very serious.


SYNOPSIS
git p4 clone [<sync options>] [<clone options>] <p4 depot path>… git p4 sync [<sync options>] [<p4 depot path>…] git p4 rebase git p4 submit [<submit options>] [<master branch name>]
DESCRIPTION
This command provides a way to interact with p4 repositories using git.
Create a new git repository from an existing p4 repository using git p4 clone, giving it one or more p4 depot paths. Incorporate new commits from p4 changes with git p4 sync. The sync command is also used to include new branches from other p4 depot paths. Submit git changes back to p4 using git p4 submit. The command git p4 rebase does a sync plus rebases the current branch onto the updated p4 remote branch.
EXAMPLE
-
Clone a repository:
$ git p4 clone //depot/path/project
-
Do some work in the newly created git repository:
$ cd project $ vi foo.h $ git commit -a -m "edited foo.h"
-
Update the git repository with recent changes from p4, rebasing your work on top:
$ git p4 rebase
-
Submit your commits back to p4:
$ git p4 submit
COMMANDS
Clone
Generally, git p4 clone is used to create a new git directory from an existing p4 repository:
$ git p4 clone //depot/path/project
This:
-
Creates an empty git repository in a subdirectory called project.
-
Imports the full contents of the head revision from the given p4 depot path into a single commit in the git branch refs/remotes/p4/master.
-
Creates a local branch, master from this remote and checks it out.
To reproduce the entire p4 history in git, use the @all modifier on the depot path:
$ git p4 clone //depot/path/project@all
Sync
As development continues in the p4 repository, those changes can be included in the git repository using:
$ git p4 sync
This command finds new changes in p4 and imports them as git commits.
P4 repositories can be added to an existing git repository using git p4 sync too:
$ mkdir repo-git
$ cd repo-git
$ git init
$ git p4 sync //path/in/your/perforce/depot
This imports the specified depot into refs/remotes/p4/master in an existing git repository. The --branch option can be used to specify a different branch to be used for the p4 content.
If a git repository includes branches refs/remotes/origin/p4, these will be fetched and consulted first during a git p4 sync. Since importing directly from p4 is considerably slower than pulling changes from a git remote, this can be useful in a multi-developer environment.
Rebase
A common working pattern is to fetch the latest changes from the p4 depot and merge them with local uncommitted changes. Often, the p4 repository is the ultimate location for all code, thus a rebase workflow makes sense. This command does git p4 sync followed by git rebase to move local commits on top of updated p4 changes.
$ git p4 rebase
Submit
Submitting changes from a git repository back to the p4 repository requires a separate p4 client workspace. This should be specified using the P4CLIENT environment variable or the git configuration variable git-p4.client. The p4 client must exist, but the client root will be created and populated if it does not already exist.
To submit all changes that are in the current git branch but not in the p4/master branch, use:
$ git p4 submit
To specify a branch other than the current one, use:
$ git p4 submit topicbranch
The upstream reference is generally refs/remotes/p4/master, but can be overridden using the --origin= command-line option.
The p4 changes will be created as the user invoking git p4 submit. The --preserve-user option will cause ownership to be modified according to the author of the git commit. This option requires admin privileges in p4, which can be granted using p4 protect.
OPTIONS
General options
All commands except clone accept these options.
- --git-dir <dir>
-
Set the GIT_DIR environment variable. See git(1).
- --verbose, -v
-
Provide more progress information.
Sync options
These options can be used in the initial clone as well as in subsequent sync operations.
- --branch <branch>
-
Import changes into given branch. If the branch starts with refs/, it will be used as is, otherwise the path refs/heads/ will be prepended. The default branch is master. If used with an initial clone, no HEAD will be checked out.
This example imports a new remote "p4/proj2" into an existing git repository:
$ git init $ git p4 sync --branch=refs/remotes/p4/proj2 //depot/proj2
- --detect-branches
-
Use the branch detection algorithm to find new paths in p4. It is documented below in "BRANCH DETECTION".
- --changesfile <file>
-
Import exactly the p4 change numbers listed in file, one per line. Normally, git p4 inspects the current p4 repository state and detects the changes it should import.
- --silent
-
Do not print any progress information.
- --detect-labels
-
Query p4 for labels associated with the depot paths, and add them as tags in git. Limited usefulness as only imports labels associated with new changelists. Deprecated.
- --import-labels
-
Import labels from p4 into git.
- --import-local
-
By default, p4 branches are stored in refs/remotes/p4/, where they will be treated as remote-tracking branches by git-branch(1) and other commands. This option instead puts p4 branches in refs/heads/p4/. Note that future sync operations must specify --import-local as well so that they can find the p4 branches in refs/heads.
- --max-changes <n>
-
Limit the number of imported changes to n. Useful to limit the amount of history when using the @all p4 revision specifier.
- --keep-path
-
The mapping of file names from the p4 depot path to git, by default, involves removing the entire depot path. With this option, the full p4 depot path is retained in git. For example, path //depot/main/foo/bar.c, when imported from //depot/main/, becomes foo/bar.c. With --keep-path, the git path is instead depot/main/foo/bar.c.
- --use-client-spec
-
Use a client spec to find the list of interesting files in p4. See the "CLIENT SPEC" section below.
Clone options
These options can be used in an initial clone, along with the sync options described above.
- --destination <directory>
-
Where to create the git repository. If not provided, the last component in the p4 depot path is used to create a new directory.
- --bare
-
Perform a bare clone. See git-clone(1).
- -/ <path>
-
Exclude selected depot paths when cloning.
Submit options
These options can be used to modify git p4 submit behavior.
- --origin <commit>
-
Upstream location from which commits are identified to submit to p4. By default, this is the most recent p4 commit reachable from HEAD.
- -M
-
Detect renames. See git-diff(1). Renames will be represented in p4 using explicit move operations. There is no corresponding option to detect copies, but there are variables for both moves and copies.
- --preserve-user
-
Re-author p4 changes before submitting to p4. This option requires p4 admin privileges.
- --export-labels
-
Export tags from git as p4 labels. Tags found in git are applied to the perforce working directory.
- --dry-run, -n
-
Show just what commits would be submitted to p4; do not change state in git or p4.
- --prepare-p4-only
-
Apply a commit to the p4 workspace, opening, adding and deleting files in p4 as for a normal submit operation. Do not issue the final "p4 submit", but instead print a message about how to submit manually or revert. This option always stops after the first (oldest) commit. Git tags are not exported to p4.
- --conflict=(ask|skip|quit)
-
Conflicts can occur when applying a commit to p4. When this happens, the default behavior ("ask") is to prompt whether to skip this commit and continue, or quit. This option can be used to bypass the prompt, causing conflicting commits to be automatically skipped, or to quit trying to apply commits, without prompting.
Rebase options
These options can be used to modify git p4 rebase behavior.
- --import-labels
-
Import p4 labels.
DEPOT PATH SYNTAX
The p4 depot path argument to git p4 sync and git p4 clone can be one or more space-separated p4 depot paths, with an optional p4 revision specifier on the end:
- "//depot/my/project"
-
Import one commit with all files in the #head change under that tree.
- "//depot/my/project@all"
-
Import one commit for each change in the history of that depot path.
- "//depot/my/project@1,6"
-
Import only changes 1 through 6.
- "//depot/proj1@all //depot/proj2@all"
-
Import all changes from both named depot paths into a single repository. Only files below these directories are included. There is not a subdirectory in git for each "proj1" and "proj2". You must use the --destination option when specifying more than one depot path. The revision specifier must be specified identically on each depot path. If there are files in the depot paths with the same name, the path with the most recently updated version of the file is the one that appears in git.
See p4 help revisions for the full syntax of p4 revision specifiers.
CLIENT SPEC
The p4 client specification is maintained with the p4 client command and contains among other fields, a View that specifies how the depot is mapped into the client repository. The clone and sync commands can consult the client spec when given the --use-client-spec option or when the useClientSpec variable is true. After git p4 clone, the useClientSpec variable is automatically set in the repository configuration file. This allows future git p4 submit commands to work properly; the submit command looks only at the variable and does not have a command-line option.
The full syntax for a p4 view is documented in p4 help views. Git p4 knows only a subset of the view syntax. It understands multi-line mappings, overlays with +, exclusions with - and double-quotes around whitespace. Of the possible wildcards, git p4 only handles …, and only when it is at the end of the path. Git p4 will complain if it encounters an unhandled wildcard.
Bugs in the implementation of overlap mappings exist. If multiple depot paths map through overlays to the same location in the repository, git p4 can choose the wrong one. This is hard to solve without dedicating a client spec just for git p4.
The name of the client can be given to git p4 in multiple ways. The variable git-p4.client takes precedence if it exists. Otherwise, normal p4 mechanisms of determining the client are used: environment variable P4CLIENT, a file referenced by P4CONFIG, or the local host name.
BRANCH DETECTION
P4 does not have the same concept of a branch as git. Instead, p4 organizes its content as a directory tree, where by convention different logical branches are in different locations in the tree. The p4 branch command is used to maintain mappings between different areas in the tree, and indicate related content. git p4 can use these mappings to determine branch relationships.
If you have a repository where all the branches of interest exist as subdirectories of a single depot path, you can use --detect-branches when cloning or syncing to have git p4 automatically find subdirectories in p4, and to generate these as branches in git.
For example, if the P4 repository structure is:
//depot/main/...
//depot/branch1/...
And "p4 branch -o branch1" shows a View line that looks like:
//depot/main/... //depot/branch1/...
Then this git p4 clone command:
git p4 clone --detect-branches //depot@all
produces a separate branch in refs/remotes/p4/ for //depot/main, called master, and one for //depot/branch1 called depot/branch1.
However, it is not necessary to create branches in p4 to be able to use them like branches. Because it is difficult to infer branch relationships automatically, a git configuration setting git-p4.branchList can be used to explicitly identify branch relationships. It is a list of "source:destination" pairs, like a simple p4 branch specification, where the "source" and "destination" are the path elements in the p4 repository. The example above relied on the presence of the p4 branch. Without p4 branches, the same result will occur with:
git config git-p4.branchList main:branch1
git p4 clone --detect-branches //depot@all
PERFORMANCE
The fast-import mechanism used by git p4 creates one pack file for each invocation of git p4 sync. Normally, git garbage compression (git-gc(1)) automatically compresses these to fewer pack files, but explicit invocation of git repack -adf may improve performance.
CONFIGURATION VARIABLES
The following config settings can be used to modify git p4 behavior. They all are in the git-p4 section.
General variables
- git-p4.user
-
User specified as an option to all p4 commands, with -u <user>. The environment variable P4USER can be used instead.
- git-p4.password
-
Password specified as an option to all p4 commands, with -P <password>. The environment variable P4PASS can be used instead.
- git-p4.port
-
Port specified as an option to all p4 commands, with -p <port>. The environment variable P4PORT can be used instead.
- git-p4.host
-
Host specified as an option to all p4 commands, with -h <host>. The environment variable P4HOST can be used instead.
- git-p4.client
-
Client specified as an option to all p4 commands, with -c <client>, including the client spec.
Clone and sync variables
- git-p4.syncFromOrigin
-
Because importing commits from other git repositories is much faster than importing them from p4, a mechanism exists to find p4 changes first in git remotes. If branches exist under refs/remote/origin/p4, those will be fetched and used when syncing from p4. This variable can be set to false to disable this behavior.
- git-p4.branchUser
-
One phase in branch detection involves looking at p4 branches to find new ones to import. By default, all branches are inspected. This option limits the search to just those owned by the single user named in the variable.
- git-p4.branchList
-
List of branches to be imported when branch detection is enabled. Each entry should be a pair of branch names separated by a colon (:). This example declares that both branchA and branchB were created from main:
git config git-p4.branchList main:branchA git config --add git-p4.branchList main:branchB
- git-p4.ignoredP4Labels
-
List of p4 labels to ignore. This is built automatically as unimportable labels are discovered.
- git-p4.importLabels
-
Import p4 labels into git, as per --import-labels.
- git-p4.labelImportRegexp
-
Only p4 labels matching this regular expression will be imported. The default value is [a-zA-Z0-9_\-.]+$.
- git-p4.useClientSpec
-
Specify that the p4 client spec should be used to identify p4 depot paths of interest. This is equivalent to specifying the option --use-client-spec. See the "CLIENT SPEC" section above. This variable is a boolean, not the name of a p4 client.
Submit variables
- git-p4.detectRenames
-
Detect renames. See git-diff(1). This can be true, false, or a score as expected by git diff -M.
- git-p4.detectCopies
-
Detect copies. See git-diff(1). This can be true, false, or a score as expected by git diff -C.
- git-p4.detectCopiesHarder
-
Detect copies harder. See git-diff(1). A boolean.
- git-p4.preserveUser
-
On submit, re-author changes to reflect the git author, regardless of who invokes git p4 submit.
- git-p4.allowMissingP4Users
-
When preserveUser is true, git p4 normally dies if it cannot find an author in the p4 user map. This setting submits the change regardless.
- git-p4.skipSubmitEdit
-
The submit process invokes the editor before each p4 change is submitted. If this setting is true, though, the editing step is skipped.
- git-p4.skipSubmitEditCheck
-
After editing the p4 change message, git p4 makes sure that the description really was changed by looking at the file modification time. This option disables that test.
- git-p4.allowSubmit
-
By default, any branch can be used as the source for a git p4 submit operation. This configuration variable, if set, permits only the named branches to be used as submit sources. Branch names must be the short names (no "refs/heads/"), and should be separated by commas (","), with no spaces.
- git-p4.skipUserNameCheck
-
If the user running git p4 submit does not exist in the p4 user map, git p4 exits. This option can be used to force submission regardless.
- git-p4.attemptRCSCleanup
-
If enabled, git p4 submit will attempt to cleanup RCS keywords ($Header$, etc). These would otherwise cause merge conflicts and prevent the submit going ahead. This option should be considered experimental at present.
- git-p4.exportLabels
-
Export git tags to p4 labels, as per --export-labels.
- git-p4.labelExportRegexp
-
Only p4 labels matching this regular expression will be exported. The default value is [a-zA-Z0-9_\-.]+$.
- git-p4.conflict
-
Specify submit behavior when a conflict with p4 is found, as per --conflict. The default behavior is ask.
IMPLEMENTATION DETAILS
-
Changesets from p4 are imported using git fast-import.
-
Cloning or syncing does not require a p4 client; file contents are collected using p4 print.
-
Submitting requires a p4 client, which is not in the same location as the git repository. Patches are applied, one at a time, to this p4 client and submitted from there.
-
Each commit imported by git p4 has a line at the end of the log message indicating the p4 depot location and change number. This line is used by later git p4 sync operations to know which p4 changes are new.


Example 2: User Signup Form
This example demonstrates:
- Processing a form POST request
- The POST => Redirect pattern
- Pushing validation errors into the model
- Exposing a method via a RESTful URL and JSON
- Calling server-side code via AJAX
- Using JSP as a templating system
Use the form and try:
- a short username
- a username of "admin"
- empty fields
- a valid form submit
Key files:
src/com/googlecode/htmleasy/playground/UserSignup.java
war/templates/playground/signup/form.jsp
war/templates/playground/signup/thanks.jsp


{% load staticfiles %} {% block styles %} {% endblock %} {% block content %}
Either you did not submit your decisions in the first day or you did not submit your decisions in {{ inactive_threshold }} or more days of the experiment so you have been automatically excluded. Unfortunately this means you will not receive any money for your participation. Although we thank you for signing up for this experiment, in the future please ensure that you do make your decisions.


---
format: html
link: http://www.tricedesigns.com/2013/02/14/transcript-from-open-session-on-phonegap-3/
author: Andrew Trice
date: 2013-02-14 18:26:28 Z
type: post
external: true
title: Transcript from Open Session On PhoneGap
status: publish
tags:
- PhoneGap Network
---
Ray and I have just concluded another Adobe TechLive Open Session on PhoneGap. These sessions are an opportunity for anyone to stop in and ask us questions. Thanks to everyone who attended and submitted their questions. We will be hosting more of these sessions in the future. You can also download a transcript of this [...]


RT @tabqwerty: "git gets easier once you get the basic idea that branches are homeomorphic endofunctors mapping submanifolds of a Hilbert s…
6/21/2015, 5:31:29 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @tabqwerty: "git gets easier once you get the basic idea that branches are homeomorphic endofunctors mapping submanifolds of a Hilbert s…
6/21/2015, 5:31:29 PM
Favs: 0
Retweets: 0
link


JQuery Weather Plugin using regular html Template
Getting data from openweather map and build plugin using Jquery, Bootstrap


To get started head over to Discord and then join our Support Guild here.
Discord is an all-in-one voice and text chat originally created for gamers,but now used by all since it's free, secure, and works on any desktop (using their dedicated client), or web browser, as well as on your smartphone, which guarantees that the fun can continue even while you are on-the-go, or off on vacation.
Imagine all the advantages and benefits of WhatsApp™, TeamSpeak™, Skype™, plus the control of the good 'ol message boards.
Well, now you can stop imagining and start enjoying them in a single app!
You don't have to share your private phone number or email to connect with people as some apps, like WhatsApp, force you to. And you can stop paying for TeamSpeak servers to keep in touch with friends. No more hassling with Skype either, or having to hunt for any sketchy ways to communicate and share with friends, or your new chosen family. Simplify your life and Join the Revolution!
Once you are ready, get your instace of ModBot using Heroku, or invite our Official Bot
This ModBot uses discord.py rewrite, the latest version of the library for Discord bots.
** All brand names are property of their respective owners, their names are mentioned here with illustrative and educational purposes only, and any similarity with real world scenarios is purely coincidential.


You can email me at<EMAIL_ADDRESS>I endeavour to reply to every email I recieve as soon as possible! (PGP Key 9AC41734, fill the subject line with nonsense if sending a PGP'd mail.)
Want something more instant? I'm available on XMPP at<EMAIL_ADDRESS>(OTR fingerprint: 8F8E747D E9887916 D4D56002 D99F6E26 914CFECC)
IRC more your style? I'm alfie there! You'll find me on freenode and a fair few other networks. My regular haunt is #DataHoarder@freenode, drop by and say hello! This is also the best way to get hold of me when I'm away from my desk, since I can access IRC from mobile. (Don't try and discuss anything sensitive over IRC, use XMPP for that)
Here are some things I do
I have a blog that I occasionally post opinions on


Hi, I'm Carlene Lebeuf, a graduate student and researcher at the University of Victoria, British Columbia. In spring 2014, I graduated with distinction from the University of Victoria, Canada, with a combined Bachelor's of Science Degree in Computer Science and Psychology. Currently, I'm working on my Master's of Computer Science with the CHISEL (Computer-Human Interaction Software Engineering Lab) Group.
Coming from a interdisciplinary background, I jump at any opportunity to explore human aspects of software development. I am passionate about software development and design, with a focus on web application development. Currently, my research focuses on the understanding and usage of software bot technologies, but I also dabble in information visualization, tools for software engineering, and all things related to UI design / UX :)
As both a graduate of the combined major in computer science / psychology bachelor's of science program and as a current Master's student in computer science, I've had the chance to develop a wide range of skills.
For more information, please see my LinkedIn Profile or download a copy of my Resume.
Throughout my schooling and work, I've had the opportunity to work on a wide range of projects. Below you'll find some of my favourite projects. Please see my github account for a more comprehensive look at what I've been working on lately.
Looking for more? Checkout my public projects on Github
Below you'll find a list of my recent publications and articles.
IEEE Software, vol. 35, pp. 18-23, January/February 2018, doi:10.1109/MS.2017.4541027.
Available Online
IEEE Software Blog, December 11th 2016.
Available Online
Talking with Conversational Agents in Collaborative Action workshop at the 20th ACM conference on Computer-Supported Cooperative Work and Social Computing (CSCW), 2017, ACM.
PDF -
arXiv
I'd love to hear from you! You can reach me at any of the following locations:


UseMyTechStuff
Home
Products
Contact
About
Sign Up
Login
Products
Laptops/Macbooks
Virtual Reality Sets
Printers/Office Equipment
Desktop PCs/iMacs
Gaming Computers
Computer Peripherals
Audio/Recording Equipment
iPhone/SmartPhones
GameConsoles