Operators
FQL supports a number of operators that can be used in expressions. There are comparison, logical, arithmetic, and the ternary operator.
Comparison operators
Comparison (or relational) operators compare two operands. They can be used with any input data types, and will return a boolean result value.The following comparison operators are supported:
==
equality!=
inequality<
less than<=
less or equal>
greater than>=
greater or equalIN
test if a value is contained in an arrayNOT IN
test if a value is not contained in an arrayLIKE
tests if a string value matches a patternNOT LIKE
tests if a string value does not match a pattern=~
tests if a string value matches a regular expression!~
tests if a string value does not match a regular expression
Each of the comparison operators returns a boolean value if the comparison can be evaluated and returns true if the comparison evaluates to true, and false otherwise.
The comparison operators accept any data types for the first and second operands. However, IN
and NOT IN
will only return a meaningful result if their right-hand operand is an array, and LIKE
will only execute if both operands are string values. The comparison operators will not perform any implicit type casts if the compared operands have different or non-sensible types.
Some examples for comparison operations in FQL:
The LIKE
operator checks whether its left operand matches the pattern specified in its right operand. The pattern can consist of wildcards. The list of supported wildcards can be found here.
The pattern matching performed by the LIKE
operator is case-sensitive.
The NOT LIKE
operator has the same characteristics as the LIKE
operator but with the result negated.
Array comparison operators
The comparison operators also exist as array variant. In the array variant, the operator is prefixed with one of the keywordsALL
, ANY
or NONE
. Using one of these keywords changes the operator behavior to execute the comparison operation for all, any, or none of its left hand argument values. It is therefore expected that the left hand argument of an array operator is an array.
Logical operators
The following logical operators are supported in FQL:&&
logical and operator||
logical or operator!
logical not/negation operator
FQL also supports the following alternative forms for the logical operators:
AND
logical and operatorOR
logical or operatorNOT
logical not/negation operator
The alternative forms are aliases and functionally equivalent to the regular operators.
The two-operand logical operators in FQL will be executed with short-circuit evaluation (except if one of the operands is or includes a subquery. In this case the subquery will be pulled out an evaluated before the logical operator).
The result of the logical operators in FQL is defined as follows:
lhs && rhs
will returnlhs
if it isfalse
or would befalse
when converted into a boolean. Iflhs
istrue
or would betrue
when converted to a boolean,rhs
will be returned.lhs || rhs
will returnlhs
if it istrue
or would betrue
when converted into a boolean. Iflhs
isfalse
or would befalse
when converted to a boolean,rhs
will be returned.! value
will return the negated value of value converted into a boolean
Passing non-boolean values to a logical operator is allowed. Any non-boolean operands will be casted to boolean implicitly by the operator, without making the query abort.
The conversion to a boolean value works as follows:
NONE
will be converted tofalse
- boolean values remain unchanged
- all numbers unequal to zero are
true
, zero isfalse
- an empty string is
false
, all other strings aretrue
- arrays, objects, binary and custom types are
true
, regardless of their contents
The result of logical and and logical or operations can now have any data type and is not necessarily a boolean value.
For example, the following logical operations will return boolean values:
whereas the following logical operations will not return boolean values:
Arithmetic operators
Arithmetic operators perform an arithmetic operation on two numeric operands. The result of an arithmetic operation is again a numeric value.FQL supports the following arithmetic operators:
+
addition-
subtraction*
multiplication/
division%
modulus
Unary plus and unary minus are supported as well:
For exponentiation, there is a numeric function POW(). The syntax base ** exp is not supported.
Some example arithmetic operations:
The arithmetic operators accept operands of any type. Passing non-numeric values to an arithmetic operator will cast the operands to numbers:
NONE
will be converted to0
false
will be converted to0
,true
will be converted to1
- a valid numeric value remains unchanged, but
NaN
and Infinity will be converted to0
- string values are converted to a number if they contain a valid string representation of a number. Any whitespace at the start or the end of the string is ignored. Strings with any other contents are converted to the number
0
- an empty array is converted to
0
, an array with one member is converted to the numeric representation of its sole member. Arrays with more members are converted to the number0
. - objects, binary and custom types are converted to the number
0
.
Here are a few examples:
Ternary operator
FQL also supports a ternary operator that can be used for conditional evaluation. The ternary operator expects a boolean condition as its first operand, and it returns the result of the second operand if the condition evaluates to true, and the third operand otherwise.There is also a shortcut variant of the ternary operator with just two operands. This variant can be used when the expression for the boolean condition and the return value should be the same:
Range operator
FQL supports expressing simple numeric ranges with the..
operator. This operator can be used to easily iterate over a sequence of numeric values.
The ..
operator will produce an array of the integer values in the defined range, with both bounding values included.
will produce the following result:
Operator precedence
The operator precedence in FQL is similar as in other familiar languages (lowest precedence first):? :
ternary operator||
logical or&&
logical and==
,!=
equality and inequalityIN
in operator<
,<=
,>=
,>
less than, less equal, greater equal, greater than+
,-
addition, subtraction*
,/
,%
multiplication, division, modulus!
,+
,-
logical negation, unary plus, unary minus()
function call.
member access[]
indexed value access
The parentheses (
and )
can be used to enforce a different operator evaluation order.


Sign Up
Already Registered?
Log In
Sign in with
Social Network
Log in with Facebook
Log in with Twitter
Log in with Instagram
OR


Answer 1:We collected money from the participants, fee was 10000KRW. It was enough
Answer 2: In total we spent 150000KRW.
Answer 1: ISSS might provide support for these activities, better to ask in their office directly.


Members
Votes
You're not a member!
Join
MemberName
0x123...456
Not a member
MemberName
0x123...456
Not a member
MemberName
0x123...456
Not a member


New Item
title
Title
note
Note
access_time
Due Date
label
Labels
add
search
Boards
add
add
dashboard
clear
Delete board
settings
Settings
Name
Name
Name
more_vert
Add Item
Delete Selected Items
Delete List


Add new memmber jqScheduler
Added two new classes Template and Session
Fix search module when data contain $ char
Fix SQL Server driver to get correct the primary key
Fix SQL Server driver for checking a undefined values
Fix fetch_num, fetch_object and coulumnCaount methods in Array driver
Fix debuging in queryGrid method
Fix export to Excel for PostgreSQL database for date fields
Fix array driver to support _ in names
Fix for array driver when search and empty result
Fix for single search method
Fix Exporting when array driver and there is a where clause
Fix properly build WHERE clause in array driver
Fix set ASC when ORDER is set to be default in array driver
Fix for closeCursor to reset the counter in array driver


Enter the maximum history you want:
Enter the pixel you want above new comments when using shortcuts to do to comments:
Use dark theme?
Change automatically to dark theme between:
to
Light theme:
Dark theme:
Save


Architecture
Overview
The architecture of the theodul player has a plugin based structure based around a core. The core and the plugins have been realized as OSGi modules. Each plugin can be separately build.
The following figure shows the OSGi architecture of the player.
All Theodul OSGi modules are stored under:
modules/engage-theodul-*
#Core module
modules/engage-theodul-api/
modules/engage-theodul-core/
#A plugin module
modules/engage-theodul-plugin-*
modules/engage-theodul-plugin-tab-description/
Plugin Manager
The main workflow is implemented by the core, which recognizes new plugins, collects information about the plugin type and resources, runs the JavaScript logic and inserts the first compiled templates into the HTML DOM.
The Plugin Manager Endpoint recognizes the OSGi modules. Each plugin has some information about its name and its resources. The Plugin Manager collects these information and publishes them via a REST endpoint. The following URL links to an example REST endpoint:
http://localhost:8080/engage/theodul/manager/list.json
The documentation and test forms of the endpoint can be found on the Opencast start page. The following data in JSON shows an example list of plugins, which are used by the player and provided by the Plugin Manager Endpoint.
{
"pluginlist":{
"plugins":[
{
"name":"EngagePluginTabSlidetext",
"id":"6",
"description":"Simple implementation of a tab with the text of the slides",
"static-path":"6\/static"
},
{
"name":"EngagePluginControlsMockup",
"id":"5",
"description":"Simple implementation of a control bar",
"static-path":"5\/static"
}]
}
}
Next to the Plugin Manager there is the Theodul Core module, which publishes the main HTML page, core.html.
UI Core
The core.html is the main entry point and starts the Javascript core logic. Following listing shows the directory structure of core in the engage-theodul-core OSGi module.
|-src
|---main
|-----java #Java impl of the plugin manager
|-----resources
|-------ui #UI of the core, core.html and engage_init.js
|---------css #Global CSS Styles
|---------js #JavaScript logic
|-----------engage #Core logic, engage_core.js and engage_model.js
|-----------lib #External libraries, backbone.js, jquery.js, require.js and underscore.js
|---test #Unit Tests
|-----resources
|-------ui #JavaScript Unit Tests
|---------js
|-----------spec
All Theodul JavaScript components are defined as a RequireJS module. The file engage_init.js
is loaded firstly and
contains the configuration of RequireJS. This init script additionally loads the core module, which is defined in the
engage_core.js
.
The core module initializes the main HTML view. This view is realized as a BackboneJS view and is linked to a global
Backbone model, which is stored in the model module in engage_model.js
. The view is returned by the core module, so
every other module, which has a dependency to the core module, has a reference to the view (simply called Engage in
the plugins) and its functions. See the Core Reference for more information about the functions of the core view.
Plugins
Plugins in the Theodul player are developed and distributed in own OSGi modules. Every plugin has a special UI type. In dependency of this type the core injects the plugin to the right position of the player. The following plugin types are possible:
| Plugin Type | Description | Characteristics | Module Name | JS Plugin Type Name | Maven Plugin Type Name |
|---|---|---|---|---|---|
| Controls | Implements the main controls of the top of the player | Only one plugin per player possible. | engage-theodul-plugin-controls | engage_controls | controls |
| Timeline | Timeline information below the main controls. | Good for processing time-based data like user tracking, slide previews or annotations. | Optional plugin, more than one possible. engage-theodul-plugin-timeline- |
engage_timeline | timeline |
| Videodisplay | Implementation of the video display. | Currently only one plugin per player possible, but in the future more video displays should be possible. | engage-theodul-plugin-video- |
engage_video | video |
| Description/Label | A plugin below the video display, good to show simple information about the video, like a title and the creator. | Only one plugin per player possible. | engage-theodul-plugin-description | engage_description | description |
| Tab | Shows a tab in the tab view at the bottom of the player. | Optional plugin, more than one possible. | engage-theodul-plugin-tab- |
engage_tab | tab |
| Custom | A custom plugin without a relationship to an UI element. | Good for a custom REST endpoint, global data representation or to load custom JS code or libraries. | Optional plugin, more than one possible. | No connection to a preserved UI element. | engage-theodul-plugin-custom- |
The following listing shows the directory structure of a plugin module:
|-src
|---main
|-----java
|-------org
|---------opencastproject
|-----------engage
|-------------theodul
|---------------plugin
|-----------------controls #Simple Java class, and optional REST endpoint
|-----resources
|-------OSGI-INF #OSGi information about the plugin
|-------static #web ressources, contains the main.js entry point of the plugin
|---------images #plugin ressources
|---------js #plugin js libs
|-----------bootstrap
|-----------jqueryui
|---test #Jasmine test ressources
|-----resources
|-------js
|---------engage #Test Wrapper of the core
|---------lib #Required test libs
|---------spec #Jasmine test specs
The main JavaScript entry point of the plugin is main.js in the static folder. This contains the RequireJS module definition of the plugin and the main logic. All other plugin logic can be implemented as a RequireJS module and loaded in the main module. The main module should have a dependency to the core, the Engage object. With this object you have access to main features of the core. See the Core Reference for more information about that.
After the initialization process of the plugin, the plugin returns a plugin object with information about the plugin, like the type, the name, the ui template etc. This object is used by the core to decide about the UI type/location of plugin. The Core Reference describes the plugin object, before and after it is being processed by the core.
Have a look to the code of a plugin to get an impression about the plugin implementation.
Model View Controller Support
The Theodul player supports MVC design patterns for each plugin based on methods and objects of the BackboneJS library. It is not necessary to design a plugin in MVC style but it is highly recommended. An overview of the methods and objects of the BackboneJS library is listed on the official website of BackboneJS.
Each plugin with a visual component has a reference to its view container and its template to fill the view container. Have a look at the Core Reference how to access the container and the template data. With this information the plugin can create a Backbone view with a reference to the to div container and a render function to compile the template.
The next step is the creation of a model, which is being bound to the view. An usual way is to create a Backbone model, which is being passed by the view. In the initialization function of the view, the view binds the model change event to his render function:
Bind the "change" event always to the render function of a view
// bind the render function always to the view
_.bindAll(this, "render");
// listen for changes of the model and bind the render function to this
this.model.bind("change", this.render);
The model can only be visible by the plugin itself or it can be added to the global Engage model of the core. Adding the model to the Engage model has the advantage, that on the one hand data can be used by other plugins and on the other hand it is able to listen to change- or add-events. So other plugins are able to listen to a change of data in another model and can react to it by e.g. re-render its view. This feature is e.g. used by the "mhConnection" custom plugin. The plugin receives data of Opencast endpoints and saves them to a model, which is being added to the Engage Model. Each time the plugin gets newer endpoint data and updates its model's data, each plugin gets a notification and can re-render its view.
A typical way to add a model to the Engage model is to add the model in the initialization function of the plugin after all other initializations. Here is an example of the video plugin:
Add a custom model to the Engage Model
Engage.model.set("videoDataModel", new VideoDataModel(videoDisplays, videoSources, duration));
In the same initialization function an event handler should be added to notice the addition of the model. Has the model successfully been added, a view with this model and other data can be created:
Model Event Handler
Engage.model.on("change:videoDataModel", function() {
new VideoDataView(this.get("videoDataModel"), plugin.template, videojs_swf);
});
If another plugin wants to use the defined "videoDataModel" model, it has to list it in its own initialization process:
Engage.model.on("change:videoDataModel", function() {
initCount -= 1;
if (initCount === 0) {
initPlugin();
}
});
Have a look at the full implementation of the VideoJS Plugin and the Controls Plugin to get an idea how the Backbone MVC design works. For completeness' sake, the "Controller" does not have an extra Object in the Backbone MVC design. The "Controller" is usually used as the render function in the view. This function can be very complex and should link to other functions, which are short and easy to be tested by the Jasmine Test Framework.


Although SMS can run on virtually all platforms supported HTML5 web browser, SMS is designed to run on smartphone. So, this section is concentrated on smartphone
selection and security hardening.
Before go into smartphone selection and hardening discussion, you should be told the best practice principles of your device for SMS communication.
You must remember that the device (no matter phone or computer) you used to connect the SMS server, should not be used for your daily life. i.e. You must isolate
your daily life (which point to your true identity) from your SMS related activities. So, you should better have at least two devices, one for your daily usage,
another is strictly for SMS communication or other secret tasks.
Now, you should determine how to select a secure smartphone. Below is a guideline about it:
| 1. |
Don't use those smartphone brands from dictatorial nations, such as China or Russia. They are long suspected to put surveillance spyware on their manufactured
smartphones to monitor users stealthily and steal data from users. Please consult
this list for details.
|
| |
| 2. |
Select those smartphones preloaded with most updated operating system, and their manufacturer also provide regular security patch, such as Google Pixel.
|
| |
| 3. |
Since only Firefox fulfil all SMS security requirements, but Firefox for iPhone and Onion browser don't have equivalent security features. Therefore,
iPhone and iPad should not be used.
|
After you get your smartphone, you need to harden it as following:
| 1. |
Fully encrypt your phone, and give a long password for it (8 or more characters). Please see
this article for details.
|
| |
| 2. |
Don't use biometric methods to unlock your smartphone, such as fingerprint or facial recognition. Always use long pin number, password or complicated
pattern. The reason is obvious, your phone can't be unlocked without your cooperation.
|
| |
| 3. |
Install at least one antivirus application. However, always avoid those antivirus applications from dictatorial nations, such as China or Russia. They may
be embedded with spyware. In additional, you should bear in mind that your phone is not 100% bullet proof even you have antivirus utility installed, you
still have chance to get malware infection.
|
| |
| 4. |
Apply security patch to your smartphone regularly and ASAP. If major upgrade of operating system of your secret phone has been rolled out, upgrade your
phone at once.
|
| |
| 5. |
State supported hackers have many hacking methods to against you, some even out of your imaginations like Sci-Fi stories. So, just install those applications you
really need and no extra application(s) on your secret phone. More applications means more chance to get vulnerabilities which could be used by hackers.
Beware the built-in 'Messages' application of your phone to receive SMS messages (SMS in here means Short Message Service, not Secret Messaging
System), it is the most favour way hackers used to infiltrate into your phone. You should turn off all automatic previews options of SMS messages, and disable
MMS auto-download. If you get a suspicious SMS message, don't open it, delete it at once.
Remember, your phone service provider is also the helper of government agents. Therefore, you should also take great care for those SMS messages sent by your phone
service provider, especially those SMS messages contain hyperlink or MMS messages. If it is possible, only accept SMS from the contact list of your secret phone.
|
| |
| 6. |
At last, your usage behavior is still the most important factor for the safety of your smartphone. Don't use your secret phone to surf risky sites or install
any application from unknown source. Simply to say, your secret phone is for SMS accessing only. And you should clean up your secret phone regularly, i.e.
delete download files you no longer needed, purge temporary system files, and also force purge everything of all your web browsers manually.
|
Basically, smartphone selection and hardening guidelines could also be applied to tablets and computers.
In addition, MS Windows, MacOS X, and Chrome OS collect too much data from user, which could expose user's true identity easily. The common anonymous operating
systems for desktop or laptop computers are Linux and BSD Unix (FreeBSD, OpenBSD, NetBSD and Dragonfly BSD). You may consult
this article and
this article for more details. And I recommend the platform
and web browser combination for SMS communication as follows:
On smartphone or tablet, use latest version of Android with Firefox over VPN or Tor browser.
On desktop or laptop computer, use Linux (anonymity variants is better) or BSD Unix with Firefox over VPN or Tor browser.
|


Generalizing Jobs
Generalization of jobs can be achieved through parameterization.Most of the properties can be parameterized in Hydrograph.
The parameter format that needs to be followed should be as below,
@{Parameter_Name}.
A parameter name can only contain combinations of "_" and alphanumeric values.
Also '@', '{','}' are the only special characters allowed in specific sequence for declaring a value as a parameter.
For instance, the image below depicts parameterization of some of the properties present in the General tab of the Input file delimited component.
Users can also parameterize field names under the schema tab. Naming conventions for parameterization are same as stated above.
Each parameter that is created by the user gets displayed on the Parameter Grid once user saves the job. Users can provide values to the parameters which get saved in a text file as key=value format.
Job parameters window above contains three sections
Parameter Files - This section list the properties file. Optionally, one may also create a properties file and browse it into the grid using below buttons,
Add project param file - to add project level parameter files
Add job param file - to add job level parameter files
Parameter File View - This section shows the contents of the file selected in the Parameter Files section. User can add/edit/delete the contents of the selected file.
Search All Parameters - This section lists all the available parameters from files listed in Parameter Files section. It also allows users to search for a particular parameter. Based on the search results user can validate the file name and value of the parameters.
Parameters once created can be used across a job at multiple locations wherever needed. e.g. Suppose all the Input/Output component in particular job needs to have the same value for "Is Header" property, then it can be achieved by parameterizing it.


I need you to understand something...

Everyone else who reads it, doesn't get it.
They may think they get it, but they don't.
This is the sign you've been looking for.
You were meant to read these words.
pleasefindthis


I have built this page, from scratch, in order to practise my front-end development skills. Here, you will find some of my projects and you will get to know me better.
Major in Software Engineering and Data Analytics.
Minor in e-Business.
2017 - 2021
2019 - 2020


Call Us... Email Us... Any day, Any time
**If you just need someone to talk to or more information on our programs and services please fill out this form and some one from our staff will get in touch with you. Thank you and God bless and keep you until we meet.**
This year the New Life Residential Center is initiating a new program to offset the dramatic budget cuts imposed by the Department of Social Services. These cuts (shelter, food, services and programs) are impacting our women’s successful reentry into productive lives were they are continuing their education, obtaining gainful employment; being reunited with their children and families and most of all, living a healthy life of sobriety. For the cost of a Starbucks cup of coffee, a Caesar’s Hot N Ready Pizza or 2 gallons of gas for your car…you can help us maintain the critical services needed for these women in transition.
Select New Life Residential Center Inc. as your charity of choice through your employer payroll deductions to the United Way. (Member #3697) Go out www.newliferesidential.com, Opportunities to Support and set up automatic drafts based on your pay period via Pay Pal. Establish New Life Residential Center Inc. as a Bill Pay Payee through your bank/checking bill pay services .
Mail your periodic commitments to: New Life Residential Center Inc. PO BOX 3451, Buffalo, NY 14240. Coming Soon… Select New Life Residential Center Inc. as your SEFA charity of choice.
Our 2015 goal is to establish 500 committed relationships. Will you be 1 of those relationships? Will you ask your friends, family and co-workers? $5.00 is just a small commitment but put together with other $5.00 commitments can mean the dramatic difference in several women's lives. COMMIT TODAY!
We thank you for your attention; we thank you for your support in the past and look forward to a new commitment in the future! We will let you know what number you are in our goal of 500! All commitments are tax-deductible. God Bless and thank you.


Megan Russell
About
Portfolio
Resume
Contact
Portfolio
Password Generator
Code Quiz
Random Acts of Kindness
whatsinmybel.ly


swarm
requirements
Ruby 2+
description
Squish or be squished!
quick installation
wget https://github.com/glucero/swarm/releases/download/1.0.2/swarm-1.0.2.gem
gem install swarm-1.0.2.gem
usage
swarm
or SWARM=easy swarm
building and installing from source
git clone https://github.com/glucero/swarm
cd swarm
bundle
gem build swarm.gemspec
gem install swarm-VERSION.gem


Hangman APP
Guesses Left : {{guesses}}
You have to guess: {{displayWord.toUpperCase()}}
Your incorrect guesses:
{{letter.toUpperCase()}}
Submit
Your correct guesses:
{{letter.toUpperCase()}}


December 4, 2019
Project 4: Timeline
I enjoyed learning about the different ways time has been measured and concpetualized across cultures while researching for this project. Accurate time-keeping is something we often take for granted nowadays, but the technological development to where we are now has been advancing piece by piece for milennia. I developed the color scheme from an astrological clock in Europe, which helped me connect the very varied time-keeping devices into a coherent illustration. I decided to contain the timeline around a sundial, hourglass, and clock to hint at the similarities between one of the oldest forms of time-keeping in existence and the design of the modern clock.
PDF fileNovember 4, 2019
Project 3: Article Illustrations
Tesla’s Autopilot Could Save the Lives of Millions, But It Will Kill Some People First
"The complicated ethics of Elon Musk’s grand autonomous vehicle experiment."
Bloomberg Businessweek
In Article PDF
In Article GIF
Amazon Sellers Are Using Facebook Chatbots To Cheat Their Way To Good Reviews
"Facebook ads touting “free” products are actually fake review programs commissioned by Amazon sellers."
Buzzfeed News
In Article PDF
In Article GIF
Amazon's Alexa may have witnessed alleged Florida murder, authorities say
"Adam Reechard Crespo is charged with murder in connection to the July death of his girlfriend, Silvia Galva, in Hallandale Beach."
NBC News
In Article PDF
In Article GIF
October 2, 2019
Project 2: Icons
The most challenging aspect of this project was keeping the icons simple and scalable, yet still interesting and visually appealing. Once I came up with the rounded rectangle theme, it became easier. Some common elements tying the icons together as a set are: shapes simplified to rectangles, rounded corners, consistent spacing between rectangles, diagonal rectangles, single open red rectangle, stroke color and weight, and consistent colors.
September 4, 2019
Project 1: Isometric Avatar
Using the isometric grid, I used Adobe Illustrator to create this avatar. Typically in Illustrator, I use the pen tool but I opted for the pencil tool for this project because I wanted more natural, flowing lines to give it a more organic feel. I tried to stick to a muted color palette because I usually wear those colors, and it gives the design a more cohesive look. My favorite part is the little bit on top of the beret which I drew as a tiny floating circle.


Less.js
Getting started
Features overview
Overview
Variables
Mixins
Nesting
Operations
Escaping
Functions
Namespaces and Accessors
Maps
Scope
Comments
Importing
Using Less.js
Command Line Usage
Installing
Installing for Node Development
Beta releases of lessc
Server-Side and Command Line Usage
Command Line Usage
Options specific to
lessc
Browser Usage
Setting Options
Browser Support
Tips
Watch Mode
Modify Variables
Debugging
Options
Options specific to Less.js in the browser
Less.js Options
Cross-Platform Options
Include Paths
Rootpath
Relative URLs
Math
Strict Units
Source Map Options
Pre-Loaded Plugins
Preprocessing
Node.js
Using the Command Line
Loading a Plugin via Less.js
Programmatic Usage
Getting Access to the Log
API
Contributing to Less.js
Install These Tools
Usage
How to Run Less in Other Environments
Guide
Functions
String Functions
escape
e
% format
replace
List Functions
length
extract
each
Math Functions
ceil
floor
percentage
round
sqrt
abs
sin
asin
cos
acos
tan
atan
pi
pow
mod
min
max
Type Functions
isnumber
isstring
iscolor
iskeyword
isurl
ispixel
isem
ispercentage
isunit
isruleset
Misc Functions
color
image-size
image-width
image-height
convert
data-uri
default
unit
get-unit
svg-gradient
Color Definition Functions
rgb
rgba
argb
hsl
hsla
hsv
hsva
Color Channel Functions
hue
saturation
lightness
hsvhue
hsvsaturation
hsvvalue
red
green
blue
alpha
luma
luminance
Color Operation Functions
saturate
desaturate
lighten
darken
fadein
fadeout
fade
spin
mix
tint
shade
greyscale
contrast
Color Blending Functions
multiply
screen
overlay
softlight
hardlight
difference
exclusion
average
negation
In-Depth Guide
Overview
Variables
Overview
Variable Interpolation
Variable Variables
Lazy Evaluation
Properties as Variables
(NEW!)
Default Variables
Parent Selectors
Multiple
&
Changing Selector Order
Combinatorial Explosion
Extend
Extend Syntax
Extend Attached to Selector
Extend Inside Ruleset
Extending Nested Selectors
Exact Matching with Extend
nth Expression
Extend "all"
Selector Interpolation with Extend
Scoping / Extend Inside @media
Duplication Detection
Use Cases for Extend
Merge
Comma
Space
Mixins
Not Outputting the Mixin
Selectors in Mixins
Namespaces
Guarded Namespaces
The
!important
keyword
Parametric Mixins
Pattern-matching
Using Mixins as Functions
Recursive Mixins
Mixin Guards
Aliasing Mixins
CSS Guards
Detached Rulesets
Scoping
Property / variable accessors
@import At-Rules
File Extensions
Import Options
reference
inline
less
css
once
multiple
optional
@plugin At-Rules
Writing your first plugin
Plugin Scope
Null Functions
The Less.js Plugin Object
Pre-Loaded Plugins
Maps
(NEW!)
Using variable variables in lookups
Tools
Frameworks Using Less
UI/Theme Frameworks and Components
Grid Systems
Mixin Libraries
Editors and Editor Plugins
Editors and IDEs
Sublime Text 2 & 3
Eclipse
Komodo Edit/IDE
Visual Studio
Dreamweaver
Notepad++ 6.x
Browser extensions
Less.js Plugins
GUIs for Less
Cross platform
Crunch 2!
SimpLESS
Koala
Specific platforms
Windows
OS X
Linux
Online Less Compilers
Online Web IDEs/Playgrounds with Less support
Third Party Compilers
Node.js Compilers
Other Technologies
Ports of Less.js
Java
.Net
PHP
Python
Ruby
Go


MC Reference Sheet:
The Basics and The First Session
MC Reference Sheet:
Threat Map,
Session: ______
Faction Sheet:
Blank
Solar System Sheet:
Blank
Reference Sheet
Detailed Factions
Detailed Solar Systems


First name
Surname
Email address
Daytime contact number
Address
Suburb
State
-- Select --
ACT
NSW
NT
QLD
SA
TAS
VIC
WA
Postcode
Enquiry type
-- Select --
General enquiry
Product feedback or enquiry
Product complaint
Product name
Product size
Use by date
Batch code
Enquiry


Validation
The mako validator provides a simple and consistent way of validating user input.
Usage
First you need to define a set of rules you want to use to validate the input.
$rules =
[
'username' => ['required', 'min_length:4', 'max_length:20'],
'password' => ['required'],
'email' => ['required', 'email'],
];
The rules defined above will make sure that the username, password and email fields are filled in. That the username is between 4 and 20 characters long, and that the email field contains a valid email address.
If all of your fields have one or more rule in common, then you can use the *
shortcut.
$rules =
[
'*' => ['required'],
'username' => ['min_length:4', 'max_length:20'],
'email' => ['email'],
];
Only non-empty fields or fields marked as required are validated.
Next you'll need to create a validation object. The first parameter is the input data you want to validate and the second is the validation rules.
$validator = $this->validator->create($this->request->post(), $rules);
Now you need to check if the input data is valid using the isValid
method.
if($validator->isValid())
{
// Save to database
}
else
{
// Handle errors
}
You can also use the isInvalid
method.
if($validator->isInvalid())
{
// Handle errors
}
else
{
// Save to database
}
Retrieving errors is done using the getErrors
method.
$errors = $validator->getErrors();
Or by using the optional $errors
parameter of the isValid
and isInvalid
methods.
if($validator->isValid($errors))
{
// Save to database
}
else
{
var_dump($errors);
}
An empty array will be returned if there are no errors.
Validation rules
The following validation rules are included with Mako:
| Name | Description |
|---|---|
| required | Checks that the field isn't empty. |
| min_length | Checks that the field value is long enough (min_length:10 ). |
| max_length | Checks that the field value is short enough (max_length:20 ). |
| exact_length | Checks that the field value is of the right length (exact_length:20 ). |
| less_than | Checks that the field value is less than x (less_than:5 ). |
| less_than_or_equal_to | Checks that the field value is less than or equal to x (less_than_or_equal_to:5 ). |
| greater_than | Checks that the field value is greater than x (greater_than:5 ). |
| greater_than_or_equal_to | Checks that the field value is greater than or equal to x (greater_than_or_equal_to:5 ). |
| between | Checks that the field value is between x and y (between:[5,10] ). |
| match | Checks that the field value matches the value of another field (match:"password_confirmation" ). |
| different | Checks that the field value is different from the value of another field (different:"old_password" ). |
| regex | Checks that the field value matches a regex pattern (regex:"/[a-z]+/i" ). |
| integer | Checks that the field value is a integer. |
| float | Checks that the field value is a float. |
| natural | Checks that the field value is a natural. |
| natural_non_zero | Checks that the field value is a natural non zero. |
| hex | Checks that the field value is valid HEX. |
| alpha | Checks that the field value only contains valid alpha characters. |
| alpha_unicode | Checks that the field value only contains valid alpha unicode characters. |
| alphanumeric | Checks that the field value only contains valid alphanumeric characters. |
| alphanumeric_unicode | Checks that the field value only contains valid alphanumeric unicode characters. |
| alpha_dash | Checks that the field value only contains valid alphanumeric, dash and underscore characters. |
| alpha_dash_unicode | Checks that the field value only contains valid alphanumeric unicode, dash and underscore characters. |
| Checks that the field value is a valid email address (uses PHP's filter_var function). | |
| email_domain | Checks that the field value contains a valid MX record. |
| ip | Checks that the field value is an IP address (uses PHP's filter_var function). |
| url | Checks that the field value is a valid URL (uses PHP's filter_var function). |
| in | Checks that the field value contains one of the given values (in:[["foo","bar","baz"]] ). |
| not_in | Checks that the field value does not contain one of the given values (not_in:[["foo","bar","baz"]] ). |
| date | Checks that the field value is a valid date (date:"Y-m-d" ). |
| before | Checks that the field value is a valid date before the provided date (before:["Y-m-d","2012-09-25"] ). |
| after | Checks that the field value is a valid date after the provided date (after:["Y-m-d","2012-09-25"] ). |
| token | Checks that the field value matches a valid session token]. |
| uuid | Checks that the field value matches a valid uuid. |
| unique | Checks that the field value doesn't exist in the database (unique:["users","email"] ). |
| exists | Checks that the field value exist in the database (exists:["users","email"] ). |
Custom messages
All error messages are defined in the app/i18n/*/strings/validate.php
language file.
Adding custom field specific error messages can be done using the overrides.messages
array:
'overrides' => array
(
'messages' => array
(
'username' => array
(
'required' => 'You need a username!',
),
),
),
You can also add custom field name translations using the overrides.fieldnames
array:
'overrides' => array
(
'fieldnames' => array
(
'email' => 'email address',
),
),
Validator plugins
You can create your own custom validator plugins. They must extend the mako\validator\plugins\ValidatorPlugin
class and implement the mako\validator\plugins\ValidatorPluginInterface
interface.
use \mako\validator\plugins\ValidatorPlugin;
use \mako\validator\plugins\ValidatorPluginInterface;
class IsFooValidator extends ValidatorPlugin implements ValidatorPluginInterface
{
protected $ruleName = 'is_foo';
public function validate($input)
{
return mb_strtolower($input) === 'foo';
}
}
Prefix the
$ruleName
value with your package name and two colons (::
) if your validator is a part of a package.
You can register the plugin with the validation factory, thus making it avaiable to all future validator instances.
$this->validator->registerPlugin(new IsFooValidator);
You can also register it into an existing validator instance.
$validator->registerPlugin(new IsFooValidator);


Source code for twilio.rest.api.v2010.account.usage
# coding=utf-8
r"""
This code was generated by
\ / _ _ _| _ _
| (_)\/(_)(_|\/| |(/_ v1.0.0
/ /
"""
from twilio.base.instance_resource import InstanceResource
from twilio.base.list_resource import ListResource
from twilio.base.page import Page
from twilio.rest.api.v2010.account.usage.record import RecordList
from twilio.rest.api.v2010.account.usage.trigger import TriggerList
[docs]class UsageList(ListResource):
def __init__(self, version, account_sid):
"""
Initialize the UsageList
:param Version version: Version that contains the resource
:param account_sid: A 34 character string that uniquely identifies this resource.
:returns: twilio.rest.api.v2010.account.usage.UsageList
:rtype: twilio.rest.api.v2010.account.usage.UsageList
"""
super(UsageList, self).__init__(version)
# Path Solution
self._solution = {'account_sid': account_sid, }
# Components
self._records = None
self._triggers = None
@property
def records(self):
"""
Access the records
:returns: twilio.rest.api.v2010.account.usage.record.RecordList
:rtype: twilio.rest.api.v2010.account.usage.record.RecordList
"""
if self._records is None:
self._records = RecordList(self._version, account_sid=self._solution['account_sid'], )
return self._records
@property
def triggers(self):
"""
Access the triggers
:returns: twilio.rest.api.v2010.account.usage.trigger.TriggerList
:rtype: twilio.rest.api.v2010.account.usage.trigger.TriggerList
"""
if self._triggers is None:
self._triggers = TriggerList(self._version, account_sid=self._solution['account_sid'], )
return self._triggers
def __repr__(self):
"""
Provide a friendly representation
:returns: Machine friendly representation
:rtype: str
"""
return '<Twilio.Api.V2010.UsageList>'
[docs]class UsagePage(Page):
def __init__(self, version, response, solution):
"""
Initialize the UsagePage
:param Version version: Version that contains the resource
:param Response response: Response from the API
:param account_sid: A 34 character string that uniquely identifies this resource.
:returns: twilio.rest.api.v2010.account.usage.UsagePage
:rtype: twilio.rest.api.v2010.account.usage.UsagePage
"""
super(UsagePage, self).__init__(version, response)
# Path Solution
self._solution = solution
[docs] def get_instance(self, payload):
"""
Build an instance of UsageInstance
:param dict payload: Payload response from the API
:returns: twilio.rest.api.v2010.account.usage.UsageInstance
:rtype: twilio.rest.api.v2010.account.usage.UsageInstance
"""
return UsageInstance(self._version, payload, account_sid=self._solution['account_sid'], )
def __repr__(self):
"""
Provide a friendly representation
:returns: Machine friendly representation
:rtype: str
"""
return '<Twilio.Api.V2010.UsagePage>'
[docs]class UsageInstance(InstanceResource):
def __init__(self, version, payload, account_sid):
"""
Initialize the UsageInstance
:returns: twilio.rest.api.v2010.account.usage.UsageInstance
:rtype: twilio.rest.api.v2010.account.usage.UsageInstance
"""
super(UsageInstance, self).__init__(version)
# Context
self._context = None
self._solution = {'account_sid': account_sid, }
def __repr__(self):
"""
Provide a friendly representation
:returns: Machine friendly representation
:rtype: str
"""
return '<Twilio.Api.V2010.UsageInstance>'


Chapter Five of Search Inside Yourself looked at emotional awarenesss and control. As with last week, the focus was on self-awareness when it comes to the emotions that are affecting you at any paticular time. This comes in most useful as times of stress and pressure, when often we feel like the emotions are taking over and may drive our actions and reactions to events, rather than the more rational side of our natures.
For me the big takeaway was the importance of taking a pause when we feel our emotions rising (called the "sacred pause" in the book) in order to take a step back and critically examine what emotions we are feeling, and what may be driving them. This is something that has helped me in the past in situations of conflict. When reflecting on situations in my own life when I have used (as well as the times when I haven't) simlar techniques, I can see the utility of them.
With ongoing practise, I'm getting more and more out of each of the 2 minutes of mindfulness that I do. It isn't quite a habit yet (I still need a seperate trigger to remind me to do it), but I do notice and enjoy the feeling once I have done it.


The bottom margin of this paragraph is collapsed …
… with the top margin of this paragraph, yielding a margin of 1.2rem
in between.
This paragraph has a .4rem
margin between it and the text above.
My bottom margin collapses with my parent, yielding a bottom margin of 2rem
.
I am 2rem
below the element above.


As a C# developer I think I’m pretty safe in saying that its not going away any time soon however, its my opinion that to not become irrelevant you need to have options. Some may argue that its better to be master of one than a Jack of all trades but lets just say you can’t find your next job in the primary language you want to work in. What do you do?
I have looked more into JavaScript recently and with that comes server and client scope for the use of the language so with some understanding of JS that would be probably the best bet for me however, as much as this may annoy some I think I actually prefer statically typed languages.
Now I know there is TypeScript that I could use for my node.js apps but I see that as more of a workaround and not a core feature of JavaScript. I’m not saying anything bad against JS and the libraries/frameworks that I have used I like but I just find it easier to learn and know what I can do when I have decent intellisense showing me what I can do with my code.
You could argue that I could go back to my first language of Delphi or I could look into C++, Java or PHP but my counter argument might just be laughter. In my opinion these are old languages. They may be reliable for some needs but I feel its looking back to the past somewhat and not looking forward.
I have recently come across Dart and want to spend some time looking into it to see if we suit each other.
Dart is a class-based, object-oriented language with lexical scoping, closures, and optional static typing. Dart helps you build structured modern web apps and is easy to learn for a wide range of developers.
There is also F# which I need to look at as my Twitter timeline has more and more references to this language.
There is also Kotlin but that’s as much as I know about it, the name. I think its based on Java and that rings alarm bells for me but I’m sure @Cranialstrain will put me right.
There is also Go and I’m sure there are many others that I could find but rightly or wrongly when deciding upon a language which lets be honest is a big investment you need to know there are the available jobs out there in that language. Its nice to learn new stuff and I highly recommend it but for me a whole new investment in a language has to warrant some pay offs such as employment.
I can’t say for sure what language I’d use if I had to change, at present most likely JavaScript but probably that is based out of limited options on my part, maybe I need to become a better polyglot programmer and learn some more languages to have better “options” and not become irrelevant.
Let me know what your primary language is and what you’d jump to if you had to.


|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use ServiceRegistrar | |
| com.sun.jini.discovery | Provides a set of constraints, low-level utility classes, and provider interfaces for participating in versions 1 and 2 of the multicast request, multicast announcement, and unicast discovery protocols. |
| net.jini.core.discovery | A standard utility class for finding particular lookup services. |
| net.jini.discovery | These are utility classes and interfaces that conform to the discovery and join protocol defined in the Jini(TM) Discovery and Join Specification. |
| net.jini.lookup | Standard utility classes for managing the join state of a service and the service discovery duties of a client or service. |
| Uses of ServiceRegistrar in com.sun.jini.discovery |
| Fields in com.sun.jini.discovery declared as ServiceRegistrar | |
protected ServiceRegistrar |
UnicastResponse.registrar
The lookup service proxy. |
| Methods in com.sun.jini.discovery that return ServiceRegistrar | |
ServiceRegistrar |
UnicastResponse.getRegistrar()
Returns the lookup service proxy. |
| Constructors in com.sun.jini.discovery with parameters of type ServiceRegistrar | |
UnicastResponse(String host,
int port,
String[] groups,
ServiceRegistrar registrar)
Creates new UnicastResponse instance containing the given
values. |
| Uses of ServiceRegistrar in net.jini.core.discovery |
| Methods in net.jini.core.discovery that return ServiceRegistrar | |
ServiceRegistrar |
LookupLocator.getRegistrar()
Perform unicast discovery and return the ServiceRegistrar object for the given lookup service. |
ServiceRegistrar |
LookupLocator.getRegistrar(int timeout)
Perform unicast discovery and return the ServiceRegistrar object for the given lookup service, with the given discovery timeout. |
| Uses of ServiceRegistrar in net.jini.discovery |
| Fields in net.jini.discovery declared as ServiceRegistrar | |
protected ServiceRegistrar |
IncomingUnicastResponse.registrar
The registrar we have discovered. |
protected ServiceRegistrar[] |
RemoteDiscoveryEvent.regs
Array containing a subset of the set of proxies to the lookup service(s) with which this event is associated. |
protected ServiceRegistrar[] |
DiscoveryEvent.regs
The registrars with which this event is associated. |
| Methods in net.jini.discovery that return ServiceRegistrar | |
ServiceRegistrar |
IncomingUnicastResponse.getRegistrar()
Return the lookup service registrar we have discovered. |
ServiceRegistrar |
ConstrainableLookupLocator.getRegistrar()
Performs unicast discovery as specified by LookupLocator.getRegistrar() with the following differences.
|
ServiceRegistrar |
ConstrainableLookupLocator.getRegistrar(int timeout)
Performs unicast discovery as specified by LookupLocator.getRegistrar(int) , additionally applying the
supplied discovery constraints. |
ServiceRegistrar[] |
LookupUnmarshalException.getRegistrars()
Accessor method that returns an array consisting of instances of ServiceRegistrar , where each element of the array
corresponds to a successfully unmarshalled object. |
ServiceRegistrar[] |
RemoteDiscoveryEvent.getRegistrars()
Returns an array consisting of instances of the ServiceRegistrar interface. |
ServiceRegistrar[] |
LookupDiscoveryRegistration.getRegistrars()
Returns an array consisting of instances of the ServiceRegistrar interface. |
ServiceRegistrar[] |
DiscoveryEvent.getRegistrars()
Return the set of registrars to which this event applies. |
ServiceRegistrar[] |
LookupLocatorDiscovery.getRegistrars()
Returns an array of instances of ServiceRegistrar , each
corresponding to a proxy to one of the currently discovered lookup
services. |
ServiceRegistrar[] |
LookupDiscovery.getRegistrars()
Returns an array of instances of ServiceRegistrar , each
corresponding to a proxy to one of the currently discovered lookup
services. |
ServiceRegistrar[] |
DiscoveryManagement.getRegistrars()
Returns an array of instances of ServiceRegistrar , each
corresponding to a proxy to one of the currently discovered lookup
services. |
ServiceRegistrar[] |
LookupDiscoveryManager.getRegistrars()
Returns an array of instances of ServiceRegistrar , each
corresponding to a proxy to one of the currently discovered lookup
services. |
| Methods in net.jini.discovery with parameters of type ServiceRegistrar | |
static void |
OutgoingUnicastResponse.marshal(OutputStream str,
ServiceRegistrar reg,
String[] groups)
Marshal a unicast response to the given output stream. |
void |
LookupDiscoveryRegistration.discard(ServiceRegistrar registrar)
Informs the lookup discovery service of the existence of an unavailable lookup service and requests that the lookup discovery service discard the unavailable lookup service. |
void |
LookupLocatorDiscovery.discard(ServiceRegistrar proxy)
Removes an instance of ServiceRegistrar from the
managed set of lookup services, making the corresponding lookup
service eligible for re-discovery. |
void |
LookupDiscovery.discard(ServiceRegistrar reg)
Discard a registrar from the set of registrars already discovered. |
void |
DiscoveryManagement.discard(ServiceRegistrar proxy)
Removes an instance of ServiceRegistrar from the
managed set of lookup services, making the corresponding lookup
service eligible for re-discovery. |
void |
LookupDiscoveryManager.discard(ServiceRegistrar proxy)
Removes an instance of ServiceRegistrar from the
managed set of lookup services, making the corresponding lookup
service eligible for re-discovery. |
int |
LookupDiscoveryManager.getFrom(ServiceRegistrar proxy)
Return where the proxy come from. |
| Constructors in net.jini.discovery with parameters of type ServiceRegistrar | |
LookupUnmarshalException(ServiceRegistrar[] registrars,
MarshalledObject[] marshalledRegistrars,
Throwable[] exceptions)
Constructs a new instance of LookupUnmarshalException . |
|
LookupUnmarshalException(ServiceRegistrar[] registrars,
MarshalledObject[] marshalledRegistrars,
Throwable[] exceptions,
String message)
Constructs a new instance of LookupUnmarshalException . |
|
DiscoveryEvent(Object source,
ServiceRegistrar[] regs)
Construct a new DiscoveryEvent object, with the given
source and set of registrars. |
| Uses of ServiceRegistrar in net.jini.lookup |
| Methods in net.jini.lookup that return ServiceRegistrar | |
ServiceRegistrar[] |
JoinManager.getJoinSet()
Returns an array of ServiceRegistrar objects, each
corresponding to a lookup service with which the service is currently
registered (joined). |
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES |


30 mins
ESCALATED
|
Payment due last week, customer checked account and payment is still outstanding
|
Christine Dixon
ZZ123456A
|
{% include "includes/v2/date.html" %}
8:01
|
{% if data['agent'] %}
Imogen Johnson
(2)
{% else %}
Callum Dalton (2)
NOT AVAILABLE
{% endif %}
|
New Claim |
First call pending |
View and update
|
55 mins
ESCALATED
|
Med 3 attached 22/02/18 – 22/03/18 – change of GP
|
Ian Jackson
AA345678B
|
{% include "includes/v2/date.html" %}
9:30
|
Grant Hopper (2)
|
Claim closure |
In progress |
View and update
|
|
56mins
|
Change in bank details / change of address
|
Adam Brown
AA123456B
|
{% include "includes/v2/date.html" %}
8:38
|
{% if data['agent'] %}
Imogen Johnson (2)
{% else %}
Imogen Johnson (1)
{% endif %}
|
Claim closure |
First call pending |
View and update
|
|
1 hour 56 mins
|
FE attached 20 pages as listed below :
Hospital report pages 1 – 9, GP letter 10-11, 12 – 20 customer statement.
|
Grace Harris
ZZ234567A
|
{% include "includes/v2/date.html" %}
9:38
|
{% if data['agent'] %}
Callum Dalton (1)
NOT AVAILABLE
{% else %}
Callum Dalton (2)
NOT AVAILABLE
{% endif %}
|
New claim |
Second call pending |
View and update
|
|
2 hours 10mins
|
Information attached as requested by Hyde BC: Mortgage details
|
Ian Jackson
AA345678B
|
{% include "includes/v2/date.html" %}
11:06
|
Grant Hopper (2)
|
Ongoing appeal |
In progress |
View and update
|


Guidance
Information about funding arrangements for schools in 2015 to 2016.
PDF , 404KB , 33 pages
MS Excel Spreadsheet , 52.9KB
PDF , 395KB , 22 pages
PDF , 1.15MB , 92 pages
The documents on this page provide information about schools funding arrangements for 2015 to 2016. This includes how the Department for Education will allocate an additional £390 million to increase the per-pupil funding of the least fairly funded local authority areas in England.
‘Fairer Schools Funding: Arrangements for 2015 to 2016’ describes how funding will be allocated by setting minimum funding levels that every local authority will attract for their pupils and schools. It also sets out arrangements for simplifying the administration of academies funding and minor changes to high needs funding and the way schools contribute to the carbon reduction commitment.
‘Annex C: Local Authority Schools Block Units of Funding 2015 to 2016’ confirms each local authority’s schools block unit of funding for 2015 to 2016. The technical note explains how we calculated the funding.
The operational guide provides detailed information and guidance for local authorities and schools explaining the changes we made to funding arrangements for 2015 to 2016.
Published: 17 July 2014
Updated: 20 March 2015


After signing in, you can start working with KBase. Upload your experimental data and perform comparative genomics and systems biology analyses by creating Narratives: interactive, dynamic, and shareable documents. Narratives include all your analysis steps, commentary, and visualizations.
Want to learn more? Check out the Narrative Interface User Guide or the Narrative Interface video tutorial, and a library of tutorials that show you how to use various KBase apps to analyze your data.


Visualization of point connectivity in 2D space.
Visualization of point connectivity in 2D space.
| kmlStr = ge_gplot(A,V) |
| kmlStr = ge_gplot(A,V,Parameter,Value) |
| kmlStr = ge_gplot(A,V) |
Generates a kml character array used for visualizing the connectivity between points in a plane parallel to the Earth's surface. Input variable "A" contains the connectivity matrix between points. If there are N points, "A" should thus be NxN. Variable "V" contains the Cartesian coordinates of all points (the so-called vertices). "V" must be Nx2, with N equal to the number of points.
| kmlStr = ge_gplot(A,V,Parameter,Value) |
In addition to the above, a number of options can be set regarding the appearance of the gplot. Assigning values to the parameters can be accomplished by inclusion of an alternating sequence of parameters and their value. The table below provides an overview of the authorized options. The order in which the parameters are included does not matter. Please be aware that the options are case-sensitive. Examples are provided further down.
| Parameter | Description |
| 'altitude' | The altitude at which the object is located can be specified in this parameter. Altitudes are interpreted differently depending on the value of parameter 'altitudeMode'. |
| 'altitudeMode' | Character array used in interpreting the position of objects along the vertical axis. Value can be one of 'clampToGround', 'relativeToGround', or 'absolute'. |
| 'description' | A description of the object can be included using this parameter. Its value must be passed as a character array. Including a description will cause a text balloon to pop up from the map at the object's location. This balloon contains the character array included in 'description'. |
| 'extrude' | See Extruding objects. |
| 'forceAsLine' | When lines do not end at the location where they started, they are sometimes automatically connected by the OpenGL renderer when displayed in the Google Earth Viewer. By setting this parameter to true, this is avoided by plotting lines from start to end and back. This will force all lines to end at their starting point. Note that this will increase file size. Default is true. |
| 'lineColor' | Line color specification, including transparency. Color value format must be passed as a character array according to the format string 'TTRRGGBB', with 'TT' representing transparency; 'RR', 'GG', and 'BB' representing red, green, and blue colors, respectively. Intensity values are denoted as two-digit hexadecimal numbers ranging from 00 to FF. For example, '80FF0000' is semi-transparent red and 'FF0000FF' is fully opaque blue. |
| 'lineWidth' | Line width specification. Must be passed as a 1x1 numerical array. |
| 'msgToScreen' | Defines whether verbose feedback is provided by the function when it is accessed and when it finishes. Default is false (which is equivalent to logical(0), but quicker). |
| 'name' | Character array with the name of the object. |
| 'snippet' | A short description of the feature. In Google Earth, this description is displayed in the Places panel under the name of the feature. If a Snippet is not supplied, the first two lines of the description are used |
| 'tessellate' | See Tessellation. |
| 'timeSpanStart' | See Dynamic visualization. |
| 'timeSpanStop' | See Dynamic visualization. |
| 'visibility' | Defines whether the object is visible. Must be passed as numerical value 1 or 0. |
Latitudes on the Southern hemisphere and longitudes on the Western hemisphere must be passed as negative values.
Some transformation may occur due to the projection.
Latitudes and longitudes should be passed in units of decimal degrees (also known as fractional degrees). Google Earth uses Simple Cylindrical projection (also known as Plate Carée) with a WGS84 datum. Altitudes are in meters.
See the demo file demo_ge_gplot for more details.
angleRad = linspace(0,(4/5)*2*pi,5)'; X = sin(angleRad); Y = cos(angleRad); V = [X,Y]; A = [0,0,1,1,0;... 0,0,0,1,1;... 1,0,0,0,1;... 1,1,0,0,0;... 0,1,1,0,0]; kmlStr = ge_gplot(A,V,'lineWidth',5.0,... 'lineColor','FF00FF00'); ge_output('example_ge_gplot.kml',kmlStr);
The above lines of code will display as follows when viewed in Google Earth: