// This will be the logic that powers both module and CLI
const generateSW = require('./lib/generate-sw');
const getFileManifestEntries = require('./lib/get-file-manifest-entries');
const generateFileManifest = require('./lib/generate-file-manifest');
const injectManifest = require('./lib/inject-manifest');
/**
* # workbox-build
*
* This Node module can be used to generate a list of assets that should be
* precached in a service worker, generating a hash that can be used to
* intelligently update a cache when the service worker is updated.
*
* This module will use glob patterns to find assets in a given directory
* and use the resulting URL and hash data for one of the follow uses:
*
* 1. Generate a complete service worker with precaching and some basic
* configurable options. See
* [generateSW()]{@link module:workbox-build.generateSW}.
* 1. Inject a manifest into an existing service worker. This allows you
* to control your own service worker while still taking advantage of
* [workboxSW.precache()]{@link module:workbox-sw.WorkboxSW#precache} logic.
* See [injectManifest()]{@link module:workbox-build.injectManifest}.
* 1. Generate a manifest file. This is useful if you want to read in the
* urls and revision details via an import script or ES2015 module import.
* See [generateFileManifest()]{@link
* module:workbox-build.generateFileManifest}.
* 1. Get a JS object of the manifest details. Can be used in a build process
* if you want to inject the manifest into a file or template yourself.
* See [getFileManifestEntries()]{@link
* module:workbox-build.getFileManifestEntries}.
*
* @example
Generate a complete service worker that will precache
* the discovered assets.

* const swBuild = require('workbox-build');
*
* swBuild.generateSW({
* globDirectory: './build/',
* globPatterns: ['**\/*.{html,js,css}'],
* globIgnores: ['service-worker.js','admin.html'],
* swDest: './build/sw.js',
* templatedUrls: {
* '/shell': ['shell.hbs', 'main.css', 'shell.css'],
* },
* })
* .then(() => {
* console.log('Service worker generated.');
* });
*
* @example
Generate a file containing the assets to precache.
*

* const swBuild = require('workbox-build');
*
* swBuild.generateFileManifest({
* globDirectory: './build/',
* globPatterns: ['**\/*.{html,js,css}'],
* globIgnores: ['service-worker.js','admin.html'],
* mainfestDest: './build/scripts/manifest.js',
* templatedUrls: {
* '/shell': ['shell.hbs', 'main.css', 'shell.css'],
* },
* })
* .then(() => {
* console.log('Build file has been created.');
* });
*
* @example
Get an Array of files with revision details.

* const swBuild = require('workbox-build');
*
* swBuild.getFileManifestEntries({
* globDirectory: './build/',
* globPatterns: ['**\/*.{html,js,css}'],
* globIgnores: ['service-worker.js','admin.html'],
* templatedUrls: {
* '/shell': ['shell.hbs', 'main.css', 'shell.css'],
* },
* })
* .then((fileDetails) => {
* // An array of file details include a `url` and `revision` parameter.
* });
*
* @module workbox-build
*/
module.exports = {
generateSW,
generateFileManifest,
getFileManifestEntries,
injectManifest,
};


Backend host URL
Run your code from the repository
Send Code
Deploying code
Run your code directly from the UI
Deploying code


PyROTChecker
{% raw %}
Check websites for hidden messages
- ROT shift -
3
5
13
21
Check Website
Example
https://en.wikipedia.org/wiki/ROT13
Try it!
search for "To get to the other side!" as "Gb trg gb gur bgure fvqr!" in ROT-13
Try it!
{{ rotChecker.status_msg }}
{% endraw %}


putting objects in perspective!
by Derek Hoiem, Alexi A Efros, Martial Hebert
an overview by mark breneman
SO WHATS THIS PAPER ALL ABOUT?
SO WHAT'S IT ABOUT?
This paper deals with object detection in a 2D image.
The authors provide a framework for for object recognition based around three main parameters:
1. Objects in the image
2. Surface orientations
3. The camera viewpoint
Using these three parameters together, iteratively, they have a way of performing fairly accurate object detection.
WHAT'S THE VALUE IN OBJECT DETECTION IN AN IMAGE?
WHAT'S THE VALUE IN OBJECT DETECTION IN AN IMAGE?
"SEMANTIC INTERPRETATION OF AN INPUT IMAGE"... OF COURSE.
What this means is that by using object detection we could have some understanding about whats in the image, without human intervention.
(THINK NO MORE MECHANICAL TURK FOR MATT RICHARDSON'S DESCRIPTIVE PRINTER).
So Hows it work?
Lets start with a example image to illustrate the challenge;
SO HOWS IT WORK?
"Currently popular object detections look at small image windows and scaled to find specific objects."
Isolating these object in the image by themselves and identifying them is near impossible right?
But if you consider them together they form a visually coherent story.
SO HOWS IT WORK?
Local object detection
Rough Surface orientations
camera viewpoint
SO HOWS IT WORK?
SURFACE ORIENTATIONS
SO HOWS IT WORK?
Camera view point
SO HOWS IT WORK?
camera viewpoint:identify horizon
SO HOWS IT WORK?
Rinse...Wash...Repeat
Combining results of surface orientations with local object detections to get better detection
So Hows it work?
RINSE...WASH...REPEAT
Combine that detection with camera view position
So Hows it work?
Rinse...Wash...Repeat
All three together iterating
Cool..SO what Can it do?
Determine heights of object within an image
Cool..So what can it do?
Build 3D maps of the environment based off the objects recognized
Awesome...but whats the catch?
The research assumes:
-
All objects rest on the ground and are perpendicular to it.
-
The camera is not tilted or it has been corrected.
-
Object independence. Overlapped objects are more difficult to identify.
-
Current object detection relies on a set of input training data.
Okay... now what CAN WE DO WITH it?
3D Print Diorama from a single image
Create a database of objects within a room so you never lose anything
Fight crime!


{% extends "base.html" %} {% block title %}Invitations Confirmed{% endblock %} {% block body %}
Thank you {{name}}, we have confirmed your invitations and will send them to your invitees in the next daily digest.


This release of the Ajax Control Toolkit focused on making fixes and improvements to the ModalPopup, AsyncFileUpload, and DropShadow controls:
ModalPopup — The ModalPopup extender has been enhanced to support animations. The ModalPopup now supports OnShowing, OnShown, OnHiding, OnHidden animations. For example, you can fade-in the popup when it opens and fade-out the popup when it closes. Or, you can get super fancy with your animations.
AsyncFileUpload — This release fixes several significant issues with the AsyncFileUpload. For example, previous to this release, the AsyncFileUpload control did not work correctly in a master page or when ClientIDMode="static". In this release, the AsyncFileUpload has been enhanced to be HTML5 compatible and to work with Mozilla Firefox 4.
DropShadow — This release fixes an issue with the DropShadow extender which prevented it from working correctly in an UpdatePanel. This release also includes better test coverage for the DropShadow with the addition of new QUnit tests.
This Binary Only version of the AJAX Control Toolkit contains the AjaxControlToolkit.dll assembly and localized resource files. Follow the instructions below to add the AJAX Control Toolkit to the Visual Studio Toolbox.
If you want to download the AJAX Control Toolkit source files then you should download the Source version of the AJAX Control Toolkit:
http://ajaxcontroltoolkit.codeplex.comNote: When opening the Ajax Control Toolkit solution in Visual Studio 2008, you will receive a security warning because the Ajax Control Toolkit project files have been modified to use the Microsoft Ajax Minifier. Select the option to Load the Project Normally.
Read the following tutorial to learn how to install the AJAX Control Toolkit in the Visual Studio Toolbox:
http://www.asp.net/ajaxlibrary/act.ashx
The ASP.NET Ajax website contains tutorials, videos, and sample code to help you learn how to use the AJAX Control Toolkit:
http://www.ASP.net/ajax


I’ve always been drawn to exploring opportunities and challenges that are meaningful to me. My career in web development has enabled me to help others and solve problems that really matter.
As a web developer, I rely on my ability to ask the right questions to the right people, my unequivocal love for making cool/useful things, and my focused work ethic to make the internet a better place.
Current Focus: AngularJS // Web Accessibility
Music subscription membership and cloud service for indie labels operated by Triplay Inc. Features a catalog of over 25MM tracks from independent artists and more than 40K subscribing active users.
Fluid and adaptive implemention to fit monitors, tablets, and mobile screens.
Meets WCAG 2.0 legal requirements for user accessibility
Dynamic, single page application built with Angular2
Features automated UI tests built on Jasmine Framework
Platform for subscription membership and cloud storage service for audiobooks operated by Triplay Inc. The eStories catalog features over 120K books from major publishers.
Single page application built with Angular2
Features automated UI tests built on Jasmine Framework
Custom media queries support mobile devices


# extends 'base.html' # import 'macro/utils.html' as utils # block content
# set instances_url = 'https://console.developers.google.com/project/%s/appengine/instances?moduleId=default&versionId=%s' % ( config.APPLICATION_ID, config.CURRENT_VERSION_NAME, ) if config.PRODUCTION else '' For most of the settings to be applied for everyone, you will # if instances_url have to restart # else have to restart # endif the instances.
# endif # block admin_header # endblock


Lua Functional 0.1.3 documentation
API Reference
«
Getting Started
::
Contents
::
Basic Functions
»
API Reference
¶
Basic Functions
Generators
Finite Generators
Infinity Generators
Random sampling
Slicing
Basic
Subsequences
Indexing
Filtering
Reducing
Folds
Predicates
Special folds
Transformations
Compositions
Operators
Comparison operators
Arithmetic operators
String operators
Logical operators
«
Getting Started
::
Contents
::
Basic Functions
»


>>
<<
Usr
Pri
JfC
LJ
Phr
Dic
Voc
!:
Help
Primer
Basic way of adding lists
You can have lists of numbers.
a =. 12 24 47
b =. 12 34 45
If you wanted to add two lists of numbers in a language like Basic you would have to get each number in turn from each list, add them together, and then stick this new result at the end of the result list.
To add two lists of numbers together in this way you need a few new primitives. You need a way to get one number from a list. The verb { (from) can do this.
0 { 7 9 2 4 NB. index 0 value
7
1 { 7 9 2 4 NB. index 1
9
2 { 7 9 2 4 NB. index 2
2
3 { 7 9 2 4 NB. index 3
4
You need to be able to append a new result value to the result list. The verb , can do this.
7 9 2 , 4 NB. append 4 to the list
7 9 2 4
7 9 2 4 , 7 NB. append 7 to the list
7 9 2 4 7
a =. 7 9 2 4
a =. a , 23
a
7 9 2 4 23
You need to know how many numbers there are in the list so that you will know when you are done. The monad # (tally) tells us how many numbers are in the list.
# 7 9 2 4
4
# 7 9 2 4 7
5
You also need a way to create an empty result to which you will add each new result. An empty string will do this.
r =. '' NB. an empty string
With these new verbs, combined with what you already know, you can write a Basic or Java style program that adds two lists.
Create a temporary script file and add the addlists definition.
addlists =: dyad : 0
r =. ''
count =. # x
i =. 0
while. i < count do.
left =. i { x
right =. i { y
sum =. left + right
r =. r , sum
i =. i + 1
end.
r
)
The local i is the index to select numbers from each list. It starts with 0 to select the first number from the left and right arguments. At the end of the while. control structure the i is incremented by 1 so that the next time the block is executed it will select the next number. The while. structure tests to see if i is less than the count of the argument. The control structure is finished when i is equal to the count of numbers to be added together. The left and right locals are defined as the next pair of numbers. They are added together and are appended to the end of the result r. The final line in the definition is r and that is the result.
Run the script and test your definition of addlists.
2 3 4 addlists 4 5 6
6 8 10
If you made a typo in the definition you will get an error or a wrong answer. In that case, you should check carefully that you have typed the definition in correctly.
Certain errors (such as omitting the line that incremented the value of i) give you a while. that runs forever. This is because the while. never ends and the program keeps adding the first element of the left and right arguments and never steps to the next element. If you are in a loop like this, you need to run the jbreak program to interrupt J execution. This is the yellow J icon in Windows and jbreak shell script in Unix.
In fact, it is worthwhile seeing how this looks. First be sure you know how to run the jbreak program to signal the interrupt (in Windows: find the yellow J icon, and in Unix have a command window ready to run the jbreak shell script in the J directory). Running jbreak while J is idle doesn't do anything. Edit the addlists definition so that i is not incremented. The easiest way to do this is to add NB. in front of the i =. i + 1 sentence. Run the script and test the verb. This will run until to use jbreak to interrupt execution (or cancel the J task).
For such a simple thing, this definition seems overly verbose in taking eleven lines. The definition can be compacted a bit by combining sentences. In the temporary script file create a second version of the definition.
adda =: dyad : 0
r =. ''
count =. # x
i =. 0
while. i < count do.
r =. r , (i { x) + (i { y)
i =. i + 1
end.
r
)
Run the script and test this new version.
2 3 4 adda 4 5 6
6 8 10
This is essentially how programmers in most languages add two lists of numbers. The program could be further streamlined, but it would still have to be a control structure that dealt with each number, one at a time. Most languages only know how to add a single number to a single number, and to add lists of numbers, you need to write a control structure that loops and explicitly adds each element of the list in turn.
>>
<<
Usr
Pri
JfC
LJ
Phr
Dic
Voc
!:
Help
Primer


Functional Mock-up Unit for Co-Simulation Import in EnergyPlus Copyright (c) 2012,
The Regents of the University of
California, through
Lawrence Berkeley National Laboratory (subject to receipt of any
required
approvals from the U.S. Dept. of Energy). All rights reserved.
If you have questions about your rights to use or distribute this
software, please contact Berkeley Lab's
Technology Transfer Department at
<EMAIL_ADDRESS>NOTICE. This software was developed under partial funding from the
U.S.
Department of Energy. As such, the U.S. Government has been granted
for itself and others acting on its behalf a paid-up, nonexclusive,
irrevocable, worldwide license in the Software to reproduce, prepare
derivative works, and perform publicly and display publicly. Beginning
five (5) years after the date permission to assert copyright is
obtained from the U.S. Department of Energy, and subject to any
subsequent five (5) year renewals, the U.S. Government is granted for
itself and others acting on its behalf a paid-up, nonexclusive,
irrevocable, worldwide license in the Software to reproduce, prepare
derivative works, distribute copies to the public, perform publicly and
display publicly, and to permit others to do so.
Functional Mock-up Unit for Co-Simulation Import in EnergyPlus Copyright (c) 2012, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy). All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
You are under no obligation whatsoever to provide any bug fixes, patches, or upgrades to the features, functionality or performance of the source code ("Enhancements") to anyone; however, if you choose to make your Enhancements available either publicly, or directly to Lawrence Berkeley National Laboratory, without imposing a separate written license agreement for such Enhancements, then you hereby grant the following license: a non-exclusive, royalty-free perpetual license to install, use, modify, prepare derivative works, incorporate into other computer software, distribute, and sublicense such enhancements or derivative works thereof, in binary and source code form.


According to Statistics Canada, only 15% of donated clothing gets used, sending the remaining 85% to landfills. Yet, there are still many individuals who don’t have the clothing necessities they need. Here at weshare, we aspire to help others by listening to what they need and connecting them with those who can donate.
We need you! There are tons of individuals out there who need help getting the essential clothing they need. Help our community. Clean out your closet and find clothing articles you no longer need. Check out what is in need by others around you.
Here on weshare, we will show you where your items are most needed. With the location information and drop-off times provided, we encourage you to donate where it counts.
With your help, we are able to provide people with more needed clothing articles than ever before. Thank you for helping out the community and our environment!
weshare wouldn't exist without your help! Together, our impact is bigger than we could imagine.


This document has these sections:
This specification defines the API for the drag and drop facilities for the Java 2 Platform.
The primary requirements that this specification addresses, are:
java.awt.datatransfer.*
package to enable the transfer of data, described by an extensible
data type system based on the MIME standard.
The specification derives from the previous work mentioned above, but incorporates significant differences from that original work as a result of the advent of the JavaBeansTM event model, lightweight (Swing) components, and an increasing understanding of the cross-platform integration and interoperability issues.
The following sections cover the drag and drop API.
Drag and drop is a direct manipulation gesture found in many graphical user interface systems that provides a mechanism to transfer information between two entities logically associated with presentation elements in the GUI. Normally driven by a physical gesture of a human user using an appropriate input device, drag and drop provides both a mechanism to enable continuous feedback regarding the possible outcome of any subsequent data transfer to the user during navigation over the presentation elements in the GUI, and the facilities to provide for any subsequent data negotiation and transfer.
A typical drag and drop operation can be decomposed into the following states (not entirely sequentially):
DragSource
comes into existence, associated with
some presentation element (Component
) in the GUI,
to initiate a drag and drop of some potentially Transferable
data.
DropTarget
s come into/go out of existence,
associated with presentation elements in the GUI (Components
),
potentially capable of consuming Transferable
data types.
DragGestureRecognizer
is obtained from the
DragSource
and is associated with a Component
in order to track and identify any drag initiating gesture by the user
over the Component
.
Component
,
which the registered DragGestureRecognizer
detects,
and notifies its DragGestureListener
of.
Note: Although the body of this document consistently refers to the
stimulus for a drag and drop operation being a physical gesture by a
human user this does not preclude a programmatically driven DnD operation
given the appropriate implementation of a DragSource
.
DragGestureListener
causes the DragSource
to initiate the drag and drop operation on behalf of the user,
perhaps animating the GUI Cursor
and/or rendering an
Image
of the item(s) that are the subject of the operation.
Component(s)
in the GUI
with associated DropTarget
(s), the DragSource
receives notifications in order to provide "Drag Over"
feedback effects, and the DropTarget
(s) receive
notifications in order to provide "Drag Under"
feedback effects based upon the operation(s) supported and the data
type(s) involved.
The gesture itself moves a logical cursor across the GUI hierarchy,
intersecting the geometry of GUI Component
(s),
possibly resulting in the logical "Drag" cursor entering,
crossing, and subsequently leaving Component(s)
and
associated DropTarget
(s).
The DragSource
object manifests "Drag Over"
feedback to the user, in the typical case by animating the GUI
Cursor
associated with the logical cursor.
DropTarget
objects manifest "Drag Under"
feedback to the user, in the typical case, by rendering animations
into their associated GUI Component
(s) under the GUI
Cursor
.
DragSource
and DropTarget
:
Copy, Move or Reference(link).
DragSource
and the set of data types comprehensible
by the DropTarget
.
DragSource
and
DropTarget
receive notifications that include,
and result in the type negotiation and transfer of, the information
associated with the DragSource
via a Transferable
object.
The remainder of this document details the proposed API changes to support this model.
The gesture(s) that can initiate a drag and drop operation vary, not only
per platform, but also per Component
, and per device.
Therefore a mechanism is required in order to encapsulate these
dependencies, thus making the task of the author of a Component
that wishes to initiate a drag and drop operation much simpler.
The DragGestureRecognizer
is an abstract base class for
all device/platform/Component
specific drag and drop
gesture recognizers, and is defined as:
public abstract DragGestureRecognizer { protected DragGestureRecognizer( DragSource ds, Component c, int srcActions, DragGestureListener dgl ); public Component getComponent(); public void setComponent(Component c); public int getSourceActions(); public void setSourceActions(int actions); public java.awt.InputEvent getTriggerEvent(); public void resetRecognizer(); public void addDragGestureListener( DragGestureListener dgl ) throws TooManyListenerExceptions; public void removeDragGestureListener( DragGestureListener dgl ); protected abstract void registerListeners(); protected abstract void unregisterListeners(); protected void fireDragGestureRecognized( int dragAction ); protected void appendEvent(InputEvent awtie); }
An appropriate concrete subclasses of DragGestureRecognizer
for a particular may be obtained in a variety of ways; from a
DragSource
instance, from the Toolkit
,
or by other means. Concrete implementation subclasses are obtained
through standard APIs' by specifying a Class
reference
to an abstract DragGestureRecognizer
superclass,
an instance of a concrete subclass of this actual parameter is
instantiated and returned to the requestor.
Once a DragGestureRecognizer
instance is associated with a
Component
and a DragSource
it registers its
own particular set of EventListener
s' with the
target Component
in order to monitor the appropriate
events being delivered to that Component
to detect an
initiating gesture. (Using registerListeners
and
unregisterListeners
to add/remove these monitoring
EventListener
s').
Note that a DragGestureRecognizer
may throw either an
IllegalStateException
or an IllegalArgumentException
if either the Component
or DragSource
specified
is either not in the correct state for, or is not interoperable with,
that DragGestureRecognizer
.
When a concrete DragGestureRecognizer
instance detects
a drag-initiating user gesture on the Component
it is
associated with, it will fire a DragGestureEvent
to the
DragGestureListener
registered on its unicast event source
for DragGestureListener
events. This
DragGestureListener
is responsible for causing the
associated DragSource
to start the drag and drop operation
(if appropriate).
The implementation provides (at least) an abstract subclass for
recognizing mouse device gestures MouseDragGestureRecognizer
.
Other abstract subclasses may be provided by the platform to support
other input devices or particular Component class semantics.
Concrete superclasses of this MouseDragGestureRecognizer
that encapsulate platform dependent mouse based gestures are available
from the Toolkit
object via its
createDragGestureRecognizer(Class adgrc, DragSource ds,
Component c, int sa, DragGestureListener dgl)
method.
This Toolkit
API provides platform dependent concrete
implementations that extend particular platform independent abstract
definitions (classes).
The MouseDragGestureRecognizer
abstract class is defined as:
public abstract MouseDragGestureRecognizer extends DragGestureRecognizer implements MouseListener, MouseMotionListener { public MouseDragGestureRecognizer( DragSource ds, Component c, int sa, DragGestureListener dsl ); //... }
The DragGestureListener
is defined as:
public interface DragGestureListener extends EventListener { void dragGestureRecognized(DragGestureEvent dge); }
Usually the dragGestureRecognized()
method will simply,
via the DragGestureEvent
's convenience API
startDrag
, start a drag and drop operation on the
associated DragSource
.
Note that per Component
(class or instance) behavior
that may effect the initiating gesture would usually be implemented
in this DragGestureListener
method, or in the
DragGestureRecognizer
subclass where appropriate or possible.
The DragGestureEvent
is defined as:
publc class DragGestureEvent extends EventObject { public DragGestureEvent(DragGestureRecognizer dgr, int dragAction, java.util.List events ); public DragGestureRecognizer getSourceAsDragGestureRecognizer(); public Component getComponent(); public DragSource getDragSource(); public java.util.Iterator iterator(); public Object[] toArray(); public Object[] toArray(Object[] array); public int getDragAction(); public startDrag(Cursor dragCursor, Transferable t, DragSourceListener dsl ); public startDrag(Cursor dragCursor, Image dragImage, Point imageOffset, Transferable t, DragSourceListener dsl ); //... }
The DragGestureEvent
encapsulates all the information
regarding the nature of the gesture that has just been recognized, including:
DragGestureRecognizer
that recognized the gesture
Component
that the gesture occurred on
DragSource
that will process the operation
InputEvent
objects that comprise the gesture.
The DragSource
is the entity responsible for the initiation
of the drag and drop operation:
The DragSource
and associated constant interfaces are
defined as follows:
The DnDConstants
class defines the operations that may be
applied to the subject of the transfer:
public final class java.awt.dnd.DnDConstants { public static int ACTION_NONE = 0x0; public static int ACTION_COPY = 0x1; public static int ACTION_MOVE = 0x2; public static int ACTION_COPY_OR_MOVE= ACTION_COPY | ACTION_MOVE; public static int ACTION_REFERENCE = 0x40000000; } public class java.awt.dnd.DragSource { public static Cursor DefaultCopyDrop; public static Cursor DefaultMoveDrop; public static Cursor DefaultLinkDrop; public static Cursor DefaultCopyNoDrop; public static Cursor DefaultMoveNoDrop; public static Cursor DefaultLinkNoDrop; public static DragSource getDefaultDragSource(); public static boolean isDragImageSupported(); public void startDrag(DragGestureEvent trigger, Cursor dragCursor, Image dragImage, Point dragImageOffset, Transferable transferable, DragSourceListener dsl, FlavorMap fm) throws InvalidDnDOperationException; protected DragSourceContext createDragSourceContext( DragSourceContextPeer dscp, DragGestureEvent trigger, Cursor dragCursor, Image dragImage, Point dragImageOffset, Transferable transferable, DragSourceListener dsl ); public FlavorMap getFlavorMap(); public DragGestureRecongizer createDragGestureRecognizer( Class abstractRecognizerClass, Component c, int srcActions, DragGestureListener dgl ); public DragGestureRecongizer createDefaultDragGestureRecognizer( Component c, int srcActions, DragGestureListener dgl ); //... }
The DragSource
may be used in a number of scenarios:
TextField
). [implementation dependent]
Component
, or
application specific object associated with a Component
instance in the GUI. [implementation dependent]
A controlling object, shall obtain a DragSource
instance
prior to a user's gesture, effecting an associated Component
,
in order to process the operation. Once obtained a
DragGestureRecognizer
should be obtained and used to
associate the DragSource
with a Component
.
The initial interpretation of the user's gesture, and the subsequent
starting of the drag operation are the responsibility of the implementing
Component
, this is usually implemented by a
DragGestureRecognizer
.
When a gesture occurs, the DragSource
's
startDrag
method shall be invoked in order to cause
processing of the user's navigational gestures and delivery of drag and
drop protocol notifications. A DragSource
shall only permit
a single drag and drop operation to be current at any one time,
and shall reject any further startDrag
requests by
throwing an IllegalDnDOperationException
until such time
as the extant operation is complete.
In order to start a drag operation the caller of the
startDrag
method shall provide the following parameters:
DragGestureEvent
for the gesture.
Cursor
representing the initial "Drag Over"
feedback for the operation(s) specified. (This shall be a
Cursor
that provides "No Drop" visual
feedback to the user).
Image
to visually represent the item, or item(s) that are the subject(s) of the operation.
On platforms that can support this feature, a "Drag"
image may be associated with the operation to enhance the fidelity
of the "Drag Over" feedback. This image would typically
be a small "iconic" representation of the object, or objects
being dragged, and would be rendered by the underlying system, tracking
the movement of, and coincident with, but typically in addition to the
Cursor
animation.
Where this facility is not available, or where the image is not of a
suitable type to be rendered by the underlying system, this parameter
is ignored and only Cursor
"Drag Over"
animation results, so applications should not depend upon this feature.
The presence of the facility on a particular platform may be tested by
invoking the static method isDragImageSupported
.
Image
is provided; a Point
(in the co-ordinate space of the Component)
specifying
the initial origin of that Image
relative to the co-ordinates
of the "hotspot" of the drag "Cursor", in the
co-ordinate space of the Component
, at the time of the
initial gesture, for the purposes of initiating a correctly positioned
"Drag Over" animation of that Image
relative
to that "hotspot".
Transferable
that describes the various
DataFlavor
(s) that represent the subject(s) of any
subsequent data transfer that may result from a successful Drop.
The Transferable
instance associated with the
DragSource
at the start of the drag operation,
represents the object(s) or data that are the operand(s),
or the subject(s), of the Drag and Drop operation, that is the
information that will subsequently be passed from the
DragSource
to the DropTarget
as a result
of a successful Drop on the Component
associated with
that DropTarget
.
Note that multiple (collections) of either homogeneous, or heterogeneous,
objects may be subject of a Drag and Drop operation, by creating a
container object, that is the subject of the transfer, and implements
Transferable
. However it should be noted that since none
of the targeted native platforms systems support a standard mechanism
for describing and thus transferring such collections it is not possible
to implement such transfers in a transparent, or platform portable fashion.
DragSourceListener
instance, which will subsequently
receive events notifying it of changes in the state of the ongoing
operation in order to provide the "Drag Over" feedback
to the user.
As stated above, the primary role of the startDrag
method
is to initiate a Drag on behalf of the user. In order to accomplish this,
the startDrag
method must create a DragSourceContext
instance to track the operation itself, and more importantly it must initiate
the operation itself in the underlying platform implementation.
In order to accomplish this, the DragSource
must first obtain
a DragSourceContextPeer
from the underlying system
(usually via an invocation of
java.awt.Toolkit.createDragSourceContextPeer
method)
and subsequently associate this newly created
DragSourceContextPeer
(which provides a platform
independent interface to the underlying systems capabilities)
with a DragSourceContext
.The startDrag
method invokes the createDragSourceContext
method to
instantiate an appropriate DragSourceContext
and associate
the DragSourceContextPeer
with that.
If the drag and drop system is unable to initiate a drag operation
for some reason the startDrag
method shall throw a
java.awt.dnd.InvalidDnDOperationException
to signal such
a condition. Typically this exception is thrown when the underlying
platform system is either not in a state to initiate a drag,
or the parameters specified are invalid.
Note that during the drag neither the set of operations the source
exposed at the start of the drag operation may change for the duration
of the operation, in other words the operation(s) and are constant
for the duration of the operation with respect to the DragSource
.
The getFlavorMap
method is used by the underlying system
to obtain a FlavorMap
object in order to map the
DataFlavors
exposed by the Transferable
to data type names of the underlying DnD platform.
[see later for details of the FlavorMap
]
A "private" FlavorMap
may be provided to the
startDrag()
method of the DragSource
, or null,
in which case the "default" FlavorMap
for that
DragSource
class or instance is used.
As a result of a DragSource
's
startDrag
method being successfully invoked an instance
of the DragSourceContext
class is created. This instance
is responsible for tracking the state of the operation on behalf of the
DragSource
and dispatching state changes to the
DragSourceListener
.
The DragSourceContext
class is defined as follows:
public class DragSourceContext implements DragSourceListener { public DragSourceContext( DragSourceContextPeer dscp, DragGestureEvent trigger, Cursor dragCursor, Image dragImage, Point dragOffset, Transferable transferable, DragSourceListener dsl ); public DragSource getDragSource(); public Component getComponent(); public DragGestureEvent getTrigger(); public Image getDragImage(); public Point getDragImageOffset(); public void transferablesFlavorsChanged(); public int getSourceActions(); public Cursor getCursor(); pbulic void setCursor(Cursor Cursor) throws InvalidDnDOperationException; public void addDragSourceListener(DragSourceListener dsl) throws TooManyListenersException; public void removeDragSourceListener(DragSourceListener dsl); protected updateCurrentCursor(int dropOperation, int targetActions, int status ); // values for status parameter above. protected static final int DEFAULT = 0; protected static final int ENTER = 1; protected static final int OVER = 2; protected static final int CHANGED = 3; //... }
Note that the DragSourceContext
itself implements
DragSourceListener
, this is to allow the platform peer,
the DragSourceContextPeer
instance, created by the
DragSource
, to notify the DragSourceContext
of changes in state in the ongoing operation, and thus allows the
DragSourceContext
to interpose itself between the platform
and the DragSourceListener
provided by the initiator of the
operation.
The state machine the platform exposes, with respect to the source, or initiator of the Drag and Drop operation is detailed below:
Notifications of changes in state with respect to the initiator
during a drag and drop operation, as illustrated above, are delivered
from the DragSourceContextPeer
, to the appropriate
DragSourceContext
, which delegates notifications,
via a unicast JavaBeans compliant EventListener
subinterface,
to an arbitrary object that implements DragSourceListener
registered with the DragSource
via startDrag
.
The primary responsibility of the DragSourceListener
is to monitor the progress of the user's navigation during the drag and
drop operation and provide the "Drag-Over" effects feedback
to the user. Typically this is accomplished via changes to the
"Drag Cursor".
Every drag operation has 2 logical cursor states (Drag Cursors) associated with it:
Cursor
, the cursor displayed when dragging
over a valid DropTarget
.
Cursor
, the cursor displayed when dragging
over everything else (the initial state of the cursor at the start
of a drag).
The state of the Cursor
may be modified by calling the
setCursor
method of the DragSourceContext
.
The DragSourceListener
interface is defined as follows:
public interface java.awt.dnd.DragSourceListener extends java.util.EventListener { void dragEnter (DragSourceDragEvent dsde); void dragOver (DragSourceDragEvent dsde); void dropActionChanged (DragSourceDragEvent dsde); void dragExit (DragSourceEvent dse); void dragDropEnd (DragSourceDropEvent dsde); }
As the drag operation progresses, the DragSourceListener'
s
dragEnter
, dragOver
, and dragExit
methods shall be invoked as a result of the user's navigation of the logical
"Drag" cursor's location intersecting the geometry
of GUI Component(s)
with associated DropTarget(s)
.
[See below for details of the DropTarget's
protocol
interactions].
The DragSourceListener
's dragEnter
method is invoked when the following conditions are true:
Component
's visible geometry.
Component
has an active DropTarget
associated.
The DropTarget
's registered DropTargetListener
dragEnter
method is invoked and returns successfully.
The registered DropTargetListener
invokes the
DropTargetDragEvent
's acceptDrag
method to accept the drag based upon interrogation of the source's
potential drop actions and available data types (DataFlavors
).
The DragSourceListener's dragOver
method is invoked
when the following conditions are true:
The DragSourceListener
's dragExit
method is invoked when one of the following conditions is true:
Component
associated with the previous
dragEnter
invocation.
Or:
Component
that the logical cursor's hotspot
intersected that resulted in the previous dragEnter
invocation, no longer has an active DropTarget
(or DropTargetListener
) associated.
Or:
DropTarget
's DropTargetListener
has invoked rejectDrag
since the last
dragEnter
or dragOver
invocation.
The DragSourceListener
's dropActionChanged()
method is invoked when the state of the input device(s), typically the
mouse buttons or keyboard modifiers, that the user is interacting with
in order to perform the drag operation, changes.
The dragDropEnd()
method is invoked to signify that the
operation is completed. The getDropSuccess
method of the
DragSourceDropEvent
can be used to determine the termination
state. The getDropAction
method returns the operation that
the DropTarget
selected (via the DropTargetDropEvent
acceptDrop
parameter) to apply to the drop operation.
Once this method is complete the current DragSourceContext
and the associated resources are invalid.
The DragSourceEvent
class is the root Event
class for all events pertaining to the DragSource
,
and is defined as follows:
public class java.awt.dnd.DragSourceEvent extends java.util.EventObject { public DragSourceEvent(DragSourceContext dsc); public DragSourceContext getDragSourceContext(); //... };
An instance of this event is passed to the DragSourceListener
dragExit
method.
The DragSourceDragEvent
class is defined as follows:
public class java.awt.dnd.DragSourceDragEvent extends DragSourceEvent { public int getTargetActions(); public int getUserAction(); public int getGestureModifiers(); public int getGestureModifiersEx(); public int getDropAction(); }
An instance of the above class is passed to a
DragSourceListener
's dragEnter
,
dragOver
, and dragGestureChanged
methods.
The getDragSourceContext
method returns the
DragSourceContext
associated with the current drag and drop
operation.
The getUserAction
method returns the action that is currently
selected by the user's gesture.
The getTargetActions
method returns the drop action selected
by the current drop target if this drop action is supported by the drag
source or DnDConstants.ACTION_NONE
if this drop action is
not supported by the drag source.
The logical intersection of these two results and the set of drop actions
supported by the drag source defines the actual effect of a drop and is
returned via getDropAction
.
The getGestureModifiers
method returns the current state of
the input device modifiers, usually the mouse buttons and keyboard
modifiers, associated with the user's gesture.
The getGestureModifiersEx
method returns the current state
of the input device extended modifiers associated with the user's
gesture.
The DragSourceDropEvent
class is defined as follows:
public public class java.awt.dnd.DragSourceDropEvent extends java.util.EventObject { public DragSourceDropEvent(DragSourceContext dsc); public DragSourceDropEvent(DragSourceContext dsc, int action, boolean success); public boolean getDropSuccess(); public int getDropAction(); }
An instance of the above class is passed to a
DragSourceListener
's dragDropEnd
method.
This event encapsulates the termination state of the drag and drop
operation for the DragSource
.
If the drop occurs, then the participating DropTarget
will signal the success or failure of the data transfer via the
DropTargetContext
's dropComplete
method,
this status is made available to the initiator via the
getDropSuccess
method. The operation that the destination
DropTarget
selected to perform on the subject of the drag
(passed by the DropTarget
's acceptDrop
method)
is returned via the getDropAction
method.
If the drag operation was aborted for any reason prior to a drop
occurring, for example if the user ends the gesture outside a
DropTarget
, or if the DropTarget
invokes
rejectDrop
, the getDropSuccess
method will
return false, otherwise true.
The java.awt.Component
class has two additional methods
added to allow the (dis)association with a DropTarget
.
In particular:
public class java.awt.Component /* ... */ { //... public synchronized void setDropTarget(DropTarget dt); public synchronized DropTarget getDropTarget(DropTarget df); //... }
To associate a DropTarget
with a Component
one may invoke either; DropTarget.setCompononent
or
Component.setDropTarget
methods. Thus conforming
implementations of both methods are required to guard against mutual
recursive invocations.
To disassociate a DropTarget
with a Component
one may invoke either; DropTarget.setCompononent(null)
or
Component.setDropTarget(null)
methods.
Conformant implementations of both setter methods in
DropTarget
and Component
should be implemented
in terms of each other to ensure proper maintenance of each other's state.
The setDropTarget
method throws
IllegalArgumentException
if the DropTarget
actual parameter is not suitable for use with this class/instance of
Component
. It may also throw
UnsupportedOperationException
if, for instance, the
Component
does not support external setting of a
DropTarget
.
A DropTarget
encapsulates all of the platform-specific
handling of the Drag and Drop protocol with respect to the role of the
recipient or destination of the operation.
A single DropTarget
instance may typically be associated
with any arbitrary instance of java.awt.Component
.
Establishing such a relationship exports the associated
Component
s geometry to the client desktop as being
receptive to drag and drop operations when the coordinates of the
logical cursor intersects that visible geometry.
The DropTarget
class is defined as follows:
public class java.awt.dnd.DropTarget implements DropTargetListener, Serializable { public DropTarget(Component c, int actions, DropTargetListener dsl, boolean isActive, FlavorMap fm ); public DropTarget(); public DropTarget(Component c); public DropTarget(Component c, DropTargetListener dsl); public Component getComponent(); public void setComponent(Component c); public DropTargetContext getDropTargetContext(); public void addDropTargetListener(DropTargetListener dte) throws TooManyListenersException; public void removeDropTargetListener(DropTargetListener dte); public void setActive(boolean active); public boolean isActive(); public FlavorMap getFlavorMap(); public void setFlavorMap(FlavorMap fm); public void setDefaultActions(int actions); public int getDefaultActions(); protected DropTargetContext createDropTargetContext(); public void addNotify(ComponentPeer cp); public void removeNotify(ComponentPeer cp); // ... }
The setComponent
method throws
IllegalArgumentException
if the Component
actual parameter is not appropriate for use with this class/instance of
DropTarget
, and may also throw
UnsupportedOperationException
if the Component
specified disallows the external setting of a DropTarget
.
The addDropTargetListener
and
removeDropTargetListener
methods allow the unicast
DropTargetListener
to be changed.
The setActive
and isActive
methods allow the
DropTarget
to be made active or otherwise and for its current
state to be determined.
The getFlavorMap
methods is used to obtain the
FlavorMap
associated with this DropTarget
for the purposes of mapping any platform dependent type names to/from
their corresponding platform independent DataFlavors
.
The setFlavorMap
method allows a new FlavorMap
to be assigned to the DropTarget
, a parameter of null causes
a "default" FlavorMap
to be installed for the
DropTarget
.
The createDropTargetContext
method is only invoked to
provide the underlying platform dependent peer with an instantiation
of a new DropTargetContext
as a Drag operation initially
encounters the Component
associated with the
DropTarget
. If no DropTargetContext
is
currently associated with a DropTarget
, a permitted
side-effect of an invocation of getDropTargetContext
is to instantiate a new DropTargetContext
.
The addNotify
and removeNotify
methods
are only called from Component
to notify the
DropTarget
of the Component
's (dis)association
with its ComponentPeer
.
Note that the DropTarget
itself implements
DropTargetListener
, this is to allow the platform peer,
the DropTargetContextPeer
instance, created by the platform,
to notify the DropTarget
of changes in state in the ongoing
operation, and thus allows the DropTarget
to interpose itself
between the platform and the DropTargetListener
registered
with the DropTarget
.
As the logical cursor associated with an ongoing drag and drop operation
first intersects the visible geometry of a Component
with
an associated DropTarget
, the DropTargetContext
associated with the DropTarget
is the interface, through which,
access to, and control over state of the recipient protocol is achieved
from the DropTargetListener
.
A DropTargetContext
is created by a
DropTarget
, via it's createDropTargetContext
method,
as a side effect of a call to a DropTarget
's
getDropTargetContext
method, if no <>DropTargetContext
currently exists for that DropTarget
.
The DropTargetContext
interface is defined as follows:
public class DropTargetContext { public DropTarget getDropTarget(); public Component getComponent(); public void dropComplete(boolean success) throws InvalidDnDOperationException; public void acceptDrag(int dropAction); public void rejectDrag(); public void acceptDrop(int dropAction); public void rejectDrop(); public void addNotify(DropTargetContextPeer dtcp); public void removeNotify(); protected Transferable createTransferableProxy(Transferable t, boolean isLocal ); protected void setTargetActions(int actions); protected int getTargetActions(); protected DataFlavor[] getCurrentDataFlavors(); protected List getCurrentDataFlavorsAsList(); protected boolean isDataFlavorSupported(DataFlavor df); protected Transferable getTransferable(); // ... }
Most of the access and control methods are protected, since public
access to their state is usually achieved by calling through a particular
DropTargetEvent
subclass that delegates the request to the
DropTargetContext
.
The getDropTarget()
method return the DropTarget
that created this DropTargetContext
.
The getComponent
method returns the Component
associated with the DropTarget
that created this
DropTargetContext
.
The acceptDrag
method is delegated from the similar
method on DropTargetDragEvent
and is invoked from one
of the DropTargetListener
's methods; dragEnter()
,
dragOver
or dropActionChanged
to signify that
the recipient is prepared to accept a drop with the operation specified,
which is usually the user's currently selected action.
The rejectDrag
method is delegated from the similar method
on DropTargetDragEvent
and is invoked from one of the
DropTargetListener
's methods; dragEnter
,
dragOver
or dropActionChanged
to signify that
the recipient is unable to accept a drop with the user's currently
selected action.
The acceptDrop
method is delegated from the similar method
on DropTargetDropEvent
and is invoked from the
DropTargetListener
's drop
method to signify
that the recipient is prepared to accept a drop with the operation specified,
which is usually the user's currently selected action.
The rejectDrop
method is delegated from the similar method
on DropTargetDropEvent
and is invoked from the
DropTargetListener
's drop
method to signify
that the recipient is unable to accept a drop with the user's currently
selected action. This terminates a drag and drop operation without a
data transfer.
The dropComplete
method signals to the originating
DragSource
that the DropTargetListener
has completed the transfer(s) that comprise the subject of the drag and drop
operation and that the operation is complete. The success (or failure)
of the transfer(s) and the subsequent application of the operation specified
is signaled by the value of the actual parameter.
The getDataFlavors
method returns an array of the
DataFlavors
available from the DragSource
.
The getTransferable
method returns a Transferable
(not necessarily the one the DragSource
registered, it may be
a proxy, and certainly shall be in the inter-JVM case) to enable data
transfers to occur via its getTransferData
method.
Note that it is illegal to invoke getTransferable
without
first invoking an acceptDrop
.
The addNotify
and removeNotify
methods are
exclusively called by the underlying platform's
DropTargetContextPeer
in order to notify the
DropTargetContext
that a drag and drop operation is
occurring/ceasing on the DropTargetContext
and associated
DropTarget
.
The createTransferableProxy
method enables a
DropTargetContext
implementation to interpose a
Transferable
between the DropTargetListener
and
the Transferable
provided by the caller, which is typically
the underlying platform DropTargetContextPeer
.
Providing the appropriate "Drag-under" feedback semantics,
and processing of any subsequent Drop, is enabled through the
DropTargetListener
asssociated with a DropTarget
.
The DropTargetListener
determines the appropriate
"Drag-under" feedback and its response to the
DragSource
regarding drop eligibility by inspecting the
sources suggested actions, the data types available and the data itself.
A particular DropTargetListener
instance may be associated
with a DropTarget
via addDropTargetListener
and removed via removeDropTargetListener
methods.
public interface java.awt.dnd.DropTargetListener extends java.util.EventListener { void dragEnter (DropTargetDragEvent dtde); void dragOver (DropTargetDragEvent dtde); void dropActionChanged (DropTargetDragEvent dtde); void dragExit (DropTargetDragEvent dtde); void drop (DropTargetDropEvent dtde); }
The dragEnter
method of the DropTargetListener
is invoked when the hotspot of the logical "Drag"
Cursor intersects a visible portion of the DropTarget
's
associated Component's
geometry. The
DropTargetListener
, upon receipt of this notification,
shall interrogate the operations or actions, and the types of the data
(DataFlavors
) and the data itself as supplied by the
DragSource
to determine the appropriate actions and
"Drag-under" feedback to respond with invocation of either
acceptDrag
or rejectDrag
.
The dragOver
method of the DropTargetListener
is invoked while the hotspot of the logical "Drag" Cursor,
in motion, continues to intersect a visible portion of the
DropTarget's
associated Component
's geometry.
The DropTargetListener
, upon receipt of this notification,
shall interrogate the operation "actions" the types of the
data and the data itself as supplied by the DragSource
to determine the appropriate "actions" and "Drag-under"
feedback to respond with an invocation of either acceptDrag
or
rejectDrag
.
The dragExit
method of the DropTargetListener
is invoked when the hotspot of the logical "Drag" Cursor
ceases to intersect a visible portion of the DropTarget's
associated Component
's geometry, or immediately prior to a
drop
notification. The DropTargetListener
,
upon receipt of this notification, shall undo any "Drag-under"
feedback effects it has previously applied. Note that the
DropTargetContext
associated with the DropTarget
is invalidated as a side-effect.
The drop
method of the DropTargetListener
is invoked as a result of the user terminating their drag gesture while
intersecting. The DropTargetListener
, upon receipt of this
notification, shall perform the operation specified by the return value
of the getSourceActions
method on the
DropTargetDropEvent
object, upon the Transferable
object returned from the getTransferable
method, and
subsequently invoke the dropComplete
method of the associated
DropTargetContext
to signal the success, or otherwise, of
the operation.
The DropTargetEvent
and DropTargetDragEvent
are
defined as follows:
public abstract class java.awt.dnd.DropTargetEvent extends java.util.EventObject { public DropTargetContext getDropTargetContext(); //... }
A DropTargetEvent
is passed to the
DropTargetListener
's dragExit
method.
public class java.awt.dnd.DropTargetDragEvent extends java.awt.dnd.DropTargetEvent { public Transferable getTransferable(); public Point getLocation(); public int getSourceActions(); public getDropAction(); public DataFlavor[] getCurrentDataFlavors(); public List getCurrentDataFlavorsAsList(); public boolean isDataFlavorSupported(); public void acceptDrag(int operation); public void rejectDrag(); //... }
A DropTargetDragEvent
is passed to the
DropTargetListener
's dragEnter
,
dragOver
and dropActionChanged
methods.
The getLocation
method return the current co-ordinates,
relative to the associated Component
's origin, of the
hotspot of the logical "Drag" cursor.
The getSourceActions
method returns the current
"actions", or operations (ACTION_MOVE, ACTION_COPY, or
ACTION_REFERENCE) the DragSource
associates with the
current drag and drop gesture.
The return value of the getDropAction
method is the
action that is selected by the user's gesture.
The getCurrentDataFlavors
,
getCurrentDataFlavorsAsList
and
isDataFlavorSupported
methods are provided in order for the
recipient to interrogate the list of types available from the source.
The getTransferable
method is provided in order for the
recipient to interrogate the data available from the source. Note that
getTransferable
on the DropTargetDragEvent
instance should only be called within the respective
DropTargetListener's
method, and all the necessary
data should be retrieved from the returned Transferable
before that method returns.
The DropTargetDropEvent
is defined as follows:
public class java.awt.dnd.DropTargetDropEvent extends java.awt.dnd.DropTargetEvent { public Point getLocation(); public int getSourceActions(); public int getDropAction(); public void acceptDrop(int dropAction); public void rejectDrop(); public boolean isLocalTransfer(); public DataFlavor[] getCurrentDataFlavors(); public List getCurrentDataFlavorsAsList(); public boolean isDataFlavorSupported(DataFlavor df); public Transferable getTransferable(); public void dropComplete(boolean success); //... }
A DropTargetDropEvent
is passed to the
DropTargetListener
's drop
method, as the
drop occurs. The DropTargetDropEvent
provides the
DropTargetListener
with access to the data associated
with the operation, via the Transferable
returned from the
getTransferable
method.
The return value of the getSourceActions
method is defined
to be the action(s) defined by the source at the time at which the
drop occurred.
The return value of the getDropAction
method is the
action that is selected by the user's gesture.
The return value of the getLocation
method is defined to be
the location at which the drop occurred.
The getCurrentDataFlavors
,
getCurrentDataFlavorsAsList
, and
isDataFlavorSupported
, methods are provided in order for the
recipient to interrogate the list of types available from the source for
subsequent transfer via the getTransferData
method of the
Transferable
.
A typical implementation of the drop
method will inspect
the actions and the DataFlavor
s' available to determine
if a successful exchange can occur or not.
When an exchange may occur, a DropTargetListener.drop
implementation shall invoke acceptDrop
with the selected
operation as an actual parameter, prior to any invocation of
getTransferable
. Calling getTransferable
prior
to acceptDrop
shall result in an
InvalidDnDOperationException
.
The rejectDrop
shall be called to reject the drop operation.
Once called no further interaction can occur between the two participants,
therefore it is typical to return from the drop
method
immediately after calling this.
The isLocalTransfer
method shall return true, if the source
of the drag and drop operation resides within the same physical JVM
as the recipient of the drop
notification, and false otherwise.
This distinction is significant to the recipient when it receives
object references back from invoking Transferable.getTransferData
in the local case, since in this case the object reference it receives is
the same object reference held by the source (i.e it is not a copy,
proxy or distinct object) thus the recipient must treat such a shared
object reference differently in the local case as follows:
dropCompete
that the transfer is effected. (Note that a source is also prohibited
from modifying the state of such an object after it has returned such an
object from it's getTransferData
method, until such time
as it receives a dragDropEnd
notification.)
dropComplete
and
dragDropEnd
methods have been processed. Thereafter the
sharing semantics are implementation dependent upon the object(s) shared.
The dropComplete
method signals the end of the associated
drag and drop operation, and indicates the success (or failure) of
the transfers performed by the recipient. Invoking this method results
in the DragSourceListener
's dragDropEnd
method being called with the appropriate state available from it's
DragSourceDropEvent
. Failure to invoke this method will
result in the drag and drop operation failing to terminate properly.
Many GUI Component
s present a scrollable
"viewport" over a (potentially) large dataset.
During a drag and drop operation it is desirable to be able to
"autoscroll" such "viewports" to allow
a user to navigate over such a dataset, scrolling to locate a
particular member (initially not visible through the "viewport")
that they wish to drop the subject of the operation upon.
Component
s that are scrollable provide drag
"autoscrolling" support to their DropTarget
by implementing the following interface:
public interface Autoscroll { Insets getAutoscrollInsets(); void autoScrollContent(Point cursorLocn); }
An implementing DropTarget
shall periodically call the
autoscroll
method of its associated
Component
(if present), passing the current logical
cursor location in Component
co-ordinates, when the
following conditions are met:
Component
's visible geometry and the boundary region
described by the Insets
returned by the
getAutoscrollInsets
method.
Should any of the above conditions cease to be valid, autoscrolling shall terminate until the next triggering condition occurs.
Both the initial delay prior to autoscrolling commencing, the interval
between autoscrolling notifications, and the pixel hysteresis value are
externally configurable and can be queried from the
Toolkit.getDesktopProperty
method.
In the case where a valid drop occurs, the DropTargetListener
's
drop
method is responsible for undertaking the transfer
of the data associated with the gesture. The DropTargetDropEvent
provides a means to obtain a Transferable
object that represent
that data object(s) to be transferred.
From the drop
method, the DropTargetListener
shall initially either rejectDrop
(immediately returning
thereafter) or acceptDrop
specifying the selected operation
from those returned by getSourceActions
.
Subsequent to an acceptDrop
, but not before,
getTransferable
may be invoked, and any data transfers
performed via the returned Transferable
's
getTransferData
method. Finally, once the destination of
the drop has completed the transfer(s) of the objects from the source
it shall signal the success, or immediate failure, of the transfer(s)
via an invocation of DropTargetContext.dropComplete
.
Upon returning from the DropTargetContext.dropComplete
method the Transferable
and DragSourceContext
instances are no longer guaranteed to be valid and all references to
them shall be discarded by the recipient to allow them to be subsequently
garbage collected.
When using the ACTION_REFERENCE operation the source and destination
should take care to agree upon the object and the associated semantics
of the transfer. Typically in intra-JVM transfers a live object reference
would be passed between source and destination, but in the case of inter-JVM
transfers, or transfers between native and Java applications, live object
references do not make sense, so some other ‘reference' type should
be exchanged such as a URI for example. Both the DragSource
and DropTarget
can detect if the transfer is intra-JVM or not.
All the target DnD platforms represent their transfer data types
using a similar mechanism, however the representations do differ.
The Java platform uses MIME types encapsulated within a DataFlavor
to represent its data types. Unfortunately in order to permit the transfer
of data between Java and platform native applications the existence of these
platform names need to be exposed, thus a mechanism is required in order
to create an extensible (platform independent) mapping between these platform
dependent type names, their representations, and the Java MIME based
DataFlavor
s.
The implementation will provide a mechanism to externally specify a
mapping between platform native data types (strings) and MIME types
(strings) used to construct DataFlavor
s. This external
mapping will be used by the underlying platform specific implementation
code in order to expose the appropriate DataFlavors
(MIME types), exported by the source, to the destination, via the
underlying platform DnD mechanisms.
Both the DragSource
and DropTarget
classes
provide access for the underlying system to map platform dependent names
to and from DataFlavors
.
public interface java.awt.datatransfer.FlavorMap { java.util.Map getNativesForFlavors(DataFlavor[] dfs); java.util.Map getFlavorsForNatives(String[] natives); }
The getNativesForFlavors
method takes an array of
DataFlavor
s and returns a Map
object
containing zero or more keys of type DataFlavor
,
from the actual parameter dfs
, with associated values
of type String
, which correspond to the platform-dependent
type name for that MIME type.
The getFlavorsForNatives
method takes an array of
String
types and returns a Map
object
containing zero or more keys of type String
, from the
actual parameter natives, with associated values of type
DataFlavor
, which correspond to the platform-independent
type for that platform-dependent type name.
The Map
object returned by both methods may be mutable
but is not required to be.
If NULL is passed to either of these methods they should return their current map of all keys and values known to the implementation at the time of the call.
For example on Win32 the Clipboard Format Name for simple text is
"CF_TEXT" (actually it is the integer 1) and on Motif it is the X11 Atom
named "STRING", the MIME type one may use to represent this would be
"text/plain;charset=us-ascii". Therefore a platform portable
FlavorMap
would map between these names; CF_TEXT on win32
and STRING on Motif/X11.
Typically, as implemented in the SystemFlavorMap
these mappings are held in an external persistent configuration
format (a properties file or URL) and are loaded from the platform
to configure the FlavorMap
appropriately for a given platform.
The SystemFlavorMap
class is provided to implement a
simple, platform configurable mechanism for specifying a system-wide
set of common mappings, and is defined as follows:
public class java.awt.datatransfer.SystemFlavorMap implements FlavorMap, FlavorTable { public static FlavorMap getSystemFlavorMap(); public synchronized Map getNativesForFlavors(DataFlavor[] dfs); public synchronized Map getFlavorsForNatives(String[] natives); public static String encodeDataFlavor(DataFlavor flav); public static String encodeJavaMIMEType(String mimeType); public static boolean isJavaMIMEType(String mimeStr); public static String decodeJavaMIMEType(String nat); public static DataFlavor decodeDataFlavor(String nat); //... }
The SystemFlavorMap
class provides a simple implementation,
using a properties file (see java.awt.Properties
),
of a persistent platform FlavorMap
. Using the value of the
AWT property "AWT.flavorMapFileURL" (see Toolkit.getProperty
)
or the default file location of
System.getProperty("java.home")
+ File.separator + "lib" + File.separator + "flavormap.properties",
this class creates the appropriate Map
s from the
properties found therein.
In addition the class provides several static convenience functions
used to encode and decode Java MimeType
s to and from a
platform dependent namespace. The syntax of the properties file is:
{ <platform_type_name> ‘=' <IETF_MIME_RFC_conformant_specification> <nl> } *
The default implementations of DragSource
and
DropTarget
return the SystemFlavorMap
from their getFlavorMap
method, unless they have been
provided with an overriding implementation.
Since one of the primary goals of this API is to allow drag and drop of data between Java and native applications this has some significant consequences upon the method and mechanism of the actual data encoding and exchange when data is passed across the boundary of the Java Virtual Machine.
Since one of the participants in such an exchange may be a native application, and thus has no knowledge of the Java type system, the drag and drop system cannot just exchange a Java object reference since the other participant may have no knowledge of, or capability to manipulate such a type.
When any exchange occurs, it can only do so, regardless of the implementation of the participants, if and only if both participants are agreed upon a familiar data type and encoding. Thus, sadly the burden of the exchange is born mostly by the participants themselves.
What this means in practical terms is that for "native" data formats, such as platform-dependent image, document, or other "Content-Types" the encoding and decoding of their associated external data format is the responsibility of the source and destination of the transfer.
The drag and drop system shall expose the external representation of
such "native" data types across the boundary of the Java Virtual Machine
as encapsulated within a java.io.InputStream
or a subclass thereof.
This means that any DataFlavor
with a representation class
that extends java.io.InputStream
can be transferred,
and will be exposed for transfer, across the Java Virtual Machine boundary.
To implement the exchange of such a native data type, a developer
would define a DataFlavor
with a MIME "Content-Type"
that describes the nature of the "native" data type, with a representation
class that extends a java.io.InputStream
class that encodes
the data encapsulated into a stream of bytes.
In particular such InputStream
subclasses shall implement
the following semantics:
java.io.InputStream
.
Provision of this constructor by a subclass of
java.io.InputStream
will allow the drag and drop system
(associated with the DropTarget
) to automatically
re-construct an instance of the representation class specified by
the requested DataFlavor
, and initialize it with an
InputStream
containing the encapsulated data formatted
according to the expectations of that subclass. Once initialized this
instance is returned to the caller of the
Transferable.getTransferData
method, thus allowing the
caller to subsequently re-read and interpret the formatted content
of the data stream transferred.
InputStream.read(byte b[], int off, int len)
.
Provision of this method (or inheriting a superclasses implementation)
enables the drag and drop system (associated with the
DragSource
) to automatically extract an encoded stream
of the encapsulated data from the Transferable
,
thus enabling the transfer of the data across the JVM boundary
as a simple byte stream to the requestor of the particular
DataFlavor
.
A typical subject of a Drag and Drop transfer is a list of one or more platform dependent filenames. In order to ease the programming task of developers either producing or consuming such lists the drag and drop system treats them as a special case.
If a DataFlavor
is specified with a MIME "Content-Type"
of application/x-java-file-list;class=java.util.List
the drag and drop system will expect the list elements to be a
homogeneous list of objects of type java.io.File
.
Thus a source shall, if supporting the transfer of a list of files,
construct such a List
of File
objects when
such a DataFlavor
is requested, and a recipient shall
expect such a List
of File
objects if it
requests such a valid DataFlavor
from its source.
This special case provides a simple mechanism for the transfer of
lists of files between source and target.
It is possible to Drag and Drop object references between JVMs' by using the facilities of the RMI mechanism. The Drag and Drop system will automatically arrange for the transfer of any object reference that adheres to these requirements:
DataFlavor
implements both
java.rmi.Remote
and java.io.Serializable
.
(the MIME "Content-Type" can be any suitable, arbitrary type or application/x-java-remote-object)
(effectively the object implementation class transferred should
be extended from java.rmi.server.UnicastRemoteObject
since the RMI system implements some required initialization,
without which the transfer will not complete properly).
If these conditions are met, then if an appropriate
DataFlavor
is requested, then the object returned
to the requestor (if it is in a difference JVM from the source)
will be an RMI reference to an instance of the Remote
object subinterface specified as the representation class of the
DataFlavor
.
Due to limitations of particular underlying platform drag and drop and
window system implementations, the interaction of a drag operation,
and the event delivery semantics to AWT Components
is
platform dependent. Therefore during a drag operation a DragSource
may process platform Window System Events pertaining to that drag to the
exclusion of normal event processing.
Due to interactions between the single-threaded design center of the
platform native DnD systems, and the native window system event dispatching
implementations in AWT, "callbacks" into
DropTargetListener
and DragSourceListener
will occur either on, or synchronized with the AWT system event dispatch
thread. This behavior is highly undesirable for security reasons but is an
implementation, not architectural feature, and is unavoidable.
To enable intra-JVM Drag and Drop Transfers the existing
DataFlavor
class will be extended to enable it to represent
the type of a "live" object reference, as opposed to a
Serialized (persistent) representation of one. Such objects may be
transferred between source and destination within the same JVM and
ClassLoader
context.
The MIME Content-Type shall be application/x-java-local-objectref.
Transferable
objects, their associated
DataFlavor
s', and the objects that encapsulate the
underlying data specified as the operand(s) of a drag and drop
operation shall remain valid until, at least, the
DragSourceListener
associated with the DragSource
controlling the operation, receives a dragDropEnd
.
The lifetime of the subject(s) of the operation, transferred between source
and target is implementation defined beyond that point in time.
The "source" of a successful Drag and Drop (ACTION_MOVE)
operation is required to delete/relinquish all references to the object(s)
that are the subject of the Transferable
immediately after
transfer has been successfully completed. That is before returning from the
DragSourceListener.dragDropEnd
notification.
As a result of significant input from developers to an earlier version of the specification an additional operation/action tag; ACTION_REFERENCE was added to include existing platform Drag and Drop"Link" semantics.
It is believed that Reference, or Link, semantics are already sufficiently poorly specified for the platform native Drag and Drop to render it essentially useless even between native applications, thus between native and platform independent Java applications it is not recommended.
For Java to Java usage the required semantic; within the same
JVM/ClassLoader
, is defined such that the destination
shall obtain a Java object reference to the subject(s) of the transfer.
Between Java JVM's or ClassLoader
s, the semantic is
implementation defined, but could be implemented through transferring
either a URL from the source to the destination or an RMI
Remote
reference.
Although not a normative part of this specification this definition is included for clarity:
public interface DropTargetPeer { void addDropTarget(DropTarget dt); void removeDropTarget(DropTarget dt); }
Although not a normative part of this specification this definition is included for clarity:
public interface DragSourceContextPeer { void startDrag(DragSourceContext dsc, Cursor c, Image di, Point ioff ) throws InvalidDnDOperationException; Cursor getCursor(); void setCursor(Cursor c) throws InvalidDnDOperationException; void transferablesFlavorsChanged(); }
Although not a normative part of this specification this definition is included for clarity:
public interface DropTargetContextPeer { int getTargetActions(); void setTargetActions(int actions); DropTarget getDropTarget(); DataFlavor[] getTransferDataFlavors(); Transferable getTransferable() throws InvalidDnDOperationException; boolean isTransferableJVMLocal(); void acceptDrag(int dragAction); void rejectDrag(); void acceptDrop(int dropAction); void rejectDrop(); void dropComplete(boolean success); }


Opening a file
Okay, now you're back in CocoaPad, and you want to open a document you saved earlier. No problem. Just like saving, opening a document in CocoaPad is like opening a document in any other application.
To open a file:
- Pull down the File menu, and select Open (or press Command-O).
- An open dialog box will appear. Choose where you want to save your document from the popup menu.
- Finally, click the Open button, and your document appears in it's own window.
If you want to use a Finder-like display for navigating to a different folder, click the blue down arrow. |
You can also use the Open button on the toolbar. If the Open button is not on the toolbar, then pull down the Window menu, and select Customize Toolbar
. Then, drag the Open item from the customization sheet to the toolbar. |


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @(params: Map[String, Any]) @uk.gov.hmrc.hmrcemailrenderer.templates.helpers.html.template_main(params, "Confirmation HMRC received your request for a pension scheme tax refund"){
Dear @params("customerName")
We confirm your request for a tax refund through the Managing Pension Schemes service. We also confirm you have told us which bank account the refund should be paid into.
Your reference is: @params("submissionReference")
We aim to process your refund request within 15 working days. If you need to contact us about your refund request, you will need to quote the reference above.
Your account balance will be adjusted once your refund has been processed.
For your security HMRC will not send personal data by email. You can contact HMRC via the Pension Schemes Services helpline, on 0300 123 1079.
From Pension Schemes Services
}


{% extends "layout_bsa.html" %} {% block page_title %} Which pension scheme or section? - Claim your NHS Pension {% endblock %} {% block content %} {% include "includes/phase_banner_beta.html" %} {% include "includes/back.html" %} Claim your NHS Pension How would you like your lump sum? Maximum tax-free amount This could be 25% of the capital value of your benefits being paid but cannot be more than 25% of your available lifetime allowance An amount less than the maximum tax-free amount permitted This amount must be in whole pounds, dividable by 12 and lower than the maximum tax-free amount. £ The maximum additional lump sum, which may incur a tax charge If this is more than the maximum tax-free amount you will have to pay tax on the excess amount. {% endblock %}
Claim your NHS Pension
This could be 25% of the capital value of your benefits being paid but cannot be more than 25% of your available lifetime allowance
This amount must be in whole pounds, dividable by 12 and lower than the maximum tax-free amount.
If this is more than the maximum tax-free amount you will have to pay tax on the excess amount.


Keeping track of time¶
pyglet’s clock module provides functionality for scheduling functions for periodic or one-shot future execution and for calculating and displaying the application frame rate.
Calling functions periodically¶
pyglet applications begin execution with:
pyglet.app.run()
Once called, this function doesn’t return until the application windows have been closed. This may leave you wondering how to execute code while the application is running.
Typical applications need to execute code in only three circumstances:
- A user input event (such as a mouse movement or key press) has been generated. In this case the appropriate code can be attached as an event handler to the window.
- An animation or other time-dependent system needs to update the position or parameters of an object. We’ll call this a “periodic” event.
- A certain amount of time has passed, perhaps indicating that an operation has timed out, or that a dialog can be automatically dismissed. We’ll call this a “one-shot” event.
To have a function called periodically, for example, once every 0.1 seconds:
def update(dt):
# ...
pyglet.clock.schedule_interval(update, 0.1)
The dt parameter gives the number of seconds (due to latency, load and timer inprecision, this might be slightly more or less than the requested interval).
Scheduling functions with a set interval is ideal for animation, physics simulation, and game state updates. pyglet ensures that the application does not consume more resources than necessary to execute the scheduled functions in time.
Rather than “limiting the frame rate”, as required in other toolkits, simply schedule all your update functions for no less than the minimum period your application or game requires. For example, most games need not run at more than 60Hz (60 times a second) for imperceptibly smooth animation, so the interval given to schedule_interval would be 1/60.0 (or more).
If you are writing a benchmarking program or otherwise wish to simply run at the highest possible frequency, use schedule:
def update(dt):
# ...
pyglet.clock.schedule(update)
By default pyglet window buffer swaps are synchronised to the display refresh rate, so you may also want to disable set_vsync.
For one-shot events, use schedule_once:
def dismiss_dialog(dt):
# ...
# Dismiss the dialog after 5 seconds.
pyglet.clock.schedule_once(dismiss_dialog, 5.0)
To stop a scheduled function from being called, including cancelling a periodic function, use pyglet.clock.unschedule.
Animation techniques¶
Every scheduled function takes a dt parameter, giving the actual “wall clock” time that passed since the previous invocation (or the time the function was scheduled, if it’s the first period). This parameter can be used for numerical integration.
For example, a non-accelerating particle with velocity v will travel some distance over a change in time dt. This distance is calculated as v * dt. Similarly, a particle under constant acceleration a will have a change in velocity of a * dt.
The following example demonstrates a simple way to move a sprite across the screen at exactly 10 pixels per second:
sprite = pyglet.sprite.Sprite(image)
sprite.dx = 10.0
def update(dt):
sprite.x += sprite.dx * dt
pyglet.clock.schedule_interval(update, 1/60.0) # update at 60Hz
This is a robust technique for simple animation, as the velocity will remain constant regardless of the speed or load of the computer.
Some examples of other common animation variables are given in the table below.
Animation parameter Distance Velocity Rotation Degrees Degrees per second Position Pixels Pixels per second Keyframes Frame number Frames per second
The frame rate¶
Game performance is often measured in terms of the number of times the display is updated every second; that is, the frames-per-second or FPS. You can determine your application’s FPS with a single function call:
pyglet.clock.get_fps()
The value returned is more useful than simply taking the reciprocal of dt from a period function, as it is averaged over a sliding window of several frames.
Displaying the frame rate¶
A simple way to profile your application performance is to display the frame rate while it is running. Printing it to the console is not ideal as this will have a severe impact on performance. pyglet provides the ClockDisplay class for displaying the frame rate with very little effort:
fps_display = pyglet.clock.ClockDisplay()
@window.event
def on_draw():
window.clear()
fps_display.draw()
By default the frame rate will be drawn in the bottom-right corner of the window in a semi-translucent large font. See the ClockDisplay documentation for details on how to customise this, or even display another clock value (such as the current time) altogether.
User-defined clocks¶
The default clock used by pyglet uses the system clock to determine the time (i.e., time.time()). Separate clocks can be created, however, allowing you to use another time source. This can be useful for implementing a separate “game time” to the real-world time, or for synchronising to a network time source or a sound device.
Each of the clock functions are aliases for the methods on a global instance of clock.Clock. You can construct or subclass your own Clock, which can then maintain its own schedule and framerate calculation. See the class documentation for more details.


Solver tests
3 = 3
3 != 4
1 + 1 = 2
2 - 1 = 1
4 - 1 != 2
4 :2 != 0.5
8 : 2 != 0.5
2 * 2 = 4
2 * 8 != 14
(1 + 1) * 10 = 20
1 + 1 * 10 != 20
x + 1 = x + 1
x + 3 != x + 1
Construction tests
Build a formula that evaluates to two.
Build a formula that evaluates to two.
Build a formula that evaluates to two.


{% extends 'base/base.html' %} {% load staticfiles %} {% load i18n %} {% block title %} The LINGUIST List {% endblock %} {% block content %}
{% trans 'Password reset successful.' %}
{% blocktrans trimmed %} We've emailed you instructions for setting your password. You should be receiving them shortly. {% endblocktrans %}
{% blocktrans trimmed %} If you don't receive an email, please make sure you've entered the address you registered with, and check your spam folder. {% endblocktrans %}


{% extends "transformation-base.html" %} {% block content %} {% load modelview_tags %} {% include "transformation/snippets/title_snippet.html" with format='RDB' %} {% for hidden in form.hidden_fields %} {{ hidden }} {% endfor %}
In this last step, you can either store your freshly forged RDF data in the LinDA Workbench data sources or download an RDF dump of it.
Please enter a name for your publication:
Please enter a name for your transformation:


General
Say me pls
(5)
Old Hexus Throw back Wednesday
(2)
How to crack Obfuscated scripts
(2)
[REL] Roblox granny (SCRIPTS) (UPDATED)
(14)
Stop pushing the developers
(
2
)
(35)
Does Hexus Bypass Roblox's Check?!
(7)
Did roblox kill
(2)
I know this is a dumb question but
(
2
)
(24)
Becoming staff strictly to update
(14)
Questions, questions, questions, and me being impatient
(3)
Vehicle Simulator Script
(13)
Im moving to somewhere Far
(16)
(Q) What kinda scripts do you want
(
2
)
(21)
Does HEXUS have a virus?
(16)
[REQ] The streets 2 script please
(2)
(REL) Script hub in progress
(2)
Does anyone know any alternatives for dex explorer?
(7)
Discord link or website?
(2)
MyACCOUNT GOT HACKED NAME IS Hexus123
(
2
)
(23)
Y invaild login
(5)
Rules
(2)
Discord is up now
(4)
Question about purchase Hexus
(3)
I cant log onto to hexus
(4)
Can i purchase Hexus right now?
(6)
Proto?
(4)
(Important) Non Buyers & Buyers
(8)
Discord is down
(5)
Sorry for being dumb but how do i inject the scripts into roblox games?
(3)
Really Op PF script
(2)
← previous page
next page →


--- layout: default title: Queenslayer Creations --- {% for post in site.posts limit:4 %} {% include post-snippit.html %} {% unless forloop.last %}


A starter project for Laravel & Angular using Angular Material.
Laravel Angular Material Starter
Get Started
&
Laravel
{{vm.laravel_description}}
<?php
class PostsController {
public function get()
{
$posts = App\Post::get();
return response()->success(compact('posts'));
}
}
Angular
{{vm.angular_description}}
function LandingController(API) {
var getPosts = function(){
API.all('posts').get().then(function(response){
this.posts = response.data;
});
}
Laravel Angular Material Starter
Laravel Angular Material Starter provides you with many features required when working with Laravel & Angular. Such as Json Web Token authentication, Angular generators and many more..
List of features coming soon..


Loading the CodeScoop Demo...
Almost there! Now launching the tool...
This can take a few seconds, or a minute. Hang tight!
Sorry, the CodeScoop demo is not supported for your browser.
Please download a recent version of Chrome, Firefox, or Safari and try again.


--- layout: post status: publish published: true title: Cubs-Padres (4/18-4/20) Series Recap author: display_name: Andy login: Andy email<EMAIL_ADDRESS>url: '' author_login: Andy author_email<EMAIL_ADDRESS>wordpress_id: 5088 wordpress_url: http://ivyenvy.com/?p=5088 date: '2011-04-22 13:45:18 +0000' date_gmt: '2011-04-22 18:45:18 +0000' categories: - Ivy Envy - Offense - Relief Pitching - Starting Pitching - The Cubs - Series Recap tags: - Alfonso Soriano - Carlos Zambrano - Reed Johnson - Ryan Dempster - Ted Lilly - WCIU - Aaron Miles - Tyler Colvin - Bronson Arroyo - Aaron Harang - James Russell comments: - id: 3317 author: Ryan author_email<EMAIL_ADDRESS>author_url: '' date: '2011-04-22 17:51:58 +0000' date_gmt: '2011-04-22 22:51:58 +0000' content: "Russell's ERA can't be good. He's taken a beating so far.\r\n\r\nMeehan" - id: 3318 author: Ryan author_email<EMAIL_ADDRESS>author_url: '' date: '2011-04-22 17:54:48 +0000' date_gmt: '2011-04-22 22:54:48 +0000' content: "Yeah it's 8 point. The only guy worse is Grabow with 8.1 and that's because he's been so distracted by Andy yelling at him about how awesome he is. \r\n\r\nMeehan" ---
The Cubs entered the series 7-8 and ended the series 9-9.
The Padres entered the series 7-8 and ended the series 8-10.
Monday, April 18th--Cubs 1, Padres 0 (10 innings)
This game was broadcast on WCIU. Listening to the game on the radio was fine, but it would've been cool to watch Zambrano's 10-strikeout performance live. I had to settle for the video highlights the next day. Despite the frigid temperature at Wrigley (34 degrees + 12 mph wind at game time), Zambrano went deep into this game, pitching eight strong innings. However, the Cubs offense was unable to take advantage of Z's start--Padres' starter Tim Stauffer blanked them through seven innings of work. It took ten innings and a pinch-hit double by Tyler Colvin to win this game. We have been bagging on Colvin a lot lately, so it was nice to actually see him get a clutch hit for once.
Tuesday, April 19th--PPD due to ridiculous weather.
Wednesday, April 20th--Game 1: Cubs 2, Padres 1 (11 innings); Game 2: Padres 5, Cubs 4
Tuesday's gelid weather forced a Wednesday double header, and unfortunately, the weather wasn't that much better on Wednesday. I tuned into game one just in time to see Reed Johnson hit his walk-off homer. Johnson later talked about the Padres' Gregerson being basically a two-pitch pitcher, and he correctly predicted a slider with a 1-1 count. This guy is a smart, hard-playing player who is hard not to like. Take a look at the replay and watch him fly out of the box after he hits this ball. The video is also worth watching for the commentators' reactions; Brenly lets out a Santo-esque shout. Also, at about 25 seconds in, look for Samardzija's amazing celebratory ballet-kick. The other good news from this game is that Garza finally had a strong outing. He pitched six scoreless innings and struck out nine.
Game two didn't go as well for the Cubs. It had already been a long day, and the Cubs were looking for James Russell to pitch as deep into the game as possible. Unfortunately, Russell gave up four earned runs and only pitched four innings. Former Bronson Arroyo groupie, Aaron Harang, pitched well for the Dads Club. He earned the win to get to 4-0 on the season. He also loves to eat bamboo.
Soriano hit a two-run homer late in the game to make it close, but the Cubs just couldn't finish the rally.
Up Next
The Dodgers Carnival rolls into Chicago for a three-game series with the Cubs. We here at Ivy Envy are really looking forward to Saturday's Dempster-Lilly matchup, but Kurt said he is more interested in seeing Aaron Miles back in Chicago. Hopefully Ted Lilly's next paycheck doesn't bounce. We might have to pass a hat around for him at the next live event.


|
RL-Bin
2.0.0
Robust Low-overhead Binary Rewriter
|
Go to the source code of this file.
Functions | |
| LONG WINAPI | RLBinExceptionHandler (PEXCEPTION_POINTERS p) |
| DEFAULT_VISIBILTY void | StartRLBin () |
| This function initalizes core modules based on mode of operation. More... | |
| DEFAULT_VISIBILTY void | FinalizeRLBin () |
| This function finializes and gets report from core modules based on mode of operation. More... | |
| DEFAULT_VISIBILTY void FinalizeRLBin | ( | ) |
| LONG WINAPI RLBinExceptionHandler | ( | PEXCEPTION_POINTERS | p | ) |
| DEFAULT_VISIBILTY void StartRLBin | ( | ) |


This module is implemented in PHP and runs on Apache httpd. See Micro Moves blog series for details. It introduced this module in Part 8.


_TextBoxMixin (dijit and mobile) non-robot tests
dijit
mobile
DOM attr
Widget attr
Events
Programmatic


Home
Travels
Music
(current)
Music
These are my current top 3 playlists that I am listening to, perhaps you will enjoy them too:


Important note: this program is doing what it promises but the programming itself is of very poor quality and for demonstration purposes only. Never ever use this program as source for your own programs because there are a lot of conversions to get it run.
Get more information about this program on
my webpage JSON web signature JWS with algorithm PS256 [RSA with RSASSA-PSS + MGF1 with SHA-256 padding and SHA-256 hashing]
Insert the Public Key you received (PEM encoding):
Enter the token to verify (in Base64Url encoding):
Instructions:
1.: insert the received public key
2.: insert the JWT/JWS token in Base64Url encoding
3.: press the "Import key" button
4.: if the public key is valid the "Verify" button is enabled
5.: press the "Verify button"
6.: receive the verification status
7.: to see the decoded header, payload or expiration data press the named buttons
verification status:
To show header, payload or expiration check press the following buttons:
Technical note: this program uses the RSA signature algorithm with a 2048 bit long key and SSA-PSS signature padding.


--- layout: post title: Next meet up; Tuesday 5th July 7pm alias: /next-meet-up-tuesday-5th-july-7pm published: true ---
Hello! A huge thanks to Steve for running the last iprug, I hear it went down extremely well.
For the next month's it's been generally decided by a whole 3 of us, we'd like to try something new, so we'll be trying the Ruby Golf that LRUG did recently and seemed to go down a storm. So, come along with your laptops to the brewery tap on the 5th July and we'll do some hacking! You'll need;
UPDATE:
So to get this running on your laptop (In case of internet connection issues);
[code] git clone git://github.com/andrewmcdonough/rubygolf.git cd rubygolf rvm use ruby-1.8.7 bundle install rake [/code]
And this should have you up and running!
Other things you might want are;
Ruby documentation download