Clang Tools
Clang Tools are standalone command line (and potentially GUI) tools design for use by C++ developers who are already using and enjoying Clang as their compiler. These tools provide developer-oriented functionality such as fast syntax checking, automatic formatting, refactoring, etc.
Only a couple of the most basic and fundamental tools are kept in the primary Clang Subversion project. The rest of the tools are kept in a side-project so that developers who don't want or need to build them don't. If you want to get access to the extra Clang Tools repository, simply check it out into the tools tree of your Clang checkout and follow the usual process for building and working with a combined LLVM/Clang checkout:
- With Subversion:
- cd llvm/tools/clang/tools
- svn co http://llvm.org/svn/llvm-project/clang-tools-extra/trunk extra
- Or with Git:
- cd llvm/tools/clang/tools
- git clone http://llvm.org/git/clang-tools-extra.git extra
This document describes a high-level overview of the organization of Clang Tools within the project as well as giving an introduction to some of the more important tools. However, it should be noted that this document is currently focused on Clang and Clang Tool developers, not on end users of these tools.
Clang Tools Organization
Clang Tools are CLI or GUI programs that are intended to be directly used by C++ developers. That is they are not primarily for use by Clang developers, although they are hopefully useful to C++ developers who happen to work on Clang, and we try to actively dogfood their functionality. They are developed in three components: the underlying infrastructure for building a standalone tool based on Clang, core shared logic used by many different tools in the form of refactoring and rewriting libraries, and the tools themselves.
The underlying infrastructure for Clang Tools is the LibTooling platform. See its documentation for much more detailed information about how this infrastructure works. The common refactoring and rewriting toolkit-style library is also part of LibTooling organizationally.
A few Clang Tools are developed along side the core Clang libraries as examples and test cases of fundamental functionality. However, most of the tools are developed in a side repository to provide easy separation from the core libraries. We intentionally do not support public libraries in the side repository, as we want to carefully review and find good APIs for libraries as they are lifted out of a few tools and into the core Clang library set.
Regardless of which repository Clang Tools' code resides in, the development process and practices for all Clang Tools are exactly those of Clang itself. They are entirely within the Clang project, regardless of the version control scheme.
Core Clang Tools
The core set of Clang tools that are within the main repository are tools that very specifically compliment, and allow use and testing of Clang specific functionality.
clang-check
This tool combines the LibTooling framework for running a Clang tool with the basic Clang diagnostics by syntax checking specific files in a fast, command line interface. It can also accept flags to re-display the diagnostics in different formats with different flags, suitable for use driving an IDE or editor. Furthermore, it can be used in fixit-mode to directly apply fixit-hints offered by clang.
FIXME: Link to user-oriented clang-check documentation.
Extra Clang Tools
As various categories of Clang Tools are added to the extra repository, they'll be tracked here. The focus of this documentation is on the scope and features of the tools for other tool developers; each tool should provide its own user-focused documentation.


Source code for importers.issue_tracker.bugzilla.querier_bugzilla
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'valerio cosentino'
import bugzilla
from util.date_util import DateUtil
import time
[docs]class BugzillaQuerier():
"""
This class collects the data available on the Bugzilla issue tracker via its API
"""
WAITING_TIME = 1800
def __init__(self, url, product, logger):
"""
:type url: str
:param url: the URL of the Bugzilla issue tracker
:type product: str
:param product: the name of the product to import from the Bugzilla issue tracker
:type logger: Object
:param logger: logger
"""
self._logger = logger
self._bzapi = self._init_bzapi(url)
self._product = product
self._date_util = DateUtil()
def _init_bzapi(self, url):
# connect to the Bugzilla API
success = False
while not success:
try:
bzapi = bugzilla.Bugzilla(url=url)
success = True
except:
time.sleep(BugzillaQuerier.WAITING_TIME)
self._logger.warning("BugzillaQuerier init standby for " +
str(BugzillaQuerier.WAITING_TIME) + " seconds")
return bzapi
[docs] def get_issue_ids(self, before_date):
"""
gets data source issue ids
:type before_date: str
:param before_date: selects issues with creation date before a given date (YYYY-mm-dd)
"""
# TODO - include_fields seems not to work properly
query = self._bzapi.build_query(product=self._product, include_fields=["id", "creation_time"])
result = self._bzapi.query(query)
if before_date:
result = [r for r in result if r.creation_time <= self._date_util.get_timestamp(before_date, "%Y-%m-%d")]
return [r.id for r in result]
[docs] def get_user_name(self, user_email):
"""
gets user name by her email
:type user_email: str
:param user_email: user email
"""
try:
user = self._bzapi.getuser(user_email)
name = user.real_name.lower()
except Exception:
self._logger.warning("BugzillaError, user with email " + user_email + " not found")
name = user_email.split('@')[0]
return name
[docs] def get_issue_creator(self, issue):
"""
gets issue creator
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.creator
[docs] def get_issue_version(self, issue):
"""
gets issue version
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.version
[docs] def get_issue_last_change_time(self, issue):
"""
gets issue last change date
:type issue: Object
:param issue: the Object representing an issue
"""
return self._date_util.get_timestamp(issue.last_change_time, '%Y%m%dT%H:%M:%S')
[docs] def get_issue_creation_time(self, issue):
"""
gets issue creation time
:type issue: Object
:param issue: the Object representing an issue
"""
return self._date_util.get_timestamp(issue.creation_time, '%Y%m%dT%H:%M:%S')
[docs] def get_issue_priority(self, issue):
"""
gets issue priority
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.priority
[docs] def get_issue_severity(self, issue):
"""
gets issue severity
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.severity
[docs] def get_issue_operating_system(self, issue):
"""
gets issue operating system
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.op_sys
[docs] def get_issue_summary(self, issue):
"""
gets issue summary
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.summary
[docs] def get_issue_component(self, issue):
"""
gets issue component
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.component
[docs] def get_issue_history(self, issue):
"""
gets issue event history
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.get_history_raw().get('bugs')[0].get('history')
[docs] def get_event_property(self, event, property):
"""
gets property of an event
:type event: Object
:param event: the Object representing an event
:type property: str
:param property: the name of the property to retrieve
"""
return event.get(property)
[docs] def get_change_property(self, change, property):
"""
gets property of a change
:type change: Object
:param change: the Object representing a change
:type property: str
:param property: the name of the property to retrieve
"""
return change.get(property)
[docs] def get_issue_keywords(self, issue):
"""
gets keywords of an issue
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.keywords
[docs] def get_issue_cc(self, issue):
"""
gets subscribers of an issue
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.cc
[docs] def get_issue_assignee(self, issue):
"""
gets assignee of an issue
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.assigned_to
[docs] def get_issue_see_also(self, issue):
"""
gets see-also issue relations of an issue
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.see_also
[docs] def get_issue_blocks(self, issue):
"""
gets blocks issue relations of an issue
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.blocks
[docs] def get_issue_dupe_of(self, issue):
"""
gets duplicate issue relations of an issue
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.dupe_of
[docs] def get_issue_depends_on(self, issue):
"""
gets depends-on issue relations of an issue
:type issue: Object
:param issue: the Object representing an issue
"""
return issue.depends_on
[docs] def get_issue(self, issue_id):
"""
gets issue by its id
:type issue_id: int
:param issue_id: the data source issue id
"""
return self._bzapi.getbug(issue_id)
[docs] def get_attachment(self, attachment_id):
"""
gets attachment by its id
:type attachment_id: int
:param attachment_id: the data source attachment id
"""
return self._bzapi.openattachment(attachment_id)


Dove
5
xyzsfsafsadfsdfdsf
20/-
UserID
User Name
Cart
Leave Mart
Change Location
Purchases
How it Works
logout
OK


Merchant Creamees:
Welcome, friend! Ah, the herbs smell wonderful, don't they? My young friend Herbiel is making a new secret potion. Why don't you take a look? Perhaps you will find something you need...
Trade accessories.
Exchange equipment.
Ask about the local lord and tax rate.
Quest


(skip this header)
Friday, January 30, 2015
Editor's note: If you are experiencing any technical issues with our comics, please email newmedia@seattlepi.com.


Website Responsive Web Design Layout
This website was made for learning purposes only. I want to have a place to publish my HTML5 + JS games while I learn new technology and programming methodologies.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda, natus est sit sunt ipsam deleniti modi eligendi.
Button!Lorem ipsum dolor sit amet, consectetur adipisicing elit. Laborum, rem, facilis, maxime nostrum asperiores molestiae eum dolor voluptatum ab officiis distinctio.
Consectetur adipisicing elit. Asperiores dolore quisquam eum ducimus officiis odio ipsum modi.
Um link de chamada para a páginaConsectetur adipisicing elit. Asperiores dolore quisquam eum ducimus officiis odio ipsum modi.
Um link de chamada para a páginaThis website was made for learning purposes only. I want to have a place to publish my HTML5 + JS games while I learn new technology and programming methodologies.


Bitmap
Text
Line
Circle
Triangle
Rect
Ellipse
PolyStar
RoundRect
Bring To Front
Send To Back
Bring Forward
Send Backward
Clockwise
Counterclockwise
+
-
Undo
Redo
Delete
Reset
Export to png image
Clone


I am a Software Engineer in Microsoft India R&D.
In the past, I have interned with the Department of Bioengineering at Stanford University under Prof. Kwabena Boahen. Helped them in achieving a real time manipulation for an articulated robot with three or more degrees of freedom having a kinematic or loop like structure using spiking silicon neurons.
I have majored in Information Technology from Indian Institute of Information Technology, Allahabad. My research interests are in Robotics, Artificial Intelligence, Machine Learning, Natural Language Processing, Computational Neuroscience and Human Computer Interactions.
I am very enthusiastic, adventurous and loves travelling. My hobbies are painting, photography & playing flute.
I am a coding freak!


- PaintAlpha - Class in org.jfree.chart.util
-
This class contains static methods for the manipulation
of objects of type Paint
The intention is to honour the alpha-channel in the process.
- PaintAlpha() - Constructor for class org.jfree.chart.util.PaintAlpha
-
- paintBar(Graphics2D, BarRenderer, int, int, RectangularShape, RectangleEdge) - Method in interface org.jfree.chart.renderer.category.BarPainter
-
Paints a single bar on behalf of a renderer.
- paintBar(Graphics2D, BarRenderer, int, int, RectangularShape, RectangleEdge) - Method in class org.jfree.chart.renderer.category.GradientBarPainter
-
Paints a single bar instance.
- paintBar(Graphics2D, BarRenderer, int, int, RectangularShape, RectangleEdge) - Method in class org.jfree.chart.renderer.category.StandardBarPainter
-
Paints a single bar instance.
- paintBar(Graphics2D, XYBarRenderer, int, int, RectangularShape, RectangleEdge) - Method in class org.jfree.chart.renderer.xy.GradientXYBarPainter
-
Paints a single bar instance.
- paintBar(Graphics2D, XYBarRenderer, int, int, RectangularShape, RectangleEdge) - Method in class org.jfree.chart.renderer.xy.StandardXYBarPainter
-
Paints a single bar instance.
- paintBar(Graphics2D, XYBarRenderer, int, int, RectangularShape, RectangleEdge) - Method in interface org.jfree.chart.renderer.xy.XYBarPainter
-
Paints a single bar on behalf of a renderer.
- paintBarShadow(Graphics2D, BarRenderer, int, int, RectangularShape, RectangleEdge, boolean) - Method in interface org.jfree.chart.renderer.category.BarPainter
-
Paints the shadow for a single bar on behalf of a renderer.
- paintBarShadow(Graphics2D, BarRenderer, int, int, RectangularShape, RectangleEdge, boolean) - Method in class org.jfree.chart.renderer.category.GradientBarPainter
-
Paints a single bar instance.
- paintBarShadow(Graphics2D, BarRenderer, int, int, RectangularShape, RectangleEdge, boolean) - Method in class org.jfree.chart.renderer.category.StandardBarPainter
-
Paints a single bar instance.
- paintBarShadow(Graphics2D, XYBarRenderer, int, int, RectangularShape, RectangleEdge, boolean) - Method in class org.jfree.chart.renderer.xy.GradientXYBarPainter
-
Paints a single bar instance.
- paintBarShadow(Graphics2D, XYBarRenderer, int, int, RectangularShape, RectangleEdge, boolean) - Method in class org.jfree.chart.renderer.xy.StandardXYBarPainter
-
Paints a single bar instance.
- paintBarShadow(Graphics2D, XYBarRenderer, int, int, RectangularShape, RectangleEdge, boolean) - Method in interface org.jfree.chart.renderer.xy.XYBarPainter
-
Paints the shadow for a single bar on behalf of a renderer.
- paintComponent(Graphics) - Method in class org.jfree.chart.ChartPanel
-
Paints the component by drawing the chart to fill the entire component,
but allowing for the insets (which will be non-zero if a border has been
set for this component).
- paintComponent(Graphics) - Method in class org.jfree.chart.editor.PaletteSample
-
Deprecated.
Draws the sample.
- PaintMap - Class in org.jfree.chart
-
A storage structure that maps Comparable
instances with
Paint
instances.
- PaintMap() - Constructor for class org.jfree.chart.PaintMap
-
Creates a new (empty) map.
- paintOverlay(Graphics2D, ChartPanel) - Method in class org.jfree.chart.panel.CrosshairOverlay
-
Paints the crosshairs in the layer.
- paintOverlay(Graphics2D, ChartPanel) - Method in interface org.jfree.chart.panel.Overlay
-
Paints the crosshairs in the layer.
- PaintScale - Interface in org.jfree.chart.renderer
-
- PaintScaleLegend - Class in org.jfree.chart.title
-
A legend that shows a range of values and their associated colors, driven
by an underlying
PaintScale
implementation.
- PaintScaleLegend(PaintScale, ValueAxis) - Constructor for class org.jfree.chart.title.PaintScaleLegend
-
Creates a new instance.
- paletteName - Variable in class org.jfree.chart.plot.ColorPalette
-
Deprecated.
The palette name.
- PaletteSample - Class in org.jfree.chart.editor
-
- PaletteSample(ColorPalette) - Constructor for class org.jfree.chart.editor.PaletteSample
-
Deprecated.
Creates a new sample.
- pan(double) - Method in class org.jfree.chart.axis.LogAxis
-
Slides the axis range by the specified percentage.
- pan(double) - Method in class org.jfree.chart.axis.ValueAxis
-
Slides the axis range by the specified percentage.
- panDomainAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.CategoryPlot
-
Pans the domain axes by the specified percentage.
- panDomainAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.CombinedRangeXYPlot
-
Pans all domain axes by the specified percentage.
- panDomainAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.FastScatterPlot
-
Pans the domain axes by the specified percentage.
- panDomainAxes(double, PlotRenderingInfo, Point2D) - Method in interface org.jfree.chart.plot.Pannable
-
Pans the domain axes by the specified percentage.
- panDomainAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.XYPlot
-
Pans the domain axes by the specified percentage.
- Pannable - Interface in org.jfree.chart.plot
-
An interface that the
ChartPanel
class uses to communicate with
plots that support panning.
- panRangeAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.CategoryPlot
-
Pans the range axes by the specified percentage.
- panRangeAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.CombinedDomainXYPlot
-
Pans all range axes by the specified percentage.
- panRangeAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.FastScatterPlot
-
Pans the range axes by the specified percentage.
- panRangeAxes(double, PlotRenderingInfo, Point2D) - Method in interface org.jfree.chart.plot.Pannable
-
Pans the range axes by the specified percentage.
- panRangeAxes(double, PlotRenderingInfo, Point2D) - Method in class org.jfree.chart.plot.XYPlot
-
Pans the range axes by the specified percentage.
- ParamChecks - Class in org.jfree.chart.util
-
A utility class for checking parameters.
- ParamChecks() - Constructor for class org.jfree.chart.util.ParamChecks
-
- pArea - Variable in class org.jfree.chart.renderer.xy.XYStepAreaRenderer
-
Area of the complete series
- parse(String, ParsePosition) - Method in class org.jfree.chart.axis.CompassFormat
-
This method returns null
for all inputs.
- parse(String, ParsePosition) - Method in class org.jfree.chart.axis.MonthDateFormat
-
Parses the given string (not implemented).
- parse(String, ParsePosition) - Method in class org.jfree.chart.axis.QuarterDateFormat
-
Parses the given string (not implemented).
- parse(String, ParsePosition) - Method in class org.jfree.chart.util.HexNumberFormat
-
Parsing is not implemented, so this method always returns
null
.
- parse(String, ParsePosition) - Method in class org.jfree.chart.util.HMSNumberFormat
-
Parsing is not implemented, so this method always returns
null
.
- parse(String, ParsePosition) - Method in class org.jfree.chart.util.LogFormat
-
Parsing is not implemented, so this method always returns
null
.
- parse(String, ParsePosition) - Method in class org.jfree.chart.util.RelativeDateFormat
-
Parses the given string (not implemented).
- parseDay(String) - Static method in class org.jfree.data.time.Day
-
Parses the string argument as a day.
- parseHour(String) - Static method in class org.jfree.data.time.Hour
-
Creates an Hour instance by parsing a string.
- parseMinute(String) - Static method in class org.jfree.data.time.Minute
-
Creates a Minute instance by parsing a string.
- parseMonth(String) - Static method in class org.jfree.data.time.Month
-
Parses the string argument as a month.
- parseQuarter(String) - Static method in class org.jfree.data.time.Quarter
-
Parses the string argument as a quarter.
- parseSecond(String) - Static method in class org.jfree.data.time.Second
-
Creates a new instance by parsing a string.
- parseWeek(String) - Static method in class org.jfree.data.time.Week
-
Parses the string argument as a week.
- parseYear(String) - Static method in class org.jfree.data.time.Year
-
Parses the string argument as a year.
- peg(Calendar) - Method in class org.jfree.data.time.Day
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.FixedMillisecond
-
This method is overridden to do nothing.
- peg(Calendar) - Method in class org.jfree.data.time.Hour
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.Millisecond
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.Minute
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.Month
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.Quarter
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.RegularTimePeriod
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.Second
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.Week
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- peg(Calendar) - Method in class org.jfree.data.time.Year
-
Recalculates the start date/time and end date/time for this time period
relative to the supplied calendar (which incorporates a time zone).
- period - Variable in class org.jfree.chart.axis.CyclicNumberAxis
-
The period.
- PeriodAxis - Class in org.jfree.chart.axis
-
- PeriodAxis(String) - Constructor for class org.jfree.chart.axis.PeriodAxis
-
Creates a new axis.
- PeriodAxis(String, RegularTimePeriod, RegularTimePeriod) - Constructor for class org.jfree.chart.axis.PeriodAxis
-
Creates a new axis.
- PeriodAxis(String, RegularTimePeriod, RegularTimePeriod, TimeZone) - Constructor for class org.jfree.chart.axis.PeriodAxis
-
- PeriodAxis(String, RegularTimePeriod, RegularTimePeriod, TimeZone, Locale) - Constructor for class org.jfree.chart.axis.PeriodAxis
-
Creates a new axis.
- PeriodAxisLabelInfo - Class in org.jfree.chart.axis
-
A record that contains information for one "band" of date labels in
a
PeriodAxis
.
- PeriodAxisLabelInfo(Class, DateFormat) - Constructor for class org.jfree.chart.axis.PeriodAxisLabelInfo
-
Creates a new instance.
- PeriodAxisLabelInfo(Class, DateFormat, RectangleInsets, Font, Paint, boolean, Stroke, Paint) - Constructor for class org.jfree.chart.axis.PeriodAxisLabelInfo
-
Creates a new instance.
- PIE - Static variable in class org.jfree.chart.plot.DialShape
-
Pie.
- PieChartDemo1 - Class in org.jfree.chart.demo
-
A simple demonstration application showing how to create a pie chart using
data from a
DefaultPieDataset
.
- PieChartDemo1(String) - Constructor for class org.jfree.chart.demo.PieChartDemo1
-
Default constructor.
- PieDataset - Interface in org.jfree.data.general
-
A general purpose dataset where values are associated with keys.
- PIEDATASET_TAG - Static variable in interface org.jfree.data.xml.DatasetTags
-
The 'PieDataset' element name.
- PieDatasetHandler - Class in org.jfree.data.xml
-
A SAX handler for reading a
PieDataset
from an XML file.
- PieDatasetHandler() - Constructor for class org.jfree.data.xml.PieDatasetHandler
-
Default constructor.
- PieLabelDistributor - Class in org.jfree.chart.plot
-
This class distributes the section labels for one side of a pie chart so
that they do not overlap.
- PieLabelDistributor(int) - Constructor for class org.jfree.chart.plot.PieLabelDistributor
-
Creates a new distributor.
- PieLabelLinkStyle - Class in org.jfree.chart.plot
-
Used to indicate the style for the lines linking pie sections to their
corresponding labels.
- PieLabelRecord - Class in org.jfree.chart.plot
-
A structure that retains information about the label for a section in a pie
chart.
- PieLabelRecord(Comparable, double, double, TextBox, double, double, double) - Constructor for class org.jfree.chart.plot.PieLabelRecord
-
Creates a new record.
- PiePlot - Class in org.jfree.chart.plot
-
A plot that displays data in the form of a pie chart, using data from any
class that implements the
PieDataset
interface.
- PiePlot() - Constructor for class org.jfree.chart.plot.PiePlot
-
Creates a new plot.
- PiePlot(PieDataset) - Constructor for class org.jfree.chart.plot.PiePlot
-
Creates a plot that will draw a pie chart for the specified dataset.
- PiePlot3D - Class in org.jfree.chart.plot
-
A plot that displays data in the form of a 3D pie chart, using data from
any class that implements the
PieDataset
interface.
- PiePlot3D() - Constructor for class org.jfree.chart.plot.PiePlot3D
-
Creates a new instance with no dataset.
- PiePlot3D(PieDataset) - Constructor for class org.jfree.chart.plot.PiePlot3D
-
Creates a pie chart with a three dimensional effect using the specified
dataset.
- PiePlotState - Class in org.jfree.chart.plot
-
A renderer state.
- PiePlotState(PlotRenderingInfo) - Constructor for class org.jfree.chart.plot.PiePlotState
-
Creates a new object for recording temporary state information for a
renderer.
- PieSectionEntity - Class in org.jfree.chart.entity
-
A chart entity that represents one section within a pie plot.
- PieSectionEntity(Shape, PieDataset, int, int, Comparable, String, String) - Constructor for class org.jfree.chart.entity.PieSectionEntity
-
Creates a new pie section entity.
- PieSectionLabelGenerator - Interface in org.jfree.chart.labels
-
Interface for a label generator for plots that use data from
a
PieDataset
.
- PieToolTipGenerator - Interface in org.jfree.chart.labels
-
A tool tip generator that is used by the
PiePlot
class.
- PieURLGenerator - Interface in org.jfree.chart.urls
-
Interface for a URL generator for plots that use data from a
PieDataset
.
- Pin() - Constructor for class org.jfree.chart.plot.dial.DialPointer.Pin
-
Creates a new instance.
- Pin(int) - Constructor for class org.jfree.chart.plot.dial.DialPointer.Pin
-
Creates a new instance.
- PinNeedle - Class in org.jfree.chart.needle
-
A needle that is drawn as a pin shape.
- PinNeedle() - Constructor for class org.jfree.chart.needle.PinNeedle
-
- Plot - Class in org.jfree.chart.plot
-
The base class for all plots in JFreeChart.
- Plot() - Constructor for class org.jfree.chart.plot.Plot
-
Creates a new plot.
- plotChanged(PlotChangeEvent) - Method in interface org.jfree.chart.event.PlotChangeListener
-
Receives notification of a plot change event.
- plotChanged(PlotChangeEvent) - Method in class org.jfree.chart.JFreeChart
-
Receives notification that the plot has changed, and passes this on to
registered listeners.
- plotChanged(PlotChangeEvent) - Method in class org.jfree.chart.plot.CombinedDomainCategoryPlot
-
- plotChanged(PlotChangeEvent) - Method in class org.jfree.chart.plot.CombinedDomainXYPlot
-
- plotChanged(PlotChangeEvent) - Method in class org.jfree.chart.plot.CombinedRangeCategoryPlot
-
- plotChanged(PlotChangeEvent) - Method in class org.jfree.chart.plot.CombinedRangeXYPlot
-
- PlotChangeEvent - Class in org.jfree.chart.event
-
- PlotChangeEvent(Plot) - Constructor for class org.jfree.chart.event.PlotChangeEvent
-
Creates a new PlotChangeEvent.
- PlotChangeListener - Interface in org.jfree.chart.event
-
The interface that must be supported by classes that wish to receive
notification of changes to a plot.
- PlotEntity - Class in org.jfree.chart.entity
-
A class that captures information about a plot.
- PlotEntity(Shape, Plot) - Constructor for class org.jfree.chart.entity.PlotEntity
-
Creates a new plot entity.
- PlotEntity(Shape, Plot, String) - Constructor for class org.jfree.chart.entity.PlotEntity
-
Creates a new plot entity.
- PlotEntity(Shape, Plot, String, String) - Constructor for class org.jfree.chart.entity.PlotEntity
-
Creates a new plot entity.
- PlotOrientation - Class in org.jfree.chart.plot
-
Used to indicate the orientation (horizontal or vertical) of a 2D plot.
- PlotRenderingInfo - Class in org.jfree.chart.plot
-
Stores information about the dimensions of a plot and its subplots.
- PlotRenderingInfo(ChartRenderingInfo) - Constructor for class org.jfree.chart.plot.PlotRenderingInfo
-
Creates a new instance.
- PlotState - Class in org.jfree.chart.plot
-
Records information about the state of a plot during the drawing process.
- PlotState() - Constructor for class org.jfree.chart.plot.PlotState
-
Creates a new state object.
- PlotUtilities - Class in org.jfree.chart.plot
-
Some utility methods related to the plot classes.
- PlotUtilities() - Constructor for class org.jfree.chart.plot.PlotUtilities
-
- PlumNeedle - Class in org.jfree.chart.needle
-
- PlumNeedle() - Constructor for class org.jfree.chart.needle.PlumNeedle
-
- PNG - Static variable in interface org.jfree.chart.encoders.ImageFormat
-
Portable Network Graphics - lossless
- Pointer() - Constructor for class org.jfree.chart.plot.dial.DialPointer.Pointer
-
Creates a new instance.
- Pointer(int) - Constructor for class org.jfree.chart.plot.dial.DialPointer.Pointer
-
Creates a new instance.
- PointerNeedle - Class in org.jfree.chart.needle
-
A needle in the shape of a pointer, for use with the
CompassPlot
class.
- PointerNeedle() - Constructor for class org.jfree.chart.needle.PointerNeedle
-
- pointRenderer(Graphics2D, Rectangle2D, PlotRenderingInfo, ContourPlot, ValueAxis, ValueAxis, ColorBar, ContourDataset, CrosshairState) - Method in class org.jfree.chart.plot.ContourPlot
-
Deprecated.
Draws the visual representation of a single data item.
- points - Variable in class org.jfree.chart.renderer.xy.XYSplineRenderer.XYSplineState
-
The points.
- pointsInTime - Variable in class org.jfree.data.time.DynamicTimeSeriesCollection
-
Storage for the x-values.
- PolarAxisLocation - Class in org.jfree.chart.plot
-
Used to indicate the location of an axis on a
PolarPlot
.
- PolarChartPanel - Class in org.jfree.chart
-
PolarChartPanel
is the top level object for using the
PolarPlot
.
- PolarChartPanel(JFreeChart) - Constructor for class org.jfree.chart.PolarChartPanel
-
Constructs a JFreeChart panel.
- PolarChartPanel(JFreeChart, boolean) - Constructor for class org.jfree.chart.PolarChartPanel
-
Creates a new panel.
- PolarItemRenderer - Interface in org.jfree.chart.renderer
-
The interface for a renderer that can be used by the
PolarPlot
class.
- PolarPlot - Class in org.jfree.chart.plot
-
Plots data that is in (theta, radius) pairs where
theta equal to zero is due north and increases clockwise.
- PolarPlot() - Constructor for class org.jfree.chart.plot.PolarPlot
-
Default constructor.
- PolarPlot(XYDataset, ValueAxis, PolarItemRenderer) - Constructor for class org.jfree.chart.plot.PolarPlot
-
Creates a new plot.
- PolynomialFunction2D - Class in org.jfree.data.function
-
A function in the form y = a0 + a1 * x + a2 * x^2 + ... + an *
x^n
.
- PolynomialFunction2D(double[]) - Constructor for class org.jfree.data.function.PolynomialFunction2D
-
Constructs a new polynomial function y = a0 + a1 * x + a2 * x^2 +
... + an * x^n
- popSubHandler() - Method in class org.jfree.data.xml.RootHandler
-
Pops a sub-handler from the stack.
- POSITION_INDEX - Static variable in class org.jfree.chart.renderer.WaferMapRenderer
-
default multivalue paint calculation
- POSITIVE - Static variable in class org.jfree.data.RangeType
-
Positive range.
- PowerFunction2D - Class in org.jfree.data.function
-
A function of the form y = a * x ^ b.
- PowerFunction2D(double, double) - Constructor for class org.jfree.data.function.PowerFunction2D
-
Creates a new power function.
- previous() - Method in class org.jfree.data.time.Day
-
Returns the day preceding this one.
- previous() - Method in class org.jfree.data.time.FixedMillisecond
-
Returns the millisecond preceding this one.
- previous() - Method in class org.jfree.data.time.Hour
-
Returns the hour preceding this one.
- previous() - Method in class org.jfree.data.time.Millisecond
-
Returns the millisecond preceding this one.
- previous() - Method in class org.jfree.data.time.Minute
-
Returns the minute preceding this one.
- previous() - Method in class org.jfree.data.time.Month
-
Returns the month preceding this one.
- previous() - Method in class org.jfree.data.time.Quarter
-
Returns the quarter preceding this one.
- previous() - Method in class org.jfree.data.time.RegularTimePeriod
-
Returns the time period preceding this one, or null
if some
lower limit has been reached.
- previous() - Method in class org.jfree.data.time.Second
-
Returns the second preceding this one.
- previous() - Method in class org.jfree.data.time.Week
-
Returns the week preceding this one.
- previous() - Method in class org.jfree.data.time.Year
-
Returns the year preceding this one.
- previousStandardDate(Date, DateTickUnit) - Method in class org.jfree.chart.axis.DateAxis
-
Returns the previous "standard" date, for a given date and tick unit.
- print(Graphics, PageFormat, int) - Method in class org.jfree.chart.ChartPanel
-
Prints the chart on a single page.
- PRINT_COMMAND - Static variable in class org.jfree.chart.ChartPanel
-
Print action command.
- PROPERTIES_COMMAND - Static variable in class org.jfree.chart.ChartPanel
-
Properties action command.
- propertyChange(PropertyChangeEvent) - Method in class org.jfree.chart.panel.CrosshairOverlay
-
Receives a property change event (typically a change in one of the
crosshairs).
- propertyChange(PropertyChangeEvent) - Method in class org.jfree.chart.plot.ContourPlot
-
Deprecated.
Notifies all registered listeners of a property change.
- prune() - Method in class org.jfree.data.xy.DefaultTableXYDataset
-
Removes all x-values for which all the y-values are null
.
- pushSubHandler(DefaultHandler) - Method in class org.jfree.data.xml.RootHandler
-
Pushes a sub-handler onto the stack.
- put(Comparable, Paint) - Method in class org.jfree.chart.PaintMap
-
Adds a mapping between the specified key
and
paint
values.
- put(Comparable, Stroke) - Method in class org.jfree.chart.StrokeMap
-
Adds a mapping between the specified key
and
stroke
values.


Google is dedicated to providing a harassment-free and inclusive event experience for everyone regardless of gender identity and expression, sexual orientation, disabilities, neurodiversity, physical appearance, body size, ethnicity, nationality, race, age, religion, or other protected category. We do not tolerate harassment of event participants in any form. Google takes violations of our policy seriously and will respond appropriately.
All participants of Google events must abide by the following policy:
Be excellent to each other.
Treat everyone with respect. Participate while acknowledging that everyone deserves to be here — and each of us has the right to enjoy our experience without fear of harassment, discrimination, or condescension, whether blatant or via micro-aggressions. Jokes shouldn’t demean others. Consider what you are saying and how it would feel if it were said to or about you.
Speak up if you see or hear something.
Harassment is not tolerated, and you are empowered to politely engage when you or others are disrespected. The person making you feel uncomfortable may not be aware of what they are doing, and politely bringing their behavior to their attention is encouraged.
Practice saying “Yes and” to each other.
It’s a theatre improv technique to build on each other’s ideas. We all benefit when we create together.
We have a ZERO TOLERANCE POLICY for harassment of any kind, including but not limited to:
- Stalking/following
- Deliberate intimidation
- Harassing photography or recording
- Sustained disruption of talks or other events
- Offensive verbal comments
- Verbal language that reinforces social structures of domination
- Sexual imagery and language in public spaces
- Inappropriate physical contact
- Unwelcome sexual or physical attention
In relation to, but not limited to:
- Neurodiversity
- Race
- Color
- National origin
- Gender identity
- Gender expression
- Sexual orientation
- Age
- Body size
- Disabilities
- Appearance
- Religion
- Pregnancy
Participants asked to stop any harassing behavior are expected to comply immediately. Our zero tolerance policy means that we will look into and review every allegation of violation of our Event Community Guidelines and Anti-Harassment Policy and respond appropriately. We empower and encourage you to report any behavior that makes you or others feel uncomfortable by finding a Google staff member.
Any person behaving in a disorderly manner, engaging in harassing or uncomfortable behavior, or otherwise failing to comply with this policy may be removed from any Google-hosted event or refused admittance (including to future Google events) at any time in Google’s sole discretion. Individuals who are expelled from an event for a violation of this policy will not be provided with a refund.
ANTI-HARASSMENT POLICY
Google is dedicated to providing a harassment-free and inclusive conference experience for everyone regardless of gender identity and expression, sexual orientation, differing abilities, neurodiversity, physical appearance, body size, ethnicity, nationality, age, religion, or other protected category. We do not tolerate harassment of conference participants in any form. Sexual language and imagery is not appropriate for any conference venue, including talks. Google takes these violations of our policy seriously and will respond appropriately. All attendees of the event must abide by our anti-harassment policy.
CONDUCT POLICY
Google reserves the right to refuse admittance to, or remove any person from the event (including future Google events) at any time in its sole discretion. This includes but is not limited to attendees behaving in a disorderly manner or failing to comply with the terms and conditions herein.
Contacts:
- Ana Cidre, +34 698 14 30 95, info@gdgvigo.com


--- layout: default ---
Get the latest blogs from me to directly in your inbox.
No advertisements. No sponsors.


DOM creation with jQuery and DOM-API compared
Simple test for div creation performances in jQuery.
Run all
Run a bench
Tests
JavaScript creation
Duration:
Run
JavaScript with attributes creation
Duration:
Run
Simple creation
Duration:
Run
Creation with inline attributes
Duration:
Run
Creation with structured attributes
Duration:
Run
Summary


As I wrote previously, I wanted to learn to use Github Pages to build a new blog and start keeping track of my personal projects and ideas. However, in getting started, I noticed that there really wasn’t a straightforward way to move from Github’s quick and dirty tutorial to actually creating a useful blog. There’s some tools like Jekyll Bootstrap, but it seems like it’s been a while since it has been updated. So after combing through a lot of other people’s pages and some Jekyll tutorials, I was finally able to get something presentable up and running. I figured I’d share the overall process I used as a first series of posts, in case someone else finds it useful.
This first post will center around getting a development environment setup and creating a “Hello, World!” type page to demonstrate the basics. So without further ado…
This guide assumes a standard Ubuntu installation and a pre-existing Github account.
Create Our Github Page
- First, we’ll want to create an empty repo out on Github. The naming here is quite important, so for a personal blog, you’ll want to name it like GITHUB_USERNAME.github.io. So login to Github and click “+ New Repository”. My repo info looked like this:
- Now, let’s clone our repo locally. This should be as simple as a
git clone https://github.com/USERNAME/USERNAME.github.io.git
in some place that you’re comfortable with. If you change into that directory, you’ll see it’s currently empty, unless you created a README or LICENSE file as part of your repo creation.
Note: If you don’t have git installed, issue sudo apt-get install git
to install.
Install The Basics
-
Let’s grab some packages we need to serve our site locally. This will be useful when writing posts, so you don’t have to push to Github constantly just to see what it looks like. Issue
sudo apt-get install ruby ruby1.9.1-dev python-pip
. -
We’ll need a Javascript parser and the Jekyll gem, so get NodeJS and Jekyll from rubygems:
sudo gem install node jekyll
-
This step is optional for some, but I needed syntax highlighting for code blocks. So install the Pygments package for Python:
sudo pip install Pygments
Create Our Folder Structure
There’s a certain folder structure that Jekyll looks for in your repo. For example, all posts must live in the ‘_posts’ folder and must be titled like YEAR-MONTH-DAY-TITLE.FORMAT. To help understand, the title of this post is 2014-09-06-creating-a-blog-1.md. Anyways, I wanted to get up and running with the absolute basic amount of stuff needed in my repo so here’s what seemed to work.
-
Change into your repo directory in a terminal. Create two directories, _layouts and _posts. They must be named exactly that, including the underscore at the front. Issue
mkdir _layouts _posts
-
Let’s also touch a couple of files that we’ll use later on. Issue
touch _config.yml index.html
Configure The Site
- We could probably do this part much later in the tutorial, but let’s go ahead and put some basic info about our site in the _config.yml file. Feel free to edit these fields to your liking, with the exception of the ‘highlighter’ option. That is for our code highlighting.
Test Our Local Server
-
Now, what’s a tutorial without a “Hello, World!” portion? Let’s go ahead and edit index.html to say that. The “Hello, World!” text should be the only thing in the file.
-
In the root of your repo, let’s tell Jekyll to server our pages so we can see if everything works. Issue
jekyll serve --watch
. The watch flag will monitor the repo for changed files and regenerate automatically, so you don’t have to start/stop the process. However, I’ve noticed that’s not the case for certain files, namely _config.yml. Your terminal should look something like this when you start the process:
- Open the address http://localhost:4000 in a browser and you should see your “Hello, World!” text. Neat!
Check It Out On Github
Okay, so we’ve got our first official page. How do we get that out to Github? Turns out, it’s really easy, because we’ve already got everything laid out just right locally.
-
Add all of our files to be commited:
git add --all
-
Commit them with a helpful message:
git commit -m "Committing basic folder structure and Hello World page."
-
Push it to Github:
git push origin master
-
Give it a few seconds, and you should see your new page at your USERNAME.github.io address:
Closing
That’s it for part one of this tutorial. We’ve now got a development environment setup and know how to push our pages to Github. In part two, we’ll explore how to use Bootstrap to setup a blog layout and create some custom layout pages so that our site looks clean and user friendly.


Your order will be delivered to: hanyayoko Jalan Bangka Raya No.45A Jakarta 17435<PHONE_NUMBER>7
Order ID : 89 Date Added : 06/08/2014 Status Order : Panding Payment : Bank Transfer
Your order will be sent after we received the payment confirmation.
Sub Total Shipping
{total} Rp.0
Don't like these annoying emails? Unsubscribe.


Dojo’s Radio
widget provides a wrapped, styleable radio widget that uses
the native <input type="radio">
as a base.
<label>
.
Radio
ensures that the proper attributes (ARIA or otherwise) are set along
with classes when properties such as disabled
, readOnly
,
invalid
, etc. are used.


Validation
Custom styles
Custom feedback styles apply custom colors, borders, focus styles, and background icons to better communicate feedback.
Background icons for <select>
s are only
available with .custom-select
, and not .form-control
.
Validation Tooltips
Custom feedback styles apply custom colors, borders, focus styles, and background icons to better communicate feedback.
Background icons for <select>
s are only
available with .custom-select
, and not .form-control
.
Validation type
Parsley is a javascript form validation library. It helps you provide your users with feedback on their form submission before sending it to your server.
Range validation
Parsley is a javascript form validation library. It helps you provide your users with feedback on their form submission before sending it to your server.


Currently the main goal of the Crystal core team is to reach 1.0 in the near future. Since achieving that goal involves a number of non-obvious tradeoffs, we want to use this post to shed some light on those inherent tensions and how they drive our work and priorities for the next few releases.
There are three main aspects of the Crystal ecosystem that in a way compete for resources and design decisions (when we say “Crystal ecosystem”, we mean: the compiler, the std-lib, official-ish and community shards, apps that depend on Crystal, and the community itself):
The language is already widely used, so we want to minimize the number of breaking changes, and when we can’t avoid them, at least minimize their impact on existing codebases. We want 1.0 to be a stable version of the language. We want the language to keep evolving (said another way, we don’t want the fact that we reached 1.0 to mean that we’re left with an ossified language).
The challenge at hand is to get as quickly as possible to a 1.0 version of Crystal that is at the same time as faithful as possible to the current state of the language, stable enough for individuals and organizations to feel comfortable adopting it for even their highest impact projects, and a solid foundation for future major versions.
Considering this context, the most important question to answer almost continuously is: what should happen before 1.0 and what can wait? Let’s delve into that!
What can wait? - after 1.0
Since we created Crystal, the language kept evolving through a very free process of exploration of new ideas, sometimes experimental ones, that we hoped would bring joy and productivity to the programmer at the end of the day. Sometimes these ideas end up requiring changes in the language. We want to continue receiving and exploring these new ideas, because these organic processes are what made Crystal what it is.
However, paying excessive attention to these kinds of novel ideas takes away precious resources and focus from the main goal of releasing 1.0. While approaching that, there will be less focus on new and enhanced features that require changes to the language.
There are also important features that are strongly wanted, but they do not require changes in the language itself. These will likely keep receiving lots of attention from the community and we will do our best to review and give feedback to help them move forward. But we will mainly be focused on the features that are holding back 1.0.
Let us go over some of those features, which might well make it into eventual 1.x versions of the language:
Windows: We aim for most of the shards and apps built on Crystal to be portable. The std-lib should hide platform specific aspects as well as possible. With that in mind adding more platforms to the supported list should not impact neither the language nor the public API. Again, recently we integrated a CI for Windows to ensure we continue moving steadily forward.
Debugger: Improving the debugging capabilities requires changes to the compiler and tool ecosystem but not to the language. There is ongoing effort from the community and further collaboration is expected and welcome. The current efforts are looking amazing. These may or may not land in 1.0, it depends a lot on timing of testing and feedback.
Multi-threading: There are pending stories to make multi-thread mode a non preview feature. To mention a few: which the desired guarantees for some parts of the std-lib are, or how the scheduler and runtime could be improved. We already polished GC
, Channel
, select
and IO
to behave correctly with multi-threading on. Future potential enhancements may allow you to use multiple threads more freely, but the core aspects of the language and runtime are set and done.
X or Y compiler bug: We will keep fixing them, before and after 1.0. Their existence didn’t prevent the existing community from building awesome stuff.
What can’t wait? - before 1.0
So, what is missing to reach 1.0?
tooling: There are a couple of stories regarding tooling that are missing and need improvements. Shards needs to be more solid for 1.0 (you might have noticed some work in the last couple of weeks on that).
multi-thread stability & documentation: With 0.33.0 we added some new features for multi-thread and improved IO handling. We want and need thread-safe IO, Channel and runtime.
std-lib polishing: Although the std-lib will keep evolving we know there are a couple of modules that do need at least a couple of iterations. We want to improve the current API before 1.0 so we allow more solid solutions to be built upon these features. Some examples of these modules include logging, Errno and general exceptions type hierarchy, as well as removing clutter from the top-level namespace.
These areas are the ones Manas & the rest of the core-team will invest most of their effort until 1.0 is reached.
Summary
With this post, we want to provide some clarity on what to expect and what not to expect from the Crystal core team for the next few months.
Of course, other areas that are not mentioned can still receive contributions. But we want to be transparent on the need to aim for fewer, smaller and self-contained changes in the API to include them in 1.0. Said another way, we’ll be much more conservative as regards our merge policy until we get to 1.0.
We already have many plans for after 1.0 that we’ll be excited to start sharing and investing efforts on after celebrating Crystal 1.0. Let’s get there first!


|
SdFat
|
#include <string.h>
#include <stddef.h>
#include <limits.h>
#include "FatLibConfig.h"
#include "FatApiConstants.h"
#include "FatStructs.h"
#include "FatVolume.h"
Classes | |
| class | FatFile |
| Basic file class. More... | |
| struct | FatPos_t |
| Internal type for file position - do not use in user apps. More... | |
| struct | fname_t |
| Internal type for Short File Name - do not use in user apps. More... | |
Macros | |
| #define | isDirSeparator(c) ((c) == '/') |
| #define | pgm_read_byte(addr) (*(const unsigned char*)(addr)) |
| #define | pgm_read_word(addr) (*(const uint16_t*)(addr)) |
| #define | PROGMEM |
| #define | PSTR(x) (x) |
Variables | |
| const uint8_t | FNAME_FLAG_LC_BASE = DIR_NT_LC_BASE |
| const uint8_t | FNAME_FLAG_LC_EXT = DIR_NT_LC_EXT |
| const uint8_t | FNAME_FLAG_LOST_CHARS = 0X01 |
| const uint8_t | FNAME_FLAG_MIXED_CASE = 0X02 |
| const uint8_t | FNAME_FLAG_NEED_LFN |
FatFile class.
Copyright (c) 2011-2018 Bill Greiman This file is part of the SdFat library for SD memory cards.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
| #define isDirSeparator | ( | c | ) | ((c) == '/') |
Expression for path name separator.
| #define pgm_read_byte | ( | addr | ) | (*(const unsigned char*)(addr)) |
read 8-bits from flash for ARM
| #define pgm_read_word | ( | addr | ) | (*(const uint16_t*)(addr)) |
read 16-bits from flash for ARM
| #define PROGMEM |
store in flash for ARM
| #define PSTR | ( | x | ) | (x) |
store literal string in flash for ARM
| const uint8_t FNAME_FLAG_LC_BASE = DIR_NT_LC_BASE |
Filename base-name is all lower case
| const uint8_t FNAME_FLAG_LC_EXT = DIR_NT_LC_EXT |
Filename extension is all lower case.
| const uint8_t FNAME_FLAG_LOST_CHARS = 0X01 |
Derived from a LFN with loss or conversion of characters.
| const uint8_t FNAME_FLAG_MIXED_CASE = 0X02 |
Base-name or extension has mixed case.
| const uint8_t FNAME_FLAG_NEED_LFN |
LFN entries are required for file name.


We're sorry but this site at <%= htmlWebpackPlugin.options.title %> doesn't work properly without JavaScript enabled. Please enable it to continue.


Customizable LVM
This lvm will be customizable, you can customize it to your liking..
Old TTS Voices!
You can get old IVONA (2) Voices, old Ceptral/Some Voiceforge Voices, and a few more!
Will there be more Features?
Yes, this project will have more features as time passes by.


ramroot
Run Linux entirely from RAM! This project creates and enables a custom
mkinitcpio hook that completely loads the root (and /boot) filesystem into
RAM during the initramfs boot stage.
Requirements
- Arch Linux
- This is was designed specifically to work with the Arch Linux
boot process. I suspect these scripts may work with slight
modifications on other distributions as well, however this is
currently untested.
- sudo
- These scripts can all be run as root, however, running them as a non
elevated user is recommended. The scripts call sudo when necessary
to modify or create initcpio files.
Installation (easy way)
All installation scripts are located in the bin/ directory. In order to
obtain correct UUIDs, you must install from a normal login session (no chroot).
To build and enable ramroot in one step, simply run the ramroot-enable
script. The newly built scripts are placed in a new build/ directory
within the respository as well as copied to their required source locations in
the filesystem.
- ramroot-build
- This creates and copies the ramroot build hook and runtime hook to
/usr/lib/initcpio/install/ramroot and /usr/lib/initcpio/hooks/ramroot
respectively.
- ramroot-enable
- This script adds ramroot to the HOOKS array directly after the udev hook
in /etc/mkinitcpio.conf. Additionally, module requirements
ext4 and zram are added to the MODULES array. A new new linux kernel
image is generated with these changes via mkinitcpio -p linux.
- ramroot-disable
- This script removes the ramroot hook and ext4, zram module requirements
in /etc/mkinitcpio.conf. A new kernel image is generated.
- ramroot-remove
- This ensures ramroot is disabled in /etc/mkinitcpio.conf and removes the
initcpio hooks at /usr/lib/initcpio/install/ramroot and
/usr/lib/initcpio/hooks/ramroot.
Usage
Once fully enabled, all that is required is a reboot. During the initial
phase of the boot process, the amount of detected RAM is displayed along with
a [y/n] prompt asking if the user wishes to load the root filesystem to RAM.
(Note that this prompt defaults to yes with a 10 second timeout if 4G or more
of RAM is detected.)
The filesystem transfer to RAM can take several minutes. As soon as the boot
process is complete, the USB device (or whatever boot device) can be removed.
Remember that all changes to files in RAM are completely lost once the
computer is shutdown. To update the system and edit files, boot the device
without transferring the filesystem to RAM.
Tips
Keep a clean and trimmed down system to maintain faster RAM sync times.
Arch Linux stores downloaded packages in /var/cache/pacman/pkg/. After
every update, if no problems occur, consider removing old packages.
Execute pacman -Sc to remove all packages that aren't currently installed.
Execute paccache -rk0 to remove all packages.
Consider that higher quality (more expensive) USB jump drives will
exhibit a noticeable difference in sync times.
Issues / to do (maybe)
- add a ramroot-flush function to sync the RAM filesystem back to the
initial boot device (simple)
- find a way to get UUIDs while in arch-chroot to allow installing via chroot
- prompt for UUIDs if none found?
- perhaps combine all the bin/ramroot-* scripts into one, or at least
- source common functions from a single file?
- test on other distros
- package up for the AUR
- add support for other partitions users may have
- warnings/no installing if user's root filesystem is to large?
- check filesystem size during boot
- default [y/n] answer at boot dependent on RAM and filesystem sizes
- add command line options to ramroot-build
- control [y/n] prompt behavior/existence/timeout
- specify UUIDs
- make a webpage to go along with arch-usb.
- right now, the fstab is completely disregarded upon a RAM boot...
- add option to keep fstab and mount other partitions in/out of RAM
- source fstab for information (UUIDs)?
Credits
This project was motivated greatly in part by the liveroot package and
by several inquisitive forum posts.
| Author: | Chris Magyar |
| License: | BSD 3-Clause |


You're probably here because you're looking for information about JOUR 490: Narrative Gaming, a directed research class being taught by Profs. Laura Davis and Jenn de la Fuente. It will be offered in Fall 2018.
Here are some game examples being used in journalism. The purpose of this class is to build something similar. You'll report on your idea, think of how to gamify it, and make it come alive! We'll also learn how game concepts can help engage people in news!


黒の手番です。62 はどう動かしますか？
Unlimited
pips Black=123 White=110
(CorrectAnswer= 0/0, ErrorScore= 0)
1. 13/11* 11/5* eq:-0.112 46.61% (G:17.27% B:0.61%) 53.39% (G:27.65% B:1.22%) 2. 8/2 4/2 eq:-0.134 (-0.022) 45.51% (G: 6.79% B:0.11%) 54.49% (G: 6.23% B:0.19%) 3. 8/2 3/1 eq:-0.314 (-0.202) 40.50% (G: 4.52% B:0.07%) 59.50% (G: 8.09% B:0.21%) 4. 8/2 6/4 eq:-0.392 (-0.280) 38.47% (G: 4.72% B:0.10%) 61.53% (G:10.24% B:0.25%) 5. 8/6 8/2 eq:-0.576 (-0.464) 34.95% (G: 4.91% B:0.13%) 65.05% (G:15.66% B:0.40%)


We're about to do some very exciting stuff -- we're going to put a whole new program right on your Blinkytape. Since this is a pretty small program that runs on a piece of hardware, we're going to call it firmware. If you're not familiar with the term already, you'll probably hear the term again when you're updating the software on a new camera, TV, car, or smart fridge. At the end of the day, it's a program like any other that runs on a tiny computer in the Blinkytape (the Blinkyboard.)
So, in order to make new firmware for your Blinkytape, we're going to install the Arduino environment, followed by a few special libraries. Then we're going to show you how to get a simple program on there. At that point, you should have the basic knowledge you need to get started on your own, so it'll be time for us to tearfully send you out into the world by yourself.
Our first step is to download the Arduino development environment. We made Blinkytape compatible with Arduino because it has a huge community and runs in Windows, Mac OS X, and Linux -- so, chances are good that you'll be able to run it on your computer and also find help if you get stuck anywhere.
The fine folks at Arduino have this covered very well, so head over to the Arduino Getting Started page for detailed install instructions. The installation process is very straightforward and they have good documentation if you have any trouble.
If you're having trouble picking a version, BlinkyTape is known to work with Arduino version 1.0.5.
If you're using Windows, you'll need the drivers for both BlinkyTape and Arduino before you can program your tape this way. Make sure that you install the PatternPaint package which includes the Blinkytape driver, and also the drivers for Arduino which are included in the Arduino package. Windows uses two slightly different drivers depending on how the tape identifies itself, but if you have both, you'll be OK in all scenarios.
Our next step is to download and install a couple of things that we've used to make the Blinkytape firmware better. If you don't know what a library is, don't worry -- just think of it as some helper code. We'll download and install these libraries so we can use the example code. Later on, when you're making your own firmware, you'll see how some of these libraries make it easier to program for BlinkyTape.
First install this -- it's called 'FastSPI_LED2' and it's for talking with LED strips like the one in your BlinkyTape. Grab the latest version, 'RC5' as of this writing.
Then go ahead and grab this! This one is called 'BlinkyTape_Arduino' and it's all the stuff we wrote, including our example code.
If you're not a Git expert, the quickest way to get our BlinkyTape_Arduino package is to use the 'Download Zip' button on the right-hand side of the page. The button should look something like this:
The best to install these particular libraries is to unzip them into the your Arduino libraries folder - they way they are named can cause trouble with the automatic method of installing Arduino libraries. Scroll down on that page for detailed info, but you'll basically take the zipfile and extract it into a folder called Documents/Arduino/libraries (or My Documents\Arduino\libraries on Windows.)
If you downloaded them as recommended above, you'll need to snip off the '-master' part of the name from the subfolder. In other words, you want it to look like 'Documents/Arduino/libraries/FastSPI_LED2' not 'Documents/Arduino/libraries/FastSPI_LED2-master' -- otherwise Arduino won't use them. (It doesn't like special characters in libary names.)
You can handle this one on your own!
Using a micro-USB cable, connect your BlinkyTape to a USB port on your computer. If this is the first time, prepare to be wowed by an epically awesome rainbow.
We're going to configure the Arduino environment to put software onto your Blinkytape. This should be pretty easy.
Let's just practice to make sure we have this part down.
Press the Upload Button in the upper right hand corner of the Arduino window to program your BlinkyTape. It should look like this:
If all goes welll, Arduino won't have a message for you, but your BlinkyTape should pause for a few seconds as the program is uploaded.
If that all went well, it should look just like when you first plugged in your BlinkyTape.
HelloBlinky will cycle through the BlinkyTape's primary colors, with a slight gradient that will make it look like the color is fading in from the end of the strip. First, let's change the speed at which it cycles to make it super fast.
Look for this lines:
int waiting_time = 40; //time in ms for color scaling
Change the value from "40"
to say, "4"
so that your code looks like this:
int waiting_time = 4; //time in ms for color scaling
Press the Upload button again, like we did in step 6. This will send your new version of the program to the BlinkyTape. When the upload is complete, the BlinkyTape should be flashing at your new preferred speed!
OK, so that was super-easy right? Right. Let's try something a bit more fun.
Now let's find the lines where we set the color. There are three lines that look something like this:
case 0: leds[i] = CRGB(i*3,0,0); break;
This is a line in a loop that increases that "i"
variable, and "i"
is going to be the number of the individual LED we're setting. We're giving each LED an RGB value, and we also use that "i"
variable to help us set the color. This line will make the LEDs a brighter red at one end than the other.
But let's change each of them so they have a color gradient instead of just brightness. To do that, we need to set two colors in each line. Let's make the first one (and first means "0"
since this is a computer!) go blue to red, the second one red to green, and the third green to blue. We'll use that "i"
variable that holds the LED number twice now, so instead of just increasing the red one, we're going to use that number to decrease the blue setting at the same time.
For the first one, let's try this:
case 0: leds[i] = CRGB(i*3,0, 180 - (i*3)); break;
And for the second, let's do:
case 1: leds[i] = CRGB(180 - (i*3),i*3,0); break;
I think you can figure out what the third one should be. Punch it in, then click that arrow button one more time to put your new, modified program on your Blinkytape, and Wow! That really kicks up the awesome quotient, right?
One important note: the above example won't work with other BlinkyTape software like PatternPaint. However, it's very easy to make your custom BlinkyTape firmware compatible with other BlinkyStuff! All you have to do is to include the function called serialLoop()
.
Look for a function that starts with this line:
void serialLoop() {
Copy the whole function into your custom Arduino Sketch, and then include these lines in your main loop:
if(Serial.available() > 0) {
serialLoop();
}
That should do it! Now you can use your own custom firmware with PatternPaint and other BlinkyTape software.
So, you might have noticed that we've been asking your BlinkyTape to pretend that it's an Arduino Leonardo. That's totally fine, since we've made sure that all of our software will work when that's the case. However...there's a little more to the story. There's an additional github repository, which you can find here, that contains the code to let your BlinkyTape think it's still a Blinkytape. You shouldn't need to do this, but if you're flashing a BlinkyTape for a friend who runs Windows and doesn't have Arduino installed, you might want to grab these files. Just make a folder called hardware
in your documents/Arduino folder and drop the files in there.
There's also some interesting stuff in this Github repository -- this contains the actual ProductionSketch, as well as the physical designs for the PCB boards, in case all of this programming stuff is just a little too virtual for you!
If the program fails to compile or upload, or the BlinkyTape is not doing what you expected, there could be a number of things to check.
Sometimes, when you try to put your new firmware on your Blinkytape, you'll see something like this:
This means that there's an issue with compiling your few program. You'll need to fix that before you can put the new firmware on your BlinkyTape. See if you can fix the compile errors -- the Arduino editor will give you some clues, including the line number where it ran into the problem. You'll find that these issues are often very simple, like a missing semicolon at the end of a line, or mismatched brackets. Check the Arduino programming reference if you get stuck.
First off, unplug your BlinkyTape, then plug it back in. If you've made a successful upload in the past, this will almost always take care of the issue. When it's plugged in, the tape should be playing the last pattern you programmed onto it.
¯\(°_o)/¯
Uh oh. This is where it gets fun. If your new program compiles, and you can flash it to your BlinkyTape, but isn't having the desired effect, it's time to rethink your approach. Read through your program again and think out each step. You'll often be able to use logic to figure out what's gone wrong. If all else fails, you can always go back to the original firmware, found at File | Examples | BlinkyTape_Arduino | ColorSwirl -- but make sure to save your custom program for later!


Hi and welcome to Ortcoi. Ortcoi is an application that's help you broadcast your presentations using the video and/or audio you recorded during your oral.
Please select the options for your presentation
Your file is now ready, click the following button to get it :
Download


Please refer to the errata for this document, which may include some normative corrections.
See also translations.
Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
HTML4 and CSS2 currently support media-dependent style sheets tailored
for different media types. For example, a document may use
sans-serif fonts when displayed on a screen and serif fonts when printed.
‘screen
’ and ‘print
’ are two media types that have been defined.
Media queries extend the functionality of media types by allowing
more precise labeling of style sheets.
A media query consists of a media type and zero or more expressions that
check for the conditions of particular media features. Among the
media features that can be used in media queries are ‘width
’, ‘height
’, and ‘color
’. By using media queries, presentations can
be tailored to a specific range of output devices without changing the
content itself.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
A W3C Recommendation is a mature document that has been widely reviewed and has been shown to be implementable. W3C encourages everybody to implement this specification. The (archived) public mailing list<EMAIL_ADDRESS>(see instructions) is preferred for discussion of this specification. When sending e-mail, please put the text “css3-mediaqueries” in the subject, preferably like this: “[css3-mediaqueries] …summary of comment…”.
This document has been reviewed by W3C Members, by software developers, and by other W3C groups and interested parties, and is endorsed by the Director as a W3C Recommendation. It is a stable document and may be used as reference material or cited from another document. W3C's role in making the Recommendation is to draw attention to the specification and to promote its widespread deployment. This enhances the functionality and interoperability of the Web.
Please see the Working Group's implementation report and the Media Queries Test Suite.
Also see the Disposition of comments and a list of changes relative to the previous Proposed Recommendation.
Publication as a W3C Recommendation does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by the CSS Working Group (part of the Style Activity).
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This document is the same as the previous, Proposed Recommendation version: except for the style sheet, editorial changes to the front matter such as the title and date, and removal of the older changes section.
(This section is not normative.)
HTML4 [HTML401] and CSS2 [CSS21] currently support media-dependent style sheets tailored for different media types. For example, a document may use different style sheets for screen and print. In HTML4, this can be written as:
<link rel="stylesheet" type="text/css" media="screen" href="sans-serif.css">
<link rel="stylesheet" type="text/css" media="print" href="serif.css">
Inside a CSS style sheet, one can declare that sections apply to certain media types:
@media screen {
* { font-family: sans-serif }
}
The ‘print
’ and ‘screen
’ media types are defined in HTML4. The
complete list of media types in HTML4 is: ‘aural
’, ‘braille
’, ‘handheld
’, ‘print
’, ‘projection
’, ‘screen
’, ‘tty
’,
‘tv
’. CSS2 defines the same list,
deprecates ‘aural
’ and adds
‘embossed
’ and ‘speech
’. Also, ‘all
’ is used to indicate that the style sheet
applies to all media types.
Media-specific style sheets are supported by several user agents. The
most commonly used feature is to distinguish between ‘screen
’ and ‘print
’.
There have been requests for ways to describe in more detail what type of output devices a style sheet applies to. Fortunately HTML4 foresaw these requests and defined a forward-compatible syntax for media types. Here is a quote from HTML4, section 6.13:
Future versions of HTML may introduce new values and may allow parameterized values. To facilitate the introduction of these extensions, conforming user agents must be able to parse the media attribute value as follows:
- The value is a comma-separated list of entries. For example,
media="screen, 3d-glasses, print and resolution > 90dpi"
is mapped to:
"screen" "3d-glasses" "print and resolution > 90dpi"
- Each entry is truncated just before the first character that isn't a US ASCII letter [a-zA-Z] (Unicode decimal 65-90, 97-122), digit [0-9] (Unicode hex 30-39), or hyphen (45). In the example, this gives:
"screen" "3d-glasses" "print"
Media queries, as described in this specification, build on the
mechanism outlined in HTML4. The syntax of media queries fit into the
media type syntax reserved in HTML4. The media
attribute of HTML4 also exists in XHTML and generic XML. The same syntax
can also be used inside in the ‘@media
’
and ‘@import
’ rules of CSS.
However, the parsing rules for media queries are incompatible with those of HTML4 so that they are consistent with those of media queries used in CSS.
HTML5 [HTML5] (at the moment of writing still work in progress) references the Media Queries specification directly and thus updates the rules for HTML.
A media query consists of a media type and zero or more expressions that check for the conditions of particular media features.
Statements regarding media queries in this section assume the syntax section is followed. Media queries that do not conform to the syntax are discussed in the error handling section. I.e. the syntax takes precedence over requirements in this section.
Here is a simple example written in HTML:
<link rel="stylesheet" media="screen and (color)" href="example.css" />
This example expresses that a certain style sheet
(example.css
) applies to devices of a certain media type
(‘screen
’) with certain feature (it
must be a color screen).
Here the same media query written in an @import-rule in CSS:
@import url(color.css) screen and (color);
A media query is a logical expression that is either true or false. A media query is true if the media type of the media query matches the media type of the device where the user agent is running (as defined in the "Applies to" line), and all expressions in the media query are true.
A shorthand syntax is offered for media queries that apply to all media
types; the keyword ‘all
’ can be left
out (along with the trailing ‘and
’).
I.e. if the media type is not explicitly given it is ‘all
’.
I.e. these are identical:
@media all and (min-width:500px) { … }
@media (min-width:500px) { … }
As are these:
@media (orientation: portrait) { … }
@media all and (orientation: portrait) { … }
Several media queries can be combined in a media query list. A
comma-separated list of media queries. If one or more of the media queries
in the comma-separated list are true, the whole list is true, and
otherwise false. In the media queries syntax, the comma expresses a
logical OR, while the ‘and
’ keyword
expresses a logical AND.
Here is an example of several media queries in a comma-separated list using the an @media-rule in CSS:
@media screen and (color), projection and (color) { … }
If the media query list is empty (i.e. the declaration is the empty string or consists solely of whitespace) it evaluates to true.
I.e. these are equivalent:
@media all { … }
@media { … }
The logical NOT can be expressed through the ‘not
’ keyword. The presence of the keyword
‘not
’ at the beginning of the media
query negates the result. I.e., if the media query had been true without
the ‘not
’ keyword it will become false,
and vice versa. User agents that only support media types (as described in
HTML4) will not recognize the ‘not
’
keyword and the associated style sheet is therefore not applied.
<link rel="stylesheet" media="not screen and (color)" href="example.css" />
The keyword ‘only
’ can also be used
to hide style sheets from older user agents. User agents must process
media queries starting with ‘only
’ as
if the ‘only
’ keyword was not present.
<link rel="stylesheet" media="only screen and (color)" href="example.css" />
The media queries syntax can be used with HTML, XHTML, XML [XMLSTYLE] and the @import and @media rules of CSS.
Here is the same example written in HTML, XHTML, XML, @import and @media:
<link rel="stylesheet" media="screen and (color), projection and (color)" rel="stylesheet" href="example.css">
<link rel="stylesheet" media="screen and (color), projection and (color)" rel="stylesheet" href="example.css" />
<?xml-stylesheet media="screen and (color), projection and (color)" rel="stylesheet" href="example.css" ?>
@import url(example.css) screen and (color), projection and (color);
@media screen and (color), projection and (color) { … }
The [XMLSTYLE] specification has not
yet been updated to use media queries in the media
pseudo-attribute.
If a media feature does not apply to the device where the UA is running, expressions involving the media feature will be false.
The media feature ‘device-aspect-ratio
’ only applies to visual
devices. On an aural device, expressions involving ‘device-aspect-ratio
’ will therefore always be
false:
<link rel="stylesheet" media="aural and (device-aspect-ratio: 16/9)" href="example.css" />
Expressions will always be false if the unit of measurement does not apply to the device.
The ‘px
’ unit does not apply to
‘speech
’ devices so the following
media query is always false:
<link rel="stylesheet" media="speech and (min-device-width: 800px)" href="example.css" />
Note that the media queries in this example would have been true if the
keyword ‘not
’ had been added to the
beginning of the media query.
To avoid circular dependencies, it is never necessary to apply the style
sheet in order to evaluate expressions. For example, the aspect ratio of a
printed document may be influenced by a style sheet, but expressions
involving ‘device-aspect-ratio
’ will be
based on the default aspect ratio of the user agent.
User agents are expected, but not required, to re-evaluate and re-layout the page in response to changes in the user environment, for example if the device is tilted from landscape to portrait mode.
The media query syntax is described in terms of the CSS2 grammar. As such,
rules not defined here are defined in CSS2. The
media_query_list
production defined below replaces the
media_list
production from CSS2. [CSS21]
media_query_list : S* [media_query [ ',' S* media_query ]* ]? ; media_query : [ONLY | NOT]? S* media_type S* [ AND S* expression ]* | expression [ AND S* expression ]* ; media_type : IDENT ; expression : '(' S* media_feature S* [ ':' S* expr ]? ')' S* ; media_feature : IDENT ;
COMMENT tokens, as defined by CSS2, do not occur in the grammar (to keep it readable), but any number of these tokens may appear anywhere between other tokens. [CSS21]
The following new definitions are introduced:
L l|\\0{0,4}(4c|6c)(\r\n|[ \t\r\n\f])?|\\l Y y|\\0{0,4}(59|79)(\r\n|[ \t\r\n\f])?|\\y
The following new tokens are introduced:
{O}{N}{L}{Y} {return ONLY;} {N}{O}{T} {return NOT;} {A}{N}{D} {return AND;} {num}{D}{P}{I} {return RESOLUTION;} {num}{D}{P}{C}{M} {return RESOLUTION;}
RESOLUTION
is to be added to the CSS2 term
production.
CSS style sheets are generally case-insensitive, and this is also the case for media queries.
In addition to conforming to the syntax, each media query needs to use media types and media features according to their respective specification in order to be considered conforming.
Only the first media query is conforming in the example below because the "example" media type does not exist.
@media all { body { background:lime } }
@media example { body { background:red } }
For media queries that are not conforming user agents need to follow the rules described in this section.
Unknown media types. Unknown media types evaluate to false. Effectively, they are treated identically to known media types that do not match the media type of the device.
The media query "unknown
" will evaluate to false, unless
unknown
is actually a supported media type. Similarly,
"not unknown
" will evaluate to true.
Unknown media types are distinct from media types that do not actually match the IDENT production. Those fall under the malformed media query clause.
Unknown media features. User agents are to represent
a media query as "not all
" when one of the specified media
features is not known.
<link rel="stylesheet" media="screen and (max-weight: 3kg) and (color), (color)" href="example.css" />
In this example, the first media query will be represented as
"not all
" and evaluate to false and the second media query
is evaluated as if the first had not been specified, effectively.
@media (min-orientation:portrait) { … }
Is represented as "not all
" because the ‘orientation
’ feature does not accept the
‘min-
’ prefix.
Unknown media feature values. As with unknown media
features, user agents are to represent a media query as "not
all
" when one of the specified media feature values is not known.
The media query (color:20example)
specifies an unknown
value for the ‘color
’ media feature
and is therefore represented as "not all
".
This media query is represented as "not all
" because
negative lengths are not allowed for the ‘width
’ media feature:
@media (min-width: -100px) { … }
Malformed media query. User agents are to handle
unexpected tokens encountered while parsing a media query by reading
until the end of the media query, while observing the rules for
matching pairs of (), [], {}, "", and '', and correctly
handling escapes. Media queries with unexpected tokens are represented
as "not all
". [CSS21]
@media (example, all,), speech { /* only applicable to speech devices */ }
@media &test, screen { /* only applicable to screen devices */ }
The following is an malformed media query because having no space
between ‘and
’ and the expression is
not allowed. (That is reserved for the functional notation syntax.)
@media all and(color) { … }
Media queries are expected to follow the error handling rules of the host language as well.
@media test;,all { body { background:lime } }
… will not apply because the semicolon terminates the
@media
rule in CSS.
Syntactically, media features resemble CSS properties: they have names and accept certain values. There are, however, several important differences between properties and media features:
min-
’ or ‘max-
’
prefixes to express "greater or equal to" and "smaller or equal to"
constraints. This syntax is used to avoid "<" and ">" characters
which may conflict with HTML and XML. Those media features that accept
prefixes will most often be used with prefixes, but can also be used
alone.
(feature)
will
evaluate to true if (feature:x)
will
evaluate to true for a value x other than zero or zero
followed by a unit identifier (i.e., other than 0
,
0px
, 0em
, etc.). Media features that are
prefixed by min/max cannot be used without a value. When a media feature
prefixed with min/max is used without a value it makes the media query
malformed.
aspect-ratio
’ and
‘device-aspect-ratio
’ media features.)
For example, the ‘color
’ media
feature can form expressions without a value (‘(color)
’), or with a value (‘(min-color: 1)
’).
This specification defines media features usable with visual and tactile devices. Similarly, media features can be defined for aural media types.
The ‘width
’ media feature describes
the width of the targeted display area of the output device. For
continuous media, this is the width of the viewport (as described by CSS2,
section 9.1.1 [CSS21]) including the size of a
rendered scroll bar (if any). For paged media, this is the width of the
page box (as described by CSS2, section 13.2 [CSS21]).
A specified <length> cannot be negative.
For example, this media query expresses that the style sheet is usable on printed output wider than 25cm:
<link rel="stylesheet" media="print and (min-width: 25cm)" href="http://…" />
This media query expresses that the style sheet is usable on devices with viewport (the part of the screen/paper where the document is rendered) widths between 400 and 700 pixels:
@media screen and (min-width: 400px) and (max-width: 700px) { … }
This media query expresses that style sheet is usable on screen and handheld devices if the width of the viewport is greater than 20em.
@media handheld and (min-width: 20em),
screen and (min-width: 20em) { … }
The ‘em
’ value is relative to the
initial value of ‘font-size’.
The ‘height
’ media feature describes
the height of the targeted display area of the output device. For
continuous media, this is the height of the viewport including the size of
a rendered scroll bar (if any). For paged media, this is the height of the
page box.
A specified <length> cannot be negative.
The ‘device-width
’ media feature
describes the width of the rendering surface of the output device. For
continuous media, this is the width of the screen. For paged media, this
is the width of the page sheet size.
A specified <length> cannot be negative.
@media screen and (device-width: 800px) { … }
In the example above, the style sheet will apply only to screens that
currently displays exactly 800 horizontal pixels. The ‘px
’ unit is of the logical kind, as described in
the Units section.
The ‘device-height
’ media feature
describes the height of the rendering surface of the output device. For
continuous media, this is the height of the screen. For paged media, this
is the height of the page sheet size.
A specified <length> cannot be negative.
<link rel="stylesheet" media="screen and (device-height: 600px)" />
In the example above, the style sheet will apply only to screens that
have exactly 600 vertical pixels. Note that the definition of the
‘px
’ unit is the same as in other
parts of CSS.
The ‘orientation
’ media feature is
‘portrait
’ when the value of the
‘height
’ media feature is greater than
or equal to the value of the ‘width
’
media feature. Otherwise ‘orientation
’
is ‘landscape
’.
@media all and (orientation:portrait) { … }
@media all and (orientation:landscape) { … }
The ‘aspect-ratio
’ media feature is
defined as the ratio of the value of the ‘width
’ media feature to the value of the
‘height
’ media feature.
The ‘device-aspect-ratio
’ media
feature is defined as the ratio of the value of the ‘device-width
’ media feature to the value of the
‘device-height
’ media feature.
For example, if a screen device with square pixels has 1280 horizontal pixels and 720 vertical pixels (commonly referred to as "16:9"), the following Media Queries will all match the device:
@media screen and (device-aspect-ratio: 16/9) { … }
@media screen and (device-aspect-ratio: 32/18) { … }
@media screen and (device-aspect-ratio: 1280/720) { … }
@media screen and (device-aspect-ratio: 2560/1440) { … }
The ‘color
’ media feature describes
the number of bits per color component of the output device. If the device
is not a color device, the value is zero.
A specified <integer> cannot be negative.
For example, these two media queries express that a style sheet applies to all color devices:
@media all and (color) { … }
@media all and (min-color: 1) { … }
This media query expresses that a style sheet applies to color devices with 2 or more bits per color component:
@media all and (min-color: 2) { … }
If different color components are represented by different number of bits, the smallest number is used.
For instance, if an 8-bit color system represents the red component
with 3 bits, the green component with 3 bits and the blue component with
2 bits, the ‘color
’ media feature will
have a value of 2.
In a device with indexed colors, the minimum number of bits per color component in the lookup table is used.
The described functionality is only able to describe color capabilities at a superficial level. If further functionality is required, RFC2531 [RFC2531] provides more specific media features which may be supported at a later stage.
The ‘color-index
’ media feature
describes the number of entries in the color lookup table of the output
device. If the device does not use a color lookup table, the value is
zero.
A specified <integer> cannot be negative.
For example, here are two ways to express that a style sheet applies to all color index devices:
@media all and (color-index) { … }
@media all and (min-color-index: 1) { … }
This media query expresses that a style sheet applies to a color index device with 256 or more entries:
<?xml-stylesheet media="all and (min-color-index: 256)"
href="http://www.example.com/…" ?>
The ‘monochrome
’ media feature
describes the number of bits per pixel in a monochrome frame buffer. If
the device is not a monochrome device, the output device value will be 0.
A specified <integer> cannot be negative.
For example, here are two ways to express that a style sheet applies to all monochrome devices:
@media all and (monochrome) { … }
@media all and (min-monochrome: 1) { … }
Express that a style sheet applies to monochrome devices with more than 2 bits per pixels:
@media all and (min-monochrome: 2) { … }
Express that there is one style sheet for color pages and another for monochrome:
<link rel="stylesheet" media="print and (color)" href="http://…" />
<link rel="stylesheet" media="print and (monochrome)" href="http://…" />
The ‘resolution
’ media feature
describes the resolution of the output device, i.e. the density of the
pixels. When querying devices with non-square pixels, in ‘min-resolution
’ queries the least-dense dimension
must be compared to the specified value and in ‘max-resolution
’ queries the most-dense dimensions
must be compared instead. A ‘resolution
’ (without a "min-" or "max-" prefix)
query never matches a device with non-square pixels.
For printers, this corresponds to the screening resolution (the resolution for printing dots of arbitrary color).
For example, this media query expresses that a style sheet is usable on devices with resolution greater than 300 dots per inch:
@media print and (min-resolution: 300dpi) { … }
This media query expresses that a style sheet is usable on devices with resolution greater than 118 dots per centimeter:
@media print and (min-resolution: 118dpcm) { … }
The ‘scan
’ media feature describes
the scanning process of "tv" output devices.
For example, this media query expresses that a style sheet is usable on tv devices with progressive scanning:
@media tv and (scan: progressive) { … }
The ‘grid
’ media feature is used to
query whether the output device is grid or bitmap. If the output device is
grid-based (e.g., a "tty" terminal, or a phone display with only one fixed
font), the value will be 1. Otherwise, the value will be 0.
Only 0 and 1 are valid values. (This includes -0.) Thus everything else creates a malformed media query.
Here are two examples:
@media handheld and (grid) and (max-width: 15em) { … }
@media handheld and (grid) and (device-max-height: 7em) { … }
This specification also introduces two new values.
The <ratio> value is a positive (not zero or negative) <integer>
followed by optional whitespace, followed by a solidus (‘/
’), followed by optional whitespace, followed by a
positive <integer>.
The <resolution> value is a positive <number> immediately followed
by a unit identifier (‘dpi
’ or
‘dpcm
’).
Whitespace, <integer>, <number> and other values used by this specification are the same as in other parts of CSS, normatively defined by CSS 2.1. [CSS21]
The units used in media queries are the same as in other parts of CSS. For example, the pixel unit represents CSS pixels and not physical pixels.
Relative units in media queries are based on the initial value, which
means that units are never based on results of declarations. For example,
in HTML, the ‘em
’ unit is relative to
the initial value of ‘font-size
’.
The ‘dpi
’ and ‘dpcm
’ units describe the resolution of an output
device, i.e., the density of device pixels. Resolution unit identifiers
are:
inch
’
centimeter
’
In this specification, these units are only used in the ‘resolution
’ media feature.
This specification is the product of the W3C Working Group on Cascading Style Sheets.
Comments from Björn Höhrmann, Christoph Päper, Chris Lilley, Simon Pieters, Rijk van Geijtenbeek, Sigurd Lerstad, Arve Bersvendsen, Susan Lesch, Philipp Hoschka, Roger Gimson, Steven Pemberton, Simon Kissane, Melinda Grant, and L. David Baron improved this specification.


Toggle navigation
NISSC
Non-Inferiority Sample Size Calculator
About
Survival Outcome
Continuous Outcome
Binary Outcome


Hiding Code Complexity
Do make it easy to read. Don't expose inner workings.
26 February 2018 | 27 April 2018
domain driven designWe like to talk about the architecture of our software because we like complexity. Software developers are the bears, and complex patterns seem to be the honey. The more I pair with people the more I wonder: “what makes us decide to take on a simple question with a difficult answer”? Why would anyone choose to implement something so complex, that it cannot be easily understood even the day after it’s committed?
Answer 1: because the underlying model is complex
Legacy systems. They always take the blame. But by introducing more complexity to work with, on the surface, we create even more legacy. The inner workings should never, ever, be exposed. I don’t care about status 40 or 70 or 10 simply because it’s persisted like that and you can’t change it. That doesn’t mean you should simply return that status and check the flags: instead we could try to hide that complex matter and encapsulate it in simple methods. That sounds simple. And it is. And yet, it almost never pops into people’s minds.
Let’s say that I’ve written a system that, based on certain statuses, should execute an action. For instance, I can only delete something in my shopping cart if the status is 40, 53 or 70.
if(shoppingCart.status == 40 || shoppingCart.status == 53 || shoppingCart.status == 70) {
delete();
}
Extract method to the rescue:
if(isPossibleToDelete(shoppingCart)) {
delete();
}
private bool isPossibleToDelete(shoppingCart) {
return shoppingCart.status == 40 || shoppingCart.status == 53 || shoppingCart.status == 70
}
But what do those numbers even mean?
private bool isPossibleToDelete(shoppingCart) {
return shoppingCart.status == CartStatus.NEW_CART || shoppingCart.status == CartStatus.BLOCKED || shoppingCart.status == CartStatus.MERGED
}
Ban those numbers to an enum and give them a meaningful name.
We’re not done yet:
if(shoppingCart.isPossibleToDelete()) {
delete();
}
It’s a subtle difference, but the cart knows about it’s status and that means you can hide that complexity behind the ShoppingCart class implementation. Most developers will know enough if they read “isPossibleToDelete” and those who need to know the details can dive deep. See how simple that was? Hidden within a method, no other tricks used. Even if the underlying model still uses the ugly status checks, the rest of your software should never check on 40, 53 or 70 again. Ban those numbers to the enum and don’t even use the enum values at your leisure.
If possible, go as far as making the status property private.
Another example. What if your legacy database structure doesn’t allow an easy-to-read persistent layer but forces you to write in four different tables to get something done? The answer is the same as above: encapsulate everything. Don’t simply implement (or generate, for that matter) CRUD operations based on your tables. Don’t let your tables (or boss) rule your codebase!
public void Save(RosterClientLink link) {
Persist(link);
var client = GetClientById(link.client.Id);
var roster = getRosterById(link.roster.Id);
client.Rosters.Add(roster);
Update(client);
}
Having such a method gives away that you’re leaning on a CRUD operation too much. The link class doesn’t say anything and it’s not even clear that it modifies client data unless you take a look. A second attempt:
public void attachWorkRosterToClient(Client client, Roster roster) {
Persist(new RosterClientLink(client.Id, roster.Id));
Persist(roster);
client.Rosters.Add(roster);
Update(client);
}
Simply having this method is better than nothing - it makes the intention to attach the roster to a client visible. Instead of requiring every developer to know the inner workings of those tables, they can simply “attach”. Your business should also be speaking about “attaching” then. But again, we’re not done yet:
public void attach(Roster roster) {
Persist(new RosterClientLink(this.Id, roster.Id));
Persist(roster);
this.Rosters.Add(roster);
Update(this);
}
That makes client.attach(roster);
possible, and that’s easier to read and ultimately, understand. One could argue that roster.attachTo(client)
makes more sense but think about responsibilities here: who owns what? Why would the roster be able to attach itself to a client, while a client owns and creates the rosters?
Answer 2: because we want to prove ourselves
You might think you look cool if you can handle a pattern in a pattern. You might be proud of yourself once you managed to generalize one callback that will never be re-used. Hoping others would be proud of you to. If those others can’t make much of your code, I would dare to say that it won’t be the case.
Using a factory because you’re convinced that creating anything has to be done by a factory might not be the best move to make. Using dependency injection because it’s best practice doesn’t make much sense to me either and that’s a trap that almost everyone falls in. What’s wrong with this:
public class Stuff {
private readonly IDep _One;
private readonly IDep two;
public Stuff(IDep one, IDep two) {
_One = one;
_Two = two;
}
public Stuff() : this(new One(), new Two()) {
}
}
The first constructor is used in unit testing and allows us to inject (aha!) mocks into the loaded instance, while the second constructor is used in production. This approach has some drawbacks, like any other approach - like the cascading effect of object creation. But that might be enough for your application.


How does one increase DC. Fir example how would a caster get a high DC. MY current 40 level caster only has a DC of 25, lots of chac seem to beat it.
Diffulty Class
Pump your main casting stat (both improving your base score and buffing it to the +12 cap), get the proper SF feats and lower or have someone else lower your enemies saves (via spells, curse song, poison, etc.). _________________ They can't stop us Let them try For Heavy Metal We will die
Thanks for the quick reply Kail.


IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE SERVICE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE SERVICE.