Chapter 2 Component construction
2.1 Trim Line
To build the trimline, you will need ~2500mm of Amsteel Blue (use only the gray color), ~80mm x 105m of insignia cloth (dark colors are better), two 18mm x 3mm nickel-plated neodymium disc magnets, one Small Stopper Ball Blue 5/32" ID (R1905 at APS Limited), and one Medium Stopper Ball Green 1/4" ID (R1994 at APS Limited).
Cut a segment of gray 4mm Amsteel Blue to a length of 2430mm with a fresh razor blade to get a clean cut. Cut a strip of sailmaker’s insignia cloth according to the dimensions shown in Figure 2.1 below to wrap the magnets.
Cut a segment of round, 0.95" diameter weed-whacker cord 150mm long to wrap around the magnets and up the trip line. Heat the middle of the plastic cord with a low flame, bend it 180 degrees around the 18mm curve of one of the disc magnets and cool it under tap water. Dry the plastic and magnet so they are ready to be glued. Taper the last 15mm of the tips of the plastic cord so it can fit more closely against the trim line. The taper should be on the interior faces of the plastic cord.
Cut a strip of insignia cloth 20mm x 90mm to use as wrap and threading end on one end of the trim line.
Using the 4mm Amsteel as the foundation of the trimline, pick out 4 strands from one end of line pulling one strand at each of 5, 10, 15, and 20mm to form a tapered end. Cut each strand off with a razor blade. Wrap the last 30mm of that end of the trim line with the 20 x 90mm insignia cloth wrapping the 20mm dimension tightly around the Amsteel. 60mm of the cloth will extend past the end of the line. Fold this portion of the cloth on itself as you wrap to form a long, narrow, flat strip.
To form the other end of the trimline, place 55mm of the unfinished end of the Amsteel on the tapered end of the magnet wrap. In your hand, place two 18mm x 3mm disc magnets edge-to-edge and align the polarity. Carefully place the pair of magnets edge-to-edge at the tip of the Amsteel aligning the long axis of the magnets with the axis of the Amsteel. The result should look like Figure 2.2.
Place the curve of the plastic cord closely around magnets. The tapered ends of the plastic cord should fit closely around the trim line.
Fold the cloth around magnets and trim line. The folds should be parallel to the trim line axis. The cloth must lay flat over the magnets. Because the trim line is narrower than the magnets, a crease will form where the magnets meet the trim line. This crease must not be on the magnets. Make sure the crease is above the magnets. Pinch the cloth closed below the magnets.
Stitch the magnet-wrap to the Amsteel so the cloth won’t creep in use. Use a triple zig-zag stitch and dark thread to secure the warp. The attractive force of the magnets is so high, it can make the trim difficult to work in a sewing machine. To reduce this effect, cut two small rectangles of cardboard from a cereal box and place them under the magnets. The increased distance between the magnets and the steel of the sewing machine should make the forces manageable. Be careful to not hit the magnets or the plastic cord with the sewing needle lest bad things happen.
Tie an overhand knot at the point where the magnet wrap meets the Amsteel. The knot should be just barely above the plastic cord buried inside the magnet wrap.
Thread a 25mm ball onto the trimline, recessed side first. Slide it all the way to the knot next to the magnet wrap. Mark the trimline 65mm above the top of the green ball. Tie and overhand knot in the trimline just above that knot. Now thread a 12mm ball onto the trim line and slide it all the way to the knot. The finished product can be seen in Figure 2.3
2.2 Cleat Jacket
The Aero Cleat requires a jacket of magnetic stainless steel sheet to create a tether point for the trimline tail. Make a template from the image in Figure 2.4, trace the pattern onto a sheet of 0.025" thick 430 stainless steel sheet. You can also make your own template by placing the metal portion of the cleat into a piece of cardboard and tracing its outline on 3 sides or just trace it directly onto the metal. Cut the shape from the metal sheet, drill out the two holes with a 5/32" bit and ease all the edges with a metal file. Most of these edges will be on grippable surfaces, so do a good job of easing them.
Disassemble the cleat and reassemble it with metal sheet between the two sections of the cleat. Bend the metal sheet around the metal portion of the Aero Cleat. To do this, clamp one side of the jacket in a vise. Use a block of wood and a mallet to fold the other side against metal side of the cleat. Flip the cleat over to expose the unfolded wing of the jacket and clamp the cleat in the vise. Again, use the block of wood and a mallet to fold the remaining wing. Remove the cleat from the vise, lay it flat on a table top and use the block and mallet to crease the folds.
2.3 Separation block and low friction ring
The juncture of the flying lines and the trim line is managed by an assembly of a plastic block known as the separation block and a low friction ring connected via a spliced length of 7/64" Amsteel.
To build the assembly, you will need 295mm of 7/64" Amsteel Blue (preferably gray), two 20mm x 65mm rectangles of insignia cloth, one FR5 Tylaska Rigging Ring Ferrule or similar, and one Separation Block release 1.4.2.
Pick out 4 strands from one end of Amsteel pulling out one strand at each of 5, 10, 15, and 20mm to form a tapered end. Cut each strand off with a razor blade. Wrap that end of theAmsteel with a rectangle of insignia cloth. Wrap the 20mm dimension around the line with 30mm on the line and 35mm off. The result should look Figure 2.5
Measure 95mm from the tip of the tapered line. Pierce the line at 95mm and start a brummel splice at the mark. Place the low-friction ring inside the loop. Pull the loop tight around the ring. Run a wire fid from a point 20mm from the opposite end of the line. Pop the fid out of the line at the ring. Use the wire fid to pull the tapered end inside. When you pull the end of the tapered end out, peel off the extra insignia cloth before you bury it. Use the second piece of insignia cloth to put a threading end on the finished piece. The result should have the dimension in Figure 2.6. It should look like the picture in Figure 2.7
Thread the resulting line-ring assembly through the center bore of the separation block. Tie an overhand knot in the Amsteel taking out as much slack as possible. The completed assembly is show in Figure 2.8
2.4 Flag line
The flag line allows the kite to be flagged out via one of the top lines. It bridges the distance from the flying line at the underside of the separation block and the underside of the kite bar. The line is about 1400 of 1/16" Ultrex 12 that jackets about 400mm of 2mm bungie. A short loop is incorporated into each end. This design allows the flag line to stay taught whether the bar is trimmed in or out. The Ultrex jacket can handle the loads experienced during release to assure a clean flag-out without damage to flag line. The dimensions for the flag line are tightly constrained by the need to maintain line tension throughout the trim range. They can be calculated using a copy of the Google Sheet kite bar elastic flag line length calculations (http://tinyurl.com/y4k5chgv)
To build the flag line, cut 1370mm of 1/16" Ultrex 12. Mark each end at 45mm, 65mm, 85mm, and 140mm. The 65mm will be the end of the loop while the 45mm and 85mm marks will align at the bottom of the loop. Make a brummel splice at one end to secure that loop. At other end, form the first loop of the brummel splice before splicing a line segment of about 40mm into the flag line between the 45mm and 85mm marks. Complete the brummel splice, and cut the ends off the short added segment and bury the remainder.
Unspool a meter of 2mm bungie and add a threading end of insignia cloth to the free end (use a 8mm x 40mm rectangle of cloth) . Measure 390mm from the back-end of the thread end and mark this point with a strip of insignia cloth. Route a very long fid inside the flag line from the near end of one loop to the near end of the other. The fid should occupy the entire length of the otherwise unoccupied flag line. Pull the 2mm bungie through the jacket and out the opposite end until only the thread end cloth is visible. Clamp this end with a spring clip. Align the strip of insignia cloth with the other entry-point into the flag line jacket. Clamp this end with the other spring clip.
Put the flag line under tension and start milking the jacket back and forth to evenly distribute the jacket and bungie. Use a 2m long stick and some cord to place the flag line under continuous tension. Continuing milking the jacket back and forth until it stops elongating. Retension the flag line and milk it again. With the flag line still stretched and the bungie still constrained by spring clips, sew the length of the flag line from spliced loop to spliced loop, back stitching at each end and on the ends of the bungie. Use a straight stitch.
Remove the spring clips and cut off the bungie that protrudes from the jacket. The bungie must be fully hidden inside the jacket to assure smooth operation.
To the lower end of the flag–the end that has not been fattened–affix a quick-release tether. The tether will require one 2" cotter pin, 40mm of 1/2" OD vinyl tubing, 200mm of 1/16" Ultrex 12, ~100mm of 2mm bungee, and the end of the handle from a plastic bucket.
Cut the end off the bucket handle and round it to form two parallel disks connected at their centers. You are creating the yellow object in the picture below. Cross drill through the vinyl tubing about 5mm from the end with a 1/16" bit. Cut the cotter pin down to 40mm and round the end on coarse stone. splice the 200mm of Ultrex to form a line with a loop on each end. One these line will need to accept the bucket handle end, so size it appropriately.
Larkshead the cotter pin and Ultrex line to the end of the flag line. Thread the 2mm bungie through the holes in the vinyl and the larkshead. Tie off each end of the bungie with an overhand knot to retain it. Leave a 5mm tail on each end. Tie off the second side of the bungie, cut it and apply cyanoacrylate glue to prevent fraying. Pull the Ultrex line down through the vinyl and slide the bucket handle end into the the loop. A finished assembly–albeit with PVC in place of the vinyl–is shown in 2.9
2.5 Stub line
The non-flagging flying line needs to be terminated at the underside of the separation block in the same manner as the flying line that does flag. This is accomplished with a short loop called the stub line. To match the upper end of the flag line, the stub line is made from 300mm of 1/16" Ultrex 12.
Mark the 300mm line segment 130mm from one end. Use a wire fid to splice the 130mm segment inside the 170mm segment that remains. The resulting segment will be about 155mm long. The segment is mostly double thickness with about 30mm of single thickness line on the end. Apply cyanoacrylate glue to the unfinished end. Fold the 155mm segment in half and tie an overhand knot to form a small loop. The finished product is about 50mm long.
2.6 Bar End Loops
The kite bar requires a loop on each end to affix the steering lines. These loops require two 350mm segments of 1/16" Ultrex 12. To make them fold each loop in half and tie an over hand knot at the end with about 10mm of tail. The length of these two lines must match. To acheive this, hook the loop ends around a rounded component on a bench vise. Gently pinch the line with an adjustable wrench on the loop side of the knots. Use the wrench to pull the knots evenly while you pull the ends with standard pliers. With the knot complete and the lines equal in length, put little cyanoacrylate glue on the line ends to prevent fraying. See the detail diagram in Figure 2.10.
2.7 Steering Lines
The steering lines run from the bar end loops to the ends of the back lines. They require two 1140mm segments of 1/16" Ultrex 12. Mark each segment at 110, 190, 270, and 410mm. Use these marks to create a brummel splice with an 80mm loop.
With the loops complete, stretch the pair of lines evenly and mark both lines at about 25mm from the non-loop end. Tie and overhand knot in each line at the mark. Gently pinch the line with an adjustable wrench on the loop side of the knots. Use the wrench to pull the knots evenly while you pull the ends with standard pliers. With the knot complete and the lines equal in length, put little cyanoacrylate glue on the line ends to prevent fraying. See the construction details in Figure 2.11.


A prime number p is called a Panaitopol prime if for some positive integersx and y.
Find how many Panaitopol primes are less than 51015.


STOCK_VIEW
About
Contact
Home
Top Gainers
Top Losers
Most Active
SYMBOL
CLOSE
CHANGE |
(change %)
SECTOR |
INDUSTRY
EXCHANGE
{% block content %}{% endblock content %}


Gecode::Branching Class Reference
[Programming actors]
Inherits Gecode::Actor.
Inherited by BlackHoleBranch [private]
, Gecode::Int::Branch::Assign, Gecode::ViewValBranching< View, Val, ViewSel, ValSel >, and QueenArmies::QueenBranch [private]
.
Detailed Description
Base-class for branchings.Note that branchings cannot be created inside a propagator (no idea why one would like to that anyway). If you do that the system will explode in a truly interesting way.
Definition at line 553 of file core.icc.
Branching | |
| virtual bool | status (const Space *home) const =0 |
| Check status of branching, return true if alternatives left. | |
| virtual const BranchingDesc * | description (const Space *home) const =0 |
| Return branching description. | |
| virtual ExecStatus | commit (Space *home, const BranchingDesc *d, unsigned int a)=0 |
| Commit for branching description d and alternative a. | |
Protected Member Functions | |
| Branching (Space *home, bool fd=false) | |
| Constructor for creation, force disposal if fd is true. | |
| Branching (Space *home, bool share, Branching &b) | |
| Constructor for cloning b. |
Constructor & Destructor Documentation
|
|
Constructor for creation, force disposal if fd is true.
|
|
|
Constructor for cloning b.
|
Member Function Documentation
|
|
Check status of branching, return true if alternatives left. This method is called when Space::status is called, it determines whether to continue branching with this branching or move on to the (possibly) next branching. Implemented in BlackHoleBranch, QueenArmies::QueenBranch, Gecode::Int::Branch::Assign, and Gecode::ViewValBranching< View, Val, ViewSel, ValSel >. |
|
|
Return branching description. Note that this method can rely on the fact that it is called immediately after a previous call to status. Hence, it is safe to remember computation from status in order to speed up description. Implemented in BlackHoleBranch, QueenArmies::QueenBranch, Gecode::Int::Branch::AssignMin, Gecode::Int::Branch::AssignMed, Gecode::Int::Branch::AssignMax, and Gecode::ViewValBranching< View, Val, ViewSel, ValSel >. |
|
|
Commit for branching description d and alternative a. The current branching in the space home performs a commit from the information provided by the branching description d and the alternative a. Implemented in BlackHoleBranch, QueenArmies::QueenBranch, Gecode::Int::Branch::Assign, and Gecode::ViewValBranching< View, Val, ViewSel, ValSel >. |
The documentation for this class was generated from the following file:
- gecode/kernel/core.icc (Revision: 3787)


Streaming ¶
Contents
- The -re flag
- Setting
- Latency
- CPU usage / File size
- Streaming a simple RTP audio stream from FFmpeg
- Codecs
- HTTP Live Streaming and Streaming with multiple bitrates
- Saving a file and Streaming at the same time
- Transcoding / repeating
- Adjusting bitrate based on line conditions
- Troubleshooting Streaming
- Point to point streaming
- External links
FFmpeg can basically stream through one of two ways: It either streams to a some "other server", which re-streams for it to multiple clients, or it can stream via UDP/TCP directly to some single destination receiver, or alternatively directly to a multicast destination. Theoretically you might be able to send to multiple receivers via Creating Multiple Outputs? but there is no built-in full blown server.
Servers which can receive from FFmpeg (to restream to multiple clients) include ffserver (linux only, though with cygwin it might work on windows), or Wowza Media Server, or Flash Media Server, Red5, or various others. Even VLC can pick up the stream from ffmpeg, then redistribute it, acting as a server. Since FFmpeg is at times more efficient than VLC at doing the raw encoding, this can be a useful option compared to doing both transcoding and streaming in VLC. Nginx also has an rtmp redistribution plugin, as does apache etc. and there is probably more out there for apache, etc.. You can also live stream to online redistribution servers like own3d.tv or justin.tv (for instance streaming your desktop). Also any rtmp server will most likely work to receive streams from FFmpeg (these typically require you to setup a running instance on a server).
The -re flag ¶
The FFmpeg's "-re" flag means to "Read input at native frame rate. Mainly used to simulate a grab device." i.e. if you wanted to stream a video file, then you would want to use this, otherwise it might stream it too fast (it attempts to stream at line speed by default). My guess is you typically don't want to use this flag when streaming from a live device, ever.
Setting ¶
Here is what another person once did for broadcast:
ffmpeg -f dshow -i video="Virtual-Camera" -preset ultrafast -vcodec libx264 -tune zerolatency -b 900k -f mpegts udp://<IP_ADDRESS>:1234
And here is what another person did:
ffmpeg -f dshow -i video="screen-capture-recorder":audio="Stereo Mix (IDT High Definition" \ -vcodec libx264 -preset ultrafast -tune zerolatency -r 10 -async 1 -acodec libmp3lame -ab 24k -ar 22050 -bsf:v h264_mp4toannexb \ -maxrate 750k -bufsize 3000k -f mpegts udp://<IP_ADDRESS>:48550
NB that they also (for directshow devices) had to adjust the rtbufsize in that example.
You can see a description of what some of these means, (for example bufsize, bitrate settings) in the Encode/H.264.
Here's how one guy broadcast a live stream (in this instance a Capture/Desktop#Windows? screen capture device):
$ ffmpeg -y -loglevel warning -f dshow -i video="screen-capture-recorder" -vf crop=690:388:136:0 -r 30 -s 962x388 -threads 2 -vcodec libx264 -vpre baseline -vpre my_ffpreset -f flv rtmp:///live/myStream.sdp
with a custom FFmpeg preset (libx264-my_ffpreset.ffpreset) in this case:
coder=1 flags2=+wpred+dct8x8 level=31 maxrate=1200000 bufsize=200000 wpredp=0 g=60 refs=1 subq=3 trellis=0 bf=0 rc_lookahead=0
Here is how you stream to twitch.tv or similar services (rtmp protocol), using ffmpeg 1.0 or ffmpeg-git (tested on 2012-11-12), this is also for pulseaudio users: Example 1, no sound:
ffmpeg -f x11grab -s 1920x1200 -framerate 15 -i :0.0 -c:v libx264 -preset fast -pix_fmt yuv420p -s 1280x800 -threads 0 -f flv "rtmp://live.twitch.tv/app/live_********_******************************"
Example 2, first screen (on dual screen setup, or if on a single screen):
ffmpeg -f x11grab -s 1920x1200 -framerate 15 -i :0.0 -f pulse -ac 2 -i default -c:v libx264 -preset fast -pix_fmt yuv420p -s 1280x800 -c:a aac -b:a 160k -ar 44100 -threads 0 -f flv "rtmp://live.twitch.tv/app/live_********_******************************"
Example 3, second screen (on dual screen setup):
ffmpeg -f x11grab -s 1920x1200 -framerate 15 -i :0.0+1920,0 -f pulse -ac 2 -i default -c:v libx264 -preset fast -pix_fmt yuv420p -s 1280x800 -c:a aac -b:a 160k -ar 44100 -threads 0 -f flv "rtmp://live.twitch.tv/app/live_********_******************************"
Latency ¶
You may be able to decrease initial "startup" latency by specifing that I-frames come "more frequently" (or basically always, in the case of x264's zerolatency setting), though this can increase frame size and decrease quality, see here for some more background. Basically for typical x264 streams, it inserts an I-frame every 250 frames. This means that new clients that connect to the stream may have to wait up to 250 frames before they can start receiving the stream (or start with old data). So increasing I-frame frequency (makes the stream larger, but might decrease latency). For real time captures you can also decrease latency of audio in windows dshow by using the dshow audio_buffer_size setting. You can also decrease latency by tuning any broadcast server you are using to minimize latency, and finally by tuning the client that receives the stream to not "cache" any incoming data, which, if it does, increases latency.
Sometimes audio codecs also introduce some latency of their own. You may be able to get less latency by using speex, for example, or opus, in place of libmp3lame.
You will also want to try and decrease latency at the server side, for instance wowza hints.
Also setting -probesize and -analyzeduration to low values may help your stream start up more quickly (it uses these to scan for "streams" in certain muxers, like ts, where some can appears "later", and also to estimate the duration, which, for live streams, the latter you don't need anyway). This should be unneeded by dshow input.
Reducing cacheing at the client side can help, too, for instance mplayer has a "-nocache" option, other players may similarly has some type of pre-playback buffering that is occurring. (The reality is mplayers -benchmark option has much more effect).
Using an encoder that encodes more quickly (or possibly even raw format?) might reduce latency.
You might get less latency by using one of the "point to point" protocols described in this document, at well. You'd lose the benefit of having a server, of course.
NB that a client when it initially starts up may have to wait until the next i-frame to be able to start receiving the stream (ex: if receiving UDP), so the GOP setting (-g) i-frame interval will have an effect on how quickly they can start streaming (i.e. they must receive an i-frame before they start). Setting it to a lower number means it will use more bandwidth, but clients will be able to connect more quickly (the default for x264 is 250--so for 30 fps that means an i-frame only once every 10 seconds or so). So it's a tradeoff if you adjust it. This does not affect actual latency (just connection time) since the client can still display frames very quickly after and once it has received its first i-frame. Also if you're using a lossy transport, like UDP, then an i-frame represents "the next change it will have to repair the stream" if there are problems from packet loss.
You can also (if capturing from a live source) increase frame rate to decrease latency (which affects throughput and also i-frame frequency, of course). This obvious sends packets more frequently, so (with 5 fps, you introduce at least a 0.2s latency, with 10 fps 0.1s latency) but it also helps clients to fill their internal buffers, etc. more quickly.
Note also that using dshow's "rtbufsize" has the unfortunate side effect of sometimes allowing frames to "buffer" while it is waiting on encoding of previous frames, or waiting for them to be sent over the wire. This means that if you use a higher value at all, it can cause/introduce added latency if it ever gets used (but if used, can be helpful for other aspects, like transmitting more frames overall consistently etc. so YMMV). Almost certainly if you set a very large value for this, and then see the "buffer XX% full! dropping!" message, you are introducing latency.
There is also apparently an option -fflags nobuffer which might possibly help, usually for receiving streams reduce latency.
mpv udp://<IP_ADDRESS>:2000 --no-cache --untimed --no-demuxer-thread --video-sync=audio --vd-lavc-threads=1
may be useful.
Testing latency ¶
By default, ffplay (as a receiver for testing latency) introduces significant latency of its own, so if you use it for testing (see troubleshooting section) it may not reflect latency accurately. FFplay introduces some video artifacts, also, see notes for it in "troubleshooting streaming" section Also some settings mentioned above like "probesize" might help it start more quickly. Also useful:
ffplay -probesize 32 -sync ext INPUT
(the sync part tells it to try and stay realtime).
Useful is mplayer with its -benchmark for testing latency (-noaudio and/or -nocache *might* be useful, though I haven't found -nocache to provide any latency benefit it might work for you).
Using the SDL out option while using FFmpeg to receive the stream might also help to view frames with less client side latency: "ffmpeg ... -f sdl <input_here> "window title"" (this works especially well with -fflags nobuffer, though in my tests is still barely more latency than using mplayer -benchmark always). This doesn't have a "drop frames if you run out of cpu" option so it can get quite far behind at times (introduce more latency variably).
Another possibly useful receiving client is "omxplayer -live"
See also "Point to point streaming" section esp. if you use UDP etc.
See also ¶
Here is a list of some other ideas to try (using VBR may help, etc.)
CPU usage / File size ¶
In general, the more CPU you use to compress, the better the output image will be, or the smaller of a file the output will be for the same quality.
Basically, the easiest way to save cpu is to decrease the input frame rate/size, or decrease the output frame rate/size.
Also you could (if capturing from live source), instruct the live source to feed a "smaller stream" (ex: webcam stream 640x480 instead of 1024x1280), or you could set a lower output "output quality" setting (q level), or specify a lower output desired bitrate (see Encode/H.264 for a background). Or try a different output codec, or specify new parameters to your codec (for instance, a different profile or preset for libx264). Specifying $ -threads 0 instructs the encoder to use all available cpu cores, which is the default. You could also resize the input first, before transcoding it, so it's not as large. Applying a smoothing filter like hqdn3d before encoding might help it compress better, yielding smaller files.
You can also set a lower output frame rate to of course decrease cpu usage.
If you're able to live capture in a pixel format that matches your output format (ex: yuv420p output from a webcam, instead of mjpeg), that might help with cpu usage, since it avoids an extra conversion. Using 64-bit instead of 32-bit executables (for those that have that choice) can result in a slight speedup. If you're able to use -vcodec copy that, of course, uses the least cpu of all options since it just sends the frames verbatim to the output.
Sometimes you can change the "pixel formats" somehow, like using rgb16 instead of rgb24, to save time/space (or yuv420 instead of yuv444 or the like, since 420 stores less information it may compress better and use less bandwidth). This may not affect latency.
Streaming a simple RTP audio stream from FFmpeg ¶
FFmpeg can stream a single stream using the RTP protocol. In order to avoid buffering problems on the other hand, the streaming should be done through the -re option, which means that the stream will be streamed in real-time (i.e. it slows it down to simulate a live streaming source.
For example the following command will generate a signal, and will stream it to the port 1234 on localhost:
ffmpeg -re -f lavfi -i aevalsrc="sin(400*2*PI*t)" -ar 8000 -f mulaw -f rtp rtp://<IP_ADDRESS>:1234
To play the stream with ffplay (which has some caveats, see above), run the command:
ffplay rtp://<IP_ADDRESS>:1234
Note that rtp by default uses UDP, which, for large streams, can cause packet loss. See the "point to point" section in this document for hints if this ever happens to you.
Codecs ¶
The most popular streaming codec is probably libx264, though if you're streaming to a device which requires a "crippled" baseline h264 implementation, you can use the x264 "baseline" profile. Some have have argued that the mp4 video codec is better than x264 baseline, because it encodes about as well with less cpu. You may be able to use other codecs, like mpeg2video, or really any other video codec you want, typically, as long as your receiver can decode it, if it suits your needs.
Also note that encoding it to the x264 "baseline" is basically a "compatibility mode" for older iOS devices or the like, see here.
The mpeg4 video codec sometimes also comes "within a few percentage" of the compression of x264 "normal settings", but uses much less cpu to do the encoding. See http://ffmpeg.zeranoe.com/forum/viewtopic.php?f=7&t=631&hilit=mpeg4+libx264+cores&start=10#p2163 for some graphs (which may be slightly outdated). Basically in that particular test it was 54 fps to 58 fps (libx264 faster), and libx264 file was 5.1MB and mpeg4 was 6MB, but mpeg4 used only half as much cpu for its computation, so take it with a grain of salt.
HTTP Live Streaming and Streaming with multiple bitrates ¶
FFmpeg supports splitting files (using "-f segment" for the output, see segment muxer) into time based chunks, useful for HTTP live streaming style file output.
How to stream with several different simultaneous bitrates is described here.
See also http://sonnati.wordpress.com/2012/07/02/ffmpeg-the-swiss-army-knife-of-internet-streaming-part-v
Saving a file and Streaming at the same time ¶
See Creating multiple outputs. Basically, you may only be able to accept from a webcam or some other source from at most one process, in this case you'll need to "split" your output if you want to save it and stream it simultaneously. Streaming and saving simultaneously (and only encoding once) can also save cpu.
Transcoding / repeating ¶
FFmpeg can also receive from "a source" (for instance live or UDP) and then transcode and re-broadcast the stream.
One mailing list user wrote this, quote:
In my application, I have a server running vlc sucking streams from some cameras, encoding them as MPEG2 streams and sending them to ports 5000 through 5003 on my intermediary server (I'll have to let someone else explain how to set that up, as that was someone else's part of the project). I have another server running Wowza, with an instance named "live". And I've got an intermediate server that sucks in MPEG2 streams coming in on ports 5000 to 5003, transcoding them into mp4 streams with H.264 and AAC codecs, and pushing the transcoded streams on to Wowza.
The command line I use to pull the stream from port 5000, transcode it, and push it is: ffmpeg -i 'udp://localhost:5000?fifo_size=1000000&overrun_nonfatal=1' -crf 30 -preset ultrafast -acodec aac -strict experimental -ar 44100 -ac 2 -b:a 96k -vcodec libx264 -r 25 -b:v 500k -f flv 'rtmp://<wowza server IP>/live/cam0'
-i 'udp://localhost:5000?fifo_size=1000000&overrun_nonfatal=1' tells ffmpeg where to pull the input stream from. The parts after the ? are probably not needed most of the time, but I did need it after all.
-crf 30 sets the Content Rate Factor. That's an x264 argument that tries to keep reasonably consistent video quality, while varying bitrate during more 'complicated' scenes, etc. A value of 30 allows somewhat lower quality and bit rate. See Encode/H.264.
-preset ultrafast as the name implies provides for the fastest possible encoding. If some tradeoff between quality and encode speed, go for the speed. This might be needed if you are going to be transcoding multiple streams on one machine.
-acodec aac sets the audio codec (internal AAC encoder)
-strict experimental allows use of some experimental codecs (the internal AAC encoder is experimental)
-ar 44100 set the audio sample rate
-ac 2 specifies two channels of audio
-b:a 96k sets the audio bit rate
-vcodec libx264 sets the video codec
-r 25 set the frame rate
-b:v 500k set the video bit rate
-f flv says to deliver the output stream in an flv wrapper
'rtmp://<wowza server IP>/live/cam0' is where the transcoded video stream gets pushed to
Adjusting bitrate based on line conditions ¶
FFmpeg doesn't (today) support varying the encoding bitrate based on fluctuating network conditions. It does support outputting in several "different" fixed bitrates, at the same time, however, see "Streaming with multiple bitrates" on this page, which is vaguely related. Also if you are during direct capture from directshow, the input device starts dropping frames when there is congestion, which somewhat simulates a variable outgoing bitrate.
Troubleshooting Streaming ¶
If you get a "black/blank" screen in the client, try sending it yuv422p or yuv420p type input. Some servers get confused if you send them yuv444 input (which is the default for libx264).
NB that when you are testing your stream settings, you may want to test them with both VLC and FFplay, as FFplay sometimes introduces its own artifacts when it is scaled (FFplay uses poor quality default scaling, which can be inaccurate). Don't use ffplay as your baseline for determining quality.
Point to point streaming ¶
If you want to stream "from one computer to another", you could start up a server on one, and then stream from FFmpeg to that server, then have the client connect to that server (server could either be on client or server side computers). Or you could do a point to point type stream, like:
ffmpeg -i INPUT -acodec libmp3lame -ar 11025 --f rtp rtp://host:port
where host is the receiving IP. Then receive the stream using VLC or ffmpeg from that port (since rtp uses UDP, the receiver can start up any time).
or
ffmpeg -i INPUT -f mpegts udp://host:port
If you run into packet loss (green frames, tearing/shearing--since UDP is not guaranteed delivery, this can occur) first make sure your FFmpeg is compiled with pthreads support enabled (if it is, then it uses a separate thread to receive from the UDP port, which can cause less packet loss). You can tell that it is by specifying a url like udp://host:post?fifo_size=10000 (if it accepts fifo_size, then you're good to go). Similarly, for mplayer, you can use mplayer ffmpeg://udp://host:port?fifo_size=XXX for possibly better results on the receiving end (mplayer needs a patch first, email<EMAIL_ADDRESS>for it, once was https://gist.githubusercontent.com/rdp/9075572/raw/002dc1b745c895693fdb160cc9be77ef31f75531/possible_mplayer_udp_fix.diff hackey work around patch, applied with ffmpeg subdir).
Alternatively, increase your buffer size, like mplayer ffmpeg://udp://host:port?buffer_size=10000000 (the default is system dependent and typically far too low for any reasonable buffering. On linux though you can only set it to like 200K max anyway, so this isn't good enough--make sure to use the circular buffer, and that the following works: ffmpeg://udp://host:port?buffer_size=10000000?fifo_size=100000 (the fifo_size should not emit a warning, and implies that you have a secondary thread that collects incoming packets for you if there is no warning).
Another option is to use some transmission type that uses TCP for your transport. (The RTMP protocol, popular in streaming to servers, uses TCP probably for this reason--you just can't use that for point to point streaming).
One option to use TCP is like this:
ffmpeg -i INPUT -f mpegts tcp://host:port
which I would guess will try and (as a client) establish a connection do that host on that port (assuming it has a server waiting for the incoming connection). You could receive it like this:
ffmpeg -i tcp://local_hostname:port?listen
(basically, one side needs to specify "listen" and the other needs to not to).
To use with mplayer as a receiver it would be like
ffmpeg -i ... -f mpegts "tcp://<IP_ADDRESS>:2000"
and on the mplayer side
mplayer ... ffmpeg://tcp://<IP_ADDRESS>:2000?listen
(start mplayer first)
Another option is to use RTP (which by default uses UDP) but by specifying it use TCP:
ffmpeg -i input -f rtsp -rtsp_transport tcp rtsp://localhost:8888/live.sdp
(For meanings of options see official documentation.
Then you may receive it like this (ffplay or ffmpeg):
ffplay -rtsp_flags listen rtsp://localhost:8888/live.sdp?tcp # ending "?tcp" may not be needed -- you will need to start the server up first, before the sending client
ffmpeg also has a "listen" option for rtmp so it may be able to receive a "straight" rtmp streams from a single client that way.
With tcp based streams you can probably use any formatting/muxer, but with udp you need to be careful and use a muxer that supports 'connecting anytime' like mpegts.
If you are forced to use udp (for instance you need to broadcast to a multicast port for whatever reason) then you may be able to avoid the packet loss by (sending less data or sending the same frames over and over again so they have a higher chance of being received).
See also the section on i-frames in #Latency.
Final working p2p client, with multicast:
server:
ffmpeg -f dshow -framerate 20 -i video=screen-capture-recorder -vf scale=1280:720 -vcodec libx264 -pix_fmt yuv420p -tune zerolatency -preset ultrafast -f mpegts udp://<IP_ADDRESS>:2000
client:
mplayer -demuxer +mpegts -framedrop -benchmark ffmpeg://udp://<IP_ADDRESS>:2000?fifo_size=100000&buffer_size=10000000 # (see note above about linux needing fifo_size as well as buffer_size).


|
UDK 3.2.7 Java API Reference | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface IEnvironment
The interface implemented by UNO environments.
With this interface, objects can be registered at and revoked from an environment.
IBridge
,
IQueryInterface
,
UnoRuntime
| Method Summary | |
|---|---|
Object |
getContext()
Deprecated. Gets the context of this environment. |
String |
getName()
Deprecated. Gets the name of this environment. |
Object |
getRegisteredInterface(String oid,
Type type)
Deprecated. Retrieves a registered object, specified by OID and UNO interface type. |
String |
getRegisteredObjectIdentifier(Object object)
Deprecated. Retrieves the OID for a registered object. |
void |
list()
Deprecated. Lists the registered objects to System.out . |
Object |
registerInterface(Object object,
String[] oid,
Type type)
Deprecated. Registers one UNO interface facet of an object. |
void |
revokeInterface(String oid,
Type type)
Deprecated. Explicitly revokes a UNO interface facet. |
| Method Detail |
|---|
Object getContext()
String getName()
Object registerInterface(Object object, String[] oid, Type type)
Such an object will typically be one of three things:
The object actually registered may differ from the specified
object
that is passed as an argument. This enables an
environment to work in a multi-threaded scenario, where two threads can
call registerInterface
for the same combination of
oid
and type
at the same time; the race
condition is solved by letting one of the calls register its argument
object
, ignoring the argument object
of the
other call, and letting both calls return the same
object
.
The registered object is held only weakly by the environment. After a
call to registerInterface
, a call to
getRegisteredInterface
only succeeds as long as the
registered object is still strongly reachable, and the registered object
has not been explicitly revoked by calling
revokeInterface
.
object
- the object to register; must be non-nulloid
- in-out parameter containing the OID of object
.
This must be a non-null reference to an array of length at least one;
the zeroth element is used to pass the argument in and out. If the
zeroth element is null on input, the OID will be computed and passed
out (that is, the zeroth element will never be null upon normal
return).type
- the UNO interface type to register. This argument must be
non-null, and must denote a UNO interface type. The given
object
should implement this type
.
object
passed in); will never be nullvoid revokeInterface(String oid, Type type)
Calls to registerInterface
and
revokeInterface
must be paired. A facet is only removed
from the environment when it has been revoked as often as it has been
registered. This may change in the future, so that a facet would be
removed upon the first call to revokeInterface
(and calls to
revokeInterface
would no longer be necessary if the calling
code does not want to control the temporal extent of the
registration).
It is not an error if the specified facet is not registered at this environment (either because no corresponding object has ever been registered, or it has been explicitly revoked, or it is no longer strongly reachable). In such a case, this method simply does nothing.
oid
- the OID of the object to revoke; must be non-nulltype
- the UNO interface type of the object to revoke. This
argument must be non-null, and must denote a UNO interface type.Object getRegisteredInterface(String oid, Type type)
oid
- the OID of the object to retrieve; must be non-nulltype
- the UNO interface type of the object to retrieve. This
argument must be non-null, and must denote a UNO interface type.
String getRegisteredObjectIdentifier(Object object)
object
- a registered object; must be non-null
object
; will never be nullvoid list()
System.out
.
This is for debug purposes.
|
UDK 3.2.7 Java API Reference | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


{{region.description}}
{{key}} : {{prop}}
This will delete the region and all its related data. Are you sure?


Art Team is in charge of the design of nearly everything in Magnify Wellness: from the social media posts, blog banners, merchandise, and more.
Hello! I’m Ella Kang, a grade 11 student in Canada. I’m passionate about everything related to STEM and I joined Magnify as a member of Art and Partnership teams. Through Magnify Wellness, I hope to bring impactful changes in society and contribute to promoting positive mental health for everyone!
Hi, I'm Saavi, a freshman in high school in Texas. I joined Magnify Wellness because their mission is amazing and I love to help others!
Hello, my name is Gretel Tassah and I’m a senior in high school from Minnesota. I write and create graphics for Magnify Wellness. In 2020, I was awarded the NCWIT Aspirations in Computing Award, Quest for Excellence New American Award, and named a QuestBridge National College Match Finalist. In my free time I enjoy spending time with friends/family and learning how to code :)
Emily Vo is a high school senior from South Florida. She enjoys watching foreign films, reading sci-fi novels, and learning about computer science. Emily is also passionate about environmental issues and combating climate injustice through STEM. In her free time, she also enjoys hiking and taking naps!
Mandy Lieng is currently a junior in high school and a member of Magnify’s Art Team. She is passionate about art and interested in pursuing a career in UI/UX design. In her free time, she loves to draw and create new playlists.
Rebecca Hong is currently a junior in high school from Fullerton and is part of Magnify’s Art Team. She is passionate about mental health support and hopes to pursue a study in psychology. In her free time, she enjoys discovering new music and growing her art skills.


To analyze data in a research notebook, create an instance of the QuantBook
class. QuantBook
is a wrapper on QCAlgorithm
, which means QuantBook
allows you to access all the methods available to QCAlgorithm
and some additional methods. The following table describes the helper methods of the QuantBook
class that aren't available in the QCAlgorithm
class:
| Method | Description |
|---|---|
| GetFundamental | Get fundamental data for some Symbol(s). |
| GetFutureHistory | Get the expiration, open interest, and price data of the contracts in a Futures chain. |
| GetOptionHistory | Get the strike, expiration, open interest, option right, and price data of the contracts in an Options chain. |
| Indicator | Get the values of an indicator for an asset over time. |
QuantBook gives you access to the vast amounts of data in the Dataset Market. Similar to backtesting, you can access that data using history calls. You can also create indicators, consolidate data, and access charting features. However, keep in mind that event-driven features available in backtesting, like universe selection and OnData events, are not available in research. After you analyze a dataset in the Research Environment, you can easily transfer the logic to the backtesting environment. For example, consider the following code in the Research Environment:
// Initialize QuantBook var qb = new QuantBook(); // Subscribe to SPY data with QuantBook var symbol = qb.AddEquity("SPY").Symbol; // Make history call with QuantBook var history = qb.History(symbol, TimeSpan.FromDays(10), Resolution.Daily);
# Initialize QuantBook qb = QuantBook() # Subscribe to SPY data with QuantBook symbol = qb.AddEquity("SPY").Symbol # Make history call with QuantBook history = qb.History(symbol, timedelta(days=10), Resolution.Daily)
To use the preceding code in a backtest, replace QuantBook()
new QuantBook()
with self
this
.
public override void Initialize() { // Set qb to instance of QCAlgorithm var qb = this; // Subscribe to SPY data with QCAlgorithm var symbol = qb.AddEquity("SPY").Symbol; // Make history call with QCAlgorithm var history = qb.History(symbol, TimeSpan.FromDays(10), Resolution.Daily); }
def Initialize(self) -> None: # Set qb to instance of QCAlgorithm qb = self # Subscribe to SPY data with QCAlgorithm symbol = qb.AddEquity("SPY").Symbol # Make history call with QCAlgorithm history = qb.History(symbol, timedelta(days=10), Resolution.Daily)


Candid snaps as panto celebrities start rehearsals in Nottingham ahead of opening night There's not long to go! 25 Nov 2019, 18:02 by Rachel Gorman The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post) The principle cast have arrived in the city today and will be doing rehearsals in College Street Centre before heading to the Theatre Royal for the technical rehearsals(Image: Nottingham Post)


MooTools is just the best JavaScript thing ever. And I say that totally subjectively because I honestly don’t have much experience with anything else other than jQuery. Some of the design decisions are nothing short of genius — custom events, element properties, and class mutators — to name a few.
The Binds mutator is particularly headache relieving. My only issue with it is that you need to list out all the methods you want bound, which somehow, I am very prone to jacking up due to forgetfulness or quick refactoring.

Class.Mutators.BindAll = function(self, bool) {
if (!bool) return self; // mutate or get out
var init = self.initialize; // save original, if there is one
var exclude = arguments.callee.exclude;
self.initialize = function() {
for (var method in this) {
if (typeof this[method] != ‘function’ || exclude.contains(method))
continue;
var unbound = this[method];
this[method] = unbound.bind(this);
this[method].parent = unbound.parent;
}
// if there was an original initialize, run it
return init ? init.apply(this, arguments) : this;
};
return self;
};
Class.Mutators.BindAll.exclude = [‘constructor’, ‘initialize’, ‘parent’];
With this, all methods get bound, and it’s this simple:
BindAll : true // or anything else truthy
So now, class methods can be passed around without fear of them forgetting who this
is:
$('flashing_red').addEvent('click', self.destruct);
This might not be for everyone, but for me, I can’t see why I wouldn’t want all my methods to be bound properly, and if I do run into that scenario, then I’d fall back to the regular Binds mutator. I also made the function name exclude list accessible to the programmer to add more if needed. Bugfixes will be made on the GitHub Gist.
Another class mutator that has gotten a fair bit of my attention is Privates, which has had many implementations, including Nathan White’s (deeply flawed), Thomas Dullnig’s (flawed), and Sean McCarthur’s (not flawed, but not pretty either). I’ve totally embarrassed myself in an email to Aaron Newton over the matter, essentially arguing the inclusion of Nathan White’s implementation into More before realizing that it was creating a bunch of global variables. Soon, I’ll write about my own implementation that I just made, as soon as I quadruple check that it isn’t flawed as well. That one will need specs!


Yeahhh Hey all . Hope you all are doing well & I wish GOd may bless you in this COVID-19 war.  I wish you all have been doing your work at home properly .This time we all learned a big lesson by this COVID-19 that lesson is that how animals feel when we Quanrantine them .Everyone has rights to live free & enjoy them life Freedomly.Stay Happy.


Require passcode
empty Immediately After 5 seconds After 15 seconds After 30 seconds After 1 minute After 2 minutes After 5 minutes After 10 minutes After 15 minutes After 30 minutes After 1 hour After 4 hours


1. Introduction
This section is non-normative.
Input events will be triggered by certain user interactions, in certain contexts, as well as via assistive technology interactions.
2. Use Cases
This section is non-normative.
2.1. Implementing an ARIA slider
TODO: Use case
3. Input Events
The [UIEVENTS] specification defines the InputEvent
type which is used by the beforeinput
and input
events.
3.1. Input event interfaces
The InputEvent
interface extends the Event
interface.
partial interface InputEvent :UIEvent {readonly attribute DOMString ?; };
inputType
- inputType
-
A
DataTransfer
object to hold data and meta data related to the event.
Note: The IDL for inputType
should be moved into [UIEVENTS] so that
it can be shared between this spec and the Input Events Level 2 spec.
3.2. Input Event Types
3.2.1. actionIncrement
An InputEvent
event with inputType
set to actionIncrement fires in
response to an input action that increments a control. For example, as a
result of a ArrowRight or ArrowUp key press.
This event type is valid for the following roles:
-
"progressbar"
-
"scrollbar"
-
"slider"
-
"spinbutton"
3.2.2. actionDecrement
An InputEvent
event with inputType
set to actionDecrement fires in
response to an input action that increments a control. For example, as a
result of a ArrowLeft or ArrowDown key press.
This event type is valid for the following roles:
-
"progressbar"
-
"scrollbar"
-
"slider"
-
"spinbutton"
3.2.3. actionDismiss
An InputEvent
event with inputType
set to actionDismiss fires when
a dialog or other dismissable ACTION element is closed.
This event type is valid for the following roles:
-
"menu"
-
"dialog"
-
"alertdialog"
3.2.4. actionScrollPageUp
An InputEvent
event with inputType
set to actionScrollPageUp fires
when user requests the current content to scroll up (or right) by a "page",
where a page of data is typically equal to one screen.
This type differs from actionIncrement in that it applies only to scrollable content.
This event type is intended for scrollable content, but is valid for all roles (since it can bubble up to the `body` element, which is scrollable).
3.2.5. actionScrollPageDown
An InputEvent
event with inputType
set to actionScrollPageDown fires
when user requests the current content to scroll down (or left) by a "page",
where a page of data is typically equal to one screen.
This type differs from actionDecrement in that it applies only to scrollable content.
This event type is intended for scrollable content, but is valid for all roles (since it can bubble up to the `body` element, which is scrollable).
4. Security Considerations
Not applicable. This specification simply adds new possible values for an
existing InputEvent
attribute.
5. Privacy Considerations
Not applicable. This specification defines new inputType
values that will be
sent for all users, not just those with accessibility features enabled.
6. Acknowledgements
This section is non-normative
We would like to acknowledge the contributions made by the following:
Dominic Mazzoni, Ian Pouncey,
James Craig, James Teh, Jeffrey Yasskin, and Léonie Watson.


the facade is supported weakly, by the remaining cocktail. and i attempt to dip in, less prepared than ever before, but with a hat to pull it together


Want to get in touch? Fill out the form below to send me a message and I will get back to you as soon as possible!
Prefer to call or text? You can reach me at the number below
510-301-2272


Most Subscribed Raids
Room
Subbed
Most Tweeted Raids (Last 60 Seconds)
Room
Tweeted
Max Stats Since Uptime (0 mins)
Max Processed Tweets
Max Connected


{{ story.by }}
{{ selectedStory.by }} Posted On {{ selectedStory.time | date }}
{{ selectedStory.text }}
This story did not have a description text. Please use the navigation link below to read the full version of this story.


origin
, to uniquely identify this repository among other remote repositories.
This is the same "name" that you use in your git remote
command. If left empty,
Jenkins will generate unique names for you.
You normally want to specify this when you have multiple remote repositories.


Adobe AIR Is a Game Changer, if People Would Build for It...
Spend five minutes talking to me about technology or business and you’ll quickly realize I’m a fan of Adobe AIR. Adobe has done a very good job building a cross-platform runtime, and providing tools that make the transition from the web to the desktop quite minimal.
First to elaborate why I like AIR. For one I’m a fan of web 2.0, the sites feel cleaner, smoother, and drive new capabilities. Versus most desktop applications that are starting to feel old, and much like 1990’s Java Applets do on the web. With Flex Builder, which is an IDE for developing for flash and/or AIR, I can develop a sweet website, but then quickly port it to the desktop while maintaining a rich web 2.0 feel.
Second, did I mention it’s cross-platform? Windows, OSX, Linux, the application in AIR will look/feel/function the same. So what? This could have been done other ways right? Well here is where I start to place my bets, no one else has really done anything in this area as well as Adobe so far. Also Adobe has made their long term strategy clear, they want to truly become a cross-platform runtime. If you’re thinking what other platforms right now, you’re not thinking large enough. They want AIR to support mobile phones, set-top boxes, likely even gaming consoles. This means I can look at one application on multiple mediums with an either identical look, of very similar one, with minimal development efforts. This allows a developer to then focus even further on improving functionality.
Finally, a bit of a rant. Adobe AIR does not have a true competitor, Silverlight is a competitor to flash (not AIR), Google Gears might be the closest thing to it. But, with regard to gears taking a website and making it available offline isn’t all AIR can do. AIR has local file access, local access to some devices, which when you’re still within a browser you can’t do. Oh, and one feature I personally just like is the auto-update ability of applications.
So….. If it’s so great, why haven’t you heard of it and why aren’t you using it? Well the single problem seems to be people building applications on it. I’ve seen very few applications that would appeal to mainstream users. I (being an avid fan of AIR and anything web 2.0), will typically use 2 AIR applications per day. One being twhirl, which I use as my primary twitter client. The other tends to vary by needs. However this is contrasted with about 20 applications that I work in over a given day. Most AIR applications thus far are simple, one-off fun applications. Perhaps to really make some penetration there should be some of the following:
- Financial/Stock tool that takes advantage of Adobe’s charting abilities
- Word Application
- Spreadsheet Editor
- Central social networking aggregator (Think one stop stop to view and update all web 2.0 networks)
- Email client


Introduction¶
This book is targeted at Mapbender3 developers and will cover useful topics not needed by administrators or users of Mapbender3 installations.
Things you should now¶
There are a couple of things you should be familiar with in order to contribute to Mapbender3:
- Object-Orientated PHP: We’re using PHP 5.3 which offers full object orientation. No simple scripts anymore.
- Symfony2: This is what we build upon. So read The Book and learn about controllers, templating and the other cool things.
- Docblock annotations: We use ApiGen to generate code documentation. More on this.
- JavaScript: We use jQuery a lot and especially the jQuery UI widget factory. These are essential to understand to write maintainable JavaScript code.
Installation¶
The installation procedure from Git is described in the chapter Git-based installation.


--- post_id: /my-music-collection-the-world date: 2007-03-07 12:16 return_url: '2007-03-07-my-music-collection-the-world.html' name: 'dinmamma' email<EMAIL_ADDRESS>comment: '
Vackert!


--- layout: page title: "404" permalink: /404 ---
It seems that the link you entered is incorrect, i really apologize
if you expected an important content here please contact me.


DISCLAIMER: This is a functional prototype of a graphical user interface
for QIIME 2. This software is to be considered an alpha version, and may
undergo drastic changes at any time. Not all features of QIIME 2 are
available at this time via the Studio --- please see q2cli for a
feature-complete interface.


THE PROBLEM
Yet another coin
Advertisements have always been a fundamentally weak proposition. They are intrusive, tangential, privacy invasive, and distract from the cleanliness of a website.
Making matters worse, creative content publishers are suffering due to the advent of ad blockers and a general disregard to what advertisements have to offer.


Thank you for stopping by to my personal website!
My name is Savvas Chanlaridis (pronounced Sáv-vas Han-la-ri-dis) and I am currently a PhD candidate at the Institute of Astrophysics - FORTH. My research interests are Theoretical Stellar Astrophysics, Pulsar Astronomy, and Nuclear Astrophysics, with a particular focus on nucleosynthesis in extreme astrophysical environments such as compact object mergers and core collapse supernovae.
Feel free to navigate through my website, learn a bit more about me or follow me on my social networks.
"We are the representatives of the cosmos; we are an example of what hydrogen atoms can do, given 15 billion years of cosmic evolution."
Carl Sagan
Since I can remember myself, I always had a soft spot for science and especially astronomy. At the age of 14, I bought my own Newtonian-type telescope and I started observing the night sky from the rooftop of my house. That was when I realized I wanted to study physics. At the age of eighteen, as a result of my success in the national terminal exams, I got accepted in the Physics Department of the Aristotle University of Thessaloniki. During the 4th year of my undergraduate studies, I decided to focus on Nuclear Physics due to some amazing professors that hooked my interest for the field.
After graduation I joined the Bonn-Cologne Graduate School in order to study Astrophysics. Over the next years I focused on Stellar Astrophysics working in the group of Prof. Dr. N. Langer at the Argelander Institute for Astronomy and in the "Fundamental Physics" group of the Max Planck Institute for Radio-Astronomy under the supervision of Dr. J. Antoniadis. Nowadays I'm studying the binary evolution of ultra-stripped helium stars towards core collapse, their viability as SNe-Ic progenitors, and their implications in the chemical enrichment of the Galactic halo, combining this way my passion for Nuclear Physics and Astronomy.
Beside my research, I also work as a tutor teaching entry-level University courses. My duties include preparation, one-on-one assistance, and evaluation of undergraduate students.
When not in my office, I enjoy most of my time being outdoors. In the winter, I usually try to explore different locations in order to practice my photography skills and/or stargaze using my 8-inch Dobsonian telescope. During the warmer months, I try to find some free time to visit my home country -Greece- where I enjoy mountain biking, free camping, and free climbing. Moreover, I try to participate and contribute in many outreach activities or science communication initiatives (Athens/Thessaloniki Science Festival, talks and lectures, organizing night-sky observations for the public etc).
When I choose to spend my spare time indoors, I enjoy playing the electric guitar/bass, coding, or studying philosophy & ethics. I have been practicing martial arts for over a decade and I'm a black belt holder in Taekwondo. Several injuries and an ACL surgery forced me to quit so I turned to another passion of mine; cooking. Finally, I try to explore the latest advancements in the front-end science world on a daily basis.
Working on the understanding of the mass spectrum of neutron stars.
Working as a guest researcher in the Laboratory of Astronomy of the Aristotle University of Thessaloniki.
Project: Probing the effects of stellar wind in non-accreting progenitors of SNe-Ia.
Master Thesis research under the supervision of Dr. J. Antoniadis and Prof. Dr. N. Langer.
physics601: Astronomical Observations with the Stockert 25-m Radio-Telescope.
Worked in the Stellar Astrophysics group under the supervision of Dr. J. Antoniadis and Prof. Dr. N. Langer.
Diploma Thesis research under the supervision of Dr. N. Servitzoglou and Prof. Dr. S. Stoulos.
Physics
Majored in : Nuclear & Elementary Particle Physics


© Crown Copyright
Your payment was cancelled. You have not been charged.
This was not a live transaction. No money has changed hands.
Thank you, your payment has been cancelled.
Merchant's reference:
0001350377259404c-tY8OoDNJkdHGr6FCgqkAw


Click on a theme name for a link to the file in revision control. Print preview this page to see how the themes work on the printed page.


WebTyping is a tool for creating type-based websites.  Feel the magic of OpenAI and GPT-3.
Fill a simple form in less than two minutes. Tell us about your company as if you were explaining it to your friend.
Just click send. Give us a few seconds. Our OpenAI and GPT-3 powered engine will create the best unique website for your product. It's gonna be amazing.
As easy as it seems. Share the result with everyone. You now have made your own site in less than your coffee.
Join WebTyping today. Decide your tier and start doing amazing things.
Typewriter mode
Try all the functionalities with TypeScript
Instant preview
Typewriter mode
Try all the functionalities with TypeScript
Instant preview
Track visitors
Build and publish webs
Typewriter mode
Try all the functionalities with TypeScript
Instant preview
Track visitors
Build and publish webs
99% SLA
Custom domain
WebTyping has changed the way I work, saving me time and focusing on what is really important
Web Developer, Freelancer
I couldn't believe that this was possible until I tried it. You should really hire the developers.
Product Manager, Cabify
This is just awesome. I seriously think it should win HackUPC 2021 and the TypeForm challenge.
Chief Information Officer, ZARA


{% extends 'home/base_home.html' %} {% block title %}Reset your Password {% endblock %} {% block content %}
Please enter your new password here.
The Password reset link is invalid or has expired, probably because it has already been used. Please request for a new password reset link.


{{ user | displayName }} {{ user.org.name }} {{ user.org.activity | toLabel:'orgActivity' }} {{ user.email }}
Buyer was interested in these Titles Export Analytics {{ title | maxLength:50 }} {{ release }} {{ countries | toLabel:'territories' }} {{ languages | toLabel:'languages' }} {{ pageView }} {{ inWishlist(wishlist) ? 'Yes' : '-' }} {{ promoElementOpened }} {{ screeningRequested }} {{ askingPriceRequested }}
Learn what Titles this particular Buyer viewed Genres Tendancy This Buyer was mostly interested in these Genres
Attended Screenings "0s" means the user watched less than a minute. Export Analytics to .CSV {{ title | maxLength: 50 }} {{ status | toLabel: 'invitationStatus' }} {{ mode | titlecase }} {{ requests }} {{ watchTime * 1000 | duration }} Watching Now


New user registerd
Settings updated
Event started
New twitter followers
See all Notafaction
Rasel ahmed Jan ,01 ,2018
Tamanna Jan ,15 ,2018
Shahin ahmed Feb ,01 ,2018
Account
Inbox
Settings
Logout
Material gives you scalable vector icons that can instantly be customized — size, color, drop shadow, and anything that can be done with the power of CSS.
For more info check out: http://Material.com/icons/


---
layout: post
title: CallManager Trace Decoding Tools
date: '2008-04-14T16:54:00.001-06:00'
author: Jay Swan
tags:
- debug
- ucm
- trace files
- callmanager
- ccm
modified_time: '2008-04-14T16:57:09.534-06:00'
blogger_id: tag:blogger.com,1999:blog-5029689981158113588.post-8525317067173356474
blogger_orig_url: http://unroutable.blogspot.com/2008/04/callmanager-trace-decoding-tools.html
---
Triple Combo looks to be a nice tool for decoding CCM/UCM trace files:
http://www.employees.org/~tiryaki/tc/
In the past I've also used TranslatorX, which is good but has some missing pieces:
http://www.employees.org/~pgiralt/TranslatorX/


| goog.Disposable | |
| goog.events.EventTarget | goog.Disposable |
| goog.ui.Component | goog.events.EventTarget |
| goog.ui.emoji.EmojiPicker | goog.ui.Component |
|
defaultImgUrl
:
Url of the img that should be used to fill up the cells in the emoji table, to prevent jittering. Should be the same size as the emoji.
|
|
opt_domHelper
: goog.dom.DomHelper=
Optional DOM helper.
|
|
addEmojiGroup(title, emojiGroup)
Adds a group of emoji to the picker.
|
code » | |||
|
adjustNumRowsIfNecessary_()
Adjusts the number of rows to be the maximum row count out of all the emoji
groups, in order to prevent jitter in switching among the tabs.
|
code » | |||
|
canDecorate(element)
⇒
EmojiPickers cannot be used to decorate pre-existing html, since the
structure they build is fairly complicated.
|
code » | |||
|
createDom()
No description.
|
code » | |||
|
createEmojiPage_(emoji, index)
⇒
Creates a page if it has not already been loaded. This has the side effects
of setting the load status of the page to true.
Arguments:
Returns:
the emoji page.
|
code » | |||
|
createPlaceholderEmojiPage_(emoji)
⇒
Creates an emoji page using placeholder emoji pointing to the default
img instead of the real emoji. Used for delayed loading.
Returns:
the emoji page.
|
code » | |||
|
disposeInternal()
No description.
|
code » | |||
|
enterDocument()
No description.
|
code » | |||
|
exitDocument()
No description.
|
code » | |||
|
getActivePage_()
⇒
No description.
Returns:
The active page of the emoji picker.
|
code » | |||
|
getCssClass()
⇒
No description.
Returns:
CSS class for the root element of EmojiPicker.
|
code » | |||
|
getNumColumns()
⇒
Gets the number of columns per grid in the emoji picker.
Returns:
number of columns per grid.
|
code » | |||
|
getNumEmojiGroups()
⇒
Returns the number of emoji groups in this picker.
Returns:
The number of emoji groups in this picker.
|
code » | |||
|
getNumRows()
⇒
Gets the number of rows per grid in the emoji picker.
Returns:
number of rows per grid.
|
code » | |||
|
getPage(index)
⇒
Returns a page from the picker. This should be considered protected, and is
ONLY FOR TESTING.
Arguments:
Returns:
the page at the specified index or null if none exists.
|
code » | |||
|
getPages()
⇒
Returns all the pages from the picker. This should be considered protected,
and is ONLY FOR TESTING.
Returns:
the pages in the picker or null if none exist.
|
code » | |||
|
Returns an array of emoji whose real URLs have been replaced with the
default img URL. Used for delayed loading.
|
code » | |||
|
getSelectedEmoji()
⇒
Returns the currently selected emoji from this picker. If the picker is
using the URL prefix optimization, allocates a new emoji object with the
full URL. This method is meant to be used by clients of the emojipicker,
e.g., in a listener on goog.ui.component.EventType.ACTION that wants to use
the just-selected emoji.
Returns:
The currently selected emoji from this picker.
|
code » | |||
|
getTabPane()
⇒
Returns the tabpane if this is a multipage picker. This should be considered
protected, and is ONLY FOR TESTING.
Returns:
the tabpane if it is a multipage picker, or null if it does not exist or is a single page picker.
|
code » | |||
|
isFocusable()
⇒
Returns true if the component is focusable, false otherwise. The default
is true. Focusable components always have a tab index and allocate a key
handler to handle keyboard events while focused.
Returns:
Whether the component is focusable.
|
code » | |||
|
loadImages()
No description.
|
code » | |||
|
loadPage_(index)
Loads a page into the picker if it has not yet been loaded.
Arguments:
|
code » | |||
|
manuallyLoadAnimatedEmoji()
No description.
|
code » | |||
|
onEmojiPaletteAction_(e)
Handles actions from the EmojiPalettes that this picker contains.
Arguments:
|
code » | |||
|
onPageChanged_(e)
Handles changes in the active page in the tabpane.
Arguments:
|
code » | |||
|
setAutoSizeByColumnCount(autoSize)
Sets whether to automatically size the emojipicker based on the number of
columns and the number of emoji in each group, so as to reduce jitter.
Arguments:
|
code » | |||
|
setDelayedLoad(shouldDelay)
Sets whether loading of images should be delayed until after dom creation.
Thus, this function must be called before #createDom. If set to true,
the client must call #loadImages when they wish the images to be
loaded.
Arguments:
|
code » | |||
|
setFocusable(focusable)
Sets whether the component is focusable. The default is true.
Focusable components always have a tab index and allocate a key handler to
handle keyboard events while focused.
Arguments:
|
code » | |||
|
setManualLoadOfAnimatedEmoji(manual)
Sets whether to require the caller to manually specify when to start loading
animated emoji. This is primarily for unittests to be able to test the
structure of the emojipicker palettes before and after the animated emoji
have been loaded. This only affects sprited emojipickers with sprite data
for animated emoji.
Arguments:
|
code » | |||
|
setNumColumns(numCols)
Sets the number of columns per grid in the emoji picker. This should only be
called before the picker has been rendered.
Arguments:
|
code » | |||
|
setNumRows(numRows)
Sets the number of rows per grid in the emoji picker. This should only be
called before the picker has been rendered.
Arguments:
|
code » | |||
|
setProgressiveRender(progressive)
Sets the progressive rendering aspect of this emojipicker. Must be called
before createDom to have an effect.
Arguments:
|
code » | |||
|
setTabLocation(tabLocation)
Sets the location of the tabs in relation to the emoji grids. This should
only be called before the picker has been rendered.
Arguments:
|
code » | |||
|
setUrlPrefix(urlPrefix)
Sets the URL prefix for the emoji URLs.
Arguments:
|
code » |
|
addChild(child, opt_render)
Adds the specified component as the last child of this component. See
goog.ui.Component#addChildAt for detailed semantics.
Arguments:
|
code » | ||||
|
addChildAt(child, index, opt_render)
Adds the specified component as a child of this component at the given
0-based index.
Both
addChild and addChildAt assume the following contract
between parent and child components:
parent.addChild(child) will throw an error if the
child component is already in the document, but the parent isn't.
Clients of this API may call addChild and addChildAt with
opt_render set to true. If opt_render is true, calling these
methods will automatically render the child component's element into the
parent component's element. However, parent.addChild(child, true)
will throw an error if:
Arguments:
|
code » | ||||
|
canDecorate(element)
⇒
Determines if a given element can be decorated by this type of component.
This method should be overridden by inheriting objects.
|
code » | ||||
|
createDom()
No description.
|
code » | ||||
|
decorate(element)
Decorates the element for the UI component.
Arguments:
|
code » | ||||
|
decorateInternal(element)
Actually decorates the element. Should be overridden by inheriting objects.
This method can assume there are checks to ensure the component has not
already been rendered have occurred and that enter document will be called
afterwards. This method is considered protected.
Arguments:
|
code » | ||||
|
disposeInternal()
Disposes of the component. Calls
exitDocument , which is expected to
remove event handlers and clean up the component. Propagates the call to
the component's children, if any. Removes the component's DOM from the
document unless it was decorated.
|
code » | ||||
|
enterDocument()
No description.
|
code » | ||||
|
exitDocument()
No description.
|
code » | ||||
|
forEachChild(f, opt_obj)
Calls the given function on each of this component's children in order. If
opt_obj is provided, it will be used as the 'this' object in the
function when called. The function should take two arguments: the child
component and its 0-based index. The return value is ignored.
Arguments:
|
code » | ||||
|
getChild(id)
⇒
Returns the child with the given ID, or null if no such child exists.
Arguments:
Returns:
The child with the given ID; null if none.
|
code » | ||||
|
getChildAt(index)
⇒
Returns the child at the given index, or null if the index is out of bounds.
Arguments:
Returns:
The child at the given index; null if none.
|
code » | ||||
|
getChildCount()
⇒
Returns the number of children of this component.
Returns:
The number of children.
|
code » | ||||
|
Returns an array containing the IDs of the children of this component, or an
empty array if the component has no children.
|
code » | ||||
|
getContentElement()
⇒
Returns the DOM element into which child components are to be rendered,
or null if the component itself hasn't been rendered yet. This default
implementation returns the component's root element. Subclasses with
complex DOM structures must override this method.
Returns:
Element to contain child elements (null if none).
|
code » | ||||
|
getDomHelper()
⇒
Returns the dom helper that is being used on this component.
Returns:
The dom helper used on this component.
|
code » | ||||
|
getElement()
⇒
Gets the component's element.
Returns:
The element for the component.
|
code » | ||||
|
getElementByFragment(idFragment)
⇒
Helper function for returning an element in the document with a unique id
generated using makeId().
|
code » | ||||
|
getFragmentFromId(id)
⇒
Helper function for returning the fragment portion of an id generated using
makeId().
|
code » | ||||
|
getHandler()
⇒
Returns the event handler for this component, lazily created the first time
this method is called.
Returns:
Event handler for this component.
|
code » | ||||
|
getId()
⇒
Gets the unique ID for the instance of this component. If the instance
doesn't already have an ID, generates one on the fly.
Returns:
Unique component ID.
|
code » | ||||
|
getModel()
⇒
*
Returns the model associated with the UI component.
Returns:
*
The model.
|
code » | ||||
|
getParent()
⇒
Returns the component's parent, if any.
Returns:
The parent component.
|
code » | ||||
|
hasChildren()
⇒
Returns true if the component has children.
Returns:
True if the component has children.
|
code » | ||||
|
indexOfChild(child)
⇒
Returns the 0-based index of the given child component, or -1 if no such
child is found.
Arguments:
Returns:
0-based index of the child component; -1 if not found.
|
code » | ||||
|
isInDocument()
⇒
Determines whether the component has been added to the document.
Returns:
TRUE if rendered. Otherwise, FALSE.
|
code » | ||||
|
isRightToLeft()
⇒
Returns true if the component is rendered right-to-left, false otherwise.
The first time this function is invoked, the right-to-left rendering property
is set if it has not been already.
Returns:
Whether the control is rendered right-to-left.
|
code » | ||||
|
makeId(idFragment)
⇒
Helper function for subclasses that gets a unique id for a given fragment,
this can be used by components to
generate unique string ids for DOM elements
|
code » | ||||
|
removeChild(child, opt_unrender)
⇒
Removes the given child from this component, and returns it. Throws an error
if the argument is invalid or if the specified child isn't found in the
parent component. The argument can either be a string (interpreted as the
ID of the child component to remove) or the child component itself.
If
opt_unrender is true, calls goog.ui.component#exitDocument
on the removed child, and subsequently detaches the child's DOM from the
document. Otherwise it is the caller's responsibility to clean up the child
component's DOM.
Arguments:
Returns:
The removed component, if any.
|
code » | ||||
|
removeChildAt(index, opt_unrender)
⇒
Removes the child at the given index from this component, and returns it.
Throws an error if the argument is out of bounds, or if the specified child
isn't found in the parent. See goog.ui.Component#removeChild for
detailed semantics.
Arguments:
Returns:
The removed component, if any.
|
code » | ||||
|
removeChildren(opt_unrender)
Removes every child component attached to this one.
Arguments:
|
code » | ||||
|
render(opt_parentElement)
Renders the component. If a parent element is supplied, it should already be
in the document and then the component's element will be appended to it. If
there is no optional parent element and the element doesn't have a parentNode
then it will be appended to the document body.
Throws an Error if the component is already rendered.
Arguments:
|
code » | ||||
|
renderBefore(siblingElement)
Renders the component before another element. The other element should be in
the document already.
Throws an Error if the component is already rendered.
Arguments:
|
code » | ||||
|
render_(opt_parentElement, opt_beforeElement)
Renders the component. If a parent element is supplied, it should already be
in the document and then the component's element will be appended to it. If
there is no optional parent element and the element doesn't have a parentNode
then it will be appended to the document body.
Throws an Error if the component is already rendered.
Arguments:
|
code » | ||||
|
setElementInternal(element)
Sets the component's root element to the given element. Considered
protected and final.
Arguments:
|
code » | ||||
|
setId(id)
Assigns an ID to this component instance. It is the caller's responsibility
to guarantee that the ID is unique. If the component is a child of a parent
component, then the parent component's child index is updated to reflect the
new ID; this may throw an error if the parent already has a child with an ID
that conflicts with the new ID.
Arguments:
|
code » | ||||
|
setModel(obj)
Sets the model associated with the UI component.
Arguments:
|
code » | ||||
|
setParent(parent)
Sets the parent of this component to use for event bubbling. Throws an error
if the component already has a parent or if an attempt is made to add a
component to itself as a child. Callers must use
removeChild
or removeChildAt to remove components from their containers before
calling this method.
Arguments:
|
code » | ||||
|
setParentEventTarget(parent)
Overrides goog.events.EventTarget#setParentEventTarget to throw an
error if the parent component is set, and the argument is not the parent.
Arguments:
|
code » | ||||
|
setRightToLeft(rightToLeft)
Set is right-to-left. This function should be used if the component needs
to know the rendering direction during dom creation (i.e. before
#enterDocument is called and is right-to-left is set).
Arguments:
|
code » | ||||
|
wasDecorated()
⇒
No description.
Returns:
Whether the component was decorated.
|
code » |
|
addEventListener(type, handler, opt_capture, opt_handlerScope)
Adds an event listener to the event target. The same handler can only be
added once per the type. Even if you add the same handler multiple times
using the same type then it will only be called once when the event is
dispatched.
Supported for legacy but use goog.events.listen(src, type, handler) instead.
Arguments:
|
code » | |||||
|
dispatchEvent(e)
⇒
Dispatches an event (or event like object) and calls all listeners
listening for events of this type. The type of the event is decided by the
type property on the event object.
If any of the listeners returns false OR calls preventDefault then this
function will return false. If one of the capture listeners calls
stopPropagation, then the bubble listeners won't fire.
Arguments:
Returns:
If anyone called preventDefault on the event object (or if any of the handlers returns false this will also return false.
|
code » | |||||
|
disposeInternal()
Unattach listeners from this object. Classes that extend EventTarget may
need to override this method in order to remove references to DOM Elements
and additional listeners, it should be something like this:
MyClass.prototype.disposeInternal = function() { MyClass.superClass_.disposeInternal.call(this); // Dispose logic for MyClass }; |
code » | |||||
|
getParentEventTarget()
⇒
Returns the parent of this event target to use for bubbling.
Returns:
The parent EventTarget or null if there is no parent.
|
code » | |||||
|
removeEventListener(type, handler, opt_capture, opt_handlerScope)
Removes an event listener from the event target. The handler must be the
same object as the one added. If the handler has not been added then
nothing is done.
Arguments:
|
code » | |||||
|
setParentEventTarget(parent)
Sets the parent of this event target to use for bubbling.
Arguments:
|
code » |
|
dispose()
No description.
|
code » | |
|
disposeInternal()
Deletes or nulls out any references to COM objects, DOM nodes, or other
disposable objects. Classes that extend
goog.Disposable should
override this method. For example:
mypackage.MyClass = function() { goog.Disposable.call(this); // Constructor logic specific to MyClass. ... }; goog.inherits(mypackage.MyClass, goog.Disposable); mypackage.MyClass.prototype.disposeInternal = function() { mypackage.MyClass.superClass_.disposeInternal.call(this); // Dispose logic specific to MyClass. ... }; |
code » | |
|
getDisposed()
⇒
No description.
Returns:
Whether the object has been disposed of.
|
code » | |
|
isDisposed()
⇒
No description.
Returns:
Whether the object has been disposed of.
|
code » |
|
activePage_
:
Index of the active page in the picker.
|
Code » | |
|
autoSizeByColumnCount_
:
Whether the number of rows in the picker should be automatically determined
by the specified number of columns so as to minimize/eliminate jitter when
switching between tabs.
|
Code » | |
|
delayedLoad_
:
If true, delay loading the images for the emojipalettes until after
construction. This gives a better user experience before the images are in
the cache, since other widgets waiting for construction of the emojipalettes
won't have to wait for all the images (which may be a substantial amount) to
load.
|
Code » | |
|
focusable_
:
Whether the component is focusable.
|
Code » | |
|
logger_
:
Logger for the emoji picker.
|
Code » | |
|
manualLoadOfAnimatedEmoji_
:
Whether to require the caller to manually specify when to start loading
animated emoji. This is primarily for unittests to be able to test the
structure of the emojipicker palettes before and after the animated emoji
have been loaded.
|
Code » | |
|
numCols_
:
Number of columns per grid of emoji.
|
Code » | |
|
numRows_
:
Number of rows per grid of emoji.
|
Code » | |
|
progressiveRender_
:
Whether to use progressive rendering in the emojipicker's palette, if using
sprited imgs. If true, then uses img tags, which most browsers render
progressively (i.e., as the data comes in). If false, then uses div tags
with the background-image, which some newer browsers render progressively
but older ones do not.
|
Code » |
|
childIndex_
:
Map of child component IDs to child components. Used for constant-time
random access to child components by ID. Lazily initialized on first use.
Must be kept in sync with
children_ . This property is strictly
private and must not be accessed directly outside of this class!
We use a plain Object, not a goog.structs.Map, for simplicity.
This means components can't have children with IDs such as 'constructor' or
'valueOf', but this shouldn't really be an issue in practice, and if it is,
we can always fix it later without changing the API.
|
Code » | |
|
children_
:
Array of child components. Lazily initialized on first use. Must be kept in
sync with
childIndex_ . This property is strictly private and must
not be accessed directly outside of this class!
|
Code » | |
|
dom_
:
DomHelper used to interact with the document, allowing components to be
created in a different window.
|
Code » | |
|
element_
:
The DOM element for the component.
|
Code » | |
|
idGenerator_
:
Generator for unique IDs.
|
Code » | |
|
id_
:
Unique ID of the component, lazily initialized in {@link
goog.ui.Component#getId} if needed. This property is strictly private and
must not be accessed directly outside of this class!
|
Code » | |
|
inDocument_
:
Whether the component is in the document.
|
Code » | |
|
parent_
:
Parent component to which events will be propagated. This property is
strictly private and must not be accessed directly outside of this class!
|
Code » | |
|
rightToLeft_
:
Whether the component is rendered right-to-left. Right-to-left is set
lazily when #isRightToLeft is called the first time, unless it has
been set by calling #setRightToLeft explicitly.
|
Code » | |
|
wasDecorated_
:
Flag used to keep track of whether a component decorated an already existing
element or whether it created the DOM itself. If an element was decorated
dispose will remove the node from the document, it is left up to the app.
|
Code » |


Instructions
| 1 | Hiding behind one of these doors is the ChoreBot. |
| 2 | Your mission is to open all of the doors without running into the ChoreBot. |
| 3 | If you manage to avoid the ChoreBot until you open the very last door, you win! |
| 4 | See if you can score a winning streak! |


Charli XCX strips to sheer lingerie for very raunchy Christmas campaign
The pop queen, 27, stripped down to lingerie for the very raunchy shoot, displaying her eye-popping toned bod for the Agent Provocateur Christmas campaign
by Brogan-Leigh HurstPop star Charli XCX has set pulses racing in incredibly saucy snaps posing in sheer lingerie for Agent Provocateur's Christmas campaign.
The songstress, 27, showed off her tiny display and toned tum in revealing pictures for the lingerie brand.
She was saddled up on a horse, leaving almost nothing to the imagination.
Charli - real name Charlotte - was pictured in several different lingerie sets in the jaw-dropping shoot.
In one snap, she's seen grabbing onto a cowboy hat while sitting on the horse, showing off her assets in a lace pink underwear set.
While in another she's spotted in a sexy red set paired with stockings.
She's not one to shy away from the camera - last night the star shared a sizzling swimsuit selfie to her Instagram page.
Charli is known to show off her stunning physique and she was back to her old tricks once again.
She rose to fame in 2013 with her chart-topping hit I Love It and the singer hasn't been afraid to express her larger-than-life persona through both her music and style.
Amid her busy work schedule, the star revealed she and Australian songwriter Troye Sivan used to enjoy some downtime by throwing huge house parties in LA.
On her wild days, the pop star told Dazed: "We went through this phase of just throwing like a f**k-load of parties.
"We would just leave the doors open, send out the biggest group texts, and so many people came. Like, the police would come, it was a real nightmare. Our neighbours hated us. All our cars got keyed."
*Charli XCX's Agent Provocateur Christmas range is available from November 11
Do you have a story to sell? Get in touch with us at<EMAIL_ADDRESS>or call us direct 0207 29 33033


Tag: Tags
algorithms
Oct 29, 2021
cluster
Oct 29, 2021
DBCAN
Oct 29, 2021
kmeans
Oct 29, 2021
ML
Oct 29, 2021
scratch
Oct 29, 2021
atuaria
Jul 18, 2021
modelagem
Jul 18, 2021
monte-carlo
Jul 18, 2021
simulacao
Jul 18, 2021
faxina
May 29, 2021
limpeza
May 29, 2021
purrr
May 29, 2021
webscraping
May 29, 2021
agendamento
May 22, 2021
csv
May 22, 2021
ETTJ
May 22, 2021
ggplot2
May 22, 2021
juros
May 22, 2021
SUSEP
Apr 30, 2021
visualizacao
Apr 30, 2021
API
Apr 29, 2021
Finance
Apr 29, 2021
R
Apr 29, 2021
Shiny
Apr 29, 2021
YahooFinance
Apr 29, 2021
Golem
Apr 28, 2021
IBGE
Apr 28, 2021
finanças
Apr 25, 2021
gif
Apr 25, 2021


[Luke Freeland] After officially starting my first “work” Lightning component, here are some tips learned so far when developing a lightning component. – Learn more at Metilllium
working code speaks
2017-05-28
2017-05-27
2017-05-23
[Robert Watson] Applications like Slack, Hipchat, and Google Hangouts are all different options that many companies use to promote sharing, collaboration, and transparency. But how do you stay connected to your overall community? – Learn more at Just Another Watson
2017-05-22
If you need to run the same Jenkins project with multiple sets of parameters, say to roll out an upgrade to a variety of client sites, here is a way to use a CSV to launch any number of sub-projects. –Learn more at LinkedIn.com
2017-05-17
[Josh Kaplan] Some of you are now saying some (or all) of the following:
“YESSSSSSSS!”
“Wait, why not me?”
“But I already had one, what now?”
“Salesforce DX rules! What about scratch orgs?”
“Great. How does this help ISVs?”
Allow me to address each of these. – Learn more at Salesforce Developers Blog
2017-05-16
[Kartik Viswanadha, David Green] Learn how you can customize Salesforce Community Cloud to fit your needs with the Lightning Bolt framework, Lightning Components and Community Builder in this Webinar by Salesforce Dev.
– Learn more at Salesforce Developers
2017-05-06
[Keir Bowden] Like a lot of other Salesforce developers I use Selenium from time to time to automatically test my Visualforce pages and Lightning Components. Now that I’m on the SalesforceDX pilot, I need to be able to use Selenium with scratch orgs. This presents a slight challenge, in that Selenium needs to open the browser and login to the scratch org rather than the sfdx cli. Wade Wegner’s post on using scratch orgs with the Salesforce Workbench detailed how to get set a scratch org password so I started down this route before realising that there’s a simpler way, based on the sfdx force:org:open command. – Learn more at Bob Buzzard
2017-04-29
[Keir Bowden] The Summer 17 release of Salesforce sees the activation of the Lightning Components Locker Service critical update - something that I’d say has been anticipated and feared in equal measure since it was announced. If you’ve been hiding under a rock for the last couple of years, the Locker Service (among other things) adds a security layer to your Lightning Components JavaScript, isolating components by namespace to ensure that your Evil Co-worker can’t write components can’t go tinkering with the standard Salesforce components for nefarious purposes. – Learn more at Bob Buzzard
2017-04-28
[Preeti Sharma] Do you want a way to perform smoke testing on new builds deployed in Test Environment? Start using Unified Modeling Language (UML) diagrams to make it easier. – Learn more at Appirio Tech Blog
2017-04-13
[Craig Ceremuga] Throughout the years NimbleUser has written a number of in-house authoritative guides and documents on the Apex programming language. While a good start, our previous guidelines were too complicated and opinionated on the types of things that were unenforceable / didn’t matter in the grand scheme of building good software. – Learn more at NimbleUser and the Apex Style Guide Site


Ex-cop wanted by police for attempted murder
Thirty-three-year-old Mowanda Pryce of Content district, Bog Walk in St Catherine, who is a former member of the Jamaica Constabulary Force has been listed as wanted.
The police say Pryce is wanted for attempted murder.
Pryce is being asked to turn himself in to the Inspectorate and Professional Oversight Bureau in St Andrew midday Thursday, November 14.
In addition, anyone knowing his whereabouts is asked to contact Crime Stop at 311, police 119 emergency number or the nearest police station.
Members of the public are being reminded that it is an offence to harbour wanted persons.


To get the latest development of Apache Clerezza, you can check out the Source Code and building Clerezza yourself:
svn co http://svn.apache.org/repos/asf/incubator/clerezza/
Additionally, the snapshots below are available for download. Click on the link and download the latest launcher from the list (file which ends with ".jar", e.g. org.apache.clerezza.platform.launcher.tdb-0.5-incubating-20110126.160353-161.jar).
All Clerezza builds are available in the Maven Repository and distributed under the terms of The Apache Software License (version 2.0).


Knowledge Graphs are gaining in popularity; their ability to merge and connect information from different domains has many applications. However, although the technology has been around for a while, it still does not present interfaces that are easy to use and understand. This workshop aims at bringing HCI and KG communities together to discuss how HCI methods could help identify and overcome the issues that keep Knowledge Graphs from better user interfaces.
Call for Participation
THE WORKSHOP IS CANCELED. WE APOLOGIZE FOR THE INCONVENIENCE.
Submission process
Please submit your paper through
easychair.org/cfp/hcikg2021
The template is ACM format, 4-6 pages (excluding references), do NOT
anonymise your submission.
Papers will be peer-reviewed by workshop organizers and other experts
on a program committee.
Those papers that align best with the goals of the workshop, or form
the best grounds for discussion will be selected for presentation.
At least one author must register for the workshop and one day of the conference, attend the workshop and provide a short presentation (practical information).
Important dates
-
First session (for authors would like to register as early bird)
- Paper deadline: February 15th 2021
- Notification: March 1st 2021
-
Second session
- Paper deadline: March 15th 2021
- Notification: April 1st 2021
- Workshop at CHI 2021: May 8th 2021
Topics
Topics of interest include, but are not limited to
- New needs and usages
- New interaction models and paradigms
- New interfaces and visualizations
- New applications
- New metrics and methodologies for evaluation
- Layers of abstraction, granularity of information
- Governance of information
- Privacy and security
- Uncertainty
- Exploratory search
- Interactive exploration
- Progressive visualization
- Data quality
- Ontology visualization