|
Ext.NET
5.3.0
.NET Component Framework for Enterprise Level Apps
|
Public Member Functions | |
| Builder (TMonthPicker component) | |
| virtual TBuilder | PostBackEvent (string postBackEvent) |
| virtual TBuilder | CancelText (string cancelText) |
| The text to display on the cancel button. More... | |
| virtual TBuilder | FooterButtonUI (UI footerButtonUI) |
| The Ext.button.Button.ui to use for the month picker's footer buttons. More... | |
| virtual TBuilder | FooterButtonUIName (string footerButtonUIName) |
| The Ext.button.Button.ui to use for the month picker's footer buttons. More... | |
| virtual TBuilder | OkText (string okText) |
| The text to display on the ok button. More... | |
| virtual TBuilder | SelectedCls (string selectedCls) |
| The class to be added to selected items in the picker. Defaults to 'x-monthpicker-selected' More... | |
| virtual TBuilder | ShowButtons (bool showButtons) |
| True to show ok and cancel buttons below the picker. More... | |
| virtual TBuilder | AutoPostBack (bool autoPostBack) |
| AutoPostBack More... | |
| virtual TBuilder | CausesValidation (bool causesValidation) |
| Gets or sets a value indicating whether validation is performed when the control is set to validate when a postback occurs. More... | |
| virtual TBuilder | ValidationGroup (string validationGroup) |
| Gets or Sets the Controls ValidationGroup More... | |
| virtual TBuilder | SelectedDate (DateTime? selectedDate) |
| Gets or sets the current selected date of the MonthPicker. Accepts and returns a DateTime object. More... | |
| virtual TBuilder | SelectedMonth (int? selectedMonth) |
| Selected month number More... | |
| virtual TBuilder | SelectedYear (int? selectedYear) |
| Selected year number More... | |
| virtual TBuilder | Listeners (Action< MonthPickerListeners > action) |
| Client-side JavaScript Event Handlers More... | |
| virtual TBuilder | DirectEvents (Action< MonthPickerDirectEvents > action) |
| Server-side Ajax Event Handlers More... | |
| Builder () | |
| Builder (MonthPicker component) | |
| Builder (MonthPicker.Config config) | |
Static Public Member Functions | |
| static implicit | operator Builder (MonthPicker component) |
| TMonthPicker | : | MonthPicker | |
| TBuilder | : | Builder | |
| TBuilder | : | TMonthPicker | |
| TBuilder | : | TBuilder |
|
inline |
|
inline |
|
inline |
|
inline |
|
inlinevirtual |
AutoPostBack
|
inlinevirtual |
The text to display on the cancel button.
|
inlinevirtual |
Gets or sets a value indicating whether validation is performed when the control is set to validate when a postback occurs.
|
inlinevirtual |
Server-side Ajax Event Handlers
| action | The action delegate |
|
inlinevirtual |
The Ext.button.Button.ui to use for the month picker's footer buttons.
|
inlinevirtual |
The Ext.button.Button.ui to use for the month picker's footer buttons.
|
inlinevirtual |
Client-side JavaScript Event Handlers
| action | The action delegate |
|
inlinevirtual |
The text to display on the ok button.
|
inlinestatic |
|
inlinevirtual |
|
inlinevirtual |
The class to be added to selected items in the picker. Defaults to 'x-monthpicker-selected'
|
inlinevirtual |
Gets or sets the current selected date of the MonthPicker. Accepts and returns a DateTime object.
|
inlinevirtual |
Selected month number
|
inlinevirtual |
Selected year number
|
inlinevirtual |
True to show ok and cancel buttons below the picker.
|
inlinevirtual |
Gets or Sets the Controls ValidationGroup


spec4php
- Spec files
A typical spec file:
<?php
describe "Calculator"
it "should multiply"
calculator(1, '*', 10) should equal 10
end
it "should divide"
calculator(4, '/', 2) should equal 2
end
end
In this example we have grouped (describe) two tests (it) where each one has a single expectation (should).
Spec files are normal PHP source code files with additional syntax to
define blocks
and expectations
. By convention they should end in
.spec.php
or Spec.php
although this is not a requirement.
The custom syntax for Spec can be made compatible with that of PHP by using dots "." as a replacement for spaces. This feature is mostly useful when you don't want your spec files to report errors in an IDE or when running the files thru a linting process.
In order to transform the custom Spec syntax to valid (and runnable) PHP
source code you'll need to use the compiler
component of spec4php(3). The
command line tool, spec4php(1), takes care of this process and will
automatically transform the files. By default, Spec will register a custom
PHP stream wrapper with the prefix spec:// which will apply the transformation
to any file it references.
These are the different blocks supported. All of them are to be terminated with
the end
keyword or enclosed in curly braces.
describe
"description"This block allows to define a group of tests. These blocks can be
nested inside other describe
blocks. They can be think of as the
equivalent of a PHPUnit suite.
it
"description"This is basically a test case.  Inside it
blocks you should include your test logic an apply
expectations over it. This is the equivalent to a PHPUnit test case method.
before
This block MUST appear inside a describe
one. It's used to setup the
world for the tests contained in the parent describe
block.
after
This block MUST appear inside a describe
one. It's used to restore or
clean up the world after all the tests contained in the parent describe
block have been run.
before_each
Almost the same as the before
block but this one is run just before every
test (it
block).
after_each
Almost the same as the after
block but this one is run just after every
test (it
block).
Note that before_each
and after_each
are inherited in nested describe
groups.
Test blocks are defined with the it
keyword. These blocks should test
your code by performing expectations over its functionality. They are equivalent
to PHPUnit's TestCase class methods. In fact, they are wrapped at runtime
in a PHPUnit TestCase class.
You can even access the test case class methods by using the $this
variable,
as you would in a class method. Spec will automatically translate occurrences
of $this
inside code blocks and convert them to a call to the underlying
test case class instance. This allows to mix the usage of Spec's native
expectations and original PHPUnit assertions.
it "should use asserts"
$this->assertEquals(1, 1);
end
This feature comes really handy when you have an extended PHPUnit test case class, like for example with the Zend_Test classes, without having to port those custom assertions to Spec matchers. Besides, it will ease the path when converting PHPUnit test cases to Spec, since most of the code used in your current tests will run unmodified when placed in a spec file.
An additional feature of it
blocks is their ability to get arguments
for the test from their own description string. Any value enclosed in
quotes (single or double) or between angle brackets (<>) will be made
available inside the code block with variables named $argX
, where X
is an integer count starting at 1.
it "should multiply '100' by '10' and return <1000>" {
$arg1 * $arg2 should equal $arg3;
}
This feature is specially suited to create dynamic tests, something that is a bit more difficult with other testing frameworks. Since test code blocks are converted to simple anonymous functions, it's possible to wrap them in loops to feed a set of data to test. The following example will create 5 individual tests feeding different data to each one of them.
$results = array(0, 100, 200, 300, 400);
foreach ($results as $i=>$result) {
it "should multiply '$i' by '100' and return '{$result[$i]}'"
$arg1 * $arg2 should equal $arg3;
end
}
All the code blocks (it
, before
, after
, before_each
and after_each
)
get automatic access to an object thru a variable named $W
(uppercase W)
representing the world. Hooks like before
or before_each
can be used
to configure this world by initializing variables, resources, database
connections, mocks...
Spec will create and restore snapshots of this object so that every test
(it
blocks) in a describe
group receives the exact same values configured
in their world object. There are some things that can't be automatically
restored by Spec though, like database connections or file resources, so try
to configure them in before
hooks instead of before_each
ones.
Note that since the world is restored after each test is ran, it's not possible to pass values using it from one test to another. You should always use the hooks to configure the world, otherwise you would run into problems when tests are executed in a different order or skipped for some reason.
describe "World"
before
$W->foo = 'bar';
end
before_each
$W->foo .= 'baz';
end
it "should get an initialized world" {
$W->foo should equal "barbaz";
}
end
Expectations are defined in Spec by using a subject-predicate form that mimics
english natural language. Basically they take the form "subject
should predicate
"
where subject
is a PHP expression and predicate
defines matchers and expected
values.
Any PHP expressions can be used before should, however some are not completely
supported, for example, it's not possible to use anonymous functions as the
expectation subject
. To improve readability and ensure the parser works as
expected is useful to wrap them in parenthesis.
Matchers in the predicate
part can have an expected value, any simple PHP
expression following the matcher phrase idents will be used as an argument to
the matcher function. If you need to use function calls or other more complex
expressions you can wrap them in parenthesis, otherwise the parser might not
be able to parse it correctly.
Expectations do not need to be ended with a semicolon character (';') when the
next word is the end
keyword or there is an empty line below it.
In some cases it makes sense to use comparison symbols instead of writing it as text. See the following table for the mapping between the comparison symbols and their matchers.
Symbol | Matcher
------------------------------
=== | same
!== | not same
== | equal
!= | not equal
> | greater
< | less
>= | at least
<= | at most
Additionally, any matcher can be negated by using the word not
in it.
See the following examples of expectations:
$result should be integer;
(1+1) should not equal 1;
trim(" foo ") should be exactly "foo";
count(array(1,2,3)) should >= 2;
$result should equal (1/2 + 5);
1 should not equal 2;
1 should != 2;
"foo" should equal (trim(" foo "))
true should be ((bool)$var)
Complex expectations can be coordinated by using operators and
, or
and
but
. It's important to understand the operator precedence rules before
using them, although they try to follow common conventions for the english
language there might be cases where they don't quite do what they look like.
All operators are left-associative and take two operands, thus the precedence rules are very simple:
operator | precedence index
---------------------------------
and | 3
or | 2
but | 1
,and | 1
Please note that it's not possible to override the standard precedence rules by using parentheses. Expectations should be kept simple, when in doubt break up complex expectations into simpler ones.
Please review the following examples to see how these precedence rules apply.
should be integer or string and equal "1"
(integer) OR (string AND equal "1")
-- Note that a comma followed by an operand behaves like an "or"
should be integer, float or string
(integer) OR (float) OR (string)
should be integer, string and equal to 10 or float
(integer) OR (string AND equal 10) OR (float)
-- Note that a comma followed by "and" behaves like a "but"
should be integer or string but less than 10
should be integer or string, and less than 10
(integer OR string) AND (less than 10)
should be integer or string and equal 0 or float
(integer) OR (string AND equal 0) OR (float)
should be integer or string and equal "1" but not be a float
( (integer) OR (string AND equal "1") ) AND (not be float)
-- Note that if no matchers are given the last one is used
should be equal to 10, 20 or 30
(equal 10) OR (equal 20) OR (equal 30)
Annotations can be defined in two ways, using the standard javadoc like
comment with @tag
entries or a more lightweight alternative using
a hash line comment followed by a word: # tag
.
Most annotations are inherited by child describe
groups and it
blocks. In the case where there is a collision the deepest one in
the hierarchy wins.
Spec understands the following annotation tags:
class
class_nameTells Spec to create a test case inheriting from the given class. This is very useful to allow the use of Spec with custom TestCase classes you might already have or for enabling the use of Zend_Test or PHPUnit's Selenium test case implementation.
throws
[code] class [message]This annotation instructs Spec to perform an additional assertion when runnning the test, ensuring that it should throw an exception matching the given code or the given exception class.
todo
, incomplete
Flags a test case as incomplete. Spec will report these test cases in a different way to standard ones, so it's easy to know when a test is passing but doesn't yet tests all the functionality it should.
skip
A test case with this tag will make Spec skip its execution but log in the report that it was skipped. It's a great way to disable some test cases known to fail for any reason.
Additionally, most PHPUnit annotations should work when using spec files too, see PHPUnit documentation
Spec will load the spec files via a custom stream wrapper which provokes
__DIR__
and __FILE__
magic constants to include the stream prefix in
them. Often times it's needed to load files relative to the spec file
location, in these cases we would usually use the __DIR__
constant. Spec
takes this into account and will automatically convert this constant to
calls to Spec::dir(__DIR__)
which returns a normalized version of the
value. For __FILE__
however there is no special threatment, so if you
use code like dirname(__FILE__)
please update it to use the __DIR__
one.
// /path/to/fixtures/class.php
include __DIR__ . '/fixtures/class.php';
// /path/to/fixtures/data.txt
$data = file_get_contents(__DIR__ . '/fixtures/data.txt');
// spec://fixtures/data.txt
$data = file_get_contents(dirname(__FILE__) . '/fixtures/data.txt');
Note that including spec files from another spec file is not officially supported yet. It might work in some cases but it's desirable to layout your tests using individual files to avoid conflicts and erroneous behavior.
It's possible to use custom test case classes that extend the
PHPUnit_Framework_TestCase
one. They can be implemented by you or come
from a framework, like the ones from Zend_Test.
Spec is able to patch any given class to add support for its features, so it's completely possible to use those classes without having to modify them in any way.
The way to tell Spec what class it should use is by defining an annotation
for a describe
or it
block, like in the following example:
# class Zend_Test_PHPUnit_ControllerTestCase
describe "Calculator"
it "should multiply" {
(1*3) should equal 3;
}
// @class PHPUnit_Framework_TestCase
it "should divide"
(3/1) should equal 3;
end
end
Note that this annotation is inherited by child blocks, so there is no need to specify it for each test.
See Spec's own tests in the GitHub repository to see examples.
Spec for PHP is Copyright (C) 2011 Ivan -DrSlump- Montes http://pollinimini.net
spec4php(1), spec4php(3), http://github.com/drslump/spec-php


Man left in despair after joystick gets chopped off in attempted ritual killing… Appeals for ‘new one’
by Sharon ChirisaMan left in despair after joystick gets chopped off in attempted ritual killing, appeals for new one
In a sad case, one Fortune Khumalo might never know what it feels like to be with a woman after losing his man_hood.
Fortune Khumalo (23) from Jilongo Village outside Malamulele, Limpopo, lost his 4-5 when he was nine years old in an attempted ritual killing.
Fortune’s life has been miserable since.
He told Daily Sun that villagers sometimes made fun of him.

Fortune said he wished to have surgery to restore his man_hood.
But the family faced challenges after Fortune’s father, Thomas, who was the breadwinner, died.
His mum supports the family through her Sassa grant money.
Fortune also helps by doing small jobs like tiling. However, he said it was hard to work in the heat as he felt pain where his 4-5 was cut.
The family said it was hard to forgive Lucky Simango (35), the man who chopped off Fortune’s 4-5 about 14 years ago, as he failed to disclose the names of the people who had sent him.
Simango was sentenced to 15 years in jail in 2008 for the crime.
CHECK OUT CELEB NEWS
PICS: Pokello thrills the Warriors with a ‘surprise’ visit….chills with Marvelous Nakamba
Savage gone wrong…. Jackie Ngarande Flees Facebook after trying to embarrass singer Pah Chihera
PICS: Baba naMai Charamba take romantic vacation in Sun City
To View and Apply for the latest Jobs and Vacancies in Zimbabwe, Please Visit our Sister website iHarare Jobs


A Tuner is only as good as the tools they are using. In today's
world the most important tools for tuning are no longer
found in your toolbox.
Just think, in the 1980's Top Fuel dragsters made 2500 hp using a 500
cubic inch ( 8.2 Liter) Aluminum Hemi headed
engine, as amazing as this might sound, today this same displacement
and very similar looking hemi headed engines are making over 8000 hp!
Why? It is all about optimizing all aspects of the engine to improving
efficiency. This demands the tools
to gather data so you can understand what is happening inside the
engine and identify opportunities to improve
efficiency. Together TunerStudio and MegaLogViewer bring you the power
to capture, view and analyze data as
your engine produces it, then act upon it. These easy to use
applications simplify making changes and even offer recommendations and
automatic correction
using data analytics at a level that is not offered by any other tuning
solutions at any price.
Just some of the TunerStudioMS features only available in the
Registered Edition
|
With a simple online registration you can Unlock
all the features of TunerStudio MS in minutes! Whether you want a more
powerful tuning aids, improved diagnostic tools, dedicated Car PC
dashboard, or built in data analytics to tune the car for you; the
registered version of TunerStudio MS preserves all your existing
settings and projects, and unlocks many additional features to save you
time and headaches! Make Payments via Credit Card or PayPal and you
will receive a registration code via email within minutes!
|
Register
Online Now!
|
Amazing Dashboards -
Perfect for setting up a dedicated car PC or giving your laptop head
snapping wow factor, TunerStudio MS brings you:
VE Analyze Live! -
Yes it really does tune the car for you while you drive! Starting with
concepts of VE Analyze in MegaLogViewer and taking it to the next
level with dynamic offset record seeking.
Whether your just running with rough tables or have already put hours
into your tune, VE Analyze Live will dial in your fuel tables to a new
state.
Why does it work so well? By combining a vast tuning experience with
expertise in data analytics you can leverage technology to improve your
tune.
An expert tuner can look at a data log record and know what changes
that record is looking for, but one record can only tell so much.
At best a record only shows the inputs and results at that instant in
time with many other outside factors effecting the data.
One record nay tell you one thing, but another on the same cell will
say something else.
To produce the best results you need to look at each record, identify
and discard the ones that are junk due to other factors, then consider
ALL quality data.
That is where the human brain fails, it simply can not consider the
full picture, computers can.
VE Analyze Live offers:
- Automatic update to controller - You can either have
TunerStudio produce a recommended table as you drive, or let it
acutally send the updates as you drive to continually improve you tune
while going down the road.
- Adjustable Standard Filter - In addition to TunerStudio
filtering data with lack of credibility, you can adjust standard
parameters such as RPM, Coolant temp, load, MAP, MAF to match your
configuration or preference.
- Custom Filters - One of the Standard Filters doesn't cut
it
for your setup? The custom filter lets you apply free form logical and
mathematical formulas to filter nearly any data you desire.
- Lambda Delay Table - Compensates for delays to your Lambda
Sensor readings caused by not just the Lambda sensor itself, but more
importantly the time spent flowing through the exhaust pipes under
varying conditions.
- Heat Maps - As you drive you can see how much data has
been
gathered for all sections of the table and how much the table values
have changed.
- Authority Limits - Allow you to limit the amount of change
TunerStudio can make in a single session to prevent damage if something
goes wrong.
- Full Readouts - Watch the major data elements as
TunerStudio
uses them with a gauge cluster and histogram to show just what your
engine is doing.
WUE
Analyzer –
The
benefits of auto tuning have now been incorporated into the warmup
enrichment curves allowing you to save time and the headache of only
being able to tune the WUE settings once a
day.
Upgraded Ignition Logger* - The
high speed logger lets you data log at a much faster sample rate
giving you a clearer picture of a sensors signal. With the additional
support from the firmware developers viewing this data has never
been easier. It allows you to graphically see the signal that your
engines sensors produce as the controller sees it. This is great for
those who have been trying to track down that one specific issue but
regular data logs just do not sample the data fast enough to give you
a clear picture of the problem or for the those using there
MegaSquirt ECU on a more uncommon engine and need to capture more
data to test your sensors or circuitry as well as calibrate the
sensors.
The
high speed loggers and viewer with x and y plotting have been
implemented in MS2 3.3.0 + and MS3 1.2.4 +. The ignition loggers are
only supported by MS1/Extra, MS2/Extra, and MS3 firmware.
Difference Reporting
-
No more guessing what you changed in that file, just look at the
difference report an see the settings side by side easy to read with
the differences highlighted!
- Compare on connect - As soon as TunerStudio connects to
your
controller it will chack to see if you have made any offline changes
since you were last connected, present the differences side by side,
and let you select which ones you want to keep.
- Compare loaded Tune to saved one - Instantly see exactly
what changed between the tune you have loaded and any other msq you may
have with a side by side visual view of settings that don't match.
Setting Notes & Comments
-
Take notes while tuning and configuring for yourself or any one you may
be sending the msq to.
Additional Tuning Aids -
Throughout the Full Edition of TunerStudioMS you will find additional
features and settings to make life simpler while tuning.
- Adjustable 2D table tell tail - Blue
line and dots to show the path through the map you have taken. The
number of records is configurable.
- Improved 3D Tables - Configurable
increment sizes, accented value changes, more user settings.
- Switchable 2D to 3D View - Snap
nearly any table to 3D view mode to gain quick insite with a different
perspective.
- Table Smoothing - Smooths out rough or bumpy table based on the smoothing factor used.
- Diagonal Fill
- S The fill feature allows you to select a cell on the Ve Table then
press the "f" key and all the cells up and to the right of the selected
cell will change to the selected cells value.
- Automatic Logging - Allows
you to set conditional expressions on a specific ECU variable so that
you can trigger your logging to start or stop based on almost any ECU
condition.
- Logging Profiles - With logging profiles you can
narrow down your logged fields list and increase the data rate of the
log being captured. This is only true for firmware that supports
partial runtime reads. Another reason for only selecting the
necessary fields to be logged is the size of the log file.
- Ve Table Generator - Is
a powerful tool to create a
good baseline Ve Table at the start of your tuning process and can
help to decrease the time it will take to fine tune your table. The Ve
Table generator has five different options to help get the base map as
accurate as possible Naturally Aspirated, Turbo, Turbo
w/Intercooler, Supercharger, and Supercharger w/Intercooler.
Automatic Tune Restore Points
- Was something working better last month? Something happened to your
Controller and you lost your settings? No need to waste
time figuring out your old settings, TunerStudio MS
will automatically capture all tune settings creating restore points
that you can go back to review or load at any time. Or you may simply
want to pull up some difference reports to compare setting changes and
differences to any point in the past.
- Automatics Restore Point on Project
Close - Each time you close the project or application, if there
were any changes to the settings, TunerStudio will create a new Restore
Point.
- Automatics Restore Point on Difference
Reports - Connect to the controller, get a difference report, even
if you select Use Controller Settings, a restore point of all local
TunerStudio settings will be created before loading the controller
settings. So if you should have any second thoughts, you can go back to
what TunerStudio had at any time.
- Restore
Point Difference Reports - Pull up a full visual difference
report for any historic restore point.
Project Archive
- This is a great feature when you want to share your tune /
project with someone or you are looking for some assistance from tech
support and need to send use your tuning files. Archiving your project
takes all the files within your project folder and saves them in a zip
format so they can quickly be emailed.
Search
- Ever have trouble finding the dialog you just had open because you
cant remember what it was called but you remember the name of the
setting, well now you can just type in a key word and the search
feature will allow you to find any dialog that contains those key
words. This is great a feature for beginners allowing you to find
specific settings in seconds rather then minutes saving you valuable
time in the tuning process.
Additional Communication options-
With the purchase of a registration you get additional communication
drivers such as USB and Wireless which adds a WiFi option so you can
connect to a IP address directly, and the D2XX COM driver that
removes the VCP (Virtual COM Port) layer allowing for faster
communication.
Performance & Economy Fields-
Wish you had some of those gauges that have recently been made almost
standard equipment on most vehicles. You know the ones, average MPG /
KML, Fuel Flow in 3 different unit options, and instant MPG / KML /
Miles Per Liter, not including the gauges you might find in some of
todays higher end sports cars like Net Power and Net Torque. We also
added two other gauges Horse Power loss do to aerodynamic drag and HP
loss do to rolling. These fields can all be data logged as well as
displayed on your Dashboard.
GPS Support - You will find the integrated GPS
support very helpful in many ways and quickly will not want a data log
without it.
Once a GPS is setup in TunerStudio, all the common GPS
fields plus more like HP, Tq and Fuel consumption become fully integrated with your TunerStudio Project
therefore are available for display on gauges and will be captured in
your data logs. These fields include:
- Latitude - GPS Latitude
- Longitude - GPS Longitude
- Heading - GPS Direction you are traveling
- Accuracy - Reported GPS Accuracy based on visibility and quality of your GPS device
- Altitude - GPS Altitude in Meters
- GPS.PositionX - A relative position in meters along the East-West axis from the point in which you first aquired GPS lock.
- GPS.PositionY - A relative position in meters along the East-West axis from the point in which you first aquired GPS lock.
- GPS_Time - Standard GPS Time in ms.
- GPS_Update - Will show as 1 each time the GPS data was updating
for that log record, 0 if it is the same data as the last record.
- MPH - Speed in MPH
- KPH - Speed in KPH
For each of these Fields you will find a Gauge to display the values in
real-time. To change a Gauge to show the GPS field, right click on it
and select:
Application Gauges --> The gauge of your choice.
CAN Project Navigation
- As you can see below when you have multiple CAN devices things can
get a little lengthy, and that is one of the shorter examples. Now with
the CAN project navigation menu you can easily switch between each
devices main menu to keep those sub menus under control.
Curve Graph Baselines -
See what the curve settings were when you started to compare the
changes you have made, or revert back if you need to.
- Curve Baselines - Quickly toggle curve baselines on or off
at any point.
- Automatics Restore Point on Difference
Reports - Connect to the controller, get a difference report, even
if you select Use Controller Settings, a restore point of all local
TunerStudio settings will be created before loading the controller
settings. So if you should have any second thoughts, you can go back to
what TunerStudio had at any time.
- Restore
Point Difference Reports - Pull up a full visual difference
report for any historic restore point.
Plugins - Now the registered
TunerStudio lets you create your own plugins or download ones created
by others.
- Easy Access to the controller
- No need to write your own communications. The TunerStudio Plugin API
lets you read runtime data and settings or update and change any
setting with simple API's.
- Plugins that integrate with TunerStudio - Extend
TunerStudio into a full CAR PC with Plugins for music players, nav
systems, what ever you can think up.
©2012 EFIAnalytics.com


Overview • Credits • Third-party software ↑ | ↓
Copyright © 2009-2013, Yevhen Polyhach, Stefan Stoll & Gunnar Jeschke
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
See the Contributed software section of the credits page for the copyright holders of contributed programs.
Also see third-party software for a list of programs that can be installed to enhance MMM's functionality, after you have obtained a license from the original authors (free for academic use).


| Name |
{{conformance.name}}{{conformance.software.name}} |
FHIR version |
{{conformance.fhirVersion}} |
| Description | {{conformance.description}} |
Publisher | {{conformance.publisher}} |
| Accept Unknown | {{conformance.acceptUnknown}} |
Formats |
{{f}}
|
Generating the quality report. Note that this can take some time as all profiles and extension definitions
are retrieved by the report. It is assumed that all these artifacts are stored on the current conformance server
(This is not required by FHIR, but is a limitation of this report)
Quality report
| {{issue.level}} |
{{issue.display}} |
| {{extension.ed.url}} |
{{extension.ed.description}} |


| nse-force {rlang} | R Documentation |
It is sometimes useful to force early evaluation of part of an expression before it gets fully evaluated. The tidy eval framework provides several forcing operators for different use cases.
The bang-bang operator !!
forces a single object. One
common case for !!
is to substitute an environment-variable
(created with <-
) with a data-variable (inside a data frame).
library(dplyr) # The environment variable `var` refers to the data-variable # `height` var <- sym("height") # We force `var`, which substitutes it with `height` starwars %>% summarise(avg = mean(!!var, na.rm = TRUE))
The big-bang operator !!!
forces-splice a list of objects.
The elements of the list are spliced in place, meaning that they
each become one single argument.
vars <- syms(c("height", "mass")) # Force-splicing is equivalent to supplying the elements separately starwars %>% select(!!!vars) starwars %>% select(height, mass)
The curly-curly operator {{ }}
for function arguments is a bit
special because it forces the function argument and immediately
defuses it. The defused expression is substituted in place, ready
to be evaluated in another context, such as the data frame.
In practice, this is useful when you have a data-variable in an env-variable (such as a function argument).
# Force-defuse all function arguments that might contain # data-variables by embracing them with {{ }} mean_by <- function(data, by, var) { data %>% group_by({{ by }}) %>% summarise(avg = mean({{ var }}, na.rm = TRUE)) } # The env-variables `by` and `var` are forced but defused. # The data-variables they contain are evaluated by dplyr later on # in data context. iris %>% mean_by(by = Species, var = Sepal.Width)
Use qq_show()
to experiment with forcing operators. qq_show()
defuses its input, processes all forcing operators, and prints the
result with expr_print()
to reveal objects inlined in the
expression by the forcing operators.
qq_show(expr)
expr |
An expression to be quasiquoted. |
When a function takes multiple named arguments
(e.g. dplyr::mutate()
), it is difficult to supply a variable as
name. Since the LHS of =
is defused, giving the name
of a variable results in the argument having the name of the
variable rather than the name stored in that variable. This problem
of forcing evaluation of names is exactly what the !!
operator is
for.
Unfortunately R is very strict about the kind of expressions
supported on the LHS of =
. This is why rlang interprets the
walrus operator :=
as an alias of =
. You can use it to supply
names, e.g. a := b
is equivalent to a = b
. Since its syntax is
more flexible you can also force names on its LHS:
name <- "Jane" list2(!!name := 1 + 2) exprs(!!name := 1 + 2)
Like =
, the :=
operator expects strings or symbols on its LHS.
Since unquoting names is related to interpolating within a string
with the glue package, we have made the glue syntax available on
the LHS of :=
:
list2("{name}" := 1) tibble("{name}" := 1)
You can also interpolate defused function arguments with double
braces {{
, similar to the curly-curly syntax:
wrapper <- function(data, var) { data %>% mutate("{{ var }}_foo" := {{ var }} * 2) }
Currently, forcing names with :=
only works in top level
expressions.
These terms have a rich history in Lisp languages, and live on in
modern languages like
Julia
and
Racket.
Calling UQ()
and UQS()
with the rlang namespace qualifier is
deprecated as of rlang 0.3.0. Just use the unqualified forms
instead:
# Bad rlang::expr(mean(rlang::UQ(var) * 100)) # Ok rlang::expr(mean(UQ(var) * 100)) # Good rlang::expr(mean(!!var * 100))
Supporting namespace qualifiers complicates the implementation of unquotation and is misleading as to the nature of unquoting operators (which are syntactic operators that operate at quotation-time rather than function calls at evaluation-time).
UQ()
and UQS()
were soft-deprecated in rlang 0.2.0 in order
to make the syntax of quasiquotation more consistent. The prefix
forms are now `!!`()
and `!!!`()
which is
consistent with other R operators (e.g. `+`(a, b)
is the
prefix form of a + b
).
Note that the prefix forms are not as relevant as before because
!!
now has the right operator precedence, i.e. the same as
unary -
or +
. It is thus safe to mingle it with other
operators, e.g. !!a + !!b
does the right thing. In addition the
parser now strips one level of parentheses around unquoted
expressions. This way (!!"foo")(...)
expands to foo(...)
.
These changes make the prefix forms less useful.
Finally, the named functional forms UQ()
and UQS()
were
misleading because they suggested that existing knowledge about
functions is applicable to quasiquotation. This was reinforced by
the visible definitions of these functions exported by rlang and
by the tidy eval parser interpreting rlang::UQ()
as !!
. In
reality unquoting is not a function call, it is a syntactic
operation. The operator form makes it clearer that unquoting is
special.
# Interpolation with {{ }} is the easiest way to forward # arguments to tidy eval functions: if (is_attached("package:dplyr")) { # Forward all arguments involving data frame columns by # interpolating them within other data masked arguments. # Here we interpolate `arg` in a `summarise()` call: my_function <- function(data, arg) { summarise(data, avg = mean({{ arg }}, na.rm = TRUE)) } my_function(mtcars, cyl) my_function(mtcars, cyl * 10) # The operator is just a shortcut for `!!enquo()`: my_function <- function(data, arg) { summarise(data, avg = mean(!!enquo(arg), na.rm = TRUE)) } my_function(mtcars, cyl) } # Quasiquotation functions quote expressions like base::quote() quote(how_many(this)) expr(how_many(this)) quo(how_many(this)) # In addition, they support unquoting. Let's store symbols # (i.e. object names) in variables: this <- sym("apples") that <- sym("oranges") # With unquotation you can insert the contents of these variables # inside the quoted expression: expr(how_many(!!this)) expr(how_many(!!that)) # You can also insert values: expr(how_many(!!(1 + 2))) quo(how_many(!!(1 + 2))) # Note that when you unquote complex objects into an expression, # the base R printer may be a bit misleading. For instance compare # the output of `expr()` and `quo()` (which uses a custom printer) # when we unquote an integer vector: expr(how_many(!!(1:10))) quo(how_many(!!(1:10))) # This is why it's often useful to use qq_show() to examine the # result of unquotation operators. It uses the same printer as # quosures but does not return anything: qq_show(how_many(!!(1:10))) # Use `!!!` to add multiple arguments to a function. Its argument # should evaluate to a list or vector: args <- list(1:3, na.rm = TRUE) quo(mean(!!!args)) # You can combine the two var <- quote(xyz) extra_args <- list(trim = 0.9, na.rm = TRUE) quo(mean(!!var , !!!extra_args)) # The plural versions have support for the `:=` operator. # Like `=`, `:=` creates named arguments: quos(mouse1 := bernard, mouse2 = bianca) # The `:=` is mainly useful to unquote names. Unlike `=` it # supports `!!` on its LHS: var <- "unquote me!" quos(!!var := bernard, mouse2 = bianca) # All these features apply to dots captured by enquos(): fn <- function(...) enquos(...) fn(!!!args, !!var := penny) # Unquoting is especially useful for building an expression by # expanding around a variable part (the unquoted part): quo1 <- quo(toupper(foo)) quo1 quo2 <- quo(paste(!!quo1, bar)) quo2 quo3 <- quo(list(!!quo2, !!!syms(letters[1:5]))) quo3


--- title: About Me description: About Eric Nguyen custom_css : about ---
I'm Eric Nguyen, a web developer, designer, and musician.
I once took a brain test that determined both my left and right brains were equally dominant. This means I enjoy creative expression just as much as analytical thinking. Pretty handy for problem solving!
I originally graduated with a degree in Architecture, but it wasn't really my cup of tea. So I learned graphic design and coding. I worked as a lead designer and developer for a number of companies. I'll let you read the details on LinkedIn.
In 2017, I quit my job to take a gap year and pursue dream projects, travel, and learn new skills. I'm currently in Montreal. If you'd like to reach me, feel free to drop me a line! I love hearing about new projects.
{% for link in site.data.footer.right_links %} {% if link.social_icon %}{% include social-icon.html icon=link.social_icon %}{% endif %} Twitter {% endfor %}


A portrait of a female bare-faced curassow, taken at the Pantanal in Brazil. This species of bird in the family Cracidae is found in eastern-central and southern Brazil, Paraguay, eastern Bolivia, and extreme northeast Argentina. Its natural habitats are tropical and subtropical dry and moist broadleaf forests.
A portrait of a female bare-faced curassow,
taken at the Pantanal in Brazil. This species of bird
in the family Cracidae is found in eastern-central and
southern Brazil, Paraguay, eastern Bolivia, and
extreme northeast Argentina.
Its natural habitats
are tropical and subtropical dry and
moist broadleaf forests.


--- layout: post title: And She Reads date: 2011-09-15 08:09:11.000000000 -04:00 categories: - Books - Steiner/Waldorf tags: [] status: draft type: post published: false meta: aktt_notify_twitter: 'no' _edit_last: '1' author: login: cint email<EMAIL_ADDRESS>display_name: Jacinta first_name: Jacinta last_name: '' ---
Scarlett is now reading and is so excited with her achievement. Well I should say, she is confident enough in herself to admit she can read. She has been able to read for a little while now, but she didn't think she could. Oh my sweet girl is her own worst critic. She want to know how to do everything immediately and if she doesn't, well, it's not often pretty.
One thing I am loving with our Steiner/Waldorf journey is how the children's journey starts off so very slow and repetition is a key in helping the basics stick. Now for a child like Scarlett who wanted to do everything yesterday, reading has been one of those things she has wanted to do without really trying. We are pretty big on reading to the children every day and we hope to instill a love of books and literature in general. Snuggling up in our bed or theirs to read books is one of my favourite times of day.
Slow to begin
Building so it is subliminal
Gentle and rhythmic
Learning is life long no need to rush things
She is about caught up with other children who have been reading since prep


Unite Gallery
general purpose responsive gallery jquery plugin
- created: 06/20/2014
- by: valiano
- email<EMAIL_ADDRESS>Licence
This item brought under MIT license. It means that you can use it in every project of yours freely.
Gallery Structure
Each gallery theme could use different gallery elements. Every one have a slider (it's the area where the images are changing). The slider area have some buttons that could be added ti it like the zoom buttons and play/stop buttons, and the text panel.
Also, the themes could use some of the thumb panels available: strip thumbs panel and grid thumbs panel.
Each of the panels has it's own options, so if you using the theme that grid panel is available, only the grid panel options will be legitimate to it.
The gallery parts are on the image below:
Installing The Gallery
Installing the gallery is very easy.
Firs, you have to copy / upload the unitegallery plugin folder to your server, to the same folder where your page located.
Then add the following code to your  section of your page:

<link rel='stylesheet' href='unitegallery/css/unite-gallery.css' type='text/css' />

<link rel='stylesheet' href='unitegallery/themes/default/ug-theme-default.css' type='text/css' />

Then in the body put following gallery markup:

When:
- alt - image title (optional)
- src - url of the thumbnail image
- data-image - url of the big image.
- data-description - the description of the image (optional)
Then add following javascript code in order to initiate the gallery:

Markup For Media Items
The gallery can play follwoing media items: Youtube, Vimeo, Html5 Video, Wistia, SoundCloud
For settnig up the videos please use following markup:

When:
* For Youtube items the thumb and big images are not a must. If some of them is missing, the script will fill it from the youtube website.
Changing Skin
Changing skin is very easy. First, you have to include the skin css (from skins folder of the gallery). Now tere is one additional skin for example: "alexis" skin, but you can add your skin simply by copying the alexis skin to another folder, rename it and change the graphical elements.

[...other includes...]
<link rel='stylesheet' href='unitegallery/skins/alexis/alexis.css' type='text/css' />

Then you have to choose what item skin you want to change. You can change every slider graphical item (all the buttons, bullets, arrows) that you have in options, grid arrows and handles. Also you can add every gallery element design that you want like gallery global wrapper css or slider css.
Also, you have global skin option (gallery_skin) that change all the skinnable elements (like global default setting).
Please see options below.
jQuery("gallery").unitegallery({
gallery_skin:"alexis" //it's the default skin
slider_bullets_skin: "alexis" //example how to change only skin for slider bullets
});
Changing Theme
The themes located under unitegallery / themes folder.
For changing the theme you have to add it's javascript in "head" section of the page, and css of the theme then if available.

[...other includes...]

after that in the javascript you need to change option: gallery_theme:"theme name" as you see in the folder.
Each theme has it's own options in addition to global gallery options. All the options you can see in theme pages in the unitegallery.net website.
jQuery("gallery").unitegallery({
gallery_theme:"compact" //example how to change skin to "compact"
});
* Note, that some theme has it's own graphical elements like "default theme", and you can't change some of them, only to disable it and add them from the "slider" options. Like slider play button and fullscreen buttons in "default" theme. It's controlled from theme options and not from the slider options, so it's not skinnable, and slider options don't related to them.
* Note, that if you include only one theme per gallery page (example load only copmact skin js and remove the default theme js, then you don't have to use "gallery_theme" option. It will be loaded automatically.
Using The API
Using gallery API is very easy. You have some functions that can control the gallery functions and some events that happends on gallery states change.
First, you have to create the API variable in the javascript of the gallery creation:
* note that the api variable has to be external, outside of the ready() function.

Then you can use the API variable in every javascript functions that you have and integrate. Below there is the functions that you can use arranged as javascript functions so you can copy / paste from the code window and use them in your code:
api.play() //start play mode
api.stop() //stop play mode
api.togglePlay() //toggle play mode
api.enterFullscreen() //enter fullscreen
api.exitFullscreen() //exit fullscreen
api.toggleFullscreen() //toggle fullscreen
api.zoomIn() //zoom in current image
api.zoomOut() //zoom out current image
api.resetZoom() //reset zoom to fit zoom mode
api.nextItem() //next item
api.prevItem() //previous item
api.selectItem(numItem) //go to some item by index (0-numItems)
api.resize(width, height) //resize the gallery to some width. Height is optionary.
api.getItem(numItem) //get data object of the item by some index.
api.getNumItems() //get number of items in the gallery
Also, there is API events on some gallery functionality that you can use. You can copy / paste the events code from the javascript code window and use it:
api.on("item_change",function(num, data){ //on item change, get item number and item data
//do something
});
api.on("resize",function(){ //on gallery resize
//do something
});
api.on("enter_fullscreen",function(){ //on enter fullscreen
//do something
});
api.on("exit_fullscreen",function(){ //on exit fulscreen
//do something
});
api.on("play",function(){ //on start playing
//do something
});
api.on("stop",function(){ //on stop playing
//do something
});
api.on("pause",function(){ //on pause playing
//do something
});
api.on("continue",function(){ //on continue playing
//do something
});
On some events and functions there is a item data object. It's fields are described below:
Note, that you can add additional data to the items as item data field, like:  . Then you'll get that field in the data object together with other fields.
data.index
data.title
data.description
data.urlImage
data.urlThumb
//that taken from  from gallery markup
data.custom //item custom field passed.


72. al-Jinn: The Jinn
1
Say (O Muhammad): It is revealed unto me that a company of the Jinn gave ear, and they said: Lo! we have heard a marvellous Qur'an,
2
Which guideth unto righteousness, so we believe in it and we ascribe no partner unto our Lord.
3
And (we believe) that He - exalted be the glory of our Lord! - hath taken neither wife nor son,
4
And that the foolish one among us used to speak concerning Allah an atrocious lie.
5
And lo! we had supposed that humankind and jinn would not speak a lie concerning Allah -
6
And indeed (O Muhammad) individuals of humankind used to invoke the protection of individuals of the jinn, so that they increased them in revolt against Allah);
7
And indeed they supposed, even as ye suppose, that Allah would not raise anyone (from the dead) -
8
And (the Jinn who had listened to the Qur'an said): We had sought the heaven but had found it filled with strong warders and meteors.
9
And we used to sit on places (high) therein to listen. But he who listeneth now findeth a flame in wait for him;
10
And we know not whether harm is boded unto all who are in the earth, or whether their Lord intendeth guidance for them.
11
And among us there are righteous folk and among us there are far from that. We are sects having different rules.
12
And we know that we cannot escape from Allah in the earth, nor can we escape by flight.
13
And when we heard the guidance, we believed therein, and whoso believeth in his Lord, he feareth neither loss nor oppression.
14
And there are among us some who have surrendered (to Allah) and there are among us some who are unjust. And whoso hath surrendered to Allah, such have taken the right path purposefully.
15
And as for those who are unjust, they are firewood for hell.
16
If they (the idolaters) tread the right path, We shall give them to drink of water in abundance
17
That We may test them thereby, and whoso turneth away from the remembrance of his Lord; He will thrust him into ever-growing torment.
18
And the places of worship are only for Allah, so pray not unto anyone along with Allah.
19
And when the slave of Allah stood up in prayer to Him, they crowded on him, almost stifling.
20
Say (unto them, O Muhammad): I pray unto Allah only, and ascribe unto Him no partner.
21
Say: Lo! I control not hurt nor benefit for you.
22
Say: Lo! none can protect me from Allah, nor can I find any refuge beside Him
23
(Mine is) but conveyance (of the Truth) from Allah, and His messages; and whoso disobeyeth Allah and His messenger, lo! his is fire of hell, wherein such dwell for ever.
24
Till (the day) when they shall behold that which they are promised (they may doubt); but then they will know (for certain) who is weaker in allies and less in multitude.
25
Say (O Muhammad, unto the disbelievers): I know not whether that which ye are promised is nigh, or if my Lord hath set a distant term for it.
26
(He is) the Knower of the Unseen, and He revealeth unto none His secret,
27
Save unto every messenger whom He hath chosen, and then He maketh a guard to go before him and a guard behind him
28
That He may know that they have indeed conveyed the messages of their Lord. He surroundeth all their doings, and He keepeth count of all things.
-- Sura 72 --


Are you sure you want to delete {{node.participantId}}?
If so, please confirm the participant ID node you want to delete in the form below:
Please note that, once deleted, this participant ID CANNOT be reused for the same participant and
environment.