DVICOPY(1) Web2C 2012 DVICOPY(1) NAME dvicopy, odvicopy - produce modified copy of DVI file SYNOPSIS dvicopy [options] [infile[.dvi] [outfile[.dvi]]] DESCRIPTION This manual page is not meant to be exhaustive. The complete documenta‐ tion for this version of TeX can be found in the info file or manual Web2C: A TeX implementation. dvicopy reads a DVI file, expands any references to virtual fonts to base fonts, and writes the resulting DVI file. Thus you can use virtual fonts even if your DVI processor does not support them, by passing the docu‐ ments through dvicopy first. OPTIONS -magnification=NUMBER Override existing magnification with NUMBER. -max-pages=NUMBER Process NUMBER pages; default one million. -page-start=PAGE-SPEC Start at PAGE-SPEC, for example `2' or `5.*.-2'. SEE ALSO dviselect(1), dvitype(1). AUTHORS Peter Breitenlohner wrote the program. Klaus Guntermann originally ported it to Unix. 24 January 1999 TeX DVICOPY(1)


There is only one way to really understand harley-davidson. ride one
But you can buy a harley-davidson and that is kind of a same thing.
Copyright © Luka Milovanovic


Instructions on performance report
The following performance report presents the performance comparison data of MOSN 0.1.0 with envoy in terms of pure TCP forwarding for Bolt and HTTP1.x protocols, mainly including QPS, RTT, failure rate, success rate and other indicators.
It is significant to note the following optimizations in v0.1.0 which are intended to improve the forwarding performance of MOSN.
- For thread model, MOSN uses the worker goroutine pool to handle stream events, and uses two independent goroutines to handle read and write IO separately.
- For single-core forwarding, in the case of specifying
P=1
, MOSN binds CPU with cores to improve the call execution efficiency of the system and the locality affinity of cache. - For memory, in the case of binding single core, MOSN uses SLAB-style recycling mechanism to improve reuse and reduce memory copy.
- For IO, MOSN mainly implements optimization by controlling the read/write buffer size, read/write timing, read/write frequency and other parameters.
The performance test data is as follows:
TCP proxy performance data
For the same deployment mode, this report compares MOSN 0.1.0 and envoy for the upper-layer protocol Bolt (SOFARPC related protocol) and HTTP1.1 respectively.
Deployment mode
The pressure test is deployed in a pure proxy mode. The client process accesses the server process through the MOSN process and serves as a forwarding proxy. The client process, MOSN process, and server process run on the machines which belong to different network segments. The network delay of the direct access from the client to server is about 2.5ms.
Client
Bolt protocol (send 1K string)
The client that sends the Bolt protocol data uses the online pressure generators developed by Ant Financial and deploys the SOFARPC client.
On the pressure generator performance page, you can see the QPS, success/failure counts, RT and other parameters.
HTTP1.1 protocol (send 1K string)
Use ApacheBench/2.3. The test instructions are:
ab -n $RPC -c $CPC -p 1k.txt -T "text/plain" -k http://<IP_ADDRESS>:12200/tcp_bench > ab.log.$CPU_IDX &
Mesh machine specifications
The mesh runs in a container where the CPU is an exclusive logical core. The specifications are as follows:
| Category | Information |
|---|---|
| OS | 3.10.0-327.ali2008.alios7.x86_64 |
| CPU | Intel® Xeon® CPU E5-2650 v2 @ 2.60GHz X 1 |
Upstream machine specifications
| Category | Information |
|---|---|
| OS | 2.6.32-431.17.1.el6.FASTSOCKET |
| CPU | Intel® Xeon® CPU E5620 @ 2.40GHz X 16 |
Bolt protocol test result
Performance data
| Indicators | MOSN | Envoy |
|---|---|---|
| QPS | 103500 | 104000 |
| RT | 16.23ms | 15.88ms |
| MEM | 31m | 18m |
| CPU | 100% | 100% |
Conclusion
For single-core TCP forwarding, there is little difference between MOSN 0.1.0 and Envoy 1.7 in terms of performance in the condition with full load, such as QPS, RTT and success/failure counts. We will continue to optimize in the subsequent versions.
HTTP/1.1 test result
Since the HTTP/1.1 request response model is PING-PONG, QPS is positively correlated with the number of concurrences. The following tests are performed for different concurrence counts.
Concurrences - 20
| Indicators | MOSN | Envoy |
|---|---|---|
| QPS | 5600 | 5600 |
| RT (mean) | 3.549ms | 3.545ms |
| RT (P99) | 4ms | 4ms |
| RT (P98) | 4ms | 4ms |
| RT (P95) | 4ms | 4ms |
| MEM | 24m | 23m |
| CPU | 40% | 20% |
Concurrences - 40
| Indicators | MOSN | Envoy |
|---|---|---|
| QPS | 11150 | 11200 |
| RT (mean) | 3.583ms | 3.565ms |
| RT (P99) | 4ms | 4ms |
| RT (P98) | 4ms | 4ms |
| RT (P95) | 4ms | 4ms |
| MEM | 34m | 24m |
| CPU | 70% | 40% |
Concurrences - 200
| Indicators | MOSN | Envoy |
|---|---|---|
| QPS | 29670 | 38800 |
| RT (mean) | 5.715ms | 5.068ms |
| RT (P99) | 16ms | 7ms |
| RT (P98) | 13ms | 7ms |
| RT (P95) | 11ms | 6ms |
| MEM | 96m | 24m |
| CPU | 100% | 95% |
Concurrences - 220
| Indicators | MOSN | Envoy |
|---|---|---|
| QPS | 30367 | 41070 |
| RT (mean) | 8.201ms | 5.369ms |
| RT (P99) | 20ms | 9ms |
| RT (P98) | 19ms | 8ms |
| RT (P95) | 16ms | 8ms |
| MEM | 100m | 24m |
| CPU | 100% | 100% |
Conclusion
When the upper-layer protocol is HTTP/1.X., a certain gap exists between MOSN and Envoy in terms of performance.
The preliminary conclusion is that in the PING-PONG package delivery model, MOSN cannot merge the read/write system calls. In the scenario where SOFARPC can merge the calls, MOSN’s HTTP performance is weaker than that of Envoy because the syscall count significantly increases.
This problem will be optimized in version 0.2.0.
Appendix
Envoy version information
- version:1.7
- Tag:1ef23d481a4701ad4a414d1ef98036bd2ed322e7
Envoy TCP test configuration
static_resources:
listeners:
- address:
socket_address:
address: <IP_ADDRESS>
port_value: 12200
filter_chains:
- filters:
- name: envoy.tcp_proxy
config:
stat_prefix: ingress_tcp
cluster: sofa_server
clusters:
- name: sofa_server
connect_timeout: 0.25s
type: static
lb_policy: round_robin
hosts:
- socket_address:
address: <IP_ADDRESS>
port_value: 12222
- socket_address:
address: <IP_ADDRESS>
port_value: 12223
- socket_address:
address: <IP_ADDRESS>
port_value: 12224
- socket_address:
address: <IP_ADDRESS>
port_value: 12225
admin:
access_log_path: "/dev/null"
address:
socket_address:
address: <IP_ADDRESS>
port_value: 8001


| Directory Structure of /src: |
| com/hackingroomba/roombacomm |
Source directory of roombacomm library + applications |
| scripts |
scripts to run the applications, and obsolete scripts that
used to build the applications |
| processing-examples |
contains directories for the /roombaring, /roombatune &
/roombaview processing
apps. These apps are intended to be copied as-is into a processing
directory. (Processing is a graphic development environment - read
"Hacking Roomba" for more details.) |
| processing-examples/roombaview |
In addition to the processing application, contains
subdirectories which support the application. See fileDescriptions. |
| packaging |
???A directory containing RoombaCommTest.app and directories
which help a Mac build an app??? |


Gelman and Rubin (1992) Inference from iterative simulation using multiple sequences Statistical Science 7(4):457-472
Vrugt, Gupta, Bouten and Sorooshian (2003) A Shuffled Complex Evolution Metropolis algorithm for optimization and uncertainty assessment of hydrologic model parameters Water Resources Research 39(8):1201 doi:10.1029/2002WR001642
Vrugt, Gupta, Bastidas, Bouten and Sorooshian (2003) Effective and efficient algorithm for multiobjective optimization of hydrologic models Water Resources Research 39(8), 1214, doi:10.1029/2002WR001746


See: Description
| Package | Description |
|---|---|
| org.apache.jena.permissions |
JenaSecurity is a SecurityEvaluator interface and a set of dynamic proxies that apply that
interface to Jena Graphs, Models, and associated methods and classes.
|
| org.apache.jena.permissions.example | |
| org.apache.jena.permissions.graph |
Secured implementation of the Graph interface and associated classes.
|
| org.apache.jena.permissions.graph.impl | |
| org.apache.jena.permissions.impl | |
| org.apache.jena.permissions.model | |
| org.apache.jena.permissions.model.impl | |
| org.apache.jena.permissions.query | |
| org.apache.jena.permissions.query.rewriter | |
| org.apache.jena.permissions.utils |
JenaSecurity is a SecurityEvaluator interface and a set of dynamic proxies that apply that interface to Jena Graphs, Models, and associated methods and classes.
The SecurityEvaluator class must be implemented. This class provides
the interface to the authentication results (e.g.
getPrincipal()
) and the authorization system.
Factory.getInstance(
SecurityEvaluator, String, Graph );
Factory.getInstance(
SecurityEvaluator, String, Model )
ModelFactory.createModelForGraph(
SecuredGraph )
See Differences Between Graph and Model below for
reasons.
Graph
and
Model
The Graph interface does not have the concept of "update". Thus all
updates are implemented as a delete and an insert. The Model interface
does have the concept of update as evidenced by the
replace()
method in the
RDFList
class. This difference means that a
Model
created by calling
ModelFactory.createModelForGraph( SecuredGraph )
will yield a model that evaluates
Update
actions differently from one created with
Factory.getInstance( SecurityEvaluator, modelIRI, model)
.
Factory.getInsance()
method.
Licensed under the Apache License, Version 2.0


{% extends "tutorial.html" %} {% block headauthor %}Paul Irish{% endblock %} {% block credits %} * Credits: * - Paul Irish (author) {% endblock %} {% block headtitle %}Quick Guide to implement webfonts via @font-face{% endblock %} {% block pagetitle %}Quick Guide to Implement Webfonts via @font-face{% endblock %} {% block pagebreadcrumb %}Quick Guide to Implement Webfonts{% endblock %} {% block date %}August 2nd, 2010{% endblock %} {% block browsersupport %} Operasupported Internet Explorersupported Safarisupported Firefoxsupported Chromesupported {% endblock %} {% block html5badge %} {% endblock %} {% block iscompatible %} return Modernizr.fontface; {% endblock %} {% block head %} {% endblock %} {% block content %}
The @font-face feature from CSS3 allows us to use custom typefaces on the web in an accessible, manipulable, and scalable way. But, you might say, "Why would we use @font-face if we have Cufon, sIFR, and using text in images?"
A few benefits of leveraging @font-face for custom fonts:
line-height
, letter-spacing
, text-shadow
, text-align
, and selectors like ::first-letter
and ::first-line
At its most basic, we declare a new custom remote font to be used like so:
@font-face { font-family: 'Tagesschrift'; src: url('tagesschrift.ttf'); }
Then put it to use:
h1, h2, h3 { font-family: 'Tagesschrift', 'Georgia', serif; }
In this @font-face declaration we're using the font-family
property to explicitly name the font. It can be anything, regardless of what the font is actually called; font-family: 'SuperDuperComicSans';
would work out just fine, though perhaps not for your reputation. In the src
property we point to where the browser can find the font asset. Depending on the browser, some valid font types are eot, ttf, otf, svg, or a data URI embedding the entire font data inline.
| otf & ttf | svg | woff | eot | |
|---|---|---|---|---|
| IE | IE9 | IE9 | IE5+ | |
| Firefox | FF3.5 | FF3.5 | FF3.6 | |
| Chrome | Chrome 4 | Chrome 0.3 | Chrome 5 | |
| Safari | 3.1 | 3.1 | ||
| Opera | Opera 10.00 | Opera 9 | ||
| iOS | iOS 1 | |||
| Android | 2.2 |
Of course, nothing is ever as simple as it should be. The initial limitation of the above code was that it did not serve an EOT to IE 6-8. The bulletproof @font-face syntax proposed a way of solving this; a robust version follows.
@font-face { font-family: 'Tagesschrift'; src: url('tagesschrift.eot'); /* IE 5-8 */ src: local('☺'), /* sneakily trick IE */ url('tagesschrift.woff') format('woff'), /* FF 3.6, Chrome 5, IE9 */ url('tagesschrift.ttf') format('truetype'), /* Opera, Safari */ url('tagesschrift.svg#font') format('svg'); /* iOS */ }
Inducing a headache yet? If you'd rather just get this off the ground quickly, head to the Font Squirrel generator, a tool that simplifies the whole process for you, taking your font and preparing its variants and CSS for you. It's indispensable for putting webfonts into practice today.
Mobile Safari supports SVG webfonts as of iOS 3.1 and Android supports otf/ttf as of version 2.2. But should your mobile users get this enhanced typographic experience? I'd recommend no. The predominant reason is due to how WebKit handles text that is awaiting a custom font via @font-face: the text is invisible. So on a low-bandwidth mobile connection, your users will see no text at all until the ~50k of font data has loaded. The Webkit team is pursuing a solution of turning on a fallback font after a few seconds have expired, but until that has landed, I wouldn't consider it fair to subject your users to such roadblocks between them and your content.
A number of services wrap the @font-face feature in an easy API, oftentimes letting you add a single CSS or script line to your HTML and some configuration and you're all done. Many like WebInk, Typekit, and Fontslive will allow you to use the fonts (sometimes up to a bandwidth cap) for a monthly fee. Using these services is very convenient for the casual developer, handing off some of the complications of serving a cross-browser solution
The Google Font API lets you use a small, curated set of freely licensed fonts by just linking to a stylesheet and letting Google handle the cross-browser and performance concerns. It's the fastest way to get off the ground and running with webfonts.
A common surprise to designers is that just because you purchase a font license (to use in your graphic design, for example), that doesn't mean you can use it in @font-face. Licenses for @font-face (or web embedding) are typically sold separately. Read the agreement carefully, and feel free to contact the font foundry if you have questions.
Fontspring is a font boutique, selling hundreds of quality professional fonts, all of them cleared for use with @font-face. FontFont, and other foundries, have begun selling @font-face licenses directly, though currently only targeting WOFF and EOT, which leave out a sizable (but shrinking) portion of the browser market. Many foundries are adding webfont licenses to their catalog, but if you can't find one for your chosen typeface, get in touch with them to ask about it.
The Flash of Unstyled Text is a phenomenon in Firefox and Opera that few web designers are fond of. When you apply a custom typeface via @font-face, there is a brief moment, when loading the page, where the font hasn't been downloaded and applied yet, and the next font in the font-family
stack is used. This causes a flash of a different (typically less good looking) font, before it gets upgraded.
Accompanying the Google Font API is the WebFont Loader, a javascript library aiming to provide a number of event hooks giving you a lot of control over the loading. Let's take a look at how you can get other browsers to mimic WebKit's behavior of hiding the fallback text while the @font-face font loads.
<script src="//ajax.googleapis.com/ajax/libs/webfont/1/webfont.js"></script> <script> WebFont.load({ custom: { families: ['Tagesschrift'], urls: ['http://paulirish.com/tagesschrift.css'] } }); </script>
/* we want Tagesschrift to apply to all h2's */ .wf-loading h2 { visibility: hidden; } .wf-active h2, .wf-inactive h2 { visibility: visible; font-family: 'Tagesschrift', 'Georgia', serif; }
If JavaScript is disabled, the text will remain visible the whole time, and if the font errors somehow, it'll fall back to a basic serif safely. Consider this a stop-gap measure for now; most webfont experts desire hiding the fallback text for 2-5 seconds, then revealing it. Low-bandwidth and mobile devices benefit greatly by this timeout. Understandably, Mozilla is looking to rectify this soon.
A more lightweight but less effective solution is the font-size-adjust
property, currently only supported in Firefox. It gives you an opportunity to normalize x-height across a font-stack, reducing the amount of visible change in the FOUT. In fact, the Font Squirrel generator just added a feature where it tells you the x-height ratio of the fonts you upload, so you can accurately set the font-size-adjust
value.
Webfonts deliver quite a bit of freedom to designers and with upcoming features like discretionary ligatures and stylistic alternates, they will have a lot more flexibility. For now, you can feel confident implementing this part of CSS3 as it covers 98% of deployed browsers. Enjoy!
{% endblock %}


Fingerprint with drawing canvas
Fingerprint without drawing canvas, metadata only:
Fingerprint without drawing canvas, metadata only:


The "microservice" isn't the right word here. In fact, the Nest microservice is just an application which is using the different transport layer (not HTTP).
Nest supplies support for 2 types of communication - TCP and Redis pub/sub, but it's easy to bring the new transport strategy by implementing CustomTransportStrategy
interface.
To create a Nest microservice, we're using the NestFactory
imported from the @nestjs/core
package.
Let's create a simple microservice which will be listening to messages via TCP protocol. We're gonna start from the bootstrap()
function.
{{ bootstrap }}
Notice Transport
is a helper enum.
The second argument of the createMicroservice()
method is an options object. This object may have 3 members:
transport |
Specifies the transport method (Transport.TCP and Transport.REDIS are available out-of-the-box) |
port |
Determines the port to make use of |
url |
Determines the url to make use of *only for Redis | .
strategy |
Determines the strategy to make use of *only for Custom Strategy | .
The Nest microservice recognizes the messages via patterns. The pattern is a plain JavaScript value - object, string, or even number.
To create a pattern handler, we're using the @MessagePattern()
decorator imported from the @nestjs/microservices
package.
{{ mathController }}
{{ mathControllerJs }}
Notice We can register the pattern handlers only inside the @Controller()
class.
The above handler is listening to messages which fulfil the cmd: 'sum'
pattern.
Each pattern handler takes a single argument, the data
passed from the client.
In this case, the data is an array of numbers, which has to be accumulated.
Each pattern handler can be async
, so you're able to return the Promise
.
Moreover, you can return the RxJS Observable
, so the values would be emitted until the stream is completed.
{{ streaming }}
{{ streamingJs }}
Above message handler will respond 3 times (with each item from the array).
To connect with the Nest microservice, we're using the ClientProxy
class, which instance is assigned to the property by @Client()
decorator.
This decorator takes single argument - the same object as a Nest microservice options object.
{{ clientDecorator }}
Notice Both@Client()
decorator andClientProxy
class are imported from the@nestjs/microservices
package.
The ClientProxy
has a send()
method. This method is intended to call the microservice and returns the Observable
with its response.
{{ sendMethod }}
{{ sendMethodJs }}
It takes 2 arguments, the pattern
and data
. The pattern
has to be same as this declared in the @MessagePattern()
decorator.
That's all.


First check if the user is logged in. Then retrieves the user's favourites ids from Firebase.
Finally, retrieve the posts from WordPress by using the obtained ids.
Returns void
loadPostsForIds
loadPostsForIds(keys: any): void
Request real posts from WordPress by passing the ids.
Keep the Favourites in rows of 4.
Parameters
keys: any
Returns void
ngOnInit
ngOnInit(): void
Returns void
openPost
openPost(id: any, title: any, catId: any): void
Open the dialog that shows all the details of a Post.
This class has all the logic behind the Favourites page.


[Erowid Note: 'Bath salts', 'plant food' and similar products generally do not list ingredients or dosage on their packaging. Analysis has revealed that ingredients in a single product of this type may vary over time.]
I'll keep it short and to the point.  Could be placebo, as these were taken orally. I stand against a wall, feel it's cold hardness and start wishing it was furry. Tell wife and girlfriend, they try to hand me a sheep skin, oh so soft, but not vertical. I couldn't lay down.
(6:00pm Wed) Girlfriend starts puking. I'm feeling somewhat erotic. Wife and I go for a quick bit of fun. No sex for me, just some play for her. I wasn't horny at all.
(6:15pm Wed) As she climaxes, I get a sudden and horrid headache in the back of my head. I've had this headache once or twice before directly after sex, but never after NO sex.
(6:30pm Wed) Finally getting the pain to go away from my head, but my stomach gives way and I begin vomiting as well. Girlfriend is still puking non-stop.
(6:30pm - 12am Wed) We both puke every 15-20 minutes for this time period. Most of it is spent trying to put water down for the next puking session. Bile never comes up, dry heaving ensues. Feels like death.
(12am Thurs - 12am Fri) No sleep, no chance for sleep. We both beg for the ability to nap, but it isn't there. The entire day is spent begging for mercy from the feeling of having been poisoned.
The rest of the weekend was the same. It is now a week later. I have visited my doctor and diagnosed with constricted veins and high BP. Feel like my chest and head are exploding, and my body feels weak and tingly. This is an entire week later. I've never felt this way before.
Not sure what chemicals were in this. Still have 2 capsules available, and would submit for analysis to interested parties. Mainly, I am holding on to them in case something gets worse for either of us.

Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Team Profile
Michael
Role: Manager
ID: 1
<EMAIL_ADDRESS>Office Number:<PHONE_NUMBER>
Michael
Role: Engineer
ID: 2
<EMAIL_ADDRESS>GitHub:
mjh1985codeman
Susan
Role: Intern
ID: 3
<EMAIL_ADDRESS>School: Vandy


runes
`Prev `__
R
`Next `__
--------------
**runes**: pl.n.
1. Anything that requires `*heavy
wizardry* <../H/heavy-wizardry.html>`__ or `*black
art* <../B/black-art.html>`__ to `*parse* <../P/parse.html>`__: core
dumps, JCL commands, APL, or code in a language you haven't a clue how
to read. Not quite as bad as `*line noise* <../L/line-noise.html>`__,
but close. Compare `*casting the
runes* <../C/casting-the-runes.html>`__, `*Great
Runes* <../G/Great-Runes.html>`__.
2. Special display characters (for example, the high-half graphics on an
IBM PC).
3. [borderline techspeak] 16-bit characters from the Unicode
multilingual character set.
--------------
+-------------------------+----------------------------+--------------------------+
| `Prev `__ | `Up <../R.html>`__ | `Next `__ |
+-------------------------+----------------------------+--------------------------+
| rude | `Home <../index.html>`__ | runic |
+-------------------------+----------------------------+--------------------------+


{% extends 'spectator_events/base.html' %} {% load spectator_core spectator_events %} {% block head_page_title %}{{ event }}{% if event.venue %} at {{ event.venue_name }}{% endif %} on {% display_date event.date as event_date %}{{ event_date|striptags }}{% endblock %} {% block content_title %}{{ event.title_html }}{% endblock %} {% block breadcrumbs %} {{ block.super }}
{% if event.venue %}At {{ event.venue_name }} on{% else %}On{% endif %} {% display_date event.date %}.
{% if event.note %} {{ event.note|safe|linebreaks }} {% endif %} {% include 'spectator_events/includes/selections.html' with selection_list=event.get_movies heading="Movies" only %} {% include 'spectator_events/includes/selections.html' with selection_list=event.get_plays heading="Plays" only %} {% include 'spectator_events/includes/selections.html' with selection_list=event.get_classical_works heading="Classical works" only %} {% include 'spectator_events/includes/selections.html' with selection_list=event.get_dance_pieces heading="Dance pieces" only %} {% include 'spectator_events/includes/selections.html' with selection_list=event.get_exhibitions heading="Exhibitions" only %} {% include 'spectator_core/includes/roles_list.html' with roles=event.roles.all heading='Featuring' only %} {% endblock content %} {% block sidebar_nav %} {% change_object_link_card object perms %} {{ block.super }} {% endblock sidebar_nav %}


The Anchoring component of PSK Web Server is linked with the Brick Storage component as it allows the association of
a set of brick hashes to a unique
identifier called anchor
. As explained in the description of the
Brick Storage
component,
a brick is stored on the PSK Web Server in a file whose name is the cryptographic hash of its content. As the
data in a brick corresponds to a block
of data in a file, any change to that block of data will lead to the creation of a new brick. The Anchoring
component allows the grouping of
different bricks that correspond to different versions of the same block inside a file under the same anchor
.
Associates an anchor to a brick id.
/anchoring/attachHashToAlias/:fileId
POST
fileId = [alphanumeric]
Content-Type: text/plain
Content: anchor
Code: 200 OK
Content: None
Retrieves a list of hashes, corresponding to different versions of a file associated with an anchor.
/anchoring/getVersions/:anchor
GET
anchor = [alphanumeric]
None
Code: 200 OK
Content-Type: application/json
Content: brick hashes
Code: 404
Reason: The anchor does not exist.


--- layout: null section-type: about title: About ---
I'm a computer science graduate at University of Illinois, Springfield, with experience in data science and software engineering.
My coursework in computer science program has assisted me to gain profound knowledge in Data Science, Data Mining, Data Visualization, NoSQL and Database Administration. I have actively contributed to various academic and research pojects during my coursework. I'm always looking for opportunities to work with those who are willing to share their knowledge. My primary goal is to create something that is useful in the field of technology.


--- layout: post status: publish published: true title: Cool "Apple Premium Reseller - Studio A" In Taiwan, P.R.China author: Leask author_login: leask author_email<EMAIL_ADDRESS>author_url: https://leaskh.com wordpress_id: 340 wordpress_url: http://leaskh.wordpress.com/2007/06/04/cool-apple-premium-reseller-studio-a-in-taiwan-p-r-china date: '2007-06-04 03:51:03 +0800' date_gmt: '2007-06-04 03:51:03 +0800' categories: - Computers and Internet tags: [] comments: [] ---


This is a showcase app to display PayNow info encoded in a QR code. Please allow camera permission to scan.


This example searches for jQuery locally at ../node_modules/jquery/dist/jquery.min.js
, but
jQuery was not found there. Please eather install jQuery (via npm or manually)
or modify this HTML file and change the src attribute of the script tag loading jQuery
to specify a different local path or a CDN URL.
This example searches for jQuery.scrollTo locally at ../node_modules/jquery.scrollto/jquery.scrollTo.min.js
, but
it was not found there. jQuery.scrollTo is an optional dependency:
The show/HideSection() plug-ins will still work, but auto-scrolling to a certain position in the viewport
will not be animated (smooth scrolling) without the scrollTo plug-in, but instead the
viewport will instantly "jump" to the target position.
Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.
Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.
Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi.
In this demo, a condition option is set and evaluated each time the button is clicked.
So, whenever the button gets clicked, the click event handler will first evaluate the condition expression (check whether the checkbox is checked) and then pass the boolean result as (static) condition to the showOrHide() function, which will in result show the section if the checkbox is checked or hide it if the checkbox is unchecked.
The expression selects all Checkboxes with the ID of this example's checkbox that are currently checked.
So, the resultset is either empty (if the checkbox is unchecked) or contains one element (the checked checkbox).
That means, the length of the resultset is either 0 (unchecked) or 1 (checked).
Actually, it's not necessary to add the "> 0" comparison to the expression, the length itself is
also a valid and equivalent condition (since the value 0 is falsy, the number 1 is truthy).
I just added this "> 0" comparison since I consider it slightly more intuitively readable.
In this demo, some non-default options are set once upon page load by:
$("#demo3").setupShowOrHideSection({
scroll: true,
store: "#${id}_state",
storeValueShowing: "open",
storeValueHidden: "closed",
condition: function() {
return $("#demo3_chk:checked").length > 0;
}
});
The condition option in this case is not a static boolean expression but
instead a callback function which will evaluate each time the showOrHide()
function is called. Since this is initially set up,
the actual showOrHideSection()
calls don't need a condition option but can be
parameterless (see button label).
Note that this setup (condition) does only affect the showOrHideSection()
function, while the showSection()
and hideSection()
(naturally) ignore the condition and always show resp. hide the section.
In addition to the condition call-back, the setup above contains a scroll
option: scroll: true
. This activates auto-scrolling.
To test this, first hide this section, then ensure that the buttons to re-show
it again are near the bottom of the window. (If necessary, show the sections
of the other demos above first or reduce your browser's window size to achieve this).
Then, if you expand the section again, it first appears below the buttons in the
invisible part of the window. With auto-scroll activated, the page will then
automatically scroll down so that the newly expanded section gets moved
into view. (This is internally done via the scrollDownIntoView()
plug-in function, see vertical viewport demos.)
For a comparison,
you can try the same with the first demos above which don't have auto-scroll enabled.
Are you designing a web-interface for a web application and want to transmit the current state of a section (visible or hidden) to your server as part of a form submit? Then you can insert a hidden input field into your form and set up the showOrHide plug-in to update this hidden field's value according to the state. This is done by the store option. While normally a hidden input is preferrable, in this demo a visible read-only input (labelled "Transmittable state") is used to visualize the technique.
This state input has the ID "demo3_state".
In this simple example, the option could also have been set constantly to
store: "#demo3_state"
, but the demonstrated syntax
store: "#${id}_state"
is recommended: In this syntax, the
expression "${id}" is dynamically replaced by the ID of the section which is about
to be shown or hidden ("demo3"
in this case).
This syntax may also be used in a common setup which is applied to more than one section,
while a constant string like "#demo3_state" can only be used if the setup is
applied to exactly one section.
By default, this input would be filled with the value "X" if the section is showing
or empty if the section is hidden. In this example, those default values have been
overridden by the options storeValueShowing
and storeValueHidden
to read "open" resp. "closed".
This demo uses 3 radio buttons and contains 3 sections, one of which can be shown at the time, depending on the selected radio button. There are several ways to achieve this. The radio buttons are equipped with a click handler which performs the change.
There are several ways to implement this click handler. One solution would be that it always hides all three sections and then shows the right one again. This implementation however, which I consider the more elegant one, uses the a condition setup (see previous demo) and always calls the showOrHide() function for all three sections (with one jQuery call selecting all three sections at once by their common class:
$(".sec.demo4").setupShowOrHideSection({
scroll: true,
condition: function() {
var radId = $(this).data("rad");
return $("#" + radId + ":checked").length > 0;
}
});
$("input[name='demo4']").click(function() {
$(".sec.demo4").showOrHideSection();
});
For each section, the condition gets evaluated individually: to true if its corresponding radiobutton is checked, or to false otherwise.
See source code of this page for details.
Content for alternative 1: This is the section with ID demo4_1
Content for alternative 2: This is the section with ID demo4_2
Content for alternative 3: This is the section with ID demo4_3