MSGCOMM(1) GNU MSGCOMM(1) NAME msgcomm - match two message catalogs SYNOPSIS msgcomm [OPTION] [INPUTFILE]... DESCRIPTION Find messages which are common to two or more of the specified PO files. By using the --more-than option, greater commonality may be requested before messages are printed. Conversely, the --less-than option may be used to specify less commonality before messages are printed (i.e. --less-than=2 will only print the unique messages). Translations, com‐ ments and extract comments will be preserved, but only from the first PO file to define them. File positions from all PO files will be cumulated. Mandatory arguments to long options are mandatory for short options too. Input file location: INPUTFILE ... input files -f, --files-from=FILE get list of input files from FILE -D, --directory=DIRECTORY add DIRECTORY to list for input files search If input file is -, standard input is read. Output file location: -o, --output-file=FILE write output to specified file The results are written to standard output if no output file is specified or if it is -. Message selection: -<, --less-than=NUMBER print messages with less than this many definitions, defaults to infinite if not set ->, --more-than=NUMBER print messages with more than this many definitions, defaults to 1 if not set -u, --unique shorthand for --less-than=2, requests that only unique messages be printed Input file syntax: -P, --properties-input input files are in Java .properties syntax --stringtable-input input files are in NeXTstep/GNUstep .strings syntax Output details: --color use colors and other text attributes always --color=WHEN use colors and other text attributes if WHEN. WHEN may be 'always', 'never', 'auto', or 'html'. --style=STYLEFILE specify CSS style rule file for --color -e, --no-escape do not use C escapes in output (default) -E, --escape use C escapes in output, no extended chars --force-po write PO file even if empty -i, --indent write the .po file using indented style --no-location do not write '#: filename:line' lines -n, --add-location generate '#: filename:line' lines (default) --strict write out strict Uniforum conforming .po file -p, --properties-output write out a Java .properties file --stringtable-output write out a NeXTstep/GNUstep .strings file -w, --width=NUMBER set output page width --no-wrap do not break long message lines, longer than the output page width, into several lines -s, --sort-output generate sorted output -F, --sort-by-file sort output by file location --omit-header don't write header with `msgid ""' entry Informative output: -h, --help display this help and exit -V, --version output version information and exit AUTHOR Written by Peter Miller. REPORTING BUGS Report bugs to<EMAIL_ADDRESS>COPYRIGHT Copyright © 1995-1998, 2000-2010 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. SEE ALSO The full documentation for msgcomm is maintained as a Texinfo manual. If the info and msgcomm programs are properly installed at your site, the command info msgcomm should give you access to the complete manual. GNU gettext-tools 0.18.1 June 2010 MSGCOMM(1)


Also displays Frame and single HTML documents. However, TFrameBrower is oriented toward Internet style protocols and URL usage.
Additional code and/or components are generally required to use TFrameBrowser.
Demos FrameBrowserDemoId10 and FrameBrowserDemoIcs offer and use such additional code. The demos are using internet access components
Indy Version 10, resp.
ICS Version 8.
Version 11 of the HtmlViewer components supports most of the HTML 4.01 specifications with many additional popular HTML 5 enhancements.
Please refer to the list of supported elements.
Many Cascading Style Sheet properties are also supported. Please refer to the list of supported style properties.
Font sizes, styles, and colors with HTML tags or default settings
Background colors and images
Formatted printing of the HTML document
Print Preview
Text search
Copy to clipboard
Subscripts and Superscripts
Touch Gestures Support (built-in panning, requires Delphi >= 2010)
While HTML documents are normally associated with the Internet World Wide Web, they are also very useful for displaying all kinds of textual material such as documentation, help files, etc.
Graphics are also easily incorporated in these documents.
Updates
For the most recent version of the HTML components and for information on what's coming, check in occasionally at:


Projects by
Saheli Basu
Web Design & Development.
Overview
More Info
Contact
Instructor's Page
Contact Section
Coursera Community Instructor.
Email
Saheli Basu


When a user accesses a web page, the server responds with a HTTP status code. In most cases the user journey isn't affected - unless there is an error. Error statuses are sorted into two groups - 400 to 499 are client-side errors and 500 to 599 are server-side errors.
Error pages should:
- be avoided - do the hard work to make sure they don't happen
- use plain English and avoid technical jargon
- avoid listing the error code - a user shouldn't need to know the error code
- make it clear how to get help
- if possible tell the user if they can complete the transaction on another channel
404 page
404 errors (sometimes known as 'page not found errors') tell a user the page they were trying to access is not there. Users encounter 404 errors when:
- we make a mistake - for example a user follows a link that is broken
- the user makes a mistake - inputting a link incorrectly
404 page examples
404 error page examples
500 page
500 errors happen when something goes wrong on the server-side. Common causes are when the server is down or maintenance work is happening.
You do not need to show different error pages for different server problems. 500 pages should only be used for short periods of time. If there is going to be a disruption to users for an extended period use shutter pages like these HMRC examples.
500 page example
404 error page examples
Get in touch
If you’ve got a question or suggestion share it on Slack #interaction-designers channel or on GitHub.


Register
Email
An email address is required.
Password
Password is required
Password
Passwords must match.
Submit


Facelets with a Content-Type attribute
Facelets with content type
This Facelet uses the contentType attribute of the f:view tag.
Some Umlauts:
äöü


In Pizza We Crust...
The best food is eaten with your hands
ORDER
Customize pizza:
Select size:
Small
Medium
Large
Select sauce:
Red
White
Select toppings:
Pepperoni
Sausage
Olives
Spinach
PLACE ORDER
Thank you for placing and order!
Your order will be ready in 15min.
Your receipt:
Size:
Sauce:
Toppings:
Total:


Gateway
BOT
14-Jun-19 09:37 AM
[dscrd-hush] <kh4567> Well americans will miss binance if that is the case..as its one of the best one
[dscrd-hush] <kh4567> Nash exchange is coming up..it seems to have a lot of potential looking at the team and all the hype...its a truely decentralised exchange
Fabio Canesin @NEO Devcon presenting a real decentralized exchange called NASH 31st March 2019 launchdate
[dscrd-hush] <kh4567> @jl777c any thoughts on nash exchange.. will it be a contender and challenge binance total dorminance
[dscrd-hush] <jl777c> it is cross chain atomic swap or proxy token ?
[dscrd-hush] <kh4567> Its like a fully decentralised dex..
[dscrd-hush] <kh4567> Cross chain
[dscrd-hush] <kh4567> The matching engine is off chain..
[dscrd-hush] <jl777c> why does it have statechannel contracts holding the funds?
[dscrd-hush] <jl777c> that makes the contract a money transmitter according to fincen
[dscrd-hush] <jl777c> i dont see where it says it is a cross chain atomic swap
[dscrd-hush] <jl777c> seems it will get tied up in regulations if it gets big enough
Our goal at Nash is to bring decentralization to everyone. Since blockchains are too slow to implement high-performance exchanges, users…
[dscrd-hush] <kh4567> Now they are trying to clear all the regulatory hurdles and getting all the licenses
(edited)
[dscrd-hush] <kh4567> Thats why there is some delays
[dscrd-hush] <jl777c> it is NOT crosschain atomic swaps
[dscrd-hush] <jl777c> "During this time, user funds are never controlled by Nash. Users must sign off on the trades they send to the matching engine and are free to withdraw their funds from our trading smart contracts at any time, even if the matching engine and Nash web platform are not functional."
[dscrd-hush] <jl777c> funds are not controlled by nash, but also not controlled by the user. it is controlled by the smart contract
[dscrd-hush] <jl777c> so you send funds to the contract
[dscrd-hush] <jl777c> trade
[dscrd-hush] <jl777c> withdraw funds from the contract
[dscrd-hush] <jl777c> the contract is the exchange
[dscrd-hush] <jl777c> it is NOT crosschain atomic swaps
[dscrd-hush] <jl777c> and who controls the actual coins that are deposited in the contract?
[dscrd-hush] <jl777c> i guess you make wrapped coins and pay ETH fees for each action
[dscrd-hush] <jl777c> and who controls the gateways for that? the privkeys for the coins that are wrapped?
[dscrd-hush] <jl777c> it is a step up from proxy based DEX, but it is not anything like a cross chain atomic swap
[dscrd-hush] <kh4567> Yes its control by the matching engine
[dscrd-hush] <kh4567> But the user interface is great
(edited)
[dscrd-hush] <kh4567> They are partner with neo
(edited)
[dscrd-hush] <kh4567> Its "off chain"


In principle, private and protected members of a class cannot be
accessed from outside the same class in which they are declared.
However, this rule does not affect friends.
Friends are functions or classes declared as such.
If we want to declare an external function as friend of a class,
thus allowing this function to have access to the private and
protected members of this class, we do it by declaring a prototype
of this external function within the class, and preceding it with
the keyword friend:
// friend functions #include <iostream> using namespace std; class CRectangle { int width, height; public: void set_values (int, int); int area () {return (width * height);} friend CRectangle duplicate (CRectangle); }; void CRectangle::set_values (int a, int b) { width = a; height = b; } CRectangle duplicate (CRectangle rectparam) { CRectangle rectres; rectres.width = rectparam.width*2; rectres.height = rectparam.height*2; return (rectres); } int main () { CRectangle rect, rectb; rect.set_values (2,3); rectb = duplicate (rect); cout << rectb.area(); return 0; }
output:
24
Just as we have the possibility to define a friend function, we can also define a class as friend of another one, granting that first class access to the protected and private members of the second one.
// friend class #include <iostream> using namespace std; class CSquare; class CRectangle { int width, height; public: int area () {return (width * height);} void convert (CSquare a); }; class CSquare { private: int side; public: void set_side (int a) {side=a;} friend class CRectangle; }; void CRectangle::convert (CSquare a) { = a.side; height = a.side; } int main () { CSquare sqr; CRectangle rect; sqr.set_side(4); rect.convert(sqr); cout << rect.area(); return 0; }
output:
16
In this example, we have declared CRectangle as a friend of CSquare so that CRectangle member functions could have access to the protected and private members of CSquare, more concretely to CSquare::side, which describes the side width of the square.
o derive a class from another, we use a colon (:) in the declaration of the derived class using the following format:
class derived_class_name: public base_class_name { /*...*/ };
Where derived_class_name is the name of the derived class and base_class_name is the name of the class on which it is based. The public access specifier may be replaced by any one of the other access specifiers protected and private. This access specifier describes the minimum access level for the members that are inherited from the base class.
// derived classes #include <iostream> using namespace std; class CPolygon { protected: int width, height; public: void set_values (int a, int b) { width=a; height=b;} }; class CRectangle: public CPolygon { public: int area () { return (width * height); } }; class CTriangle: public CPolygon { public: int area () { return (width * height / 2); } }; int main () { CRectangle rect; CTriangle trgl; rect.set_values (4,5); trgl.set_values (4,5); cout << rect.area() << endl; cout << trgl.area() << endl; return 0; }
In principle, a derived class inherits every member of a base class except:
Although the constructors and destructors of the base class are not
inherited themselves, its default constructor (i.e., its constructor
with no parameters) and its destructor are always called when a new
object of a derived class is created or destroyed.
If the base class has no default constructor or you want that an
overloaded constructor is called when a new derived object is
created, you can specify it in each constructor definition of the
derived class:
derived_constructor_name (parameters) : base_constructor_name (parameters) {...}
For example:
// constructors and derived classes #include <iostream> using namespace std; class mother { public: mother () { cout << "mother: no parameters\n"; } mother (int a) { cout << "mother: int parameter\n"; } }; class daughter : public mother { public: daughter (int a) { cout << "daughter: int parameter\n\n"; } }; class son : public mother { public: son (int a) : mother (a) { cout << "son: int parameter\n\n"; } }; int main () { daughter cynthia (0); son daniel(0); return 0; }
output:
mother: no parameters daughter: int parameter mother: int parameter son: int parameter
In C++ it is perfectly possible that a class inherits members from
more than one class. This is done by simply separating the different
base classes with commas in the derived class declaration.
example:
// multiple inheritance #include <iostream> using namespace std; class CPolygon { protected: int width, height; public: void set_values (int a, int b) { width=a; height=b;} }; class COutput { public: void output (int i); }; void COutput::output (int i) { cout << i << endl; } class CRectangle: public CPolygon, public COutput { public: int area () { return (width * height); } }; class CTriangle: public CPolygon, public COutput { public: int area () { return (width * height / 2); } }; int main () { CRectangle rect; CTriangle trgl; rect.set_values (4,5); trgl.set_values (4,5); rect.output (rect.area()); trgl.output (trgl.area()); return 0; }
output:
20 10


We visualize metrics!
- integrate customized architectures
- architect world-class e-tailers
- incentivize bricks-and-clicks schemas
- target global applications
- drive compelling models
- incentivize virtual platforms
- e-enable transparent e-tailers
- recontextualize web-enabled deliverables
- implement synergistic synergies
- optimize best-of-breed web-readiness
- visualize B2B channels
- enhance best-of-breed schemas
- seize turn-key infrastructures
- synthesize cross-media models
- disintermediate interactive e-tailers


<< Index
Java Step 2: Stage Sources
Settings
Docker Image
Debug Mode
Generated Sources Zip
Staging
Repository
User Name
Security Token
Run Tests


The three main points relevant for most people are:
- Even though Elektra provides a global key database, that allows read- and write access of every single parameter for any application in an integrated fashion, configuration files stay human read- and writable.
- Flexible adoption on how the configuration is accessed via plugins: you can run arbitrary code in multiple languages or notify others when configuration files are changed. Plugins allow us to support hundreds of different configuration file formats.
- Elektra allows us to specify configuration values:
Why not Other Solutions?
Some might ask: isn't this solution overkill? Why not tackle these three issues separately? The answer is:
- If we would only implement a configuration file library for applications, we would hinder the work of administrators and would not provide external access to configuration.
- If we only implement an administrator tool that can parse and generate configuration files, but is not used by the applications themselves, we create a gap that leads to inconsistent understanding of the configuration syntax.
- If we only specify the meaning of configuration within applications but not in a form accessible for administrators, we would create a gap that leads to inconsistent understanding of the configuration semantics.
For common understanding of syntax and semantics of configuration files a full-stack solution like Elektra is required. We acknowledge, however, that such a change cannot be done overnight, thus we integrate as many configuration file formats as possible. This way, people can continue using files in /etc
, regardless of whether or not Elektra is used.
To give one example, in OpenLDAP 2.4.39 the value of listener-threads
will be reduced to the next number that is a power of 2. To correctly manipulate the setting we need not only know the syntax of how to write listener-threads correctly in the configuration file, but also the knowledge how the value is transformed internally. Elektra solves all three issues, and then users can easily externally manipulate listener-threads
, without caring about the concrete syntax of the file and getting feedback of the semantics (you might get validation errors and you can receive the value exactly as the application will get it).
Who Should use Elektra?
Elektra targets different kinds of users:
- Developers to develop a better integrated free software ecosystem and plugins for better validation/notification. If you have an application that reads or writes configuration files, you are in the target group.
- System administrators to have a higher-level view of their configuration and enable them to better consider context. If you want to specify or automate configuration tasks, you are in the target group.
Unique Features
Features that rarely can be found elsewhere (at least in this combination):
- Bootstrap code and proper abstraction is included:
- You do not need to worry about the file names of configuration files in the application.
- Cascading between
/etc
, $HOME
, cwd
and so on.
- You can change which Elektra path is connected to which configuration file with mounting.
- Portable across OS (Linux, BSD, w64, macOS,.. ) and desktop systems (GNOME, KDE,...).
- No daemon, so no single point of failure but still having guarantees of consistent, validated files with good performance.
- Provides 3-way merging for configuration upgrades.
Further Reasons
- Links and automatic calculation of values: unlike with other solutions you do not need to duplicate configuration values for different applications but you can comfortably link between them which makes many inconsistencies impossible.
- Allows us to easily create GUIs and web-UIs for the whole configuration on the system.
- Allows you to import/export all parts of the configuration.
- Syntax independence: you can consistently use your favorite syntax.
- Configuration Management (such as Puppet) can be used on top of it without having to fiddle with specifics of every configuration file.
- CLI-tool available
kdb editor
allows you to edit any path of Elektra with your favorite syntax (independent of the actual syntax of the configuration files that store values of this path).
- Allows us to also integrate command-line arguments and environment into a consistent place for configuration.
- Reduces huge amount of code: Nearly every application has very similar code:
- finding the correct configuration file (for different OS)
- parsing configuration files
- validating configuration files
- replace configuration files on changes
- All advantages libraries have:
- Performance: Improvements in the library benefits all applications.
- The library only needs to be loaded once in the memory.
- On fixes not all binaries of all applications need to be replaced.
- All advantages maintained code with a community has:
- If something does not work, open an issue.
- If you have a question, open an issue.
- Regular releases.
Further Readings


Behaviours: application.
One-stop shop for all your OTPCL needs.
Theotpcl
module re-exports various functions for convenience when using
OTPCL from within other OTP applications.
column_no() = integer()
eval_error() = {error, reason(), state()}
eval_input() = string() | binary() | [token()]
eval_success() = {ok, state()}
filename() = any()
funs() = map()
level() = atom()
line_no() = integer()
parse_error() = {error, reason(), level(), [token()], [tree()]}
parse_success() = {ok, tree(), [token()]}
position() = {filename(), line_no(), column_no()}
reason() = atom() | {atom(), any()}
str_or_bin() = string() | binary()
token() = {char(), position()}
tree() = {parsed, level(), [tree()] | [token()]}
vars() = map()
| cmd/2 | Get the function backing a command from an OTPCL interpreter state. |
| cmd/3 | Set the function backing a command in an OTPCL interpreter state. |
| eval/1 | Interpret a (charlist/binary/token) string as an OTPCL program with the default starting state. |
| eval/2 | Interpret a (charlist/binary/token) string as an OTPCL program with a custom starting state. |
| eval_file/1 | Interpret the contents of a file as an OTPCL program with the default starting state. |
| eval_file/2 | Interpret the contents of a file as an OTPCL program with a custom starting state. |
| get/2 | Get the value of a variable from an OTPCL interpreter state. |
| import/2 | Import all the functions from a module into an OTPCL interpreter state. |
| import/3 | Import a specific function from a module into an OTPCL interpreter state. |
| interpret/1 | Interpret an OTPCL parse tree with the default starting state. |
| interpret/2 | Interpret an OTPCL parse tree with a custom starting state. |
| parse/1 | Parse a (charlist/binary/token) string as an OTPCL program. |
| scan/1 | Convert a charlist string or binary string into a token string. |
| scan/2 | Convert a charlist string or binary string into a token string. |
| set/3 | Set the value of a variable in an OTPCL interpreter state. |
Get the function backing a command from an OTPCL interpreter state.
Set the function backing a command in an OTPCL interpreter state.
eval(Src::eval_input()) -> eval_success() | eval_error()
Interpret a (charlist/binary/token) string as an OTPCL program with the default starting state.
eval(Src::eval_input(), State::state()) -> eval_success() | eval_error()
Interpret a (charlist/binary/token) string as an OTPCL program with a custom starting state.
eval_file(Filename::filename()) -> eval_success() | eval_error()
Interpret the contents of a file as an OTPCL program with the default starting state.
eval_file(Filename::filename(), State::state()) -> eval_success() | eval_error()
Interpret the contents of a file as an OTPCL program with a custom starting state.
Get the value of a variable from an OTPCL interpreter state.
Import all the functions from a module into an OTPCL interpreter state.
Import a specific function from a module into an OTPCL interpreter state.
interpret(Tree::tree()) -> eval_success() | eval_error()
Interpret an OTPCL parse tree with the default starting state.
interpret(Tree::tree(), State::state()) -> eval_success() | eval_error()
Interpret an OTPCL parse tree with a custom starting state.
parse(Src::eval_input()) -> parse_success() | parse_error()
Parse a (charlist/binary/token) string as an OTPCL program.
scan(Txt::str_or_bin()) -> [token()]
Convert a charlist string or binary string into a token string. The
resulting tokens will start from the default starting position
({nofile,0,0}
).
scan(Txt::str_or_bin(), Pos::position()) -> [token()]
Convert a charlist string or binary string into a token string. The
resulting tokens will start from the starting position Pos
.
Set the value of a variable in an OTPCL interpreter state.
Generated by EDoc


--- layout: example.html title: Geolocation Example shortdesc: Demonstrates how to track user's location on a map. docs: >


Westernmost coordinate of the limit of the dataset extent, expressed in longitude in decimal degrees. Longitudes in the western hemisphere should be negative (e.g., -95.123).
Easternmost coordinate of the limit of the dataset extent, expressed in longitude in decimal degrees. Longitudes in the eastern hemisphere should be negative (e.g., -92.123).
Southernmost coordinate of the limit of the dataset extent, expressed in latitude in decimal degrees. (e.g., 27.123)
Northernmost coordinate of the limit of the dataset extent, expressed in latitude in decimal degrees. (e.g., 29.123)


-
Before a cursor can be used it must be declared (defined).
This process does not actually retrieve any data; it merely
defines the
SELECT
statement to be used.
`
-
After it is declared, the cursor must be opened for use.
This process actually retrieves the data using the
previously defined
SELECT
statement. - With the cursor populated with data, individual rows can be fetched (retrieved) as needed.
- When it is done, the cursor must be closed.
After a cursor is declared, it may be opened and closed as often as needed. After it is open, fetch operations can be performed as often as needed.
Creating Cursors
Cursors are created using the DECLARE
statement.
DECLARE
names the cursor and takes a
SELECT
statement, complete with
WHERE
and other clauses if needed. For example,
this statement defines a cursor named
ordernumbers
using a
SELECT
statement that retrieves all orders:
CREATE PROCEDURE processorders() BEGIN DECLARE ordernumbers CURSOR FOR SELECT ordernum FROM orders; END;
This stored procedure does not do a whole lot. A
DECLARE
statement is used to define and name the
cursorin this case ordernumbers
. Nothing is done
with the cursor, and as soon as the stored procedure finishes
processing it will cease to exist (as it is local to the
stored procedure itself).
Now that the cursor is defined, it is ready to be opened.
Opening and Closing Cursors
Cursors are opened using the
OPEN CURSOR
statement, like this:
OPEN ordernumbers;
When the OPEN
statement is processed, the query
is executed, and the retrieved data is stored for subsequent
browsing and scrolling.
After cursor processing is complete, the cursor should be
closed using the CLOSE
statement, as follows:
CLOSE ordernumbers;
CLOSE
frees up any internal memory and resources
used by the cursor, and so every cursor should be closed when
it is no longer needed.
After a cursor is closed, it cannot be reused without being
opened again. However, a cursor does not need to be declared
again to be used; an OPEN
statement is
sufficient.
If you do not explicitly close a cursor, MySQL will close it
automatically when the END
statement is reached.
Here is an updated version of the previous example:
CREATE PROCEDURE processorders() BEGIN -- Declare the cursor DECLARE ordernumbers CURSOR FOR SELECT order_num FROM orders; -- Open the cursor OPEN ordernumbers; -- Close the cursor CLOSE ordernumbers; END;
This stored procedure declares, opens, and closes a cursor. However, nothing is done with the retrieved data.
Using Cursor Data
After a cursor is opened, each row can be accessed
individually using a FETCH
statement.
FETCH
specifies what is to be retrieved (the
desired columns) and where retrieved data should be stored. It
also advances the internal row pointer within the cursor so
the next FETCH
statement will retrieve the next
row (and not the same one over and over).
The first example retrieves a single row from the cursor (the first row):
CREATE PROCEDURE processorders() BEGIN -- Declare local variables DECLARE o INT; -- Declare the cursor DECLARE ordernumbers CURSOR FOR SELECT order_num FROM orders; -- Open the cursor OPEN ordernumbers; -- Get order number FETCH ordernumbers INTO o; -- Close the cursor CLOSE ordernumbers; END;
Here FETCH
is used to retrieve the
order_num
column of the current row (it'll start
at the first row automatically) into a local declared variable
named o
. Nothing is done with the retrieved data.
In the next example, the retrieved data is looped through from the first row to the last:
CREATE PROCEDURE processorders() BEGIN -- Declare local variables DECLARE done BOOLEAN DEFAULT 0; DECLARE o INT; -- Declare the cursor DECLARE ordernumbers CURSOR FOR SELECT order_num FROM orders; -- Declare continue handler DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done=1; -- Open the cursor OPEN ordernumbers; -- Loop through all rows REPEAT -- Get order number FETCH ordernumbers INTO o; -- End of loop UNTIL done END REPEAT; -- Close the cursor CLOSE ordernumbers; END;
Like the previous example, this example uses
FETCH
to retrieve the current
order_num
into a declared variable named
o
. Unlike the previous example, the
FETCH
here is within a REPEAT
so it
is repeated over and over until done
is true (as
specified by UNTIL done END REPEAT;
). To make
this work, variable done
is defined with a
DEFAULT 0
(false, not done). So how does
done
get set to true when done? The answer is
this statement:
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done=1;
This statement defines a CONTINUE HANDLER
, code
that will be executed when a condition occurs. Here it
specifies that when SQLSTATE '02000'
occurs, then
SET done=1
. And SQLSTATE '02000'
is
a not found condition and so it occurs when
REPEAT
cannot continue because there are no more
rows to loop through.
MySQL Error Codes
For a complete list of MySQL
error codes used by MySQL 5, see
http://dev.mysql.com/doc/mysql/en/error-handling.html
.
There is specific order in which
DECLARE
statements, if used, must be issued.
Local variables defined with DECLARE
must be
defined before any cursors or handlers are defined, and
handlers must be defined after any cursors. Failure to follow
this sequencing will generate an error message.
If you were to call this stored procedure it would define
variables and a CONTINUE HANDLER
, define and open
a cursor, repeat through all rows, and then close the cursor.
With this functionality in place you can now place any needed
processing inside the loop (after the
FETCH
statement and before the end of the loop).
In addition to the REPEAT
statement used here,
MySQL also supports a LOOP
statement that can be
used to repeat code until the LOOP
is manually
exited using a LEAVE
statement. In general, the
syntax of the REPEAT
statement makes it better
suited for looping through cursors.
To put this all together, here is one further revision of our example stored procedure with cursor, this time with some actual processing of fetched data:
CREATE PROCEDURE processorders() BEGIN -- Declare local variables DECLARE done BOOLEAN DEFAULT 0; DECLARE o INT; DECLARE t DECIMAL(8,2); -- Declare the cursor DECLARE ordernumbers CURSOR FOR SELECT order_num FROM orders; -- Declare continue handler DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done=1; -- Create a table to store the results CREATE TABLE IF NOT EXISTS ordertotals (order_num INT, total DECIMAL(8,2)); -- Open the cursor OPEN ordernumbers; -- Loop through all rows REPEAT -- Get order number FETCH ordernumbers INTO o; -- Get the total for this order CALL ordertotal(o, 1, t); -- Insert order and total into ordertotals INSERT INTO ordertotals(order_num, total) VALUES(o, t); -- End of loop UNTIL done END REPEAT; -- Close the cursor CLOSE ordernumbers; END;
In this example, we've added another variable named
t
(this will store the total for each order). The
stored procedure also creates a new table on the fly (if it
does not exist) named ordertotals
. This table
will store the results generated by the stored procedure.
FETCH
fetches each order_num
as it
did before, and then used CALL
to execute another
stored procedure (the one we created in the previous tutorial)
to calculate the total with tax for each order (the result of
which is stored in t
). And then finally,
INSERT
is used to save the order number and total
for each order.
This stored procedure returns no data, but it does create and
populate another table that can then be viewed using a simple
SELECT
statement:
SELECT * FROM ordertotals;
+-----------+---------+ | order_num | total | +-----------+---------+ | 20005 | 158.86 | | 20006 | 58.30 | | 20007 | 1060.00 | | 20008 | 132.50 | | 20009 | 40.78 | +-----------+---------+
And then you have it, a complete working example of stored procedures, cursors, row-by-row processing, and even stored procedures calling other stored procedures.


Spike Lee Directing Hip-Hop Version Of "Romeo And Juliet"
by AllHipHop StaffThe legendary director will return to Brooklyn to shoot a hip-hop version of William Shakespeare's classic.
(AllHipHop News) Spike Lee is to direct a version of William Shakespeare's "Romeo And Juliet" set in the 1980s New York hip-hop scene.
According to The Hollywood Reporter, the "BlacKkKlansman" filmmaker has closed a deal to direct "Prince of Cats," an adaptation of Ron Wimberly's graphic novel.
The 2012 book tells Romeo and Juliet's story through the eyes of her hot-headed cousin Tybalt and transports the story to a fictionalized version of 1980s Brooklyn.
The project has been in development since 2018, when it was to star Lakeith Stanfield, but the "Knives Out" actor has since dropped out of the movie.
Spike Lee will rewrite the script with Wimberly and former The Source editor Selwyn Seyfu Hinds, who wrote the original adapted screenplay. Casting details are yet to be announced.
In "Prince of Cats," Tybalt and his Capulet brothers, battle with their rival Montagues for control of Da People's Republic of Brooklyn, where underground sword duelling has become a method of settling disputes, among youngsters obsessed with hip-hop, DJing and graffiti.
His follow-up project is "Da 5 Bloods," a Vietnam War thriller starring Chadwick Boseman.


Here are some useful tips to help you enjoy this site more:
Click on an image to see more information about that image
Search for images by their category by filling in the 'search category' form on the navbar. Note that available categories are Fashion, Food ,Architecture, Pets and Travel
Search for images based on their locations by clicking on the 'Search locations' tab in the navbar and filling in the location you want in the search form.Note that if you do not enter a location, all images from all locations will be displayed to you.
To copy an image link to your clipboard, click on the image, then click the copy button in the pop-up


Mahout Quick Start
TODO : Fill this in with the bare essential basics
Mahout MapReduce Overview
Getting Mahout
Download the latest release
Download the latest release here.
Or checkout the latest code from here
Alternatively: Add Mahout 0.13.0 to a maven project
Mahout is also available via a maven repository under the group id org.apache.mahout. If you would like to import the latest release of mahout into a java project, add the following dependency in your pom.xml:
<dependency>
<groupId>org.apache.mahout</groupId>
<artifactId>mahout-mr</artifactId>
<version>0.13.0</version>
</dependency>
Features
For a full list of Mahout’s features see our Features by Engine page.
Using Mahout
Mahout has prepared a bunch of examples and tutorials for users to quickly learn how to use its machine learning algorithms.
Recommendations
Check the Recommender Quickstart or the tutorial on creating a userbased recommender in 5 minutes.
If you are building a recommender system for the first time, please also refer to a list of Dos and Don’ts that might be helpful.
Clustering
Check the Synthetic data example.
Classification
If you are interested in how to train a Naive Bayes model, look at the 20 newsgroups example.
If you plan to build a Hidden Markov Model for speech recognition, the example here might be instructive.
Or you could build a Random Forest model by following this quick start page.
Working with Text
If you need to convert raw text into word vectors as input to clustering or classification algorithms, please refer to this page on how to create vectors from text.


THE HAUNTING A film review by Mark R. Leeper
Capsule: What starts as a new version of THE HAUNTING mixes in aspects of THE UNINVITED and THE LEGEND OF HELL HOUSE. Eventually director Jan de Bont gives in to the temptation to excess and his film turns into POLTERGEIST. Still enough is worth seeing here, particularly for the beautiful production design by Eugenio Zanetti. Jan de Bont was the wrong person to direct, but the film still succeeds in raising gooseflesh thanks in large part to the atmosphere created by Zanetti. Rating: 7 (0 to 10), low +2 (-4 to +4)
For me there are three ghost stories on film that I would put in my first tier-these are the best. Those are THE UNINVITED, THE INNOCENTS, and THE HAUNTING (1963). The second tier would include THE LEGEND OF HELL HOUSE, THE CHANGELING, and THE LADY IN WHITE. There would probably be a few others. The third tier would probably include POLTERGEIST, effective but a little soul-less. In interviews about the new THE HAUNTING from The Dreamworks, this second film based on the novel THE HAUNTING OF HILL HOUSE by Shirley Jackson, director Jan de Bont (SPEED, TWISTER) said that he was not really approaching this as a horror film. What he wanted was to make was a different sort of action film. Audiences are tired of traditional crime action films, but not many have been done as horror. Given that that is the case, it is remarkable that the new THE HAUNTING is as good as it is at raising gooseflesh. For now I would put it in the second tier. I may or may not feel that positive on the film in five years. Time and again de Bont does wrong what director Robert Wise did so very right in the 1963 version. Part of what made the original film effective is that the main character was weak. We could empathize with her rather than admire her and we saw the film from inside her head, even to the point of hearing her thoughts. The horror in the 1963 version is almost all heard rather than seen. There is just a hint that is visual that any of this is really happening. Wise had to use very three-dimensional characters to make the people and the threat to them seem real. Today's younger action audience might not have responded to that, so instead de Bont gives us some strong characters and the scariest haunted house money can buy. There are more special effects in the trailer to the new film than Wise put into the entirety of his version.
Eleanor Lance (played by Lili Taylor) gets an invitation to be part of a sleep study by Dr. Jeffrey Marrow (Liam Neeson). The study will have her staying in a huge old mansion dating back to 1837. The house was built by a textile magnate and was the scene of much unhappiness. Eleanor's fellow test subjects include the seductive Theodora (Catherine Zeta-Jones) and the irreverent Luke Sannerson (Owen Wilson). What none of the subjects knows is that the study is not about sleep but about fear. Marrow is intentionally putting them into a frightening house to observe their reaction. As Marrow says "you don't tell the rats the rats will be in a maze." But the house may be scarier than he realizes. Even Marrow does not know the full history of evil in this house or of the spirits of the original master among others who still make the house their home. While starting with the plot from the book and the original film, this plot goes off in some new directions. Jerry Goldsmith makes his own comment on the profusion of haunting phenomena we see in this film by starting his end-credit music with a carnival theme.
There are far too many touches in this film that just seem weak after having seen the Robert Wise version (two nights earlier, in fact). In the original the groundskeeper and housekeeper seem to have been taken over by the spirit of the house and themselves seem to be a bit haunted. In this version they just come off as mean. Bruce Dern plays the groundskeeper as just his usual nasty, bullying character. It is not as effective as weaker-than-the-house characters in the original. But de Bont has a hard time doing weak characters. This version makes much more use of the early residents of Hill House, particularly the industrialist who built it and who here looks a lot like the early makeup designs for THE PLANET OF THE APES. De Bont replaces the mysterious seductive evil of the house with too great an abundance of strange phenomena. If Hill House is getting this treatment from the spirits, are not there a lot of places in which greater evils occurred. Why do we not see this degree of haunting more places?
The production design is credited to Eugenio Zanetti. If that name does not sound familiar consider that he performed the same function on such beautiful films as FLATLINERS, RESTORATION, and WHAT DREAMS MAY COME. Zanetti won the Academy Award for set design for RESTORATION and was nominated (and deserved to win) for WHAT DREAMS MAY COME. The Hill House he designed would be a dominating spirit even if there were no haunting. I hope Jan de Bont realizes how very much he owes to Zanetti for making this film as good as it is.
This version of THE HAUNTING would be a better film by another name. On its own it is actually quite a good ghost story about what is the most incredibly haunted house the screen has yet seen. By inviting comparison to one of the three best ghost stories on film, this action- oriented version comes up a poor second. But if we had to have a graphic version of Jackson's novel, this is far better than any we could have expected. I give it a 7 on the 0 to 10 scale and a low +2 on the -4 to +4 scale.
Mark R. Leeper<EMAIL_ADDRESS>Copyright 1999 Mark R. Leeper
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Chris is a Senior Undergrad UCSD student, where he is currently pursuing his Bachelors degree in Computer Science. He previously attended two junior colleges, Cuesta and Palomar, to complete majority of his GE's.


Update 1 (September 29, 2013) – Added references and more CMS.
Update 2 (September 30, 2013) – ComfortableMexicanSofa does not use Liquid Template, as GBH has pointed out in the comment.
Selecting a Content Management System (CMS) is never an easy task. I have recently spent a good amount of time tinkering with different implementations and would like to share my learnings here.
There are many solutions on the market so you should solidify your requirements to help you narrow down the choices. This CMS will be used for ForYogi with the following requirements:
- Admin can add tutorials on how to use the site for teachers/studios/users.
- Admin can add articles for yoga-related topics into a knowledge base. Topics can be as simple as definition of yogi or Sanskrit terminologies such as asana.
- Admin can add help content which can be accessed by the application and displayed in various parts of the app.
- Admin can add FAQs.
- Users can search contents in Knowledge Base.
- Admin can customize layout and css style.
- Drop-in support for existing Rails4 (Ruby 2) project.
- Inexpensive – Some hosted solution can get pricey depending on storage and other factors.
General Impression
CMS is often used by developers to create customizable mostly static websites for clients. Most of the Rails CMS gems have over the years, enginfied, providing drop-in support for existing Rails apps.
There are free and pro episodes of it on RailsCasts.com. I don’t have a pro-account so I only examined the free content. My impression is it’s easy to set it ground-up with customized style. This CMS has been around for a long time and has a good community build around it. There are two factors against me choosing it though:
- At the time of writing, its Rails4 support is work in progress.
- Integrating it with an existing application using devise is quite involved according to this article.
This one has a nicely styled site (compare to some other CMS) but has a few things that concerns me:
- It requires MongoDB. It is not a big deal. I’m not using Mongo in my current setup. I can get a small setup using Heroku add-on but I’d probably have to pay to get a storage bump-up in the near future.
- Weak documentation. I looked through the content and found documentation is quite superficial and lacking depth. It is understandable as they offer a hosting solution.
- The issue on Rails4 support concerns me the most:
Probably by the end of the year. However, It could happen sooner depending on how successful would be our hosting solution…Long story short, we need financial support to handle the next big version of the engine which will include a new UI.
As there is no guarantee for a rather future release of Rails4 support (at least not in their current roadmap), I pass.
AlchemyCMS
I first learned about this CMS through the comments on the free RailsCasts episode. They argued about why they are better than refineryCMS. I liked their idea of storing pure content, not css style and layouts in database. It’ll only make migration to other systems easier. I also noticed that they have a 3.0-dev branch supporting Rails4 with this sha. Installation has proven to be hard as there are a few conflict in various gems (if you use activeadmin and devise). I was able to install it after some struggle. However, I encountered problems running it (devise login, actions_cache). It was just wasting more time than I wanted at this point.
The first problem I had is jquery-rails version being too low even for their Rails 4 master branch for which peakpg opened an issue. After fixing that in my own fork, I continue running into other problems. Basically the Rails4 support is not quite ready yet.
This cleverly named gem is lesser popular than the other gems I’ve looked at based on the number of watches and forks on github. However, it is the only one that worked out-of-box with an existing Rails4 app with devise authentication. The documentation explains the theory well but lacks examples. I suggest watching the RailsCasts free episode on Liquid template and really understand tags and how to apply partials/helpers.
Here is how to create a simple navigation for all the pages. According to the guide, you need to add something like this:
1 2 3 |
|
But where do you add it? I tried to create a new partial _kb.html.erb under app/views/layouts and got a no partial found error. It is looking for cms_content and application directories for partials. So I created app/views/cms_content directory and moved the partial there. This kind/level of details should, ideally, be in the guide. You can then invoke this partial inside of a layout:
{{ cms:partial:kb }}
Once you get how Liquid template markup works with comfy sofa, it becomes intuitive to create sites/layouts/pages.
It is based on active_admin and uses devise for authentication. It is Rails4 only but it is an app and not meant to be used with any existing Rails application.
Conclusion
I selected ComfortableMexicanSofa for its ease in integration into an existing Rails4 application with devise authentication. The customization seems to be quite flexible. It is also possible to invoke it from the main app which enables me to display help content in various places inside of the app. The only requirement I haven’t looked at is search.
References


Form Validation
Name
What's your gender?
Male
Female
What's your birth date?
Email
Password
Confirm password
Submit


Police: Two teen girls taken into custody after stealing car, crashing on interstate
by Logan RudeMEDINA, Wis. - Two 15-year-old girls were taken into custody Saturday after they crashed a stolen car on I-94 in the town of Medina, according to an incident report.
According to the report, the girls got out of the car and ran into nearby cornfields. Police said they chased them down and took them into custody. Both were taken to the Juvenile Reception Center, police said.
The car, an Audi A5, was stolen around 5:35 a.m. Thursday when the owner left it running in a driveway to warm up, according to the report.
Police said witnesses saw the vehicle spin out of control on I-94 while heading westbound. The vehicle reportedly went across the median and into eastbound lanes.
The Wisconsin State Patrol is investigating the crash.


composer require wallee/oxid-6.0
If you don’t already have one, create a wallee account.
Download the extension.
Extract the files and upload them to the root directory of your store using FTP/SSH.
Run on the same path via terminal (required on oxid 6.10 upwards) this command to install the plugin:
composer require wallee/oxid-6.0
If the plugin still don’t work you need to run these commands:
./vendor/bin/oe-console oe:module:install source/modules/wle/Wallee
./vendor/bin/oe-console oe:module:install-configuration source/modules/wle/Wallee
./vendor/bin/oe-console oe:module:activate Wallee
./vendor/bin/oe-console oe:module:apply-configuration
Login to the backend of your OXID eSales store.
Navigate to Extensions → Modules and activate the wallee module.
You may wish to install the following extensions to enhance your and your customer’s experience:
FrontendOrderList This extension allows to restrict customer order overview based on transaction status. OrderListStatus This extension allows to restrict & sort admin order overview based on transaction status. The OXID eSales system only references orders with status New, Finished and Problems, while wallee references more states, see State graph.
Under Extensions > Modules > wallee, switch to the settings of the activated module and enter the wallee Space ID, User ID and Authentification Key that you can create an application user.
If you are using EE with multistore, the settings under Global Settings are shared over all stores. You may use different spaces for each store to configure different behaviours.
After saving the configuration, the payment methods are created in the OXID eSales store and the necessary webhooks are set up.
|
Note
|
Payment methods will only be available in your store once you assign them to shipping method(s). see Payment method configuration |
Optionally disable downloading invoice and packing slip. These settings allow customers to download the documents from their order overview in the OXID eSales frontend.
Optionally change the debug level which increases what information is logged in your /logs folder, see Error logging.
The main configuration is now finished. You should see the payment methods in your checkout. To view the payment method configuration in the backend of OXID eSales eSales go to Shop Settings > Payment Methods.
The wallee payment method configurations are synchronized automatically into the OXID eSales store. There are just a few payment method settings in the OXID eSales store under Shop Settings → Payment Methods.
To be available in your store, payment methods must be assigned to shipping method(s). This can be done as follows:
Navigate to Shop Settings → Shipping Methods and select the shipping method where the payment method(s) should be available.
Switch to the Payment
tab, and select Assign Payment Methods
.
Drag the wallee payment methods which should be available into the right column.
If you want to change the payment method description, title, logo, etc you need to do this in the payment method configuration. Changes will be synchronized automatically.
The Payment Process of wallee is completely standardized for every payment method you can process. This gives you the ability to simply add a payment method or processor without changes inside of your Magento configuration. An overview about the states and the payment processes of wallee can be found in the Payment Documentation.
In the following section we provide you an overview about how the wallee states are mapped into the OXID eSales State graph for orders.
OXID eSales only shows by default the order states New
, Finished
and Problems
.
The order status New
contains all orders that are in state Fulfill
.
The order status Problems
contains all orders that need your manual attention or are not considered to be ready for fulfillment (e.g Authorized
and Completed
)
The order status Finished
contains all failed orders.
In order to map the states from wallee to the OXID eSales status, you should install the OrderListStatus plugin. You will then get more information about the order state in wallee.
Below you find a diagram that shows the state machine of OXID eSales for orders including additional information for the state transitions.
OXID eSales does not have a separate invoice entity. However, we track the payment state of an order. An order is marked as paid if the following conditions are fulfilled:
A transaction is in the state Fulfill
.
The invoice in wallee has the state N/A
or paid
You can capture, cancel and refund transactions directly from within the OXID eSales backend. Please note if you refund, void or capture transaction inside wallee the events may not be synchronized into OXID eSales.
You have the possibility for your transactions to have the payment only authorized after the order is placed. Inside the connector configuration you have the option, if the payment method supports it, to define whether the payment should be completed immediately or deferred.
In order to capture a transaction, navigate to Administer Orders → wallee Transactions, open the transaction and click on the Complete
button.
|
Note
|
When the completion is pending in wallee the order will stay in pending state. |
In order to void a transaction, open the transaction and click on the Void
button.
|
Note
|
You can only void transactions that are not yet completed. |
You have the possibility to refund already completed transactions. In order to do so, open the transaction and click on the Refund
button. In case the payment method does not support refund, you will not see the possibility to issue online refunds.
You can make refunds based on product quantity. In order to do so enter the amount of products you wish to refund to your customer.
You can carry out as many individual refunds as you wish until you have reached the quantity of the original order. The status of the order then automatically switches to complete.
|
Note
|
It can take some time until you see the refund in OXID eSales. Refunds will only be visible once they have been processed successfully. |
As long as the delivery should not be done the state of the order will be in wallee_Completed
. This happens when the transaction in wallee
has not reached the fulfill state.
There are essentially two reasons why this can happen:
The transaction is not completed. In this case you have to complete the transaction as written above.
As long as we are not able to tell you if you should fulfill the order. The delivery decision is done automatically. If this does not happen within the defined time frame, wallee will generate a manual task which you should observe and follow the instructions. When there is a manual task we will also display it in the OXID eSales Backend.
You can find more information about manual tasks in our Manual Task Documentation.
Please note that captures, voids and refunds done in wallee are synchronized. However, there are some limitations. Inside wallee you are able to change the unit price and the quantity at once. This can not be done in the OXID eSales backend. We therefore recommend that you perform the refunds always inside the OXID eSales backend and not inside wallee. If a refund cannot be synchronized it will be sent to the processor but it could be that you do not see it inside your OXID eSales backend.
You can find more information about Refunds in wallee in our Refund Documentation.
In case the payment method supports tokenization you can store the payment details of your customer for future purchases.
In order to use this feature make sure that the One-Click-Payment Mode in your payment method configuration is set to allow
or force
storage.
|
Note
|
Tokenization is not available for guest checkouts. |
The extension will log various unexpected errors or information which can help identify the cause of the error. You can find the logs on the server of your store in the /logs folder. You have the option to change the debug level which increases what information is logged in your /logs folder:
Error (Default): Logs unexpected errors only.
Debug: Logs more information helpful for debugging.
Make sure that you followed the Configuration section by stating your wallee space ID and application user’s access information in the OXID eSales backend. By saving the configuration form the synchronization of the payment methods and the set up of the webhooks are initiated.
If this does not solve the problem, it could be that you use a special fee or coupon module that we do not support. Try to disable this plugin and see if it helps. The payment methods are only displayed if the plugin’s total calculation matches the actual order total.
If you need help, feel free to contact our support.


Ticket Reservation
- Voyage Assured offers first-class ticketing services on both local and international flights.
- We ensure you get the best location most convenient for you and your family members amongst available seats.
- Our clients know we effectively curb problems such as; unavailability of seats, missing of flights, and other several hassles at the airport.
- Our Inventory Control System has a real time interface to major airlines’ Yield management system to support a permanent optimization of the offered booking classes in response to changes in demand or pricing strategies of a competitor. We therefore know the availability of airlines as well as the respective special offers of various airlines at real-time basis – this is why our clients enjoy the best price ever.
So, let us help you see the world on a budget! Begin your search for cheap airfare and plenty of other travel deals at Voyage Assured. Whether you’re planning a family vacation, a romantic weekend getaway, a business trip, or travel to your ultimate dream locale, we have you covered with affordable domestic and international flights.
Contact us on: 081-2025-7343


Music Analizer
About
Analize
Contact
Music Analizer
With Music Analizer you can:
Find out information about songs (genre, album, rating, etc.)
Find out information about artists (popular songs, rating, country, etc.)
Extract key words and mood of songs and artists' discographies.
Analize
Enter an artist or a song
Name
Song
Artist
Search
Contact us


April 25
It's Beginning to Rain
Be glad then, ye children of Zion, and rejoice in the Lord your God: for he hath given you the former rain moderately, and he will cause to come down for you the rain, the former rain, and the latter rain the first month.
Joel 2:23
There's a spiritual flood coming. God has promised it. He's promised us an outpouring of Holy Spirit power that will bring in the greatest harvest of souls any of us have ever seen.
As believers, we've been reading about it in the Word and hearing about it from the pulpit for years. We've been staring toward heaven so long, waiting for it to come, that we've gotten cricks in our spiritual necks. We've had this mental image of God pouring down His Spirit from some sort of big heavenly pitcher above us.
But you know what? We've been looking in the wrong direction!
The pitchers God is going to use to pour out His power are right here on earth. Jesus explained it this way. "He that believeth on me, as the scripture hath said, out of his belly shall flow rivers of living water" John 7:38.
The end-time flood we've all been expecting is going to be composed of living waters that will pour forth from believers. The Holy Spirit within us will be the source of all the signs and wonders and miracles the prophets foretold. And when we begin to fervently pray the prayer of intercession, the flood of that power will begin to flow.
Zechariah 10:1 says, "Ask ye of the Lord rain in the time of the latter rain; so the Lord shall make bright clouds, and give them showers for rain, to every one grass in the
field."
Our prayers, our intercession, is what will release the great outpouring of God's Spirit. As we begin to join together and become a flood of Spiritual power in the earth.
So, ask, pray for a Holy Ghost gullywasher. Intercede for the outpouring.
Glory to God, it's already beginning to rain!
Scripture Reading: Joel 2:23-32


Long Huynh
Home
(current)
Contact
(current)
Portfolio
Contact Me!
Atlanta, Georgia
Email<EMAIL_ADDRESS>Mobile:(678)-799-5090
Check my resume here
Name
Email address
Message
Submit form


The home page displays the latest posts added to wellpapp. On the left you have a search field where you can type in a search expression. Tags are separated by space, and can be prefixed with - to exclude, ! to require fully set tags, and ~ to require weakly set tags.
Under this field there is a list of the most common tags in the search result you're viewing (excluding the tags you searched for). You can click on of them to see posts with that tag instead, or on + or - after them to include or exclude them from your current search.
You also get links under each tag in your current search to modify how it is used (move your mouse over the tag to see them). They mean the same thing as in a search expression except that + means normal inclusion (no prefix in expression) and X removes the tag from your search.
I you have a browser with modern javascript support you get completion in text fields (like the search box). This happens for any word you type with at least two characters. It pops up suggestions under the text field, you can use the mouse or arrow keys + enter to select one. In most browsers you can also press tab to get the common prefix of all suggestions (which is the whole thing if there is only a single suggestion).
The suggestion mechanism tries to be clever, and will not suggest aliases unless nothing else matches, and will suggest approximate matches if nothing matches exactly.
There are two ways to tag. The first is to go to an image and tag just that image. This works in all browsers. If you try to use a tag that doesn't exist you get to choose a type for it and create it.
The second (and much more convenient) way is to use the tag mode. This can be used on any search result (or search result-like page), but only if your browser has modern javascript support.
First click Tagmode to enable it. You get the tagmode interface at the top of the page. Clicking a thumbnail toggles selecting that image, and you have buttons to select all, none, or the inverse of what you have selected now. Select the images you wish to tag.
Now you can add or remove tags to/from these images. Say you want them to have the tag foo, and the tag bar weakly, but not the tag baz. You would enter "foo ~bar -baz" and press enter (or click apply). If any of these tags don't exist, you will be presented with an opportunity to create them. Choose a type and click create, or click cancel to return the tag to your text field (maybe you misspelled it). It isn't possible to use the rest of tagmode while creating tags.
You can also click on one of the tags on the left to enter them in the field. Hovering over one of the images shows what tags it currently has.


Quick start
Welcome to the Finqware API!
This alpha phase is about learning and testing various Open Banking APIs.
- Register yourself (personal or company) as a
servicer
- Register a tenant app with your servicer and get your API keys
- Go through the skills catalog and check what you want to implement
- Write the code, use the sandbox mode for each skill for test & dev
Overview
Skills
Concept
Open Banking is about opening access for businesses to create value on top of financial services provided via APIs.
Each API that we integrate into our middleware is a skill
. Examples: an account information API from Bank X is a skill, a payment initiation service from Bank Y is another skill.
With the initial releases, we'll focus on three skill types: account information, payment initiation and marketplace. As a roadmap item we're planning to introduce more utility such as customer care and skills related to resource management.
Each skill comes in two flavors: production and sandbox. Test & dev tenants will use sandbox skills.
Account information
These skills are mainly based on PSD2 AISP APIs from various banks.
Use cases: wallet applications or enterprise systems that need to query for bank accounts and transaction reports.
Payment initiation
Initially based on PSD2 PISP APIs from various banks.
Use cases: merchants willing to accept payments through a direct account-to-account transfer bypassing classic payment schemes.
Marketplace
Based on custom connectors that we're building with our partner servicers.
Use cases: marketplaces interested in selling financial products without the hassle of a direct integration with banks, insurance providers etc.
Servicers
A servicer
is a partner company registered with Finqware.
It may be a bank or an insurance company providing skills into the middleware, or a fintech that consumes the Finqware API.
Or even both: a bank may be providing its own APIs into the middleware and at the same time it may implement a multi-banking experience on top of Finqware.
From a Finqware API consumer standpoint, a servicer may register multiple tenant
apps.
A servicer has a number of developers/users with credentials on our developer's portal.
Tenants
A tenant
is your software, consuming the Finqware API. It usually has two components:
- a client-side application (eg: a mobile and/or a web front-end)
- a server. This is where you run the business logic, the user database etc.
It's important to make a clear distinction between the two. There are specific data items (i.e. tokens, secrets) that you can safely store in your client app, and others that we recommend to be used only in a server-to-Finqware communication.
A servicer may register multiple tenant apps for different business cases or just for technical reasons (eg: test & prod apps).
For a granular access control and reporting, each tenant is required to register the list of skills it connects to.
Security model
The Finqware API is protected by a number of keys and tokens.
It is important to follow the best practice around where it's safe to store/use them. You can make an API call from a web application using the client_id
, but use an access_token
only from your server-side code. Currently, a generally accepted opinion among security experts is that you cannot safely store secrets in a client application.
| Token/key | Client | Description |
|---|---|---|
| client_id | yes | An identifier for a tenant app |
| client_secret | no | A secret generated for each tenant app |
| client_app_key | yes | Used to initate a user session |
| temp_token | yes | A temporary token that can be exchanged for an access_token |
| access_token | no | A permanent token authorizing access to user data |
| credentials_id | no | Points to user data (eg: a bank account, an insurance) |
Tenant-level elements
Each tenant application will have three security elements associated with it:
- client_id
- client_secret
- client_app_key
They do not expire, but can be refreshed using the developer's portal.
As you'll notice in the developer's guide, a user session ends with receiving a temp_token
. The reason we're not sending the access_token
directly is that we designed the session flow to be developed entirely in a web/mobile context. This choice also facilitates the future development of client SDKs. Hence the middleware returns a temporary token that needs to be sent to your backend first and then exchanged for the final access_token
via a server-to-Finqware API call.
As a side note: we're also considering introducing a callback endpoint as an option. Following the end of a session, Finqware would call an API endpoint provided by your server for the token exchange.
User-level elements
Taking a user through a session is about obtaining consent to access their data (eg: an existing bank account), or creating new value for that user (eg: selling a new insurance). In both cases, there is at least one target object created at the middleware level.
Finqware does not store data that identifies the owner, but we return a credentials_id
that represents your acccess point to these objects.
Practical example: for an account information skill backed by PSD2 AISP, a user may give their consent to access three bank accounts. In this case, your generated credentials_id
will point to these three objects.
An API call where credentials_id
is specified, needs to be authorized by its respective acccess_token
.
Your user may have multiple pairs of [credentials_id
, access_token
] depending on how many resources they decide to access through your app. Plan and design your user database considering this aspect.
Guide
This section is for tenant app developers who want to implement the base API (REST & GraphQL). We'll also make SDK's available, but the API endpoints will always remain open for those who need maximum flexibility.
Implementing Finqware skills is always centered around the end-user - that being the individual or institution who owns the data queried through the middleware. As a tenant app developer, you're implementing two aspects:
A conversational UX that takes the user through a number of action steps in order to get access to the data. This is a web or native-mobile UI that takes your user through an onboarding experience.
A Backend/server piece that consumes data the user has already consented for in the previous step.
User onboarding
The first thing to focus on is to offer your user a smooth onboarding experience. You may design a classic wizard with a step-by-step approach or have a more inovative approach like chatbot or voice-based UIs.
The Sessions API helps you implement such a UI. A session is very similar to what most of us know from web programming: an ordered sequence of steps that share the same state. Although this is a unified developer experience, each skill may have particular steps to implement.
Practical examples:
- getting the user consent for an account information skill is a one-step session (i.e. trigger the strong customer authentication process)
- selling a bank deposit product takes the user through multiple steps where the user may be required to submit information and upload data in separate steps due to inter-step dependencies.
As we integrate more skills into the middleware, we'll be documenting the required steps for each case. The Sessions API is generic enough to support complex conversational UIs that involve multiple iterations, uploads, synchronous and asynchronous communication (eg: cases where the online session might be interrupted due to an offline verification).
This diagram is an example of a three-step session, where the first two steps have attachments (uploads).
A session is essentially a conversation where each message may include attachments.
Detailed flow
An oboarding session is triggered by a HTTP POST
to the /sessions
endpoint. It has to include three elements:
client_id
: identifies your tenant applicationclient_app_key
: authorizes the call (safe to be used from a client app)skill
: which skill you're starting the onboarding session for. This is taken from the skills catalog published and updated on our docs.
{
"client_id": "{{client_id}}",
"client_app_key": "{{client_app_key}}",
"skill": "xyz_aisp_sbx_#1.0"
}
Following a successfull call, you will receive a message including:
- a
session_id
: identifies the newly created session. You will use this to submit subsequent steps. - a
nonce
: a temporary token safe to be used from a client app. You will use this to submit data in the next iteration - that would be step #1 into your session. Currently the nonce expires in 30 minutes. - a
status
: an informative message
{
"nonce": "F3YXJlCjAwMTZpZGVudGlmaWVyIG5vbmNlcwowMDJlY2lkIHRpbWU8MjAxOS0wNS0zMVQwOToxNToxNS41OTE5Nz",
"session_id": "7489fe74-a91d-4897-8895-cd5e05c0fc4b",
"status": "SESSION_CREATED"
}
Now that the session is created, you can start submitting data specific to each skill. At each iteration you specify the step
and provide the nonce
retrieved from the previous one. In a multi-step session, at each step submission, the response message will include a step_id
and the nonce
for the next step.
Use the /sessions/{session_id}/steps
endpoint to submit data for a specific step.
{
"client_id": "{{client_id}}",
"nonce": "{{nonce}}",
"skill": "xyz_sbx_#3.0",
"step": "product_form",
"data": {
"value": "100000",
"currency": "EUR",
"period": "12"
}
}
At certain steps, a skill might require specific uploads. An example would be an onboarding session for a credit card product. The KYC (know your customer) flow asks for personal data, ID upload and photo/selfies.
Use the /steps/{step_id}/upload
endpoint to submit uploads for a specific step.
In the above diagram please notice the moments where nonce
for each step and the temp_token
are generated.
The nonce to be used for any API call related to step #1 is generated when the session is initialized. The nonce to be used for any API call related to step #2 is generated when step #1 data is submitted.
The temp_token is generated when you submit data with the last step - in the example above, the session has two steps, hence it's generated with Step #2. This marks the end of a successful user session: user consent has been given or the product onboarding was done without any issue.
This is an important point in this flow, as you need to make the switch to the server-side. The switch is made by sending the temp_token
to your backend server. This is where you call the /token
endpoint to exchange it for an access_token
along with the credentials_id
that points to the newly created object/s.
The call to /token
is authenticated by using the client_id
and client_secret
. The access_token
plus the credentials_id
need to be stored by your backend along with the end-user data.
Consuming data
Having the access_token
and the credentials_id
for a certain resource generated with the flow above, you can now start querying the data.
This is specific for each skill. An account information skill would be used by querying the /accounts
and /transactions
API endpoints. We're also planning to release the GrapqhQL endpoints, including support for realtime subscriptions - currently in internal testing phase.
At this stage, all the API calls should be done by your tenant's backend, authenticated with the tenant's client_id
and client_secret
.
Designing a tenant app
As mentioned before, building an application on top of Finqware means in general that you have to build a front-end (web/mobile) and a backend. It is unsafe to build a client-only app unless it will run on trusted devices.
It will be possible to build your app entirely on the backend though. This is targeted to enterprise applications.
The front-end
The challenge here is to design how to keep state between Session steps. State management in web/mobile apps has become a hot topic, especially since Facebook introduced the flux pattern back in 2014. It's always a matter of taste and depends greatly on what programming language and framework you're using.
The diagram below is a screenshot of a Redux store used in our demo mobile app. The app, which we'll open source, is actually written with Flutter and uses a port of Redux in Dart.
In the example below, the client app has a central Redux state where we keep parameters related to the GUI (eg: isLoading
) and pervasive data such as what we need for session/steps.
A 1st-level branch stores a list of skills queried using the Catalog API. The other 1st-level branches are actual objects that store session/step data: webdepo
is a bank deposit product and aispSession
holds data for any skill based on PSD2 AISP.
The backend
A super simple UML design for your database potentially looks like this:
In the example above: an end-user would give you access to multiple financial assets by completing onboarding session/s. Each asset has a pointer to the respective Finqware resource in the form of the pair [finq_credentials_id
, finq_access_token
]. It also has a number of transactions associated - if the asset is for example a credit card.
Catalog API
Sessions API
Accounts API
Transactions API
Errors
The Kittn API uses the following error codes:
| Error Code | Meaning |
|---|---|
| 400 | Bad Request -- Your request is invalid. |
| 401 | Unauthorized -- Your API key is wrong. |
| 403 | Forbidden -- The kitten requested is hidden for administrators only. |
| 404 | Not Found -- The specified kitten could not be found. |
| 405 | Method Not Allowed -- You tried to access a kitten with an invalid method. |
| 406 | Not Acceptable -- You requested a format that isn't json. |
| 410 | Gone -- The kitten requested has been removed from our servers. |
| 418 | I'm a teapot. |
| 429 | Too Many Requests -- You're requesting too many kittens! Slow down! |
| 500 | Internal Server Error -- We had a problem with our server. Try again later. |
| 503 | Service Unavailable -- We're temporarily offline for maintenance. Please try again later. |


{% extends "base.html" %} {% block content %}
Query the acsql Database
Query form »
Links to public ACS archival data.
Archive »


Home | Meditation Process
Before reading chapter 2, my thoughts about the topic were all based on my previous experiences exploring the concepts or practice of meditation. I have trialed similar methods in the past but never commited enough time to it in order to notice the benefits.
In chapter 2 an example is given about a particular study which suggests there maybe a direct link between the increased antibody levels in a test subject who was vaccinated while meditating. This is not something I would have expected could be achieved through meditation and I'd be interested in seeing if further stuies have been done.
Not really, I think its about finding a comfortable position to support yourself so that it has the least affect on your meditation session.
Yeh, although I believe meditation could be a really beneficial tool for personal development, I'm not quite ready to concede that some of the supernatural claims in chapter 2 are as valid as the author claims.
Work being done by KEELAN WALKER


Submit
Reset
Portcullis
-
+
Cheval de Frise
-
+
Moat
-
+
Ramparts
-
+
Drawbridge
-
+
Sally Port
-
+
Rock Wall
-
+
Rough Terrain
-
+
Low Bar
-
+
Low Goals
-
+
High Goal Misses
-
+
High Goal Scores
-
+
Challenged Tower?
Climbed tower?
No
Partially
Yes
Defense?
Auto
Crossed a defense?
No
Portcullis
Cheval
Moat
Ramparts
Drawbridge
Sally Port
Rock Wall
Rough Terrain
Low Bar
Low Goals
-
+
High Goal Misses
-
+
High Goal Scores
-
+


Woman Battling Depression Jumps Off Mumbai Highrise, Dies
by Press Trust Of IndiaCity News
A 36-year-old woman undergoing treatment for depression jumped from the 13th floor of a building in Nagpada in south Mumbai on Saturday morning.
Written By Press Trust Of India | Mumbai | Updated On: November 24, 2019 19:32 IST
A 36-year-old woman undergoing treatment for depression jumped from the 13th floor of a building in Nagpada in south Mumbai on Saturday morning, police said. An official said the woman, whom police refused to identify, was distressed after undergoing divorce and due to the recent death of her parents.
READ: Depression: Exercises And Asanas To Help Alleviate Depression Symptoms
"The woman, a resident of Mira Road, had seen her seven-year marriage end in divorce recently. She was living with her parents here. However, her parents died recently after which she slipped into depression and was being treated at Kokilaben Hospital," a Nagpada police station official said.
She was staying with her cousin and uncle in Orchid Enclave in Nagpada. On Friday too she had attempted suicide but was rescued, the official said. "On Saturday, unknown to relatives, she went to the 13th floor of Orchid Enclave and jumped off at around 10:15am.  We have registered an accidental death report," he added.
READ: Surveen Chawla Talks About Post-partum Depression And Losing Weight


Exercise 4: Create a custom Effect (XAM330)
In this exercise, you'll create a brand new gradient effect and apply it to a button.
To complete the exercise, you will need Visual Studio for Windows or macOS with the Xamarin development tools installed. You will also need either an emulator/simulator or a device to run the exercise on. Please see the setup page if you need help installing the Xamarin development environment.
Open the starter solution
Open the starter solution from the Exercise 4 > Start folder in your copy of the cloned or downloaded course materials in either Visual Studio on Windows or Visual Studio for Mac.
Create the Android Effect
To create the Android effect, you'll add a new PlatformEffect
class to the Android head project and override OnAttached and OnDetached to apply and remove the gradient.
- Add Gradient.Droid.cs to the Android head project.
- Create a new class named MyButtonGradientEffect in the Android project.
- Update the class to derive from
PlatformEffect
. You may need to add theXamarin.Forms.Platform.Android
using statement. - Override the
OnAttached
andOnDetached
methods. -
Add a
Drawable
field named oldDrawable. You'll use this field to cache off the existing background.using Xamarin.Forms; using Xamarin.Forms.Platform.Android; namespace ControlExplorer.Droid { public class MyButtonGradientEffect : PlatformEffect { Drawable oldDrawable; protected override void OnAttached() { } protected override void OnDetached() { } } }
- Create a new method named SetGradient.
- Cast the
Element
property to a Xamarin.FormsButton
and save it to a local variable named xfButton. - Read the
BackgroundColor
property of xfButton and save it to local variable named colorTop. - Create another
Xamarin.Forms.Color
variable named colorBottom and set it to black. - Call the static method
GetGradientDrawable
on the providedGradient
class, passing in both colors. You'll need to callToAndroid
to convert them from Xamarin.Forms colors to Android colors. -
Call the
SetBackground
method on theControl
property passing in the returnedDrawable
fromGetGradientColor
.void SetGradient() { var xfButton = Element as Xamarin.Forms.Button; var colorTop = xfButton.BackgroundColor; var colorBottom = Xamarin.Forms.Color.Black; var drawable = Gradient.GetGradientDrawable(colorTop.ToAndroid(), colorBottom.ToAndroid()); Control.SetBackground(drawable); }
- In
OnAttached
check if theElement
property is aButton
, if not return. - Save the existing
Control.Background
Drawable
to the oldDrawable field. - Call
SetGradient
. -
In
OnDetached
, check if oldDrawable is non-null, and if so, assign it toControl.Background
.protected override void OnAttached() { if (Element is Button == false) return; oldDrawable = Control.Background; SetGradient(); } protected override void OnDetached() { if (oldDrawable != null) Control.Background = oldDrawable; }
- Use the
ResolutionGroupName
assembly attribute to set the group name to Xamarin (you only need to apply this attribute once per assembly, so if you already have it from a previous effect, you would not repeat it here). -
Use the
ExportEffect
assembly attribute to export the effect name as ButtonGradientEffect.[assembly: ResolutionGroupName ("Xamarin")] [assembly: ExportEffect (typeof (MyButtonGradientEffect), "ButtonGradientEffect")]
Create the iOS Effect
To create the iOS effect you'll follow very similar steps to those above for the Android effect, except you'll use the native iOS APIs. You'll add a new PlatformEffect
class to the iOS head project and override OnAttached and OnDetached to apply and remove the gradient.
- Add the provided Gradient.iOS.cs file to the iOS head project.
- Create a new class named MyButtonGradientEffect in the iOS project.
- Update the class to derive from
PlatformEffect
. You may need to add theXamarin.Forms.Platform.iOS
using statement. - Override the
OnAttached
andOnDetached
methods. -
Add a
CAGradientLayer
field named gradLayer. You'll use this field to cache your gradient.using Xamarin.Forms; using Xamarin.Forms.Platform.iOS; using CoreAnimation; namespace ControlExplorer.iOS { public class MyButtonGradientEffect : PlatformEffect { CAGradientLayer gradLayer; protected override void OnAttached() { } protected override void OnDetached() { } } }
- Create a new method named SetGradient.
- In the new method, check if gradLayer is non-null, and if so, remove it using its
RemoveFromSuperLayer
method. - Cast the
Element
property to a Xamarin.FormsButton
and save it to a local variable named xfButton. - Read the
BackgroundColor
property of xfButton and save it to local variable named colorTop. - Create another
Color
variable named colorBottom and set it to black. - Call the static method
GetGradientLayer
on the providedGradient
class, passing in both colors andxfButton
's width and height. You'll need to callToCGColor
to covert the colors from Xamarin.Forms colors to CGColors (this is an extension method, include ausing
statement forXamarin.Forms.Platform.iOS
to access it). -
Insert the returned
CAGradientLayer
at position 0 ofControl.Layer
.void SetGradient() { gradLayer?.RemoveFromSuperLayer(); var xfButton = Element as Button; var colorTop = xfButton.BackgroundColor; var colorBottom = Color.Black; gradLayer = Gradient.GetGradientLayer(colorTop.ToCGColor(), colorBottom.ToCGColor(), (float)xfButton.Width, (float)xfButton.Height); Control.Layer.InsertSublayer(gradLayer, 0); }
- In
OnAttached
check if theElement
property is aButton
, if not return. - Call
SetGradient
. -
In
OnDetached
, check if gradLayer is non-null, and if so, remove it using itsRemoveFromSuperLayer
method.protected override void OnAttached() { if (Element is Button == false) return; SetGradient(); } protected override void OnDetached() { if(gradLayer != null) gradLayer.RemoveFromSuperLayer (); }
- Use the
ResolutionGroupName
assembly attribute to set the group or company name to Xamarin (you only need to apply this attribute once per assembly, so if you already have it from a previous effect, you would not repeat it here). -
Use the
ExportEffect
assembly attribute to export the effect name as ButtonGradientEffect.[assembly: ResolutionGroupName ("Xamarin")] [assembly: ExportEffect (typeof (MyButtonGradientEffect), "ButtonGradientEffect")]
Create the UWP Effect
To create the Windows effects you'll add a new PlatformEffect class to the UWP project and override OnAttached and OnDetached to apply and remove the gradient.
- Add Gradient.UWP.cs to the UWP head project.
- Create a new class named MyButtonGradientEffect in the head project.
- Update the class to derive from
PlatformEffect
. You may need to add the Xamarin.Forms.Platform.UWP using statement. - Override the
OnAttached
andOnDetached
methods. -
Add a
Brush
field named oldBrush. You'll use this field to save the original brush.using Xamarin.Forms; using Xamarin.Forms.Platform.UWP; namespace ControlExplorer.UWP { public class MyButtonGradientEffect : PlatformEffect { Brush oldBrush; protected override void OnAttached() { } protected override void OnDetached() { } } }
-
Create a new method named GetWindowsColor that accepts a
Color
parameter. This method will be used to covert Xamarin.Forms colors to Windows UI colors. The code is identical for all 3 Windows platforms (see below).Windows.UI.Color GetWindowsColor (Color color) { return Windows.UI.Color.FromArgb((byte)(255 * color.A), (byte)(255 * color.R), (byte)(255 * color.G), (byte)(255 * color.B)); }
- Create a new method named SetGradient.
- Cast the
Element
property to a Xamarin.FormsButton
and save it to a local variable named xfButton. - Cast the
Control
property to aFormsButton
and save it to a local variable named button. This is a subclass of the native Windows button. - Read the
BackgroundColor
property of xfButton and save it to local variable named colorTop. - Create another
Color
variable named colorBottom and set it to black. - Call the static method
GetGradientBrush
on the providedGradient
class, passing in both colors. You'll need to callGetWindowsColor
to convert them from Xamarin.Forms colors to Windows colors. -
Assign the returned
Brush
to theBackgroundColor
property onbutton
.void SetGradient() { var xfButton = Element as Button; var button = Control as FormsButton; var colorTop = xfButton.BackgroundColor; var colorBottom = Color.Black; button.BackgroundColor = Gradient.GetGradientBrush(GetWindowsColor(colorTop), GetWindowsColor(colorBottom)); }
- In
OnAttached
check if theElement
property is aButton
, if not return. - Cast
Control
to aFormsButton
and save it to a local variable. - Assign the
BackgroundColor
property of theFormsBrush
to oldBrush. - Call
SetGradient
. -
In
OnDetached
, check if oldBrush is non-null, and if so, again castControl
to aFormsButton
and assign oldBrush to itsBackgroundColor
property.protected override void OnAttached() { if (Element is Button == false) return; var button = Control as FormsButton; oldBrush = button.BackgroundColor; SetGradient(); } protected override void OnDetached() { if (oldBrush == null) return; var button = Control as FormsButton; button.BackgroundColor = oldBrush; }
- Use the
ResolutionGroupName
assembly attribute to set the group or company name to Xamarin (you only need to apply this attribute once per assembly, so if you already have it from a previous effect, you would not repeat it here). -
Use the
ExportEffect
assembly attribute to export the effect name as ButtonGradientEffect.[assembly: ResolutionGroupName ("Xamarin")] [assembly: ExportEffect (typeof (MyButtonGradientEffect), "ButtonGradientEffect")]
Create a RoutingEffect
Create a RoutingEffect
class in the ControlExplorer PCL named ButtonGradientEffect. Refer to the previous exercise if you need help creating the RoutingEffect.
public class ButtonGradientEffect : RoutingEffect
{
public ButtonGradientEffect () : base ("Xamarin.ButtonGradientEffect")
{}
}
Use the Gradient Effect
You'll apply the effect programmatically in preparation for the next exercise. Remember that the iOS effect needed the width and height of the button to create the gradient layer. Because of this, you need to ensure the visual tree has been rendered before applying the effect so you'll use one of the ContentPage lifecycle methods.
- Open MainPage.xaml.cs in the PCL.
- Override
OnAppearing
. -
In the method, apply the effect by instantiating an instance of
ButtonGradientEffect
and adding it to buttonClick'sEffects
collection.public partial class MainPage : ContentPage { ... protected override void OnAppearing() { base.OnAppearing(); buttonClick.Effects.Add(new ButtonGradientEffect()); }
Exercise summary
In this exercise you created a custom effect in each platform-specific project to display a gradient background onto a button.
You can view the completed solution in the Exercise 4 > Completed folder of your copy of the cloned or downloaded course materials.


Surface air temperature anomalies in the zonally redistributed heat flux simulations. The NP-Cool/NA-Warm simulation ( a) prescribes a negative heat flux perturbation in North Pacific (−1 W/m 2 global) compensated with an equivalent positive North Atlantic Q-flux perturbation (+1 W/m 2 global), such that the net global energy perturbation is zero. The sign of the heat flux perturbations in the NP-Warm/NA-Cool simulation ( b) are reversed relative to the NP-Cool/NA-Warm simulation. In both simulations, the North Pacific heat flux anomaly dominates the surface air temperature response in the Artic. Gray areas indicate changes not significant at the 95% confidence level


@* * Copyright 2019 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import config.AppConfig @import uk.gov.hmrc.play.views.html._ @import controllers.routes._ @import uk.gov.hmrc.wco.dec.GovernmentProcedure @(form:Form[_], governmentProcedures: Seq[GovernmentProcedure])(implicit request: Request[_], messages: Messages,appConfig:AppConfig) @main_template( title = messages("governmentprocedures.title"), bodyClasses = None) { @helpers.form(action = controllers.goodsitems.routes.GovernmentProceduresController.onSubmit()) { @components.error_summary(form.errors)
} }


XCloud
Hello, this is
XCloud
, an AI cloud platform maintained by
LucasX
. You are visiting NLP module.


The NPSTreeData class is used to represent tree objects. Each nod of the tree, including the root node, is an NPSTreeData instance. Each node may have its own content, a parent or children.
The content of each node is either set when it is created or using the .setContent method.
.getContent returns the content.
.getContentForDisplay is used by the widgets that display trees, which expect it to return a string that can be displayed to the user to represent the content. You might want to overload this method.
newChild(content=...) creates a new child node.
selectable (new in version 2.0pre70) If this attribute is true the user can mark a value as ‘selected’. This is used by MLTreeMultiSelect widget, and is True by default.
The values attribute of this class must store an NPSTree instance. However, if you wish you can override the method convertToTree of this class. This method should return an NPSTree instance. The function will be called automatically whenever values is assigned.
By default this class uses TreeLine widgets to display each line of the tree. In derived classes You can change this by changing the class attribute _contained_widgets. The class attribute _contained_widget_height specifies how many lines of the screen each widget should be given.
New in version 2.0pre70
This class allows you to select multiple items of a tree. You can select which nodes of NPSTreeData the user is able to select by setting the attribute selectable on that node.
The method get_selected_objects(self, return_node=True,) returns an generator object that lists the nodes that are selected. If return_node is True, the actual node itself is yielded, otherwise the value of node.getContent() is yielded instead.
New in Version 2.0pre71 If the attribute select_cascades is True (which can be set by passing the argument select_cascades at the time of creation or setting the attribute directly later), selecting a node will automatically select any selectable nodes under the selected node. This is set to True by default.
The selected nodes also have their attribute selected set to True, and so you can walk through the tree to find them if you prefer.
The widget used to display each line is TreeLineSelectable.
New in version 2.0pre71
A version of the MLTreeMultiSelect class that uses TreeLineSelectableAnnotated as its display widgets.
These classes are provided solely for compatibility with old code. New classes should use the MLTree and related classes
The values attribute of this class must store an NPSTree instance. However, if you wish you can override the method convertToTree of this class. This method should return an NPSTree instance. The function will be called automatically whenever values is assigned.
By default this class uses TreeLineAnnotated widgets to display each line of the tree. In derived classes You can change this by changing the class attribute _contained_widgets.
These classes are provided solely for compatibility with old code. New classes should use the MLTree and related classes
By default this class uses TreeLineAnnotated widgets to display each line of the tree. In derived classes You can change this by changing the class attribute _contained_widgets.