wiki:Zh_CN:Help/Styles/MapCSSImplementation

Context Navigation

translation incomplete

其他语言:

总体结构
选择器
样式设置
属性
数值表达式
1. 示例
兼容性说明
1. MapCSS 0.2
  1. 语法
  2. 属性
2. Halcyon (Potlatch 2)
3. Kothic
4. Ceyx
媒体查询（已废弃）

MapCSS 实现

JOSM 的 MapCSS 实现用于实现以下功能：

地图样式 (en)
Validator rules (en), 参见 MapCSS 标签检查器 (en)仅用于规则的特殊部分。
搜索对话框 (en)

另外，可以在 VS code 中安装 MapCSS 语法高亮器，为 MapCSS 绘图和验证器语法添加可视化高亮。

总体结构

MapCSS 样式表的规则形式为

selector {
    prop: value;
    /* ... */
    prop: value;
    /* and/or */
    set: class;
    set: .class;
    /* note that validator rules do not use the colon after set */
}

为给定对象查找样式的算法如下：

 - for each rule:
     if the selector applies, set the properties from the { } block
 - analyze the final list of properties and generate styles from it

MapCSS uses the comment format of CSS (/* ... */). Note that when commenting out large parts of a MapCSS file, some constructs may cause an unexpected end of the comment, for instance:

/*
*[highway][name =~ /^R(\.|:)? .*/] { /* the end of the regular expression defines the unexpected end of the comment */
        throwWarning: tr("foo");
}
*/

选择器

选择器 "是表示 MapCSS 规则的过滤表达式。只有当选择器与地图对象匹配时，该规则才会应用于该对象。

MapCSS 中的选择器不同于网页标准 CSS。MapCSS 只支持标准 CSS 选择器的一个子集，但扩展了 OSM 数据所需的其他选择器。

一些示例如下:

/* applied to ways with a tag highway=residential */
way[highway=residential] {  /*  the styles */}

/* applied to new, closed ways on layer 1, provided they have the tag amenity=parking and access=customers, and provided 
 * the zoom level is between 11 and 14 
 */
way|z11-14[amenity=parking][access=customers]:closed:new::layer_1 {...}


area[amenity=parking][access=customers], area[amenity=parking][!access] {...}
relation[type=route][route=foot] > way::relation_underlay {..}

The different elements (type-, zoom- , condition selector, pseudo classes, layer identifier, grouping and child combinator) are explained below.

类别选择器

Selector

Description

Matches with any object

node, way, relation

Matches with the osm objects of the given type.

area

Matches with any area regardless of whether the area border is only modelled with a single way or with a set of ways glued together with a relation.

area[natural=beach] {...} 
/* ... is equal to ... */
way[natural=beach], relation[type=multipolygon][natural=beach] {...}

Note that area selects unclosed ways as well, so it may be useful to add the :closed pseudo class. The JOSM Validator will give a warning for unclosed ways that have an area style.

meta

The meta selector starts a special rule that should stand at the beginning of the file. It gives some general information on the style sheet. All software that supports MapCSS should be able to parse this sections without errors, so do not use exotic syntax extensions in this part.

meta {
    title: "Parking lanes";   /* title shown in the menu */
    icon: "logo_16x16x8.png"; /* small icon shown in the menu next to the title */
    version: "1.2";           /* the version of the style */
    description: "...";       /* one or two sentences of describing the style */
    author: "...";            /* the author(s) of the style */
    link: "https://...";      /* URL to the web page of the style */
    min-josm-version: 6789;   /* the minimum JOSM version where this style works */
}

canvas

Some style information not specific to nodes, ways or relations.

canvas {
    fill-color: #ffffea; /* the former background-color is deprecated since r7110 */
    default-points: false;
    default-lines: false;
}

Key	Description	Value Format	Default Value
`fill-color`	Specifies the overall fill/background color (`background-color` is deprecated since r7110).	Color	`black`
`default-points`	Whether default point style should be added to nodes where no style applies.	Boolean	`true`
`default-lines`	Whether default line style should be added to ways where no style applies.	Boolean	`true`

子节点选择器

如果一个节点是一个方式的一部分，我们就说它是这个方式的 "子节点"。同样，如果一个节点、一条路或一个关系是一个关系的成员，我们就说它是这个关系的组成部分。

在 MapCSS 中，你可以使用子选择器，它只有在父对象和子对象都匹配的情况下才会匹配。

示例如下:

/*
 * only matches for a way which is a child of a relation with tags 
 * type=route and route=foot
 */
relation[type=route][route=foot] > way {...}

注释

缩放选择器和层标识符只适用于 > 符号右侧的部分。
函数prop()和is_prop_set()只支持 > 符号右侧的部分。
函数"'parent_tag'"和"'parent_tags'"（见下文）可用于访问父级标记。
为了与 MapCSS 0.2 标准兼容，也支持不带大于号 > 的 relation[type=route][route=foot]方式 {/*...*/}。但是，在这种情况下不能指定链接选择器。

父选择器

除了子选择器之外，JOSM 还支持父选择器的概念。请注意，父选择器是 MapCSS 在 JOSM 中的特定扩展，其它 MapCSS 实现中并不存在。

与子选择器类似，父选择器只有在父对象和子对象都匹配时才会匹配。与子选择器不同的是，父选择器使用字符 <。

与子选择器不同的是，父对象将被 "选中"。换句话说，{{{...}}}-声明块中的属性适用于"<"符号右侧的对象。

示例如下:

/*
 * matches for a highway which has at least one node tagged as traffic_calming=*
 */
node[traffic_calming] < way[highway] {...}

条件选择器

选择器可以包含一组条件。如果其中任何一个条件求值为假，则选择器不匹配，样式规则也不会应用。

属性条件指定 OSM 对象标签的条件。

Operator	Description	Example
`=`	Exact match of the value.	way[highway=residential] /* is case sensitive, i.e. does NOT match e.g. highway=Residential or Highway=residential / node[name="My name"] / use quotes if key or value includes spaces / node["name:pl"="Królewiec"] / use quotes if key or value includes special characters like colons or unicode characters */
`!=`	Value not equal	way[highway!=residential] node[name!="My name"] node["name:pl"!="Królewiec"]
`<`, `>`, `<=`, `>=`	Comparison for numeric values.	node[population >= 50000] /* population greater than or equal to 50000 / node[ele = 3000] / elevation with exactly 3000 meters */
`^=`	Prefix match	node[name ^= "myprefix"] /* value starts with 'myprefix' */
`$=`	Postfix match	node[name $= "mypostfix"] /* value ends with 'mypostfix' */
`*=`	Substring match	node[name = "my substring"] / value contains the substring 'my substring' */
`~=`	List membership	[vending~=stamps] / the tag value for the tag 'vending' consists of a list of ;-separated values / / and one of these values is 'stamps' */
`=~`	Regular expression match	[name=~/^My_pattern./] /* the value of the tag 'name' matches with the regular expression '^My_pattern.' / /* Note, that reqular expressions have to be enclosed in /.../ / Case-insensitive matching can be enabled via the embedded flag expression `(?i)` (see Pattern.CASE_INSENSITIVE). [name =~ /^(?i)(parking)$/] /* matches parking, Parking, PARKING, PaRkInG,... / [name =~ /^(?U)(\p{Lower})+$/] /* name consists of only lower case unicode characters */
`!~` (since r6455)	negated Regular expression match	*[surface!~/paved\|unpaved/]
`∈` (U+2208, since r6609)	element of Matches when an object matches the right selector(s) contains at least one element which match the left selector(s).	*[amenity=parking] ∈ area[amenity=parking] { throwWarning: tr("{0} inside {1}", "amenity=parking", "amenity=parking"); } Finds areas with `amenity=parking` that contain at least one node or area with `amenity=parking`. Since r15064 this rule produces one warning for each element on the left when there are multiple matches.
`⊆` (U+2286, since r15102)	Subset of or Equal To Synonym for `∈`.	*[amenity=parking] ⊆ area[amenity=parking] { throwWarning: tr("{0} inside {1}", "amenity=parking", "amenity=parking"); }
`⊇` (U+2287, since r15102)	Superset of or Equal To Matches when an object matches the right selector(s) and is contained in one or more elements which match the left selectors.	area[amenity=parking] ⊇ *[amenity=parking] finds nodes or areas with `amenity=parking` inside areas with `amenity=parking`. Slower than `⊆` and thus not useful in validator rules, but can be useful in the search dialog.
`⊈` (U+2288, since r15102)	Neither a Subset of nor Equal To Matches when an object matches the right selector(s) and does not contain any element which matches the left selectors.	*[highway=street_lamp] ⊈ area:closed2[amenity=parking][lit=yes] finds areas amenity=parking that have lit=yes but don't contain a lamp. Always add `:closed2` to avoid false positives as unclosed areas never contain something.
`⊉` (U+2289, since r15102)	Neither a Superset of nor Equal To Matches when an object matches the right selector(s) and is not contained in any area which matches the left selectors.	area[landuse=residential] ⊉ *[building] finds buildings which are not inside any landuse=residential area. Note that this operator is likely to produce false positives when you have `landuse=residential`areas which don't match `:closed2`.
`⧉` (U+29C9, since r6613)	crossing	area:closed:areaStyle ⧉ area:closed:areaStyle { throwOther: tr("Overlapping Areas"); } takes `layer` tag into account if set (since r12986)

Since r6554, it is possible to prefix the "value" (i.e., expression after the operator) with a * in order to "de-reference" it (i.e., obtain consider it as another key and obtain its value). Thus, [key1 = *key2] or [key1=*key2] compares the value of key1 with the value of key2, and [key =~ */pattern/] considers the value of the key pattern as a regular expression and matches it against the value of key.

In addition, you can test whether a tag is present or not:

Condition	Example
Presence of tag	way[highway] /* matches any way with a tag 'highway' (is case sensitive) / way["name:fr"] / use quotes if the tag name includes special caracters (white space, colons, unicode characters, etc.) */
Absence of tag	way[!highway] /* matches any way which does not have a tag 'highway' (is case sensitive) / way[!"name:fr"] / use quotes if the tag name includes special caracters (white space, colons, unicode characters, etc.) */
Presence of tag by Regular expression match (since r6547)	way[/^addr:/] /* matches any `addr:` key /
Absence of tag by Regular expression match	way[!/^addr:/] /* matches any way which does not have a tag 'addr:' /

You can test whether the value of a tag is logical truth value. The value is evaluated to true, if it is either "yes", "true", or "1". All other values are evaluated to false.

Condition	Example
Testing for truth value	way[oneway?] /* matches any way with a truth value in the tag 'oneway' */
Testing for false value (since r6513)	way[oneway?!] /* matches any way with a false value in the tag 'oneway' */

境域选择器

您可以测试对象是位于特定区域内还是区域外。为此，JOSM 有一个内部数据库。您可以下载territories 文件并在 JOSM 中打开boundaries.png（截图预览）来研究它。该文件包含世界上所有国家的边界。由于性能原因，边界被简化了。可根据要求对特殊情况进行细化。领土用ISO_3166-1_alpha-2 代码"标记"。美国、加拿大、中国、印度和澳大利亚的分区有额外的边界。请参阅以下示例了解如何使用领土选择器。领土选择器在 mappaint 风格中的作用较小，可能会占用大量资源。不过，它们在mapcss based validator rules (en)中的作用要大得多。要选择左侧交通或右侧交通的区域，有一个更简单的方法，请参阅伪类。有关此功能的主要实现，请参见 #10387。

                                      /* matches any node located …                             */
node[inside("FR")]                    /* … inside of France (includes the overseas territories) */
node[inside("FX")]                    /* … inside of Metropolitan France (i.e. only the 
                                         mainland part with its near islands including Corse)   */
node[inside("EU")]                    /* … inside of the European Union                         */
node[inside("FR,DE")]                 /* … inside of France __OR__ inside of Germany            */
node[inside("US-FL")]                 /* … inside of the US state Florida                       */

node[outside("FR")]                   /* … outside of France                                    */
node[outside("FR,DE")]                /* … outside of France __AND__ outside of Germany         */
node[inside("US")][outside("US-FL")]  /* … inside of the USA except the state Florida           */

链接选择器

在子对象选择器中，可以对父对象和子对象之间的联系设置条件。

如果父对象是一个关系，则可以为成员对象在该关系中的 "角色 "设置条件。

relation[type=route] >[role="link"] way {  /* matches any way which is a member of route relation with role 'link' */ 
   color: blue;
}

Operator	Description	Example
`=`	Exact match of the role name. The name `role` is compulsory in this context.	relation >[role=residential] way relation >[role="My name"] way /* use quotes if the role value includes spaces or other special characters */

The operators !=, ^=, $=, *= and ~= are supported too. Please refer to condition selector operators.

Nodes in ways and members in relations are ordered. You can formulate conditions on the position of a node in a way or a member object in a relation. Positive numbers count from first to last element, negative numbers (since r8236) count from last to first element.

relation[type=route] >[index=1] way {  /* matches the first way which is a member of route relation  */ 
   color: blue;
}

way >[index=-1] node {  /* matches the last node of a way  */ 
   symbol-stroke-color: green;
}

way!:closed >[index=1] node!:connection,
way!:closed >[index=-1] node!:connection {  /* matches all single way end nodes */ 
   symbol-stroke-color: green;
}

缩放选择器

您可以用缩放选择器来装饰类型选择器。缩放选择器限制了应用相应 MapCSS 规则的缩放级别范围。

示例1	示例2	示例3	说明
`way\|z12 {...}`	`node\|z12 {...}`	`node\|z12[...] {...}`	缩放级别为12
`way\|z13-15 {...}`	`node\|z13-15 {...}`	`way\|z13-15[...] {...}`	缩放级别为13-15
`way\|z16- {...}`	`node\|z16- {...}`	`node\|z16-[...] {...}`	缩放级别为16以上
`way\|z-12 {...}`	`node\|z-12 {...}`	`node\|z-12[...] {...}`	缩放级别为12以下
`way {...}`	`node{...}`	`way[...] {...}`	所有缩放级别

每个缩放级别的比例范围的精确定义将来可能会改变。根据经验法则，当图像显示n级的滑动地图瓦片时，您的缩放级别大约为n级。

虚拟类

See Javadoc for the up-to-date list of pseudo classes supported by JOSM's MapCSS implementation.

Class	Description
`:closed`	true for ways where the first node is the same as the last and for any (completely downloaded) multipolygon relation
`:closed2`	same as above, but this one ignores if a multipolygon is downloaded completely (since r9099)
`:completely_downloaded`	true for a relation whose members are all downloaded (since r9099)
`:new`	all new objects
`:connection`	true for nodes that are used by more than one way
`:unconnected`	true for nodes that are not used by any way (since r6687)
`:tagged`	What JOSM considers tagged, i.e. an object that with a tag key other than the following: `source`, `source_ref`, `note`, `comment`, `converted_by`, `created_by`, `watch`, `fixme`, `FIXME`, `description`, `attribution` (version r4008; in this list, `*` is a glob)
`:area-style`	true if the object has an area style
`:righthandtraffic`	true if there is right-hand traffic at the current location (since r7193); see left-right-hand-traffic (en) for screenshot of areas
`:clockwise`	Whether the way is closed and oriented clockwise, or non-closed and the 1st, 2nd and last node are in clockwise order.
`:anticlockwise`	Whether the way is closed and oriented anticlockwise, or non-closed and the 1st, 2nd and last node are in anticlockwise order.
`:unclosed_multipolygon`	true for fully loaded unclosed multipolygon relations (since r8252)
`:open_end`	to select end nodes of unclosed multipolygon relations with `relation:unclosed_multipolygon >:open_end node` (since r8252)
`:in-downloaded-area`	true if an object is within source area and false if in the hatched area (since r8495).
`:selected`	true if an object is selected in the editor (since r9341).
`:highlighted`	true if the object is highlighted
`:modified`	changed and new objects (since r7193).

You can also negate pseudo classes. E.g. !:new for all old objects.

图层标识符

图层可用于为一个对象创建多个样式。下面是一个例子：

way[highway=secondary] {
    width: 3;
    color: yellow;
}

way[highway=tertiary] {
    width: 2;
    color: orange;
}

way[access][access!=yes]::non_public_access_layer {
    width: +2; 
    color:red; 
    dashes: 2; 
    object-z-index:-1.0;
}

way[bridge]::bridge_layer {
    width: +3; 
    color:#000080;
    opacity:0.5;
    object-z-index:1.0; 
}

This draws all secondary and tertiary roads in yellow and orange respectively. Any road with an access tag other than yes will get an extra line style below (object-z-index:-1.0;) the main line. If that part of the street happens to be a bridge, it will also get a half transparent blue overlay. The relative width value (width: +2;) refers to the width on the default layer (2 or 3 in this case).

The name for the layer can be any identifier.

If you omit the layer in the selector, this is the same as using ::default.

One more example:

node[amenity=parking] {
    icon-image: "presets/vehicle/parking/parking.svg";    /* displays the josm internal parking icon in the default layer */
    text: ref;                                            /* displays the value of the key ref as text in the default layer */
}

node[amenity=parking][fee=yes]::fee {
    icon-image: "presets/money/exchange.svg";             /* displays the josm internal exchange icon in the fee layer */
    icon-offset-x: 14;                                    /* shift the icon */
    icon-offset-y: -12;                                   /* shift the icon */
    text: charge;                                         /* displays the value of the key charge as text in the fee layer */
    text-offset-x: 16;                                    /* shift the text */
    text-offset-y: 17;                                    /* shift the text */
}

The result looks this way:

No image "multiple_icons_and_texts.png" attached to Zh_CN:Help/Styles/MapCSSImplementation

In addition, you can use the * layer to override and initialize all layers.
It overrides all existing subparts, so

way::A { a; } 
way::B { b; } 
way::* { c; }  /* overrides all existing subparts */

is equivalent to

way::A { a; } 
way::B { b; } 
way::A { c; } /* overrides a with c all existing subparts */
way::B { c; } /* overrides b with c all existing subparts */

And it initializes new subparts. In other words:

way::* { a; } 
way::A { b; }

is equivalent to

way::A {} 
way::* { a; } 
way::A { b; }

which is in turn the same as

way::A { a; } 
way::A { b; }

way::A { a; b; }

分组

Rules with common declaration block can be grouped into one:

area[landuse=forest] { color: green;   width: 2; }
area[natural=wood] { color: green;   width: 2; }

is the same as

area[landuse=forest], area[natural=wood] { color: green;   width: 2; }

类别

您可以为匹配的元素指定类别，并使用这些类别定义其他选择器：

/* assigning classes */
selector {
  set class;
  /* or equivalently */
  set .class;
}

/* matching classes */
way.class, node[foo=bar].class {
  /* ... */
}

Example for assigning/matching a class named path:

way[highway=footway] { set path; color: #FF6644; width: 2; }
way[highway=path]    { set path; color: brown; width: 2; }
way.path { text:auto; text-color: green; text-position: line; text-offset: 5; }

You can also negate classes. E.g. way!.path for all ways, which are not part of the class .path.

Classes and Layer together

If you want to use layer and classes together, please note that you have to identify the class via is_prop_set.

node[railway=signal] { set sgnl; }

/* it doesn't work */
node.sgnl::layer_signal_icon  { z-index: 1000; ... icon: icon/signal-icon.svg; ... }
node.sgnl::layer_signal_text  { z-index: 1010; ... text: concat("Name of signal: ", tag("ref")); ..... )

/* use instead: is_prop_set("...", "default") */
node[is_prop_set("sgnl", "default")]::layer_signal_icon  { z-index: 1000; ... icon: icon/signal-icon.svg; ... }
node[is_prop_set("sgnl", "default")]::layer_signal_text  { z-index: 1010; ... text: concat("Name of signal: ", tag("ref")); ..... )

@supports Conditional Processing

@supports rules are used to skip a section of the style under certain conditions. Typically you want to use a feature which is introduced in a newer version of JOSM, but like to have a fall back style for users of older JOSM clients. This feature came with r8087. Example:

@supports (min-josm-version: 9789) {
    way[highway] {
        width: 4;
        color: orange;
    }
    /* fancy new stuff */
    /* ... */
}

@supports (max-josm-version: 9788) {
    way[highway] {
        width: 4;
        color: blue;
    }
    /* fall back mode, using more simple features */
    /* ... */
}

@supports (icon-offset-x) {
    /* only if icon-offset-x property is supported */
    node[amenity] {
        icon-offset-x: 5;
    }
}

The syntax closely matches the official css syntax. The following conditions are supported:

Condition	Description
(<mapcsskey>)	Check if a certain mapcss key is supported, e.g. `repeat-image` or `icon-offset-x`.
(min-josm-version: <number>)	Only include `@supports` section when the current version of JOSM is greater than or equal to the specified number.
(max-josm-version: <number>)	Only include `@supports` section when the current version of JOSM is lower than or equal to the specified number.
(user-agent: <string>)	Only include `@supports` section when the name of the editor / renderer matches the given string. In JOSM, the only accepted value is `josm`.

Conditions can be combined with and:

@supports (min-josm-version: 8087) and (max-josm-version: 8200) {
 /* only for JOSM versions 8087 to 8200 */
}

Other logical operators like or and not can also be used. Parentheses are needed if you want to combine different logical operators:

@supports ((min-josm-version: 8087) and (max-josm-version: 8200)) or (user-agent: myEditor) {
  /* for JOSM version 8087 to 8200 and for the editor called "myEditor" */
}

Since @supports rules are only supported in JOSM r8087 and later, you should also specify this as minimum JOSM version in the meta selector:

meta {
    min-josm-version: "8087"; /* This style uses @supports rules */
    /* ... */
}

样式设置

Styles settings (en) are used to provide the user settings to customize a mappaint style. The user can use them in the MapPaint dialog (en). The following type of settings are available:

boolean (since r7450)
double (since r15731, see #10435)
string (since r15731, see #10435)
color (since r16843, see #10435)

布尔类型的设置

Create a setting of type boolean:

setting::highway_casing {
  type: boolean;
  label: tr("Draw highway casing");
  default: true;
}

Use a setting of type boolean:

way[highway][setting("highway_casing")] {
  casing-width: 2;
  casing-color: white;
}

Settings of type `double`

Create a setting of type double:

setting::place_font_size {
  type: double;
  label: tr("Set place name font size...");
  default: 11;
}

Use a setting of type double:

node.place, way.place, area.place {
  font-size: setting("place_font_size");
}

字符串类型的设置

Create a setting of type string:

setting::textdisplay {
  type: string;
  label: tr("key used for displaying");
  default: "name"; /* examples for usage: alt_name, old_name, addr:housename, ref, operator, ... */
}

Use a setting of type string:

way {
  text: tag(setting("textdisplay"));
}

Settings of type `color`

Create a setting of type color. The default color can be any color as understood under Property values explanations:

setting::colordisplay {
  type: color;
  label: tr("key used for displaying");
  default: colorDisplayCustomPref#FF00FF;
}

Use a setting of type color:

way {
  color: setting("colordisplay");
}

分组设置

Similar settings can be grouped together by defining settings groups (since r15289):

settings::my_group {
  label: tr("my wonderful group");
  icon: "my_beautiful_icon";
}

标签是必须的，图标是可选的。

一旦定义了一个设置组，就可以从属于该组的所有设置中引用它：

setting::hide_icons {
  type: boolean;
  label: tr("Hide icons at low zoom");
  default: true;
  group: "my_group";
}

Settings groups are displayed as sub-menus from the style settings menu. If at least two settings belong to a group, a special "Toggle all settings" menu item allows to quickly switch on/off all settings from this group at once. Usage example: MapWithAI (en).

属性

一般属性

Key	Description	Value Format	Default Value
`z-index`	Specify the order the objects are drawn: The objects with higher z-index are drawn on top of objects with lower z-index	Number (can be negative)	0
`major-z-index`	Similar to `z-index`, but it has higher priority than `z-index`. So if one object has a higher `major-z-index` than the other, it is drawn on top. If the `major-z-index` is the same, `z-index` decides.	Number (can be negative)	Depends on style element: area: 1, casing: 2, left-/right-casing: 2.1, line-pattern: 2.9, line: 3, point: 4, default-point: 4.1, line-text: 4.9, point-text: 5
`object-z-index`	Similar to `z-index`, but has lower priority. Controls the painting order for overlapping objects. E.g. for two crossing ways with text: Use `z-index` or `major-z-index` if you first want to draw the two lines and then the two captions. Use `object-z-index` if one of the ways should be completely on top of the other.	Number (can be negative)	0
`modifier`	Better control, whether a default line / node symbol is generated by JOSM. This happens when there is no proper style (`modifier=false`) found on any layer.	`false` or `true`	`false` for the default layer and `true` for any other layer

Note that due to performance reasons the values for the three z-indexes are limited to 24 bit float values with max. 5 decimal digits. Currently the internal mappaint style uses values with max. 2 digits before and after the decimal separator. To avoid problems use values of z-indexes between -99.999 and +99.999. (See also #14485)

Icon and symbol styles

Key	Description	Value Format	Default Value
`icon-image`	The icon at node position. See also Images (en).	Image	-
`icon-opacity`	Opacity of the icon image	Opacity	1.0
`icon-width`	Width of the icon. If only one of the properties `icon-width` and `icon-height` is given, the image will be scaled proportionally. The icon will keep the original size, if neither `icon-width` nor `icon-height` is set.	Number	-
`icon-height`	Height of the icon. (See `icon-width`)	Number	-
`icon-offset-x`	Shift the icon in horizontal direction (positive values to the right) (since r8085)	Number	0
`icon-offset-y`	Shift the icon in vertical direction (positive values downwards) (since r8085)	Number	0
`icon-rotation`	Rotate the icon clockwise or anti clockwise (negative value)(since r8260)	`[rad]`, `[rad]rad`, `[deg]°`, `[deg]deg`, `[grad]grad`, `[turn]turn` (definition) or a cardinal direction (e.g. `northeast` or `sw`); or `way` to rotate the icon in the direction of the parent way. See also the functions `degree_to_radians`, `cardinal_to_radians`. Since version 18678 function parent_way_angle() is an alternativ to way: e.g. `way > node[...]::layer_x { ... icon-rotation: parent_way_angle(); ... }`	-
`icon-position`	Define the position of the icon for areas. Same as `text-position` (since r11730).	`center`, `inside`, `line`	`center`
`symbol-shape`	Display a symbol at the position of the node	`square`, `circle`, `triangle`, `pentagon`, `hexagon`, `heptagon`, `octagon`, `nonagon`, `decagon`	-
`symbol-size`	Size of the symbol	Number, can be relative ("+4")	10
`symbol-stroke-width`	outline stroke width	Width	1.0 if `symbol-stroke-color` is set
`symbol-stroke-color`	line color	Color	`#FFC800` if `symbol-stroke-width` is set
`symbol-stroke-opacity`	line opacity	Opacity	1.0
`symbol-fill-color`	fill color for the shape	Color	`blue`, unless either `symbol-stroke-width` or `symbol-stroke-color` is set
`symbol-fill-opacity`	fill opacity	Opacity	1.0
`text-...`, `font-...`	see general Text & Font properties

Do not rely on the default values for symbol-... properties (except for opacity). They are intended for "quick & dirty" style sheets and should be set to an explicit value.

Line styles

Key	Description	Value Format	Default Value
`width`	Line width	Width	-
`color`	Line color	Color	value of `fill-color` or (if unset) JOSM's default untagged color (`#808080`)
`opacity`	How transparent the line is.	Opacity	1.0
`dashes`	An array of alternating on/off lengths	list of numbers, e.g. > 15, 5 may be written as expression: > `list(3, 4, 5, 6)` or the keyword `none` to turn dashes off	-
`dashes-offset`	shift the dash pattern by a certain amount	Number (>= 0)	0
`dashes-background-color`	The color to use in between the dashes (optional)	Color	-
`dashes-background-opacity`	Opacity value for the dashes background	Opacity	value of `opacity`
`linecap`	Shape at the end of the line (see here)	`none`, `round`, `square`	`none`
`linejoin`	Shape at the line corners	`round`, `miter`, `bevel`	`round`
`miterlimit`	Applies for `linejoin: miter`. Sets the maximum overshoot when line segments meet at a very small angle	Number (>= 1.0)	10.0
`offset`	Move line to the left or right (when looking in way direction). This could be used to draw multiple lanes for one way or mark left and right side of a way differently.	Number (positive value moves line to the left, negative to the right)	0
`text-position`	set to `line`, if text should be drawn along the line	`line`, `center`	-
`text-...`, `font-...`	see general Text & Font properties
`repeat-image`	repeated image along a line (since r5801)	Image	-
`repeat-image-width`	Width of the image (optional, see `icon-width`) (since r5811)	Number	-
`repeat-image-height`	Height of the image (optional) (since r5811)	Number	-
`repeat-image-align`	Alignment of the image. Top-, bottom edge or the (horizontal) center line of the image will be along the line (since r5801)	`top`, `center`, `bottom`	`center`
`repeat-image-offset`	Offset from the line (since r5801)	Number	0
`repeat-image-spacing`	Spacing between repeated images (since r5801)	Number	0
`repeat-image-phase`	Initial spacing at the beginning of the line (since r5812)	Number	0
`repeat-image-opacity`	Opacity of the repeated image (since r16700)	Number	1.0

All these properties (except for text-... and font-...) exist also with the casing- prefix. The casing is a second independent line element, that is drawn below the normal line and can be used to draw a thin frame around the line in another color.

Key	Description	Value Format	Default Value
`casing-width`	Width of the border on both sides of the main line. In JOSM < 5214: Total width of the casing	Width (revers to `width` if relative width is specified)	-
`casing-color`	Casing color	Color	value of `fill-color` or (if unset) JOSM's default untagged color (`#808080`)
`casing-opacity`	How transparent the casing is.	Opacity	1.0
`casing-`...	...	...	...

Similar to casing-, there is also the left-casing- and right-casing- prefix. It draws additional lines to the left and to the right of the main line.

Area styles

Key	Description	Value Format	Default Value
`fill-color`	Color in which to fill the area. Until 11700, the alpha component was set to 50 to create a transparency effect.	Color	-
`fill-image`	Image pattern	Image	-
`fill-extent`	Set this property, to draw only the outline of the area. The number specifies, how far to fill from the border of the area towards the center. (If unset, the area will be filled completely) (since r9008)	Number	-
`fill-extent-threshold`	Set this property, to draw full area when the given percentage of coverage is reached. Can be greater than 100% as the covered area is estimated as *perimeter extent**.	Number	-
`fill-opacity`	How transparent the fill is; applies to both color and image	Opacity	0.2 (since r11700, 1.0 before that) (can be changed with the `mappaint.fillalpha` and `mappaint.fill-image-alpha` preferences)
`text-position`	set to `center`, if text should be drawn in the center of the area. Set to `inside` to place the text completely inside the area. (since r11722)	`line`, `center`, `inside`	-
`text-...`, `font-...`	see general text & font properties

Required properties to create an Area style: fill-color or fill-image

Text & Font properties

Key	Description	Value Format	Default Value
`text`	How to find the label text. No label is displayed, unless this instruction is present.	`auto` Derive the text automatically. The default name tags are: "`name:`"+<LANG>, "`name`", "`int_name`", "`ref`", "`operator`", "`brand`" and "`addr:housenumber`". Configure a list of tag names in the preference "`mappaint.nameOrder`" in order to change this list. (After changing the list, a restart of JOSM is required.) String Denotes the key of the tag whose value is used as text. Expressions You can enter an expression to compute the text to be displayed. Examples: `eval("this is a static text")` - renderes a static text `eval(concat(tag("first"), "-", tag("second")))` - displays the concatenated tags "first" and "second" `""` To delete a previous set text.	-
`text-color`	the text color	Color	`white` for lines and nodes, `#c0c0c0` for areas (JOSM "`text`" and "`areatext`" color preferences)
`text-opacity`	how transparent the text is	Opacity	1.0
`text-offset-x`	shift the text horizontally, (not supported for text along line)	Number	0
`text-offset-y` (can also be written as `text-offset`)	shift the text vertically, positive values shift the text in upwards direction	Number	0
`text-halo-radius`	size of text background border (to make text visible on background with a similar color)	Number	-
`text-halo-color`	color of the text halo	Color	complement of the text color
`text-halo-opacity`	transparency for the text halo	Opacity	1.0
`text-anchor-horizontal`	horizontal text label placement	`left`, `center`, `right`	`right`
`text-anchor-vertical`	vertical text label placement	`above`, `top`, `center`, `bottom`, `below`	`bottom`
`text-rotation`	Rotate the text clockwise or anti clockwise (negative value) (since r16253)	`[rad]`, `[rad]rad`, `[deg]°`, `[deg]deg`, `[grad]grad`, `[turn]turn` (definition) or a cardinal direction (e.g. `northeast` or `sw`); or `way` to rotate the text in the direction of the parent way. See also the functions `degree_to_radians`, `cardinal_to_radians`. Since version 18678 function parent_way_angle() is an alternativ to way: e.g. `way > node[...]::layer_x { ... text-rotation: parent_way_angle(); ... }` (Note that the direction means where the upper edge of the text faces. That means with the default direction of north the text flows to east (with a left to right language). So if you want to flow it to e.g. south you need to set east.)	-
`text-position`	see Area styles and Line styles
`font-family`	font family	String	"Droid Sans" (JOSM preference "`mappaint.font`")
`font-size`	font size	Number	8 (JOSM preference "`mappaint.fontsize`")
`font-weight`	bold or not	`bold`, `normal`	`normal`
`font-style`	italic or not	`italic`, `normal`	`normal`

用户自定义属性

In Mappaint styles (en) you can define any custom property, e.g.: crc: CRC32_checksum(tag(name))/429496.7296;
In Validator rules (en) they must be prefixed by a -, e.g.: -osmoseItemClassLevel: "1210/1/1";

属性值解释

Width

14.0 (any positive number)
default (use JOSM's default line width, which is 2, but can be configured)
thinnest (draws the line as thin as possible)
+3 (with plus sign in front) adds the amount to the width on the default layer. This applies only for styles that are not on the default layer, e.g. highlights. Another way to write this would be prop("width","default")+3. For casing-width, this refers to the width value on the same layer.

Image

See Help/Styles/Images (en).

Color

named color as found in this list
html style: #RRGGBB, #RGB, #RRGGBBAA
rgb(/*r*/, /*g*/, /*b*/) - rgb value with arguments from 0.0 to 1.0
rgba(/*r*/, /*g*/, /*b*/, /*alpha*/) - rgb value with alpha
hsb_color(/*hue*/, /*saturation*/, /*brightness*/) - color from HSB color space
if the color is prefixed with a name and #, e.g. color: highway_track#6e541c; it will appear in the Color Preference (en) and end users can adjust the color there themself

Opacity

from 0.0 (transparent) to 1.0 (opaque)

String

any character sequence, in quotes, e.g. "images/fill.png". If the string is an identifier, quotes are optional. (Quote and backslash sign can be escaped.)

Number

integer or floating point (in simple form e.g. 0.3). In general can be negative, but most properties do not support negative numbers
has a special meaning if you put a "+" sign in front (relative width)

数值表达式

请参阅 Javadoc of Functions 获取 JOSM 的 MapCSS 实现所支持函数的最新列表。

+, -, *, /: arithmetic operations
||, &&, !: boolean operations
<, >, <=, >=, ==, !=: comparison operators
asin, atan, atan2, ceil, cos, cosh, exp, floor, log, max, min, mod (since r17759), random, round, signum, sin, sinh, sqrt, tan, tanh: the usual meaning, details
cond(b, fst, snd)
b ? fst : snd: if (b) then fst else snd
list(a, b, ...): create list of values, e.g. for the dashes property
get(lst, n): get the nth element of the list lst (counting starts at 0) [since r5699]
split(sep, str): splits string str at occurrences of the separator string sep, returns a list [since r5699]
prop(p_name): value of the property p_name of the current layer, e.g. prop("width")
prop(p_name, layer_name): property from the layer layer_name
is_prop_set(p_name): true, if property p_name is set for the current layer
is_prop_set(p_name, layer_name): true, if property p_name is set for the layer layer_name
tag(key_name): get the value of the key key_name from the object in question
parent_tag(key_name): get the value of the key key_name from the object's parent
parent_tags(key_name): returns all parent's values for the key key_name as a list ordered by a natural ordering [since r8775]
has_tag_key(key_name): true, if the object has a tag with the given key
rgb(r, g, b): create color value (arguments from 0.0 to 1.0)
hsb_color(h, s, b): create color from hue, saturation and brightness (arguments from 0.0 to 1.0) [since r6899]
red(clr), green(clr), blue(clr): get value of color channels in rgb color model
alpha(clr): get the alpha value of the given color [since r6749]
length(str): length of a string
count(lst): length of a list, i.e., counts its elements [since r7162]
length(lst): length of a list ([since r5699] – deprecated since r7162
any(obj1, obj2, ...): returns the first object which is not null (formerly coalesce, [since r7164])
concat(str1, str2, ...): assemble the strings to one
join(sep, str1, str2, ...): join strings, with sep as separator [since r6737]
join_list(sep, list_name): joins the elements of the list list_name to one string separated by the separator sep [since r8775]
upper(str): converts string to upper case [since r11756]
lower(str): converts string to lower case [since r11756]
title(str): converts string to title case [since r17613] ("i am FINE" → "I Am Fine")
trim(str): remove leading and trailing whitespace from string [since r11756]
trim_list(list_name): remove leading and trailing whitespace from a list of strings, will remove entries that are empty afterwards [since r15591]
JOSM_search("..."): true, if JOSM search applies to the object
tr(str, arg0, arg1, ...): translate from English to the current language (only for strings in the JOSM user interface) [since r6506]
regexp_test(regexp, string): test if string matches pattern regexp [since r5699]
regexp_test(regexp, string, flags): test if string matches pattern regexp; flags is a string that may contain "i" (case insensitive), "m" (multiline) and "s" ("dot all") [since r5699]
regexp_match(regexp, string): Tries to match string against pattern regexp. Returns a list of capture groups in case of success. The first element (index 0) is the complete match (i.e. string). Further elements correspond to the bracketed parts of the regular expression. [since r5701]
regexp_match(regexp, string, flags): Tries to match string against pattern regexp. Returns a list of capture groups in case of success. The first element (index 0) is the complete match (i.e. string). Further elements correspond to the bracketed parts of the regular expression. Flags is a string that may contain "i" (case insensitive), "m" (multiline) and "s" ("dot all") [since r5701]
substring(str, idx): return the substring of str, starting at index idx (0-indexed) [since r6534]
substring(str, start, end): return the substring of str, starting at index start (inclusive) up to end (exclusive) (0-indexed) [since r6534]
replace(string, old, new): Replaces any occurrence of the substring old within the string string with the text new
osm_id(): returns the OSM id of the current object [since r5699]
osm_user_name(): returns the OSM user name who last touched the current object [since r15246]
osm_user_id(): returns the OSM user id who last touched the current object [since r15246]
osm_version(): returns the OSM version number of the current object [since r15246]
osm_changeset_id(): returns the id of the changeset the current object was last uploaded to [since r15246]
osm_timestamp(): returns the time of last modification to the current object, as timestamp [since r15246]
parent_osm_id(): returns the OSM id of the object's parent (matched by child selector) [since r13094]
URL_encode(str): percent-encode a string. May be useful for data URLs [since r6805]
URL_decode(str): percent-decode a string. [since r11756]
XML_encode(str): escape special characters in xml. E.g. < becomes <, other special characters: >, ", ', &, \n, \t and \r [since r6809]
CRC32_checksum(str): calculate the CRC32 checksum of a string (result is an integer from 0 to 2³²-1) [since r6908]
is_right_hand_traffic(): Check if there is left-hand or right-hand traffic at the current location. [since r7193]
number_of_tags(): returns the number of tags for the current OSM object [since r7237]
print(o): prints a string representation of o to the command line (for debugging) [since r7237]
println(o): prints a string representation of o to the command line, followed by a new line (for debugging) [since r7237]
JOSM_pref(key, default): Get value from the JOSM advanced preferences. This way you can offer certain options to the user and make the style customizable. It works with strings, numbers, colors and boolean values.
[This function exists since version r3856, but with some restrictions. JOSM_pref always returns a string, but in version r7237 and earlier, the automatic conversion of string to boolean and color was not working. You can use the following workarounds for boolean values and color in version r7237 and earlier: cond(JOSM_pref("myprefkey", "true")="true", "X", "O") and html2color(JOSM_pref("mycolor", "#FF345611")). These explicit conversions should be no longer necessary in version r7238 and later. Automatic conversion to a number works in any version. Furthermore, in version r16590, can be used to set color properties. So * { set_color: JOSM_pref("pref", #000000); } will create a color property now.]
setting(): to use a style setting [since r7450]
degree_to_radians(): returns a in degree given direction in radians [since r8260]
cardinal_to_radians(): returns a cardinal direction in radians [since r8260]
waylength(): returns the length of the way in metres [since r8253]
areasize(): returns the area of a closed way in square meters [since r8253]
at(lat,lon): returns true if the object centroid lies at given lat/lon coordinates, e.g. to check for nodes at "null island" node[at(0.0,0.0)] [since r12514]
is_similar(str1, str2): returns true if the two strings are similar, but not identical, i.e., have a Levenshtein distance of 1 or 2. Example: way[highway][name][is_similar(tag(name), "Main Street")] checks for streets with a possible typo in the name (e.g. Main Streeg). [since r14371]
gpx_distance(): returns the lowest distance between the OSM object and a GPX point [since r14802]
count_roles(): returns the number of primitives in a relation with the specified roles [since r15275]
sort(str1, str2, str3, ...): sorts an array of strings [since r15279]
sort_list(): sorts a list of strings [since r15279]
tag_regex(regex): returns a list of values that match the regex [since r15317]
to_boolean(str): returns the string argument as a boolean [since r16110]
to_byte(str): returns the string argument as a byte [since r16110]
to_short(str): returns the string argument as a short [since r16110]
to_int(str): returns the string argument as a int [since r16110]
to_long(str): returns the string argument as a long [since r16110]
to_float(str): returns the string argument as a float [since r16110]
to_double(str): returns the string argument as a double [since r16110]
uniq(str1, str2, str3, ...): returns a list of strings that only have unique values from an array of strings [since r15323]
uniq_list(): returns a list of strings that only have unique values from a list of strings [since r15353]
parent_way_angle(): returns the angle of the parent way as a double in rad [since r18678] (see: text-rotation or icon-rotation)
convert_primitive_to_string(PrimitiveId): returns the primitive id as a string [since r18829]
convert_primitives_to_string(PrimitiveId, PrimitiveId, ...): returns a list of primitive ids converted to strings [since r18829]
parent_osm_primitives(optional key, optional value): returns a list of primitive ids which match the key and value (if present) [since r18829]

示例

表示门牌号码的圆圈符号，大小取决于位数

node[addr:housenumber] { 
    symbol-shape: circle; 
    symbol-size: eval((min(length(tag("addr:housenumber")), 3) * 5) + 3); 
    symbol-fill-color: #B0E0E6; 

    text: "addr:housenumber"; 
    text-anchor-horizontal: center; 
    text-anchor-vertical: center; 
    text-offset-x: -1; 
    text-offset-y: -1; }
    
node[addr:housenumber]::hn_casing { 
    z-index: -100; 
    symbol-shape: circle; 
    symbol-size: +2; 
    symbol-fill-color: blue; 
}

invert colors

*::* {
    color: eval(rgb(1 - red(prop(color)), 1 - green(prop(color)), 1 - blue(prop(color))));
    fill-color: eval(rgb(1 - red(prop(fill-color)), 1 - green(prop(fill-color)), 1 - blue(prop(fill-color))));
}

random stuff

way {
    width: eval(random() * 20);
    color: eval(rgb(random(), random(), random()));
}

regexp matching example: change "nameXXXsubname" to "name::subname"

*[name=~/.+XXX.+/] 
{
    _match: regexp_match("(.+?)XXX(.+)", tag("name"));
    text: concat(get(prop("_match"),1), "::", get(prop("_match"),2));
}

paint buildings in different colors according to street in the address tags

area[building][addr:street] {
    fill-color: hsb_color(CRC32_checksum(tag("addr:street"))/4294967296.0, 0.9, 0.7);
    fill-opacity: 0.8;
}

casing on inside of area

area[building]:clockwise {
    right-casing-width: 10;
}
area[building]:anticlockwise {
    left-casing-width: 10;
}
/* or */
area[building][is_clockwise()] {
    right-casing-width: 10;
}
area[building][is_anticlockwise()] {
    left-casing-width: 10;
}

case insensitive selector. This matches: Name=Main Street, but also naMe=MAIN STREET
```
way[/(?i)^name$/ =~ /(?i)^Main Street$/] {
}
```

兼容性说明

MapCSS 0.2

语法

way[oneway=yes] does not have any magic, you can use way[oneway?] instead
no @import
JOSM does not require eval(...) to be wrapped around expressions, but for compatibility with other MapCSS implementations you should write it out.

属性

At the moment, JOSM does not support the following properties:

line:: image
label:: font-variant, text-decoration, text-transform, max-width
shield:: not supported

Halcyon (Potlatch 2)

Text label is placed in the center of the icon. For compatibility with Halcyon put
```
node { text-anchor-vertical: center; text-anchor-horizontal: center; }
```
at the beginning of your style sheet.
standard z-index in Halcyon is 5, but it is 0 in JOSM
image: circle; corresponds to symbol-shape: circle;

Kothic

Kothic 支持 eval，这可能与 JOSM 的 eval 不同。
Kothic 能理解单位，而 JOSM 总是以像素为单位计算。
JOSM 中没有挤出功能。

Ceyx

似乎有 [tunnel=1]，而不是 [tunnel=yes]（Halcyon）或 [tunnel?]（JOSM）。

媒体查询（已废弃）

注意：媒体查询已被弃用。应使用 @supports 规则（见上文）。

媒体查询用于在特定条件下跳过样式的某个部分。通常情况下，你想使用较新版本的 JOSM 中引入的功能，但又希望为旧版本的 JOSM 客户端用户提供一种备用样式。此功能在 r6970 中出现。例如：

@media (min-josm-version: 9789) {
    way[highway] {
        width: 4;
        color: orange;
    }
    /* fancy new stuff */
    /* ... */
}

@media (max-josm-version: 9788) {
    way[highway] {
        width: 4;
        color: blue;
    }
    /* fall back mode, using more simple features */
    /* ... */
}

该语法与官方css 语法非常吻合。支持以下条件：

Media condition	Description
(min-josm-version: <number>)	Only include `@media` section when the current version of JOSM is greater than or equal to the specified number.
(max-josm-version: <number>)	Only include `@media` section when the current version of JOSM is lower than or equal to the specified number.
(user-agent: <string>)	Only include `@media` section when the name of the editor / renderer matches the given string. In JOSM, the only accepted value is `josm`.

条件可以与 "和 "结合使用：

@media (min-josm-version: 6970) and (max-josm-version: 7014) {
 /* only for JOSM versions 6970 to 7014 */
}

多个组合条件可以用逗号（逻辑 "或"）串联起来：

@media (min-josm-version: 6970) and (max-josm-version: 7014), (user-agent: myEditor) {
  /* for JOSM version 6970 to 7014 and for the editor called "myEditor" */
}

由于媒体查询只支持 JOSM 6970 及更高版本，因此还应在元选择器中将其指定为最低 JOSM 版本：

meta {
    min-josm-version: "6970"; /* This style uses media queries */
    /* ... */
}

Last modified 3 months ago Last modified on 2024-02-25T15:04:00+01:00

Note: See TracWiki for help on using the wiki.

Download in other formats:

Plain Text