Troll Print Example
Troll Print is an example application that lets the user choose printer settings. It comes in two versions: English and Portuguese.
We've included a translation file, trollprint_pt.ts
, which contains some Portuguese translations for this example.
We will consider two releases of the same application: Troll Print 1.0 and 1.1. We will learn to reuse the translations created for one release in a subsequent release. (In this tutorial, you need to edit some source files. It's probably best to copy all the files to a new temporary directory and work from there.)
See the Qt Linguist Manual for more information about translating Qt application.
Line by Line Walkthrough
The PrintPanel
class is defined in printpanel.h
.
class PrintPanel : public QWidget { Q_OBJECT
PrintPanel
is a QWidget. It needs the Q_OBJECT
macro for tr()
to work properly.
The implementation file is printpanel.cpp
.
PrintPanel::PrintPanel(QWidget *parent) : QWidget(parent) { /* QLabel *label = new QLabel(tr("TROLL PRINT")); label->setAlignment(Qt::AlignCenter); */
Some of the code is commented out in Troll Print 1.0; you will uncomment it later, for Troll Print 1.1.
twoSidedGroupBox = new QGroupBox(tr("2-sided")); twoSidedEnabledRadio = new QRadioButton(tr("Enabled")); twoSidedDisabledRadio = new QRadioButton(tr("Disabled")); twoSidedDisabledRadio->setChecked(true); colorsGroupBox = new QGroupBox(tr("Colors")); colorsEnabledRadio = new QRadioButton(tr("Enabled")); colorsDisabledRadio = new QRadioButton(tr("Disabled"));
Notice the two occurrences of tr("Enabled")
and of tr("Disabled")
in PrintPanel. Since both "Enabled"s and "Disabled"s appear in the same context Qt Linguist will only display one occurrence of each and will use the same translations for the duplicates that it doesn't display. Whilst this is a useful timesaver, in some languages, such as Portuguese, the second occurrence requires a separate translation. We will see how Qt Linguist can be made to display all the occurrences for separate translation shortly.
The header file for MainWindow
, mainwindow.h
, contains no surprises. In the implementation, mainwindow.cpp
, we have some user-visible source texts that must be marked for translation.
setWindowTitle(tr("Troll Print 1.0"));
We must translate the window title.
void MainWindow::createActions() { exitAct = new QAction(tr("E&xit"), this); exitAct->setShortcut(tr("Ctrl+Q", "Quit")); connect(exitAct, SIGNAL(triggered()), this, SLOT(close())); aboutAct = new QAction(tr("&About"), this); aboutAct->setShortcut(Qt::Key_F1); connect(aboutAct, SIGNAL(triggered()), this, SLOT(about())); aboutQtAct = new QAction(tr("About &Qt"), this); connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt())); } void MainWindow::createMenus() { QMenu *fileMenu = menuBar()->addMenu(tr("&File")); fileMenu->addAction(exitAct); menuBar()->addSeparator(); QMenu *helpMenu = menuBar()->addMenu(tr("&Help")); helpMenu->addAction(aboutAct); helpMenu->addAction(aboutQtAct); }
We also need to translate the actions and menus. Note that the two argument form of tr()
is used for the keyboard accelerator, "Ctrl+Q", since the second argument is the only clue the translator has to indicate what function that accelerator will perform.
QTranslator translator; translator.load(QString("trollprint_") + locale); app.installTranslator(&translator);
The main()
function in main.cpp
is the same as the one in the Arrow Pad example. In particular, it chooses a translation file based on the current locale.
Running Troll Print 1.0 in English and in Portuguese
We will use the translations in the trollprint_pt.ts
file that is provided.
Set the LANG
environment variable to pt
, and then run trollprint
. You should still see the English version. Now run lrelease
, e.g. lrelease trollprint.pro
, and then run the example again. Now you should see the Portuguese edition (Troll Imprimir 1.0):
Whilst the translation has appeared correctly, it is in fact wrong. In good Portuguese, the second occurrence of "Enabled" should be "Ativadas", not "Ativado" and the ending for the second translation of "Disabled" must change similarly too.
If you open trollprint_pt.ts
using Qt Linguist, you will see that there is just one occurrence of "Enabled" and of "Disabled" in the translation source file, even though there are two of each in the source code. This is because Qt Linguist tries to minimize the translator's work by using the same translation for duplicate source texts. In cases such as this where an identical translation is wrong, the programmer must disambiguate the duplicate occurrences. This is easily achieved by using the two argument form of tr()
.
We can easily determine which file must be changed because the translator's "context" is in fact the class name for the class where the texts that must be changed appears. In this case the file is printpanel.cpp
, where there are four lines to change. Add the second argument "two-sided" in the appropriate tr()
calls to the first pair of radio buttons:
twoSidedEnabledRadio = new QRadioButton(tr("Enabled", "two-sided")); twoSidedDisabledRadio = new QRadioButton(tr("Disabled", "two-sided"));
and add the second argument "colors" in the appropriate tr()
calls for the second pair of radio buttons:
colorsEnabledRadio = new QRadioButton(tr("Enabled", "colors"), colors); colorsDisabledRadio = new QRadioButton(tr("Disabled", "colors"), colors);
Now run lupdate
and open trollprint_pt.ts
with Qt Linguist. You should now see two changes.
First, the translation source file now contains three "Enabled", "Disabled" pairs. The first pair is marked "(obs.)" signifying that they are obsolete. This is because these texts appeared in tr()
calls that have been replaced by new calls with two arguments. The second pair has "two-sided" as their comment, and the third pair has "colors" as their comment. The comments are shown in the Source text and comments area in Qt Linguist.
Second, the translation text "Ativado" and "Desativado" have been automatically used as translations for the new "Enabled" and "Disabled" texts, again to minimize the translator's work. Of course in this case these are not correct for the second occurrence of each word, but they provide a good starting point.
Change the second "Ativado" into "Ativadas" and the second "Desativado" into "Desativadas", then save and quit. Run lrelease
to obtain an up-to-date binary trollprint_pt.qm
file, and run Troll Print (or rather Troll Imprimir).
The second argument to tr()
calls, called "comments" in Qt Linguist, distinguish between identical source texts that occur in the same context (class). They are also useful in other cases to give clues to the translator, and in the case of Ctrl key accelerators are the only means of conveying the function performed by the accelerator to the translator.
An additional way of helping the translator is to provide information on how to navigate to the particular part of the application that contains the source texts they must translate. This helps them see the context in which the translation appears and also helps them to find and test the translations. This can be achieved by using a TRANSLATOR
comment in the source code:
/*
TRANSLATOR MainWindow
In this application the whole application is a MainWindow.
Choose Help|About from the menu bar to see some text
belonging to MainWindow.
...
*/
Try adding these comments to some source files, particularly to dialog classes, describing the navigation necessary to reach the dialogs. You could also add them to the example files, e.g. mainwindow.cpp
and printpanel.cpp
are appropriate files. Run lupdate
and then start Qt Linguist and load in trollprint_pt.ts
. You should see the comments in the Source text and comments area as you browse through the list of source texts.
Sometimes, particularly with large programs, it can be difficult for the translator to find their translations and check that they're correct. Comments that provide good navigation information can save them time:
/*
TRANSLATOR ZClientErrorDialog
Choose Client|Edit to reach the Client Edit dialog, then choose
Client Specification from the drop down list at the top and pick
client Bartel Leendert van der Waerden. Now check the Profile
checkbox and then click the Start Processing button. You should
now see a pop up window with the text "Error: Name too long!".
This window is a ZClientErrorDialog.
*/
Troll Print 1.1
We'll now prepare release 1.1 of Troll Print. Start your favorite text editor and follow these steps:
- Uncomment the two lines that create a QLabel with the text "TROLL PRINT" in
printpanel.cpp
. - Word-tidying: Replace "2-sided" by "Two-sided" in
printpanel.cpp
. - Replace "1.0" with "1.1" everywhere it occurs in
mainwindow.cpp
. - Update the copyright year to 1999-2000 in
mainwindow.cpp
.
(Of course the version number and copyright year would be consts or #defines in a real application.)
Once finished, run lupdate
, then open trollprint_pt.ts
in Qt Linguist. The following items are of special interest:
MainWindow
- Troll Print 1.0 - marked "(obs.)", obsolete
- About Troll Print 1.0 - marked "(obs.)", obsolete
- Troll Print 1.0. Copyright 1999 Software, Inc. - marked obsolete
- Troll Print 1.1 - automatically translated as "Troll Imprimir 1.1"
- About Troll Print 1.1 - automatically translated as "Troll Imprimir 1.1"
- Troll Print 1.1. Copyright 1999-2000 Software, Inc. - automatically translated as "Troll Imprimir 1.1. Copyright 1999-2000 Software, Inc."
PrintPanel
- 2-sided - marked "(obs.)", obsolete
- TROLL PRINT - unmarked, i.e. untranslated
- Two-sided - unmarked, i.e. untranslated.
Notice that lupdate
works hard behind the scenes to make revisions easier, and it's pretty smart with numbers.
Go over the translations in MainWindow
and mark these as "done". Translate "TROLL PRINT" as "TROLL IMPRIMIR". When you're translating "Two-sided", press the Guess Again button to translate "Two-sided", but change the "2" into "Dois".
Save and quit, then run lrelease
. The Portuguese version should look like this:
Choose Ajuda|Sobre (Help|About) to see the about box.
If you choose Ajuda|Sobre Qt (Help|About Qt), you'll get an English dialog. Oops! Qt itself needs to be translated. See Internationalization with Qt for details.
Now set LANG=en
to get the original English version:
Files:


CS140 Topcoder problems
- Class on 1/16/14:
SRM 564, D2, 250-pointer.
(FauxPalindromes).
These are
lecture notes on using topcoder, with this problem as an example.
- Class on 1/16/14:
SRM 604, D2, 250-pointer.
(FoxAndWord).
Hints.
- Lab on 1/24, 1/27 and 1/29: SRM 350, D2, 250-Pointer (DistanceBetweenStrings)
Here is the help file I gave in lab.
- Class on 1/30 and 2/4: SRM 603, D2, 250-Pointer (MiddleCode)
commentary.
- Lab on 1/31, 2/3 and 2/5: SRM 587, D2, 250-Pointer (InsertZ):
Hints
- Lab on 1/31, 2/3 and 2/5: SRM 605, D2, 250-Pointer (AllenAndPassword):
Hints
- Lab on 2/7, 2/10 and 2/12: SRM 607, D2, 250-Pointer (BoundingBox):
Hints
- Lab on 2/14, 2/17 and 2/19: SRM 583, D2, 250-Pointer (SwappingDigits):
Hints
- Lab on 2/21, 2/24 and 2/26: SRM 609, D2, 250-Pointer (MagicalStringDiv2):
Hints
- Lab on 2/21, 2/24 and 2/26: SRM 297, D2, 250-Pointer (PackingParts):
Hints
- Class on 2/27: SRM 346, D2, 250-Pointer (DiamondHunt):
See the lecture
notes on lists.
- Lab on 2/28, 3/3 and 3/5: SRM 610, D2, 250-Pointer (DivideByZero)
Hints
- Lab on 3/7, 3/10 and 3/12: SRM 611, D2, 250-Pointer (InterestingNumber)
Hints
- Class on 3/13, and Lab on 3/14, 3/24 and 3/26: SRM 474, D1, 250-Pointer (RouteIntersection)
Writeup
- Class on 3/13, and Lab on 3/14, 3/24 and 3/26: SRM 499, D1, 250-Pointer (ColorfulRabbits)
Hints
- Lab on 3/28, 3/31 and 4/02: SRM 499, D2, 250-Pointer (Cryptography)
Hints - I
wanted you to get this in 20 minutes.
- Lab on 3/28, 3/31 and 4/02: SRM 499, D2, 500-Pointer (InternetSecurity)
Hints
- Lab on 4/4, 4/7 and 4/9: SRM 613, D2, 500-Pointer (TaroFriends)
Hints -
This one took some thinking.
- Lab on 4/4, 4/7 and 4/9: SRM 508, D2, 250-Pointer (CandyShop)
Hints -
This one was optional.
- Lab on 4/11, 4/14 and 4/16: SRM 615, D2, 250-Pointer (AmebaDiv2)
Hints -
This is a warmup problem. You should be getting these very quickly (under 15 minutes)
by this point.
- Lab on 4/11, 4/14 and 4/16: SRM 615, D1, 250-Pointer (AmebaDiv1)
Hints -
This is good practice for using sets in the STL.


Notice: This page was written in ES6(ECMAScript 2015), if something goes wrong, please try another browser.
Loading...


--- layout: data_model title: NetflowV9DataFlowSetType this_version: 1.0.1 ---
Specifies a Data FlowSet, which is one or more records, of the same type, that are grouped together in an Export Packet. Each record is either a Flow Data Record or an Options Data Record previously defined by a Template Record or an Options Template Record. http://www.ietf.org/rfc/rfc3954.txt
| Field Name | Type | Description |
|---|---|---|
| Flow_Set_ID_Template_ID0..1 | IntegerObjectPropertyType |
Specifies the FlowSet ID, which corresponds to the Template ID from a Template Flow Set or an Options Template Flow Set. |
| Length0..1 | IntegerObjectPropertyType |
Specifies the length of this FlowSet. |
| Data_Record0..n | NetflowV9DataRecordType |
The remainder of the Data FlowSet is a collection of Flow Data Record(s), each containing a set of field values. The Type and Length of the fields have been previously defined in the Template Record referenced by the FlowSet ID or Template ID. Specifies either a template flow set or an options template flow set. http://www.ietf.org/rfc/rfc3954.txt |
| Padding0..1 | HexBinaryObjectPropertyType |
Specifies the padding bytes used so that the subsequent FlowSet starts at a 4-byte aligned boundary. It is important to note that the Length field includes the padding bytes. Padding SHOULD be using zeros. |


{% load compress umap_tags i18n %}
Predominantly workshops, factories or warehouses
A park. Open, green area for recreation, usually municipal


--- layout: default title: Home class: styleguide ---
A Style Guide serves as an easy reference for refactoring prior projects and a 'jumping-off' codebase for new projects. Always start with brand approved elements and work out from there.
The Pattern Library is a collection of pre-compiled components made up of the elements from the Style Guide. The purpose is to demonstrate the way these elements come together to form new components.
The Web-Components section is a sandbox for Polymer UI elements that are created ongoing. These components can then be re-used for future development.
A Style Guide and reference point for email templates.


React and XR
webXR and Native XR
Disclaimer
I am here on my own behalf and my views reflect only my own
and not my employer. Everything that will be demonstrated
here will be free and open source. All contents will be available
Why react?
-
Virtual DOM, Tree Reconciliation, Memory Optimizations
-
The use of reusable, compassable, and stateful components
-
The nature of reactive updates
-
Many things you do in react can be ported over to native
-
You can share buisness logic between web and native clients
What do I need to start? No need for expensive tools!
-
Node
-
git
-
your favorite ide (Visual Code Studio)
-
patience and passion
When should I use aFrame?
-
You need quick access to lowlevel threeJS quickly.
-
You would like to utilize custom shaders, post-processing effects
-
You can quickly leverage packages the community built
-
Your need an intricate vr environment
-
You can easily add redux and redux-sagas to maintain state!
What can I do with react and aFrame?
Pros and Cons of aFrame and React
-
Pro lots of freedom to rapidly prototype
-
Pro you can easily setup complex environments
-
Pro great support for GLTF
-
Con setup can be tedious
-
Con you may spend lots of time optimizing
When should I use React360?
-
When you want to build an interactive story that communicates to the user by utilizing video, images, and minimal amounts of 3d.
-
When you want to display audio and video quickly in an webVR setting.
-
React360 is perfect for marketing material and vr video delivery.
-
React360 has excellent support for flexbox so it is perfect for projecting 2d in vr scenes
React360 is perfect for story telling and marketing
-
React360 is well suited for broadcast and video content
-
React360 is perfect for journalism and vr documentaries
-
React360 is perfect for ephemeral vr conent
Just how does React360 work?
React360 is built on ReactNative
React 360’s architecture mirrors that of React Native, with the React application code running in a background thread — in this case, a Web Worker in the web browser. When the application’s React components are rendered, React 360 utilizes the React Native bridge to serialize any necessary UI changes and pass them to the main thread, which in this case is the browser’s main JavaScript runtime. Here, React 360 utilizes a library from Oculus called OVRUI to translate the payload of pending UI updates into Three.js commands, rendering a 3D scene using WebGL.
Here is a high level view of React360 runtime
Pros and Cons of React360
-
Pro excellent command line interface
-
Pro excellent choice for video or panoramic content delivery
-
Pro great for creating a mashup where data visualization is important
-
Pro performance is well above average
-
Pro great support for GLTF
-
Con native modules can be a challenge
-
Con you may find it difficult to do things that are easy to do in aFrame
What about react-native and native XR?
-
Expo
-
Viroreact
-
ARKit and ARcore support
-
Native VR support for Daydream, GearVR, Occulus Go, and Cardboard
-
GLTF Support
What can I build with expo?
Let see somethings you've made?
What about ViroReact
-
You can quickly prototype responsive xr and vr experinces!
-
Their application allows you to rapidly test your prototype with their app! Kind of like expo
-
In general if you love react this looks like a promising work flow for react developers over unity
-
Supports GLTF!


{% extends "_layouts/base.html" %} {% block metaTitle %}Blog | Carina by Rackspace{% endblock %} {% block metaDescription %}News and announcements about Carina by Rackspace, the high-powered Docker container environment for developers{% endblock %} {% block ogTitle %}Blog | Carina by Rackspace{% endblock %} {% block ogDescription %}News and announcements about Carina by Rackspace, the high-powered Docker container environment for developers{% endblock %} {% block twitterTitle %}Blog | Carina by Rackspace{% endblock %} {% block twitterDescription %}News and announcements about Carina by Rackspace, the high-powered Docker container environment for developers{% endblock %} {% block bodyClass %}blog-home{% endblock %} {% block bodyContent %} {% include "_partials/docs-hero-short.svg" %} Carina™ Blog News and announcements from the Carina team Subscribe via RSS {{ deconst.content.envelope.body }} {% endblock %}
News and announcements from the Carina team
Subscribe via RSS


Council plan to extend an Irvine cemetery with 420 new lairs
The council hopes to place the additional lairs on a 3290 square metre site beside Knadgerhill.
by Irvine Herald, Sarah Hilley, https://www.dailyrecord.co.uk/authors/irvine-herald/, https://www.dailyrecord.co.uk/authors/sarah-hilley/Hundreds of new graves are set to be created at an Irvine cemetery as space for new lairs begins to run out.
North Ayrshire Council wants to extend the town's Knadgerhill Cemetery, which is nearly 100 years-old.
The council hopes to put 420 lairs on a 3290 square metre wasteland site beside the Bank Street burial ground.
The number of proposed plots includes space for ashes.
Work on the expansion would involve the formation of access roads and landscaping.
The scheme will cost about £620,000 and the extended area will be on adjacent common good land.
Ten out of the 18 cemeteries, which currently have new lairs available, are due to reach capacity within the next decade.
A council spokesman said: “We regularly monitor the capacity of our cemeteries to ensure ongoing availability of burial space for loved ones. This approach allows us to consider options for any additional capacity at an early stage.
“We have therefore made a decision to extend Knadgerhill through the provision of an additional 420 lairs. This work will be subject to planning permission being granted, and is scheduled for completion in summer 2020."
SEPA raised concerns about potential risk to the water environment after the council asked for advice on the site in August.
The environment agency handed the council a list of issues to be addressed.
The council planning application described the proposal as “change of use of land to form extension to existing cemetery.”
Knadgerhill Cemetery opened in 1926.
A new graveyard could also be built in Kilwinning to cope with demand in the town.


|
ECS160Android
FortNitta Android platform team
|
Public Member Functions | |
| final void | ResetForMap (CTerrainMap map) |
| Clears map and cannons, and resizes the construction map for a terrain map. More... | |
| final void | Draw2D (CGame game) |
| Draws the walls, floors, and cannons in 2D. More... | |
| final void | Draw2DCannons (CGame game) |
| Draws the cannons in 2D. More... | |
| final void | Draw3D (CGame game, int XIndex, int YIndex, int XPos, int YPos) |
| Draws the walls and floors in 3D. More... | |
| final void | Draw3DFloor (CGame game, int XIndex, int YIndex, int XPos, int YPos) |
| Draws the floors in 3D. More... | |
| final void | Draw3DWalls (CGame game, int XIndex, int YIndex, int XPos, int YPos) |
| Draws the walls in 3D. More... | |
| final void | Draw3DCannons (CGame game, int XPos, int YPos) |
| Draws the cannons in 3D. More... | |
| final void | SurroundCastle (CGame game, Castle castle) |
| Builds walls around a castle, adjusting for obstructions. More... | |
| final boolean | IsSpaceOpenForColor (EPlayerColor player_color, Vector2 position, Vector2 size) |
| Determines if the given rectangle is open in the map for a color. More... | |
| final boolean | IsSpaceFreeOfCannons (Vector2 position, Vector2 size) |
| Determines if given rectangle does not collide with cannons. More... | |
| final CConstructionTile | GetTileAt (Vector2 position) |
| Gets the construction tile at the position. More... | |
| final java.util.ArrayList< java.util.ArrayList< CConstructionTile > > | Tiles () |
| Getter for tiles of map. More... | |
| final java.util.ArrayList< CCannon > | Cannons () |
| Getter for cannons of map. More... | |
Static Public Member Functions | |
| static boolean | TileTypeIsFloor (CConstructionTile tile) |
| static boolean | TileTypeIsFloorDamaged (CConstructionTile tile) |
| static boolean | TileTypeIsWall (CConstructionTile tile) |
| static boolean | TileTypeIsWallDamaged (CConstructionTile tile) |
| static boolean | TileTypeIsFloorGroundDamaged (CConstructionTile tile) |
Public Attributes | |
| java.util.ArrayList< java.util.ArrayList< CConstructionTile > > | DTiles = new java.util.ArrayList<java.util.ArrayList<CConstructionTile>>() |
| Stores the 2D array of construction. | |
Protected Attributes | |
| java.util.ArrayList< CCannon > | DCannons = new java.util.ArrayList<CCannon>() |
| Stores the list of cannons. | |
| final java.util.ArrayList<CCannon> game.CConstructionMap.Cannons | ( | ) |
Getter for cannons of map.
| final void game.CConstructionMap.Draw2D | ( | CGame | game | ) |
Draws the walls, floors, and cannons in 2D.
| game | Game to draw in |
| final void game.CConstructionMap.Draw2DCannons | ( | CGame | game | ) |
Draws the cannons in 2D.
| game | Game to draw in |
| final void game.CConstructionMap.Draw3D | ( | CGame | game, |
| int | XIndex, | ||
| int | YIndex, | ||
| int | XPos, | ||
| int | YPos | ||
| ) |
Draws the walls and floors in 3D.
| game | The game to draw in |
| final void game.CConstructionMap.Draw3DCannons | ( | CGame | game, |
| int | XPos, | ||
| int | YPos | ||
| ) |
Draws the cannons in 3D.
| game | The game to draw in |
| final void game.CConstructionMap.Draw3DFloor | ( | CGame | game, |
| int | XIndex, | ||
| int | YIndex, | ||
| int | XPos, | ||
| int | YPos | ||
| ) |
Draws the floors in 3D.
| game | The game to draw in |
For each tile, check whether tile should be a wall or floor, and if they are damaged, then draw that tile.
| final void game.CConstructionMap.Draw3DWalls | ( | CGame | game, |
| int | XIndex, | ||
| int | YIndex, | ||
| int | XPos, | ||
| int | YPos | ||
| ) |
Draws the walls in 3D.
| game | The game to draw in |
| final CConstructionTile game.CConstructionMap.GetTileAt | ( | Vector2 | position | ) |
Gets the construction tile at the position.
| position | Index of the tile |
| final boolean game.CConstructionMap.IsSpaceFreeOfCannons | ( | Vector2 | position, |
| Vector2 | size | ||
| ) |
Determines if given rectangle does not collide with cannons.
| position | The top left of the rectangle |
| size | The size of the rectangle |
| final boolean game.CConstructionMap.IsSpaceOpenForColor | ( | EPlayerColor | player_color, |
| Vector2 | position, | ||
| Vector2 | size | ||
| ) |
Determines if the given rectangle is open in the map for a color.
| player_color | The color to be open for |
| position | The top left of the rectangle |
| size | The size of the rectangle |
| final void game.CConstructionMap.ResetForMap | ( | CTerrainMap | map | ) |
Clears map and cannons, and resizes the construction map for a terrain map.
| map | Terrain map to match size |
Builds walls around a castle, adjusting for obstructions.
| game | The game playing |
| castle | The castle to surround |
| final java.util.ArrayList<java.util.ArrayList<CConstructionTile> > game.CConstructionMap.Tiles | ( | ) |
Getter for tiles of map.


fv Scripting Guide
Because fv and POW are written in Tcl, they are inherently scriptable. So long as one knows the necessary data structures and function calls, everything fv does can be controlled by a user-created Tcl script running inside of fv. This, however, is a formidable task. Plus, fv's internal behavior and data are subject to change with each new release.
To make scripting possible, then, a simplified (and hence limited) script interface has been added to fv. It consists of a small set of commands which perform the basic operations of opening FITS files and displaying their contents. Future versions should contain more capabilities.
(Note: This method of scripting fv replaces an earlier method. Although the older method still can be used, it is deprecated.)
Operational Summary
There are several ways to access fv's scripting commands. The simplest is to write a Tcl script which uses the commands directly and then have fv execute it. Give the script a ".fv" filename extension so that fv can recognize it. This method requires the user to open the file interactively within fv (using the same method as opening a FITS file). This scripting method is useful for implementing macros which can perform certain common operations at the user's request.
Alternatively, fv can be scripted by other programs, allowing those programs to make use of fv's capabilities remotely. These programs, however, do not need to be written in Tcl so long as they can communicate with fv. Currently fv supports XPA on unix platforms and AppleScript on MacOS for communication:
The XPA messaging system (http://hea-www.harvard.edu/RD/xpa/) developed by the SAO/HEAD R&D group implements a method of communicating between two programs running on unix platforms. Communication occurs either through standalone programs (ie, xpaget and xpaset), a C subroutine library, or a Tcl extension. fv uses the Tcl extension to make its scripting commands available, but the calling program can use any of the XPA methods to access the commands. The XPA software is not distributed with fv and must be obtained and built by the user. (Use '--with-tcl=$FV/lib' when configuring XPA to have it build the tcl extension; if not installing XPA into the fv directories, using '--prefix=$FV', one must also set the LD_LIBRARY_PATH environment variable to point to the directory containing libtclxpa.so.)
AppleScript (http://www.apple.com/applescript), the English-like language on all Macintosh computers (circa MacOS 7.5 and up), can also be used to control fv remotely. (Actually, any program on the Mac can control fv through the use of Apple Events.) Using the do script command, Tcl code can be passed to fv. Due to how Tcl's do script command and fv's scripting commands are implemented, fv commands must be prefixed with the fvCmds:: namespace specifier.
Many scripting commands also can be used as inquiries. Inquiries and commands are implemented using the same syntax, differing only in that commands supply the necessary parameters to perform an action, whereas inquiries leave them off indicating fv should return the current settings. When used with XPA, inquiries must use the xpaget tool and commands the xpaset tool.
Command Summary
| preference | parameter | valid value |
| open preference panel | open | N/A |
| close preference panel | close | N/A |
| minimize preference panel | minimize | N/A |
| iconify preference panel | iconify | N/A |
| select preference page | page | App, Keywords, Tables, Graphs, and Colors |
| display File Selection | fileSelection | Open, Close |
| color choice | activebackground | red, green, #cccccc, etc |
| color choice | activeforeground | red, green, #cccccc, etc |
| color choice | background | red, green, #cccccc, etc |
| color choice | checkbuttoncolor | red, green, #cccccc, etc |
| color choice | foreground | red, green, #cccccc, etc |
| graph display | displayer | ds9, pow, saotng |
| graph display | graphsize | 300x300, 500x300, 300x500 500x500, 700x500, 500x700 700x700 |
| desk topy help | help | N/A |
| auto-plot primary image | autoplotprimary | 0 - deselect 1 - select |
| automatic format keys | autoreformatkeys | 0 - deselect 1 - select |
| automatic update checksum | autoupdatechecksum | 0 - never 1 - if exist 2 - always |
| display Fits file only | dispfitsonly | 0 - deselect 1 - select |
| left justify string | leftjustifystring | 0 - right 1 - left |
| protect required keyword | protectedkeys | 0 - deselect 1 - select |
| show desktop manager | usedesktopmanager | 0 - deselect 1 - select |
| use WCS info | wcsinfo | 0 - deselect 1 - selects |
| write history key after modification | writehiskey | 0 - deselect 1 - select |
| Window Management | winmanagement | Keep, Hid, Close |
Examples
The following commands will open 2 files and display their contents in several ways.
open ngc1316r.fit rate.fit # open 2 files included with fv select rate.fit # select one of files display header 1 # Open window of first extension's keywords display curve 1 time rate # Plot a curve of time vs rate in POW pow bounds 720 -30 950 300 # Resize graph's bounding box select ngc1316r.fit # Select other file display image 0 # Plot image set x [version] # Get fv's version numberType the preceding lines (without the comments) into a text file, name it commands.fv, then run it: either put it in the command line when starting fv (eg, "fv commands.fv") or open the file with the Open File menu item.
Using XPA from a Unix shell, one would do the following:
xpaset -p fv open ngc1316r.fit rate.fit xpaset -p fv select rate.fit xpaset -p fv display header 1 xpaset -p fv display curve 1 time rate xpaset -p fv pow bounds 720 -30 950 300 xpaset -p fv select ngc1316r.fit xpaset -p fv display image 0 xpaget fv versionThe -p option tells xpaset to not read any data from stdin. One can instead use stdin to send a series of Tcl commands en masse, using the command...
cat commands.fv | xpaset fv tclThis latter method allows one to insert real Tcl commands into the command sequence, whereas the individual xpaget/xpaset calls are restricted to the specific scripting commands.
Finally, if using AppleScript, the commands are...
tell application "fv" activate do script "fvCmds::open ngc1316r.fit rate.fit" do script "fvCmds::select rate.fit" do script "fvCmds::display header 1" do script "fvCmds::display curve 1 time rate" do script "fvCmds::pow bounds 720 -30 950 300" do script "fvCmds::select ngc1316r.fit" do script "fvCmds::display image 0" do script "fvCmds::version" set x to the result end tellNote that AppleScript will actually start fv if it isn't already running.
Additional examples of scripting can be found in the sample_scripts directory within the fv distribution.


20-story occupied condominium building with 230 units 1120 Windows and 110 Terrace Doors Replaced Architect: Kellermeyer Godfryt Hart, P.C.


Install dependencies
sudo apt-get install adduser authbind openjdk-7-jre-headless unzip
Download and extract the binary release into /opt/mireka
# Mireka version to be installed VERSION=4.0 cd ~ # Download binary package: wget http://mireka.googlecode.com/files/mireka-$VERSION.zip # Extract it unzip mireka-$VERSION.zip # No more need for the downloaded archive rm mireka-$VERSION.zip # Move the extracted content to /opt/mireka sudo mv mireka-$VERSION /opt/mireka cd /opt/mireka
Create a user account named mireka
, Mireka will run as that user
# Create mireka user sudo adduser --system --home /opt/mireka --no-create-home --group --disabled-password --shell /bin/false mireka
Setup file ownerships
# Set the default: owned by root, readable by everybody sudo chown -R root:root . # Logs are writable by mireka, and readable by operators and nobody else. sudo chown -R mireka:adm log sudo chmod 2750 log # Directories containing mails are writable by mireka and nobody else can see them. sudo chown -R mireka:mireka maildrops postmaster queues sudo chmod 750 maildrops postmaster queues # The configuration file which contains passwords are writable only to root, # readable for mireka, others must not see it. sudo chown root:mireka conf/global-users.js sudo chmod 640 conf/global-users.js
Configure authbind to enable Mireka to listen on the standard mail ports while running as non-root. These ports are lower than 1024, and by default are reserved for root.
# authbind in Ubuntu 12.10 require ports in the 512-1023 to be included in files starting with ! MIREKA_UID=$(id -u mireka) echo -e "<IP_ADDRESS>/0:25,25\n<IP_ADDRESS>/0:110,110\n<IP_ADDRESS>/0:587,587" | sudo tee /etc/authbind/byuid/$MIREKA_UID /etc/authbind/byuid/\!$MIREKA_UID
Install Upstart job configuration file to run Mireka as a dameon and start it.
sudo cp doc/examples/daemon/upstart.conf /etc/init/mireka.conf sudo start mireka
You will find the log files in /opt/mireka/log
, the configuration files in /opt/mireka/conf
.
The Mireka home dir is /opt/mireka
.
You can start it using sudo start mireka
and stop it using sudo stop mireka
.


{include file="layouts/_layui" /}
{block name="body-content"}{/block}
{block name="single-content"}{/block}


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 4
A lovely dish for a summer day, when courgettes are at their best. You could make the risotto a day in advance and fry it just before serving.
For the risotto, melt 25g/1oz of the butter in a large pan until foaming, then fry the onion and garlic for 2-3 minutes, or until softened. Add the risotto rice and stir well to coat with the butter.
Cook for 1-2 minutes, or until the rice grains start to turn translucent, then add the wine and cook for 3-4 minutes, or until nearly all of the liquid has evaporated.
Add a ladleful of the chicken stock to the pan and stir well. Cook for 1-2 minutes, or until nearly all of the stock has been absorbed, then add another ladleful of the stock. Repeat the process until the rice is cooked but still al dente.
Add the courgette during the last 2-3 minutes of cooking and then stir in the mascarpone, 25g/1oz of the parmesan and 25g/1oz of butter. Season, to taste, with salt and freshly ground black pepper. Remove the pan from the heat and cool then chill.
Heat a frying pan until medium hot, add the last of the butter and the olive oil and place a 10cm x 2.5cm/4in x 1in metal ring into the pan. Fill the ring with the cold risotto and pack down well.
Cook until the bottom is crisp and golden brown then flip over and cook on the other side until it is crisp and the rice is hot through. Set aside and keep warm.
For the ragu, heat a sauté pan until medium hot then add the olive oil, tomatoes and garlic.
Cook over a medium high heat for 3-4 minutes, or until the tomato is just starting to break down. Stir in the basil and season, to taste, with salt and freshly ground black pepper. Remove the pan from the heat and set aside in a warm place.
For the courgette tempura, heat a deep-sided frying pan filled two thirds full with vegetable oil until hot but not smoking, or heat a deep-fat fryer to 190C.
Meanwhile, place the flour, cornflour and salt into a bowl and add the sparkling water. Stir to combine very briefly, until the batter just comes together, leaving any lumps. Add a little more water if necessary.
Drop the courgette slices into the batter, coat fully then place straight into the hot oil.
Fry on each side until just golden and crisp. Remove from the pan and drain onto kitchen paper. (CAUTION: hot oil can be dangerous. Never leave the pan unattended.)
To serve, spoon some tomato ragu into the centre of the plate. Lay the risotto cake on top then add a grating of parmesan and a pile of courgette tempura.


Invite a Member of the Micronaut Team to Speak at Your Event
First Name
Please enter your first name.
Last Name
Please enter your last name.
Email Address
Please enter your email address.
Message (optional)
Submit My Request


Collapse Whitespace
Configuration
The 'Collapse Whitespace' filter is enabled by specifying:
- Apache:
ModPagespeedEnableFilters collapse_whitespace
- Nginx:
pagespeed EnableFilters collapse_whitespace;
in the configuration file.
Description
The 'Collapse Whitespace' filter reduces bytes transmitted in an HTML file by removing unnecessary whitespace.
Operation
The filter reduces the transfer size of HTML files by replacing contiguous whitespace with a single whitespace character. Because HTML is often formatted with extra whitespace for human readability or as an incidental effect of the templates used to generate it, this technique can reduce the number of bytes needed to transmit HTML resources.For example, if the HTML document looks like this:
  <title>Hello, world! </title>    Hello, World!
 Hello, World!

Then PageSpeed will rewrite it into:
  <title>Hello, world!</title>    Hello, World!
 Hello, World!

Example
You can see the filter in action at www.modpagespeed.com
on this
example.
Requirements
The 'Collapse Whitespace' filter will not modify whitespace appearing
within

, <textarea>
,


Match Play. 4-4 to 7. How should Red play 41?
pips Red=105 White=114
(CorrectAnswer= 0/0, ErrorScore= 0)
This is a very close call but paying now and gaining some flexibility with 18/13 is correct. 6/5, 6/2 is a small mistake rather than an error.
Theory is great but could you bring yourself to leave that voluntary shot in live play?
Theory is great but could you bring yourself to leave that voluntary shot in live play?
1. Cubeful 2-ply 18/13 Eq.: +0.413 0.582 0.181 0.007 - 0.418 0.127 0.001 2. Cubeful 2-ply 18/14 6/5 Eq.: +0.381 (-0.032) 0.571 0.166 0.006 - 0.429 0.125 0.001 3. Cubeful 2-ply 6/5 6/2 Eq.: +0.339 (-0.074) 0.561 0.132 0.004 - 0.439 0.113 0.001 4. Cubeful 2-ply 18/17 6/2 Eq.: +0.169 (-0.243) 0.507 0.135 0.005 - 0.493 0.154 0.002 5. Cubeful 0-ply 6/2 5/4 Eq.: +0.119 (-0.293) 0.495 0.119 0.005 - 0.505 0.170 0.002


| Package | Description |
|---|---|
| it.unimi.dsi.fastutil.bytes |
Provides type-specific classes for byte elements or keys.
|
| it.unimi.dsi.fastutil.chars |
Provides type-specific classes for character elements or keys.
|
| it.unimi.dsi.fastutil.doubles |
Provides type-specific classes for double elements or keys.
|
| it.unimi.dsi.fastutil.floats |
Provides type-specific classes for float elements or keys.
|
| it.unimi.dsi.fastutil.ints |
Provides type-specific classes for integer elements or keys.
|
| it.unimi.dsi.fastutil.io |
Provides classes and static methods that make object and primitive-type I/O easier and faster.
|
| it.unimi.dsi.fastutil.longs |
Provides type-specific classes for long elements or keys.
|
| it.unimi.dsi.fastutil.objects |
Provides type-specific classes for object elements or keys.
|
| it.unimi.dsi.fastutil.shorts |
Provides type-specific classes for short elements or keys.
|
| Class and Description |
|---|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractChar2BooleanFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2BooleanMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2BooleanSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2ByteFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2ByteMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2ByteSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2CharFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2CharMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2CharSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2DoubleFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2DoubleMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2DoubleSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2FloatFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2FloatMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2FloatSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2IntFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2IntMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2IntSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2LongFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2LongMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2LongSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2ObjectFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2ObjectMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2ObjectSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2ReferenceFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2ReferenceMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2ReferenceSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractChar2ShortFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractChar2ShortMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractChar2ShortSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractCharBidirectionalIterator
An abstract class facilitating the creation of type-specific bidirectional iterators.
|
| AbstractCharBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractCharBigListIterator
An abstract class facilitating the creation of type-specific big-list iterators.
|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharComparator
An abstract class facilitating the creation of type-specific comparators.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractCharList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractCharListIterator
An abstract class facilitating the creation of type-specific list iterators.
|
| AbstractCharPriorityQueue
An abstract class providing basic methods for priority queues implementing a type-specific interface.
|
| AbstractCharSet
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractCharSortedSet
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| Char2BooleanArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2BooleanAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2BooleanFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2BooleanFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2BooleanFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2BooleanFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2BooleanFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2BooleanLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2BooleanMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2BooleanMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2BooleanMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2BooleanMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2BooleanMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2BooleanMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2BooleanMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2BooleanOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2BooleanOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2BooleanRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2BooleanSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2BooleanSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2BooleanSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2ByteArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2ByteAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2ByteFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ByteFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2ByteFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2ByteFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2ByteFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2ByteLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2ByteMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2ByteMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2ByteMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2ByteMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2ByteMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2ByteMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2ByteMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2ByteOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2ByteOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2ByteRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2ByteSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ByteSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2ByteSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2CharArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2CharAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2CharFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2CharFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2CharFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2CharFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2CharFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2CharLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2CharMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2CharMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2CharMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2CharMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2CharMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2CharMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2CharMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2CharOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2CharOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2CharRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2CharSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2CharSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2CharSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2DoubleArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2DoubleAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2DoubleFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2DoubleFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2DoubleFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2DoubleFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2DoubleFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2DoubleLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2DoubleMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2DoubleMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2DoubleMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2DoubleMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2DoubleMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2DoubleMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2DoubleMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2DoubleOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2DoubleOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2DoubleRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2DoubleSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2DoubleSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2DoubleSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2FloatArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2FloatAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2FloatFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2FloatFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2FloatFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2FloatFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2FloatFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2FloatLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2FloatMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2FloatMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2FloatMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2FloatMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2FloatMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2FloatMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2FloatMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2FloatOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2FloatOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2FloatRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2FloatSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2FloatSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2FloatSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2IntArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2IntAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2IntFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2IntFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2IntFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2IntFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2IntFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2IntLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2IntMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2IntMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2IntMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2IntMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2IntMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2IntMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2IntMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2IntOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2IntOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2IntRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2IntSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2IntSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2IntSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2LongArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2LongAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2LongFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2LongFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2LongFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2LongFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2LongFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2LongLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2LongMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2LongMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2LongMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2LongMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2LongMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2LongMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2LongMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2LongOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2LongOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2LongRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2LongSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2LongSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2LongSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2ObjectArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2ObjectAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2ObjectFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ObjectFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2ObjectFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2ObjectFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2ObjectFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2ObjectLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2ObjectMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2ObjectMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2ObjectMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2ObjectMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2ObjectMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2ObjectMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2ObjectMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2ObjectOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2ObjectOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2ObjectRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2ObjectSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ObjectSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2ObjectSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2ReferenceArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2ReferenceAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2ReferenceFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ReferenceFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2ReferenceFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2ReferenceFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2ReferenceFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2ReferenceLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2ReferenceMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2ReferenceMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2ReferenceMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2ReferenceMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2ReferenceMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2ReferenceMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2ReferenceMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2ReferenceOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2ReferenceOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2ReferenceRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2ReferenceSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ReferenceSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2ReferenceSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Char2ShortArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Char2ShortAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Char2ShortFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ShortFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Char2ShortFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Char2ShortFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Char2ShortFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Char2ShortLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Char2ShortMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Char2ShortMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Char2ShortMap.FastEntrySet
An entry set providing fast iteration.
|
| Char2ShortMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Char2ShortMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Char2ShortMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Char2ShortMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Char2ShortOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Char2ShortOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Char2ShortRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Char2ShortSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Char2ShortSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Char2ShortSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| CharArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
| CharArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| CharArrays.Segment |
| CharArraySet
A simple, brute-force implementation of a set based on a backing array.
|
| CharBidirectionalIterator
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| CharBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| CharBigList
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharBigListIterator
A type-specific
BigListIterator . |
| CharBigListIterators.EmptyBigListIterator
A class returning no elements and a type-specific big list iterator interface.
|
| CharBigLists.EmptyBigList
An immutable class representing an empty type-specific big list.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharCollections.EmptyCollection
An immutable class representing an empty type-specific collection.
|
| CharCollections.SynchronizedCollection
A synchronized wrapper class for collections.
|
| CharCollections.UnmodifiableCollection
An unmodifiable wrapper class for collections.
|
| CharComparator
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| CharHash.Strategy
A type-specific hash strategy.
|
| CharHeapSemiIndirectPriorityQueue
A type-specific heap-based semi-indirect priority queue.
|
| CharIndirectPriorityQueue
A type-specific
IndirectPriorityQueue . |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| CharIterators.EmptyIterator
A class returning no elements and a type-specific iterator interface.
|
| CharLinkedOpenCustomHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| CharLinkedOpenHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| CharList
A type-specific
List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharListIterator
A type-specific bidirectional iterator that is also a
ListIterator . |
| CharLists.EmptyList
An immutable class representing an empty type-specific list.
|
| CharLists.SynchronizedList
A synchronized wrapper class for lists.
|
| CharLists.UnmodifiableList
An unmodifiable wrapper class for lists.
|
| CharOpenCustomHashSet
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| CharOpenHashSet
A type-specific hash set with with a fast, small-footprint implementation.
|
| CharPriorityQueue
A type-specific
PriorityQueue ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharSet
A type-specific
Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharSets.EmptySet
An immutable class representing the empty set and implementing a type-specific set interface.
|
| CharSets.Singleton
An immutable class representing a type-specific singleton set.
|
| CharSets.SynchronizedSet
A synchronized wrapper class for sets.
|
| CharSets.UnmodifiableSet
An unmodifiable wrapper class for sets.
|
| CharSortedSet
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| CharSortedSets.EmptySet
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| CharStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Class and Description |
|---|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractCharCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractCharIterator
An abstract class facilitating the creation of type-specific iterators.
|
| CharCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| CharIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| CharIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
Copyright © 2019. All rights reserved.


FeynmanJS comes with a $\LaTeX$-based parser out of the box, however it is extendable and you can write your own plugin.
FeynmanJS will try to figure out the best possible layout for your diagram without any manual fiddling with pixel coordinates etc.
Diagrams are drawn with SVG meaning they scale well on all devices.
Just insert a new block element where you would like your diagram to be rendered to; then assign the feynmanjs
class to to that element.

Next, add some diagram code in JSON.

{
"title" : "Box diagram",
"width" : 400,
"height" : 270,
"diagram": [
"fmfleftn{2}",
"fmfrightn{2}",
"fmf{fermion}{o1,v2,v1,i1}",
"fmf{fermion}{i2,v3,v4,o2}",
"fmf{photon}{v1,v3}",
"fmf{photon}{v2,v4}"
]
}

All is left is to include Feynman and instantiate it


| DOSE: T+ 0:00 |
0.5 hits |
oral |
LSD |
(blotter / tab) |
| T+ 1:30 |
1.0 g |
smoked |
Cannabis |
(plant material) |
| T+ 5:00 |
2 shots |
oral |
Alcohol - Hard |
(liquid) |
EXPERIENCE LEVEL AT THE TIME OF THE TRIP: marijuana (daily, chronic user), LSD (4 trips), mushrooms (5), XTC (7 times)
I believe I have to add something from me here, so that others can read and think for themselves :-) but I am writing this not only for the others to see but also for me - to get it off my chest and to be able to come to terms with that was the by far SCARIEST experience of my life. It might be lengthy but it is MY story so I will try to give you the most accurate report.
OK, now for some introduction- (dating back to 1998)
I live in Poland, am 23 at the moment. It wasn't until after my 18th birthday when I began experimenting with drugs. I went on winter holidays with my friends. Until then, I only drank beer and vodka and that's it. I didn't even smoke cigarettes. During our 7-day stay in Austria, my friends convinced me to smoke some pot. I thought 'What the heck?' and tried it. I didn't feel much the first time, but eventually I loved that shit :-) and after about 1 year of occasional smoking I have developed a habit of daily smoking which lasts until now. :-)
### 4 years later ###
I have a girlfriend, Mary (she was 22 at the time), whom I love and care for. We went through a lot together. It is January. Mary's parents decided to visit their friends and we had an empty house for ourselves, except for Mary's younger brother who was 17, for like 7-8 hours until we had to drive to get them back from the party which was on the outskirts of our city (this is important, will be explained later). Because I had some acid we decided to drop it that day and drive for Mary's parents after it comes down.
OK, so it was about 16:00 when we split the blotter in half and held it under our tongues. Mary's brother picked up some friends of his (3 guys of his age). He doesn't smoke weed, doesn't do any drugs, only alcohol. So they bought some cheap liquor and started drinking.
Mary invited some of her friends, but nobody showed up until 17:00 when only a couple came (Michael & Dorothy). OK, so until like 17:30 nothing was really happening. We had a laugh here and there, but no visual no trippy thoughts no nothing. Being a chronic heavy weed smoker :-) I proposed smoking some pot from what you would call a 'crack pipe' in the U.S. This is a very popular way of smoking weed in Poland - and a very efficient one. OK, so we took a couple of hits from the 'crack pipe' of what was very good quality skunk, but 15 minutes later, still nothing was happening. Then Michael proposed doing some bucket hits (gravity bong). I agreed. He did everything, set up the bucket, filled it with water, prepared the plastic bottle, etc.
We took a huge glass pipe and filled it with approx. 0.5g of the skunk. He did the set-up and I was the first one to take the hit. OK, so I took it, big deal.
OK, I was able to breathe again. I felt the hit, but still nothing was happening. Now it was Mary's turn. She turned to me and said 'Maybe I shouldn't do this' and then I said 'No, it's prefectly okay, do it'. She was hesitating but she took the hit.
And then...
THE SCARIEST EXPERIENCE OF MY LIFE BEGAN...
She took the bucket hit and she didn't cough. She turned red. Her whole face was red. She looked at me. She couldn't even cough it out. She couldn't breathe. Meanwhile, my hit started really affecting me. Everything slowed down 10x. Trails were starting to appear. My heart was beating veeery fast, way too fast. I was really scared, but it was only the beginning.
 I take her to her room.  A 'movie' starts forming in my head. I gave her the acid, I convinced her to do the hit, now I am responsible and she looks like she's dying in front of me. I make her sit on her bed and look deeply in her eyes. 'Do you want me to call an ambulance?'. She shakes her head. Mary's father is a policeman so my terror was overtaking me. Now thoughts of guilt and fear start overtaking my mind.
Finally, after what seemed like ages, she exhaled a cloud of smoke and started crying. The thoughts in my head were even worse now 'Why is she crying? What did I do to her?'. This became almost psychotic. I sat beside her on the bed and that was when the bucket hit really affected me. Everything suddenly went 2D, cartoon-like. I didn't see any depth in my vision. It was like falling away from a flat screen. I didn't know it was the weed. I felt extremely petrified. My girlfiend's hands grew veeeeeeeeeery long and suddenly I couldn't recognize her.
'Who is this girl?' I though. Then she looked like my English teacher, then like my mother, then like some other girl. 'Who is she?' I though. 'Who am I?' was another thought. Terror. Fear. 'What is happening? How am I going to survive in a 2D world'? It was 18:10, approx. 5 mins after my bucket hit.
My girlfriend stood up and I tried to say something 'happy' to cheer her up or just to ground us because I saw my fear in her eyes. I said 'We are on LSD, we are coming up'. And then I felt it. Oh My God!!! I couldn't understand it then, but it felt like things were happening just as I was saying them. I said 'We are coming up into higher dimensions'. And I felt it. I knew that we both felt it. It was like we were becoming ONE MIND. We tried talking, but that didn't help. It was like:
ME: What...
MARY: is happening?
ME: I...
MARY: know
ME: How...?
MARY: I don't know. But...
ME: what...
MARY: is happening?
Looping conversations leading to the starting point. We couldn't get out of this situation. So we decided to go outside. Going through the corridor was scary, but when we came out, I was petrified. Suddenly, EVERYTHING in my field of vision started leaving LONG trails.  I held Mary as we stood near the door. I looked at her. It was completely dark, but I saw her face glowing with light. She later told me she saw the same but she also saw my thoughts as 'dreadlocks' coming from my hair to the back of my skull. :-/
So we were standing outside in the dark and she said 'Honey, I'm so scared'. Well, so was I. 'Don't worry' I said 'We are in the matrix'. And then I felt it again. We were a couple hanging inside the matrix which was infinite and a light breeze was blowing.
It was so scary that we decided to head back into the house. When we closed the door, suddenly a question came out of nowhere 'WHO AM I?'. I was walking with Mary to her room and I couldn't recognize where is up, down, left or right. I suddenly felt like Johny Depp in 'Fear and Loathing...' when he was walking like a madman, and I understood him :-) why he was walking like that.
We came back to the room and Mary just laid on her bed. I desperately wanted to keep track of time, so I looked at my cellphone. It was 18:17. This was SCARY as for me eternity has passed, ages, but it was only 7 mins. :-( I turned on the stopwatch and look at it and I was petrified. There was the hour counter, minute counter, second counter and 100ths of seconds counter which looked like this 00:00:00.74 etc. Now normally the 100ths of seconds go so fast you can't even see them.
Mary asked my 'Honey, what is happening?' She had no clue. I told her 'We have to survive 45 minutes until the peak is over'. I had an idea to put on some music, one CD, until it all comes down a bit. So I took Lauryn Hill 'miseducation' and I put it on. When you take this cd and listen to it, when you put on the intro, there is a ring, like 'rrrrrrrrring' for a few seconds. For me it was an everlasting 'rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrring' which couldn't end so I turned the CD player off.
Terror, fear, guilt, all were in me. I couldn't bear it. I went to another room, where Mary's brother's friends were driking. They had some different music. I danced to it (I DON'T DANCE AT ALL usually) and I was like a visualizer from Winamp. I danced for what seemed like minutes, but Mary's brother told me later it was like 6 or 7 seconds :-)
I came back to Mary and sat with her. I suddenly saw 'tunnels' of thoughts in my head. There was a small 'bubble' flowing through these tunnels. I concentrated on the bubble and everything disappeared and only the 'bubble' stayed. I mean I felt a bubble (as a mathematical point with no dimension) in my head and INFINITE space in each direction. This was the peak.
Eventually we came down at around 21:00 (3 hours later), had to drive to pick up Mary's parents, which was like 20 miles but felt like driving from New York to San Francisco. I had a couple of shots of vodka still a bit high on acid and with my pupils huge as pizza plates :-). Its funny no one noticed that :-)
[Erowid Note: Driving while intoxicated or tripping is dangerous and irresponsible because it endangers other people. Don't do it!]
The funny thing is Mary's brother's friends were all drunk and vomitting around 20:00 and they came back to life at 21:00, they woke up exactly at the time we came down.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


--- layout: post title: I Love Seeing Projects I Worked On In The Wild published: true ---
She was having serious fun too.


--- layout: post status: publish published: true title: Vote for Ivy Envy to Receive a Podcast Award author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 7829 wordpress_url: http://ivyenvy.com/?p=7829 date: '2012-10-11 12:51:38 +0000' date_gmt: '2012-10-11 17:51:38 +0000' categories: - Ivy Envy tags: [] comments: - id: 5540 author: Michael Cotton author_email: '' author_url: '' date: '2012-10-11 13:15:21 +0000' date_gmt: '2012-10-11 18:15:21 +0000' content: Done. You wanted to be up for best comedy show right? - id: 5541 author: Bob Hall author_email: '' author_url: '' date: '2012-10-11 15:30:18 +0000' date_gmt: '2012-10-11 20:30:18 +0000' content: Best Amazon consumer guides...? ---
After four seasons of podcasting on the Cubs, we feel that we deserve to throw our hat in the ring for some podcast awards. We'd love it if you would help us out by nominating our podcast with the 2012 Stitcher Awards and The 8th Annual Podcast Awards Below is a post we took from Relentless Podcast Network's website. It tells you how to nominate us for these awards and there's a few suggestions on podcasts for nominate in other categories. Thank you for your support.
The nomination periods for two different podcast awards are going on right now and RPN shows would love your votes.
The 2012 Stitcher Awards
The First Annual Stitcher Awards nomination process is underway and will end on October 19th. By going to http://stitcher.promotw.com, you can nominate your favorite shows. Our suggestions are to nominate the following shows in the these categories:
Ivy Envy for Best Sports Commentary
Mommy's Cocktail Hour for Best Health and Lifestyle...because being a drunk mom is a lifestyle.
Patrick's Path to Sustainable Farming in Best Business and Finance
QC STEP Podcast in Education and Learning
There are a few podcasts that aren't on RPN, but we'd like to show our support. Vote for these shows too!
100 Words or Less in Best Music Commentary
On What Grounds in Best Comedy
You can vote once a day with the Stitcher Awards, so go there every day until October 19th and vote for these podcasts.
8th Annual Podcast Awards
Also, the 8th Annual Podcast Awards nomination period is underway. Unlike the Stitcher nomination process, with the Podcast Awards, you may only fill out one form. The nomination process for the Podcast Awards ends on Monday, October 15th. Simply go to http://www.podcastawards.com and for the following shows in these categories:
Ivy Envy (http://ivyenvy.com) in Sports
Mommmy's Cocktail Hour (http://mommyscocktailhour.com) in Food and Drink
Patrick's Path to Sustainable Farming (http://patrickspath.com) in Business
The shows that aren't on RPN that you should also vote for are:
100 Words or Less (http://100wordspodcast.com) in Culture/Arts
On What Grounds (http://zpnetwork.com/category/owg/) in Comedy
The Awesome 80's Podcast (http://theawesome80s.net) in Movies/Films


Process name
{%- if not handler -%}
{%- for process_name, process_entry in synergy_process_context.items() -%}
{{ process_name }}
{%- endfor -%}
{%- else -%}
{%- endif -%}
Entry name
Name of the schedulable item. Has to be unique.
Description
Human-readable description of the schedulable item
Is Active
Defines whether the schedulable is active and running OR deactivated and idle
Trigger time
-
every XXX
where XXX stands for seconds;
For instance:
every 60
-
at DoW-HH:MM, ..., DoW-HH:MM
where DoW is numerical Day Of Week (Mon-0, Sun-6, *-every day);
For instance:
at 2-15:00
- specifies Wed, 15:00 UTC
at *-12:00, 3-09:09
specifies everyday at 12:00 UTC and Thu at 15:00 UTC
Arguments
{%- if handler -%} {{ handler.process_entry.arguments|jsonify }} {%- else -%} {"cmd_path": "", "cmd_file": "", "cmd_args": "", "cmd_host": "" } {%- endif -%}
This is process-specific set of arguments that are used to construct and run an actual job
{%- if not handler -%}
Insert
{%- else -%}
Update
Delete
{%- endif -%}
Cancel


{% extends "base.html" %} {% block breadcrumb %}
Select the values for this Collection Instrument. All values must be populated
No Collection Instrument selectors for survey


Using AWS Lambda with Amazon CloudWatch Events
Amazon CloudWatch events help you to respond to state changes in your AWS resources. When your resources change state, they automatically send events into an event stream. You can create rules that match selected events in the stream and route them to your AWS Lambda function to take action. For example, you can automatically invoke an AWS Lambda function to log the state of an EC2 instance or AutoScaling group.
CloudWatch Events invokes your function asynchronously with an event document that wraps the event from its source. The following example shows an event that originated from a database snapshot in Amazon Relational Database Service.
Example CloudWatch Events event
{ "version": "0", "id": "fe8d3c65-xmpl-c5c3-2c87-81584709a377", "detail-type": "RDS DB Instance Event", "source": "aws.rds", "account": "123456789012", "time": "2020-04-28T07:20:20Z", "region": "us-east-2", "resources": [ "arn:aws:rds:us-east-2:123456789012:db:rdz6xmpliljlb1" ], "detail": { "EventCategories": [ "backup" ], "SourceType": "DB_INSTANCE", "SourceArn": "arn:aws:rds:us-east-2:123456789012:db:rdz6xmpliljlb1", "Date": "2020-04-28T07:20:20.112Z", "Message": "Finished DB Instance backup", "SourceIdentifier": "rdz6xmpliljlb1" } }
You can also create a Lambda function and direct AWS Lambda to invoke it on a regular schedule. You can specify a fixed rate (for example, invoke a Lambda function every hour or 15 minutes), or you can specify a Cron expression.
Example CloudWatch Events message event
{ "account": "123456789012", "region": "us-east-2", "detail": {}, "detail-type": "Scheduled Event", "source": "aws.events", "time": "2019-03-01T01:23:45Z", "id": "cdc73f9d-aea9-11e3-9d5a-835b769c0d9c", "resources": [ "arn:aws:events:us-east-1:123456789012:rule/my-schedule" ] }
To configure CloudWatch Events to invoke your function
-
Open the Functions page
on the Lambda console. -
Choose a function
-
Under Designer, choose Add trigger.
-
Set the trigger type to CloudWatch Events/EventBridge.
-
For Rule, choose Create a new rule.
-
Configure the remaining options and choose Add.
For more information on expressions schedules, see Schedule expressions using rate or cron.
Each AWS account can have up to 100 unique event sources of the CloudWatch Events- Schedule source type. Each of these can be the event source for up to five Lambda functions. That is, you can have up to 500 Lambda functions that can be executing on a schedule in your AWS account.
Topics


program demo_system_chmod
use M_system, only : system_chmod
use M_system, only : system_stat
use M_system, only : R_GRP,R_OTH,R_USR, RWX_G, RWX_U, W_OTH, X_GRP
!use M_system, only : RWX_O, W_GRP,W_USR,X_OTH,X_USR
!use M_system, only : DEFFILEMODE, ACCESSPERMS
use,intrinsic :: iso_fortran_env, only : int64
implicit none
integer :: ierr
integer :: status
integer(kind=int64) :: buffer(13)
!Setting Read Permissions for User, Group, and Others
! The following example sets read permissions for the owner, group,
! and others.
open(file='_test1',unit=10)
write(10,*)'TEST FILE 1'
close(unit=10)
ierr=system_chmod('_test1', IANY([R_USR,R_GRP,R_OTH]))
!Setting Read, Write, and Execute Permissions for the Owner Only
! The following example sets read, write, and execute permissions
! for the owner, and no permissions for group and others.
open(file='_test2',unit=10)
write(10,*)'TEST FILE 2'
close(unit=10)
ierr=system_chmod('_test2', RWX_U)
!Setting Different Permissions for Owner, Group, and Other
! The following example sets owner permissions for CHANGEFILE to
! read, write, and execute, group permissions to read and
! execute, and other permissions to read.
open(file='_test3',unit=10)
write(10,*)'TEST FILE 3'
close(unit=10)
ierr=system_chmod('_test3', IANY([RWX_U,R_GRP,X_GRP,R_OTH]));
!Setting and Checking File Permissions
! The following example sets the file permission bits for a file
! named /home/cnd/mod1, then calls the stat() function to
! verify the permissions.
ierr=system_chmod("home/cnd/mod1", IANY([RWX_U,RWX_G,R_OTH,W_OTH]))
call system_stat("home/cnd/mod1", buffer,status)
! In order to ensure that the S_ISUID and S_ISGID bits are set,
! an application requiring this should use stat() after a
! successful chmod() to verify this.
! Any files currently open could possibly become invalid if the
! mode of the file is changed to a value which would deny access
! to that process.
end program demo_system_chmod


About us
Your safety, our concern
Welcome to Motor Info the quickest,easiest,and safest means to parking
with no hustle at the city center
How motor info works
- User enters their destination
- User then gets to see a map with a pin that shows a parking area.
- The user will also be able to see restricted areas for motorcyccles within the Cetral Bussines District(CBD)


For decades, swimming bans along Lake Michigan’s shores were a major, and all too frequent, frustration for Chicago beach-goers. Beaches were closed when daily water samples showed unusually high levels of E. coli, a sign that the water is contaminated with other, more dangerous bacteria. These tests took time to analyze. By the time results were in, the sample was almost a day old. This delay meant beach-goers were kept out of the water even after it was safe to swim again.
The Chicago Park District has moved away from individual samples in favor of buoys that transmit data in real time. The buoys measure things like water temperature, wave movement, and cloudiness, each of which has a hand in high E. coli levels. Officials use this information to predict when bacteria have contaminated the water. The city no longer bans swimming due to E. coli. Instead, they warn swimmers that they are taking a risk if they go for a dip.
Data on wave height and frequency are also used by the National Weather Service to warn boaters and beach goers about strong waves and potential rip currents. Each year, roughly three to five people drown after getting caught in rip currents, making them the leading hazard for anyone spending a day on Lake Michigan’s shores. The data collected from buoys helps meteorologists anticipate where these hazardous currents will likely spring up and inform officials when swimmers should be kept out of the water.


{% assign icon = include.icon | default: "search" %}
{{ include.title | default: "No results found" }}
{{ include.subtitle | default: "Try adjusting your search or filter to find what you're looking for." }}


When I saw that the Call for papers for Codemotion Madrid 2016 process was open, I thought that I could explain my journey to becoming a Front-end developer because it can be useful for others.
As a said in another posts, I am Front-end developer since March last year, but I know that I have to improve a lot. Because of that, I thought that implementing a learning process can help me and others in the same situation improving in this field. The Codemotion conference is in November, so I have 5 months ahead to organize myself, keep improving and show the results there (and here in my blog). If my talk is not chosen, I can still explain this in other meetups or conferences that can be interested in this organization plan and I will also improve my skills in between, so I can’t lose.
I use 2 types of calendar that I add to a physical board. The first is the usual one, where I write down the meetups/meetings/free time stuff/trips, etc. With this first calendar I can see when I have time to learn. In the second one I write down the things that I would like to accomplished by month.
The bad thing about the second board is that I don’t usually know how many tasks I will accomplish in a month and I would like to reorganize order of tasks in a visual way.
For that, I am going to start using Kanban with the open source tool <a href=”https://taiga.io/”Taiga. In the learning Front-end development project I will add each task that I would like to accomplish in a user story. In the first version I am adding all the tasks, ideas and resources in the TO-DO column, I don’t know if I will separate them in some way to distinguish which kind of task is.
The organization in the Kanban board is the usual for this method, that is, columns TO-DO, DOING and DONE. However, I have added a ADD-TO-BLOG column to write a little explanation, example or conclusion in the blog after finishing doing each task. This way, other people can take advantage of the time inverted there.
I use Evernote to write about each task that I do, make list of things that I need to do to accomplish it or steps that I will use in the future again (for example, steps to upload a new blog post to GitHub). After finishing each task, I can get the important parts from there and adding them to the blog.
These are the tasks for this project:
Tasks: HTML, CSS & JS, Sass, PostCSS, Flexbox, responsive web design, best practices, workflow front-end development, accesibility, Material Design, UX
Resources: Free books to learn web design, articles
Ideas: Apply learning with personal projects, go to meetups/conferences, follow people that are where you want to be in front-end development


?HERBARIO
NACIONAL
DE
MEXICO
(MEXU)
Aristida
ternipes
Cav.
var.
floridana
(Chapm.)
Sanchez-Ken
J.
S^nchez-Ken
1996
Cf,
New
York
Botanical
Garden
ibsibti
University
of
Pennsylvania
Expedition
to
British
West
Indies.
Winter
of
1890-91.
'?ff
Dr.
J.
T.
ROTHROCK
1659661
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high