Mercurial > hg > jdk9-shenandoah > jdk
changeset 2734:80a8742483bf
Merge
author | lana |
---|---|
date | Thu, 02 Sep 2010 22:11:05 -0700 |
parents | b200263f1b68 (current diff) 043d2736d44c (diff) |
children | 10728041e814 |
files | src/share/classes/sun/java2d/pisces/PiscesMath.java src/share/classes/sun/java2d/pisces/Transform4.java |
diffstat | 32 files changed, 1182 insertions(+), 1511 deletions(-) [+] |
line wrap: on
line diff
--- a/.hgtags Wed Sep 01 17:37:45 2010 -0700 +++ b/.hgtags Thu Sep 02 22:11:05 2010 -0700 @@ -79,3 +79,6 @@ 13029a61b16bec06535d4f0aa98229b358684128 jdk7-b102 6488b70a23cc6dc4b7e00809bc503c2884bafb28 jdk7-b103 1a92820132a0221c5bdedd42d0888c57ce4cbb34 jdk7-b104 +3b0abcb512807bb6f6d27755bc50103211bde6ee jdk7-b105 +b91ef6b60f4e19bf4592c6dd594c9bac62487519 jdk7-b106 +882103f334bb23745d3fd70fb7928c347478b0f4 jdk7-b107
--- a/make/sun/javazic/tzdata/VERSION Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/VERSION Thu Sep 02 22:11:05 2010 -0700 @@ -21,4 +21,4 @@ # or visit www.oracle.com if you need additional information or have any # questions. # -tzdata2010i +tzdata2010l
--- a/make/sun/javazic/tzdata/africa Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/africa Thu Sep 02 22:11:05 2010 -0700 @@ -316,8 +316,25 @@ # and can be found by searching for "winter" in their search engine # (at least today). +# From Alexander Krivenyshev (2010-07-20): +# According to News from Egypt - Al-Masry Al-Youm Egypt's cabinet has +# decided that Daylight Saving Time will not be used in Egypt during +# Ramadan. +# +# Arabic translation: +# "Clocks to go back during Ramadan--and then forward again" +# <a href="http://www.almasryalyoum.com/en/news/clocks-go-back-during-ramadan-and-then-forward-again"> +# http://www.almasryalyoum.com/en/news/clocks-go-back-during-ramadan-and-then-forward-again +# </a> +# or +# <a href="http://www.worldtimezone.com/dst_news/dst_news_egypt02.html"> +# http://www.worldtimezone.com/dst_news/dst_news_egypt02.html +# </a> + Rule Egypt 2008 only - Aug lastThu 23:00s 0 - Rule Egypt 2009 only - Aug 20 23:00s 0 - +Rule Egypt 2010 only - Aug 11 0:00 0 - +Rule Egypt 2010 only - Sep 10 0:00 1:00 S Rule Egypt 2010 max - Sep lastThu 23:00s 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL]
--- a/make/sun/javazic/tzdata/asia Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/asia Thu Sep 02 22:11:05 2010 -0700 @@ -2200,6 +2200,18 @@ # "At 12:01am Friday, clocks in Israel and the West Bank will change to # 1:01am, while Gaza clocks will change at 12:01am Saturday morning." +# From Steffen Thorsen (2010-08-11): +# According to several sources, including +# <a href="http://www.maannews.net/eng/ViewDetails.aspx?ID=306795"> +# http://www.maannews.net/eng/ViewDetails.aspx?ID=306795 +# </a> +# the clocks were set back one hour at 2010-08-11 00:00:00 local time in +# Gaza and the West Bank. +# Some more background info: +# <a href="http://www.timeanddate.com/news/time/westbank-gaza-end-dst-2010.html"> +# http://www.timeanddate.com/news/time/westbank-gaza-end-dst-2010.html +# </a> + # The rules for Egypt are stolen from the `africa' file. # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S Rule EgyptAsia 1957 only - May 10 0:00 1:00 S @@ -2220,6 +2232,7 @@ Rule Palestine 2009 only - Mar lastFri 0:00 1:00 S Rule Palestine 2010 max - Mar lastSat 0:01 1:00 S Rule Palestine 2009 max - Sep Fri>=1 2:00 0 - +Rule Palestine 2010 only - Aug 11 0:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Asia/Gaza 2:17:52 - LMT 1900 Oct
--- a/make/sun/javazic/tzdata/australasia Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/australasia Thu Sep 02 22:11:05 2010 -0700 @@ -368,10 +368,10 @@ # Micronesia # Zone NAME GMTOFF RULES FORMAT [UNTIL] -Zone Pacific/Truk 10:07:08 - LMT 1901 - 10:00 - TRUT # Truk Time -Zone Pacific/Ponape 10:32:52 - LMT 1901 # Kolonia - 11:00 - PONT # Ponape Time +Zone Pacific/Chuuk 10:07:08 - LMT 1901 + 10:00 - CHUT # Chuuk Time +Zone Pacific/Pohnpei 10:32:52 - LMT 1901 # Kolonia + 11:00 - PONT # Pohnpei Time Zone Pacific/Kosrae 10:51:56 - LMT 1901 11:00 - KOST 1969 Oct # Kosrae Time 12:00 - KOST 1999
--- a/make/sun/javazic/tzdata/backward Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/backward Thu Sep 02 22:11:05 2010 -0700 @@ -112,7 +112,9 @@ Link America/Denver Navajo Link Asia/Shanghai PRC Link Pacific/Pago_Pago Pacific/Samoa -Link Pacific/Truk Pacific/Yap +Link Pacific/Chuuk Pacific/Yap +Link Pacific/Chuuk Pacific/Truk +Link Pacific/Pohnpei Pacific/Ponape Link Europe/Warsaw Poland Link Europe/Lisbon Portugal Link Asia/Taipei ROC
--- a/make/sun/javazic/tzdata/europe Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/europe Thu Sep 02 22:11:05 2010 -0700 @@ -1035,22 +1035,47 @@ 2:00 EU EE%sT # Finland -# + # From Hannu Strang (1994-09-25 06:03:37 UTC): # Well, here in Helsinki we're just changing from summer time to regular one, # and it's supposed to change at 4am... + +# From Janne Snabb (2010-0715): # -# From Paul Eggert (2006-03-22): -# Shanks & Pottenger say Finland has switched at 02:00 standard time -# since 1981. Go with Strang instead. +# I noticed that the Finland data is not accurate for years 1981 and 1982. +# During these two first trial years the DST adjustment was made one hour +# earlier than in forthcoming years. Starting 1983 the adjustment was made +# according to the central European standards. +# +# This is documented in Heikki Oja: Aikakirja 2007, published by The Almanac +# Office of University of Helsinki, ISBN 952-10-3221-9, available online (in +# Finnish) at +# +# <a href="http://almanakka.helsinki.fi/aikakirja/Aikakirja2007kokonaan.pdf"> +# http://almanakka.helsinki.fi/aikakirja/Aikakirja2007kokonaan.pdf +# </a> # +# Page 105 (56 in PDF version) has a handy table of all past daylight savings +# transitions. It is easy enough to interpret without Finnish skills. +# +# This is also confirmed by Finnish Broadcasting Company's archive at: +# +# <a href="http://www.yle.fi/elavaarkisto/?s=s&g=1&ag=5&t=&a=3401"> +# http://www.yle.fi/elavaarkisto/?s=s&g=1&ag=5&t=&a=3401 +# </a> +# +# The news clip from 1981 says that "the time between 2 and 3 o'clock does not +# exist tonight." + # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S Rule Finland 1942 only - Apr 3 0:00 1:00 S Rule Finland 1942 only - Oct 3 0:00 0 - +Rule Finland 1981 1982 - Mar lastSun 2:00 1:00 S +Rule Finland 1981 1982 - Sep lastSun 3:00 0 - # Zone NAME GMTOFF RULES FORMAT [UNTIL] Zone Europe/Helsinki 1:39:52 - LMT 1878 May 31 1:39:52 - HMT 1921 May # Helsinki Mean Time - 2:00 Finland EE%sT 1981 Mar 29 2:00 + 2:00 Finland EE%sT 1983 2:00 EU EE%sT # Aaland Is
--- a/make/sun/javazic/tzdata/leapseconds Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/leapseconds Thu Sep 02 22:11:05 2010 -0700 @@ -82,9 +82,9 @@ # FAX : 33 (0) 1 40 51 22 91 # Internet : services.iers@obspm.fr # -# Paris, 4 July 2009 +# Paris, 14 July 2010 # -# Bulletin C 38 +# Bulletin C 40 # # To authorities responsible # for the measurement and @@ -92,9 +92,9 @@ # # INFORMATION ON UTC - TAI # -# NO positive leap second will be introduced at the end of December 2009. +# NO positive leap second will be introduced at the end of December 2010. # The difference between Coordinated Universal Time UTC and the -# International Atomic Time TAI is : +# International Atomic Time TAI is : # # from 2009 January 1, 0h UTC, until further notice : UTC-TAI = -34 s # @@ -104,6 +104,6 @@ # will be no time step at the next possible date. # # Daniel GAMBIS -# Director +# Director # Earth Orientation Center of IERS # Observatoire de Paris, France
--- a/make/sun/javazic/tzdata/northamerica Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/northamerica Thu Sep 02 22:11:05 2010 -0700 @@ -1346,6 +1346,83 @@ # entry since our cutoff date of 1970, so we can move # America/Coral_Harbour to the 'backward' file. +# From Mark Brader (2010-03-06): +# +# Currently the database has: +# +# # Ontario +# +# # From Paul Eggert (2006-07-09): +# # Shanks & Pottenger write that since 1970 most of Ontario has been like +# # Toronto. +# # Thunder Bay skipped DST in 1973. +# # Many smaller locales did not observe peacetime DST until 1974; +# # Nipigon (EST) and Rainy River (CST) are the largest that we know of. +# +# In the (Toronto) Globe and Mail for Saturday, 1955-09-24, in the bottom +# right corner of page 1, it says that Toronto will return to standard +# time at 2 am Sunday morning (which agrees with the database), and that: +# +# The one-hour setback will go into effect throughout most of Ontario, +# except in areas like Windsor which remains on standard time all year. +# +# Windsor is, of course, a lot larger than Nipigon. +# +# I only came across this incidentally. I don't know if Windsor began +# observing DST when Detroit did, or in 1974, or on some other date. +# +# By the way, the article continues by noting that: +# +# Some cities in the United States have pushed the deadline back +# three weeks and will change over from daylight saving in October. + +# From Arthur David Olson (2010-07-17): +# +# "Standard Time and Time Zones in Canada" appeared in +# The Journal of The Royal Astronomical Society of Canada, +# volume 26, number 2 (February 1932) and, as of 2010-07-17, +# was available at +# <a href="http://adsabs.harvard.edu/full/1932JRASC..26...49S"> +# http://adsabs.harvard.edu/full/1932JRASC..26...49S +# </a> +# +# It includes the text below (starting on page 57): +# +# A list of the places in Canada using daylight saving time would +# require yearly revision. From information kindly furnished by +# the provincial governments and by the postmasters in many cities +# and towns, it is found that the following places used daylight sav- +# ing in 1930. The information for the province of Quebec is definite, +# for the other provinces only approximate: +# +# Province Daylight saving time used +# Prince Edward Island Not used. +# Nova Scotia In Halifax only. +# New Brunswick In St. John only. +# Quebec In the following places: +# Montreal Lachine +# Quebec Mont-Royal +# Levis Iberville +# St. Lambert Cap de la Madeleine +# Verdun Loretteville +# Westmount Richmond +# Outremont St. Jerome +# Longueuil Greenfield Park +# Arvida Waterloo +# Chambly-Canton Beaulieu +# Melbourne La Tuque +# St. Theophile Buckingham +# Ontario Used generally in the cities and towns along +# the southerly part of the province. Not +# used in the northwesterlhy part. +# Manitoba Not used. +# Saskatchewan In Regina only. +# Alberta Not used. +# British Columbia Not used. +# +# With some exceptions, the use of daylight saving may be said to be limited +# to those cities and towns lying between Quebec city and Windsor, Ont. + # Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S Rule Toronto 1919 only - Mar 30 23:30 1:00 D Rule Toronto 1919 only - Oct 26 0:00 0 S @@ -2111,7 +2188,44 @@ -8:00 - PST 1970 -7:00 Mexico M%sT 1999 -7:00 - MST + +# From Alexander Krivenyshev (2010-04-21): +# According to news, Bahía de Banderas (Mexican state of Nayarit) +# changed time zone UTC-7 to new time zone UTC-6 on April 4, 2010 (to +# share the same time zone as nearby city Puerto Vallarta, Jalisco). +# +# (Spanish) +# Bahía de Banderas homologa su horario al del centro del +# país, a partir de este domingo +# <a href="http://www.nayarit.gob.mx/notes.asp?id=20748"> +# http://www.nayarit.gob.mx/notes.asp?id=20748 +# </a> +# +# Bahía de Banderas homologa su horario con el del Centro del +# País +# <a href="http://www.bahiadebanderas.gob.mx/principal/index.php?option=com_content&view=article&id=261:bahia-de-banderas-homologa-su-horario-con-el-del-centro-del-pais&catid=42:comunicacion-social&Itemid=50"> +# http://www.bahiadebanderas.gob.mx/principal/index.php?option=com_content&view=article&id=261:bahia-de-banderas-homologa-su-horario-con-el-del-centro-del-pais&catid=42:comunicacion-social&Itemid=50" +# </a> +# +# (English) +# Puerto Vallarta and Bahía de Banderas: One Time Zone +# <a href="http://virtualvallarta.com/puertovallarta/puertovallarta/localnews/2009-12-03-Puerto-Vallarta-and-Bahia-de-Banderas-One-Time-Zone.shtml"> +# http://virtualvallarta.com/puertovallarta/puertovallarta/localnews/2009-12-03-Puerto-Vallarta-and-Bahia-de-Banderas-One-Time-Zone.shtml +# </a> +# +# or +# <a href="http://www.worldtimezone.com/dst_news/dst_news_mexico08.html"> +# http://www.worldtimezone.com/dst_news/dst_news_mexico08.html +# </a> +# +# "Mexico's Senate approved the amendments to the Mexican Schedule System that +# will allow Bahía de Banderas and Puerto Vallarta to share the same time +# zone ..." # Baja California Sur, Nayarit, Sinaloa + +# From Arthur David Olson (2010-05-01): +# Use "Bahia_Banderas" to keep the name to fourteen characters. + Zone America/Mazatlan -7:05:40 - LMT 1921 Dec 31 23:54:20 -7:00 - MST 1927 Jun 10 23:00 -6:00 - CST 1930 Nov 15 @@ -2122,6 +2236,19 @@ -7:00 - MST 1949 Jan 14 -8:00 - PST 1970 -7:00 Mexico M%sT + +Zone America/Bahia_Banderas -7:01:00 - LMT 1921 Dec 31 23:59:00 + -7:00 - MST 1927 Jun 10 23:00 + -6:00 - CST 1930 Nov 15 + -7:00 - MST 1931 May 1 23:00 + -6:00 - CST 1931 Oct + -7:00 - MST 1932 Apr 1 + -6:00 - CST 1942 Apr 24 + -7:00 - MST 1949 Jan 14 + -8:00 - PST 1970 + -7:00 Mexico M%sT 2010 Apr 4 2:00 + -6:00 Mexico C%sT + # Baja California (near US border) Zone America/Tijuana -7:48:04 - LMT 1922 Jan 1 0:11:56 -7:00 - MST 1924
--- a/make/sun/javazic/tzdata/zone.tab Wed Sep 01 17:37:45 2010 -0700 +++ b/make/sun/javazic/tzdata/zone.tab Thu Sep 02 22:11:05 2010 -0700 @@ -199,8 +199,8 @@ FI +6010+02458 Europe/Helsinki FJ -1808+17825 Pacific/Fiji FK -5142-05751 Atlantic/Stanley -FM +0725+15147 Pacific/Truk Truk (Chuuk) and Yap -FM +0658+15813 Pacific/Ponape Ponape (Pohnpei) +FM +0725+15147 Pacific/Chuuk Chuuk (Truk) and Yap +FM +0658+15813 Pacific/Pohnpei Pohnpei (Ponape) FM +0519+16259 Pacific/Kosrae Kosrae FO +6201-00646 Atlantic/Faroe FR +4852+00220 Europe/Paris @@ -310,6 +310,7 @@ MX +2904-11058 America/Hermosillo Mountain Standard Time - Sonora MX +3232-11701 America/Tijuana US Pacific Time - Baja California near US border MX +3018-11452 America/Santa_Isabel Mexican Pacific Time - Baja California away from US border +MX +2048-10515 America/Bahia_Banderas Mexican Central Time - Bahia de Banderas MY +0310+10142 Asia/Kuala_Lumpur peninsular Malaysia MY +0133+11020 Asia/Kuching Sabah & Sarawak MZ -2558+03235 Africa/Maputo
--- a/src/share/classes/com/sun/tools/example/debug/tty/TTYResources.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/com/sun/tools/example/debug/tty/TTYResources.java Thu Sep 02 22:11:05 2010 -0700 @@ -45,7 +45,7 @@ * @return the contents of this <code>ResourceBundle</code>. */ public Object[][] getContents() { - return new Object[][] { + Object[][] temp = new Object[][] { // NOTE: The value strings in this file containing "{0}" are // processed by the java.text.MessageFormat class. Any // single quotes appearing in these strings need to be @@ -449,5 +449,7 @@ "For command help type ''help'' at {0} prompt"}, // END OF MATERIAL TO LOCALIZE }; + + return temp; } }
--- a/src/share/classes/javax/swing/JTable.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/javax/swing/JTable.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -946,7 +946,6 @@ /** * Returns the height of a table row, in pixels. - * The default row height is 16.0. * * @return the height in pixels of a table row * @see #setRowHeight
--- a/src/share/classes/sun/applet/resources/MsgAppletViewer.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/applet/resources/MsgAppletViewer.java Thu Sep 02 22:11:05 2010 -0700 @@ -29,7 +29,7 @@ public class MsgAppletViewer extends ListResourceBundle { public Object[][] getContents() { - return new Object[][] { + Object[][] temp = new Object[][] { {"textframe.button.dismiss", "Dismiss"}, {"appletviewer.tool.title", "Applet Viewer: {0}"}, {"appletviewer.menu.applet", "Applet"}, @@ -197,5 +197,7 @@ {"appletsecurityexception.checkread.unknown", "unknown class loader type. unable to check for checking read {0}"}, {"appletsecurityexception.checkconnect.unknown", "unknown class loader type. unable to check for checking connect"}, }; + + return temp; } }
--- a/src/share/classes/sun/java2d/pisces/Dasher.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/java2d/pisces/Dasher.java Thu Sep 02 22:11:05 2010 -0700 @@ -36,117 +36,71 @@ * semantics are unclear. * */ -public class Dasher extends LineSink { +public class Dasher implements LineSink { + private final LineSink output; + private final float[] dash; + private final float startPhase; + private final boolean startDashOn; + private final int startIdx; - LineSink output; - int[] dash; - int startPhase; - boolean startDashOn; - int startIdx; - - int idx; - boolean dashOn; - int phase; - - int sx, sy; - int x0, y0; + private final float m00, m10, m01, m11; + private final float det; - int m00, m01; - int m10, m11; - - Transform4 transform; - - boolean symmetric; - long ldet; + private boolean firstDashOn; + private boolean starting; - boolean firstDashOn; - boolean starting; - int sx1, sy1; + private int idx; + private boolean dashOn; + private float phase; - /** - * Empty constructor. <code>setOutput</code> and - * <code>setParameters</code> must be called prior to calling any - * other methods. - */ - public Dasher() {} + private float sx, sy; + private float x0, y0; + private float sx1, sy1; + /** * Constructs a <code>Dasher</code>. * * @param output an output <code>LineSink</code>. - * @param dash an array of <code>int</code>s containing the dash - * pattern in S15.16 format. - * @param phase an <code>int</code> containing the dash phase in - * S15.16 format. + * @param dash an array of <code>int</code>s containing the dash pattern + * @param phase an <code>int</code> containing the dash phase * @param transform a <code>Transform4</code> object indicating * the transform that has been previously applied to all incoming * coordinates. This is required in order to compute dash lengths * properly. */ public Dasher(LineSink output, - int[] dash, int phase, - Transform4 transform) { - setOutput(output); - setParameters(dash, phase, transform); - } - - /** - * Sets the output <code>LineSink</code> of this - * <code>Dasher</code>. - * - * @param output an output <code>LineSink</code>. - */ - public void setOutput(LineSink output) { - this.output = output; - } - - /** - * Sets the parameters of this <code>Dasher</code>. - * - * @param dash an array of <code>int</code>s containing the dash - * pattern in S15.16 format. - * @param phase an <code>int</code> containing the dash phase in - * S15.16 format. - * @param transform a <code>Transform4</code> object indicating - * the transform that has been previously applied to all incoming - * coordinates. This is required in order to compute dash lengths - * properly. - */ - public void setParameters(int[] dash, int phase, - Transform4 transform) { + float[] dash, float phase, + float a00, float a01, float a10, float a11) { if (phase < 0) { throw new IllegalArgumentException("phase < 0 !"); } + this.output = output; + // Normalize so 0 <= phase < dash[0] int idx = 0; dashOn = true; - int d; + float d; while (phase >= (d = dash[idx])) { phase -= d; idx = (idx + 1) % dash.length; dashOn = !dashOn; } - this.dash = new int[dash.length]; - for (int i = 0; i < dash.length; i++) { - this.dash[i] = dash[i]; - } + this.dash = dash; this.startPhase = this.phase = phase; this.startDashOn = dashOn; this.startIdx = idx; - this.transform = transform; - - this.m00 = transform.m00; - this.m01 = transform.m01; - this.m10 = transform.m10; - this.m11 = transform.m11; - this.ldet = ((long)m00*m11 - (long)m01*m10) >> 16; - this.symmetric = (m00 == m11 && m10 == -m01); + m00 = a00; + m01 = a01; + m10 = a10; + m11 = a11; + det = m00 * m11 - m01 * m10; } - public void moveTo(int x0, int y0) { + public void moveTo(float x0, float y0) { output.moveTo(x0, y0); this.idx = startIdx; this.dashOn = this.startDashOn; @@ -160,7 +114,7 @@ output.lineJoin(); } - private void goTo(int x1, int y1) { + private void goTo(float x1, float y1) { if (dashOn) { if (starting) { this.sx1 = x1; @@ -180,52 +134,64 @@ this.y0 = y1; } - public void lineTo(int x1, int y1) { - while (true) { - int d = dash[idx] - phase; - int lx = x1 - x0; - int ly = y1 - y0; + public void lineTo(float x1, float y1) { + // The widened line is squished to a 0 width one, so no drawing is done + if (det == 0) { + goTo(x1, y1); + return; + } + float dx = x1 - x0; + float dy = y1 - y0; - // Compute segment length in the untransformed - // coordinate system - // IMPL NOTE - use fixed point + + // Compute segment length in the untransformed + // coordinate system - int l; - if (symmetric) { - l = (int)((PiscesMath.hypot(lx, ly)*65536L)/ldet); - } else{ - long la = ((long)ly*m00 - (long)lx*m10)/ldet; - long lb = ((long)ly*m01 - (long)lx*m11)/ldet; - l = (int)PiscesMath.hypot(la, lb); - } + float la = (dy*m00 - dx*m10)/det; + float lb = (dy*m01 - dx*m11)/det; + float origLen = (float) Math.hypot(la, lb); - if (l < d) { + if (origLen == 0) { + // Let the output LineSink deal with cases where dx, dy are 0. + goTo(x1, y1); + return; + } + + // The scaling factors needed to get the dx and dy of the + // transformed dash segments. + float cx = dx / origLen; + float cy = dy / origLen; + + while (true) { + float leftInThisDashSegment = dash[idx] - phase; + if (origLen < leftInThisDashSegment) { goTo(x1, y1); // Advance phase within current dash segment - phase += l; + phase += origLen; + return; + } else if (origLen == leftInThisDashSegment) { + goTo(x1, y1); + phase = 0f; + idx = (idx + 1) % dash.length; + dashOn = !dashOn; return; } - long t; - int xsplit, ysplit; -// // For zero length dashses, SE appears to move 1/8 unit -// // in device space -// if (d == 0) { -// double dlx = lx/65536.0; -// double dly = ly/65536.0; -// len = PiscesMath.hypot(dlx, dly); -// double dt = 1.0/(8*len); -// double dxsplit = (x0/65536.0) + dt*dlx; -// double dysplit = (y0/65536.0) + dt*dly; -// xsplit = (int)(dxsplit*65536.0); -// ysplit = (int)(dysplit*65536.0); -// } else { - t = ((long)d << 16)/l; - xsplit = x0 + (int)(t*(x1 - x0) >> 16); - ysplit = y0 + (int)(t*(y1 - y0) >> 16); -// } - goTo(xsplit, ysplit); + float dashx, dashy; + float dashdx = dash[idx] * cx; + float dashdy = dash[idx] * cy; + if (phase == 0) { + dashx = x0 + dashdx; + dashy = y0 + dashdy; + } else { + float p = (leftInThisDashSegment) / dash[idx]; + dashx = x0 + p * dashdx; + dashy = y0 + p * dashdy; + } + goTo(dashx, dashy); + + origLen -= (dash[idx] - phase); // Advance to next dash segment idx = (idx + 1) % dash.length; dashOn = !dashOn; @@ -233,6 +199,7 @@ } } + public void close() { lineTo(sx, sy); if (firstDashOn) {
--- a/src/share/classes/sun/java2d/pisces/LineSink.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/java2d/pisces/LineSink.java Thu Sep 02 22:11:05 2010 -0700 @@ -39,16 +39,16 @@ * <code>LineSink</code> interface. * */ -public abstract class LineSink { +public interface LineSink { /** * Moves the current drawing position to the point <code>(x0, * y0)</code>. * - * @param x0 the X coordinate in S15.16 format - * @param y0 the Y coordinate in S15.16 format + * @param x0 the X coordinate + * @param y0 the Y coordinate */ - public abstract void moveTo(int x0, int y0); + public void moveTo(float x0, float y0); /** * Provides a hint that the current segment should be joined to @@ -65,29 +65,29 @@ * <p> Other <code>LineSink</code> classes should simply pass this * hint to their output sink as needed. */ - public abstract void lineJoin(); + public void lineJoin(); /** * Draws a line from the current drawing position to the point * <code>(x1, y1)</code> and sets the current drawing position to * <code>(x1, y1)</code>. * - * @param x1 the X coordinate in S15.16 format - * @param y1 the Y coordinate in S15.16 format + * @param x1 the X coordinate + * @param y1 the Y coordinate */ - public abstract void lineTo(int x1, int y1); + public void lineTo(float x1, float y1); /** * Closes the current path by drawing a line from the current * drawing position to the point specified by the moset recent * <code>moveTo</code> command. */ - public abstract void close(); + public void close(); /** * Ends the current path. It may be necessary to end a path in * order to allow end caps to be drawn. */ - public abstract void end(); + public void end(); }
--- a/src/share/classes/sun/java2d/pisces/PiscesMath.java Wed Sep 01 17:37:45 2010 -0700 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,155 +0,0 @@ -/* - * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package sun.java2d.pisces; - -public class PiscesMath { - - private PiscesMath() {} - - private static final int SINTAB_LG_ENTRIES = 10; - private static final int SINTAB_ENTRIES = 1 << SINTAB_LG_ENTRIES; - private static int[] sintab; - - public static final int PI = (int)(Math.PI*65536.0); - public static final int TWO_PI = (int)(2.0*Math.PI*65536.0); - public static final int PI_OVER_TWO = (int)((Math.PI/2.0)*65536.0); - public static final int SQRT_TWO = (int)(Math.sqrt(2.0)*65536.0); - - static { - sintab = new int[SINTAB_ENTRIES + 1]; - for (int i = 0; i < SINTAB_ENTRIES + 1; i++) { - double theta = i*(Math.PI/2.0)/SINTAB_ENTRIES; - sintab[i] = (int)(Math.sin(theta)*65536.0); - } - } - - public static int sin(int theta) { - int sign = 1; - if (theta < 0) { - theta = -theta; - sign = -1; - } - // 0 <= theta - while (theta >= TWO_PI) { - theta -= TWO_PI; - } - // 0 <= theta < 2*PI - if (theta >= PI) { - theta = TWO_PI - theta; - sign = -sign; - } - // 0 <= theta < PI - if (theta > PI_OVER_TWO) { - theta = PI - theta; - } - // 0 <= theta <= PI/2 - int itheta = (int)((long)theta*SINTAB_ENTRIES/(PI_OVER_TWO)); - return sign*sintab[itheta]; - } - - public static int cos(int theta) { - return sin(PI_OVER_TWO - theta); - } - -// public static double sqrt(double x) { -// double dsqrt = Math.sqrt(x); -// int ix = (int)(x*65536.0); -// Int Isqrt = Isqrt(Ix); - -// Long Lx = (Long)(X*65536.0); -// Long Lsqrt = Lsqrt(Lx); - -// System.Out.Println(); -// System.Out.Println("X = " + X); -// System.Out.Println("Dsqrt = " + Dsqrt); - -// System.Out.Println("Ix = " + Ix); -// System.Out.Println("Isqrt = " + Isqrt/65536.0); - -// System.Out.Println("Lx = " + Lx); -// System.Out.Println("Lsqrt = " + Lsqrt/65536.0); - -// Return Dsqrt; -// } - - // From Ken Turkowski, _Fixed-Point Square Root_, In Graphics Gems V - public static int isqrt(int x) { - int fracbits = 16; - - int root = 0; - int remHi = 0; - int remLo = x; - int count = 15 + fracbits/2; - - do { - remHi = (remHi << 2) | (remLo >>> 30); // N.B. - unsigned shift R - remLo <<= 2; - root <<= 1; - int testdiv = (root << 1) + 1; - if (remHi >= testdiv) { - remHi -= testdiv; - root++; - } - } while (count-- != 0); - - return root; - } - - public static long lsqrt(long x) { - int fracbits = 16; - - long root = 0; - long remHi = 0; - long remLo = x; - int count = 31 + fracbits/2; - - do { - remHi = (remHi << 2) | (remLo >>> 62); // N.B. - unsigned shift R - remLo <<= 2; - root <<= 1; - long testDiv = (root << 1) + 1; - if (remHi >= testDiv) { - remHi -= testDiv; - root++; - } - } while (count-- != 0); - - return root; - } - - public static double hypot(double x, double y) { - // new RuntimeException().printStackTrace(); - return Math.sqrt(x*x + y*y); - } - - public static int hypot(int x, int y) { - return (int)((lsqrt((long)x*x + (long)y*y) + 128) >> 8); - } - - public static long hypot(long x, long y) { - return (lsqrt(x*x + y*y) + 128) >> 8; - } -}
--- a/src/share/classes/sun/java2d/pisces/PiscesRenderingEngine.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/java2d/pisces/PiscesRenderingEngine.java Thu Sep 02 22:11:05 2010 -0700 @@ -27,6 +27,7 @@ import java.awt.Shape; import java.awt.BasicStroke; +import java.awt.geom.FlatteningPathIterator; import java.awt.geom.Path2D; import java.awt.geom.AffineTransform; import java.awt.geom.PathIterator; @@ -37,23 +38,9 @@ import sun.java2d.pipe.AATileGenerator; public class PiscesRenderingEngine extends RenderingEngine { - public static Transform4 IdentT4 = new Transform4(); public static double defaultFlat = 0.1; - static int FloatToS15_16(float flt) { - flt = flt * 65536f + 0.5f; - if (flt <= -(65536f * 65536f)) { - return Integer.MIN_VALUE; - } else if (flt >= (65536f * 65536f)) { - return Integer.MAX_VALUE; - } else { - return (int) Math.floor(flt); - } - } - - static float S15_16ToFloat(int fix) { - return (fix / 65536f); - } + private static enum NormMode {OFF, ON_NO_AA, ON_WITH_AA} /** * Create a widened path as specified by the parameters. @@ -85,18 +72,19 @@ strokeTo(src, null, width, + NormMode.OFF, caps, join, miterlimit, dashes, dashphase, new LineSink() { - public void moveTo(int x0, int y0) { - p2d.moveTo(S15_16ToFloat(x0), S15_16ToFloat(y0)); + public void moveTo(float x0, float y0) { + p2d.moveTo(x0, y0); } public void lineJoin() {} - public void lineTo(int x1, int y1) { - p2d.lineTo(S15_16ToFloat(x1), S15_16ToFloat(y1)); + public void lineTo(float x1, float y1) { + p2d.lineTo(x1, y1); } public void close() { p2d.closePath(); @@ -142,14 +130,17 @@ boolean antialias, final PathConsumer2D consumer) { - strokeTo(src, at, bs, thin, normalize, antialias, + NormMode norm = (normalize) ? + ((antialias) ? NormMode.ON_WITH_AA : NormMode.ON_NO_AA) + : NormMode.OFF; + strokeTo(src, at, bs, thin, norm, antialias, new LineSink() { - public void moveTo(int x0, int y0) { - consumer.moveTo(S15_16ToFloat(x0), S15_16ToFloat(y0)); + public void moveTo(float x0, float y0) { + consumer.moveTo(x0, y0); } public void lineJoin() {} - public void lineTo(int x1, int y1) { - consumer.lineTo(S15_16ToFloat(x1), S15_16ToFloat(y1)); + public void lineTo(float x1, float y1) { + consumer.lineTo(x1, y1); } public void close() { consumer.closePath(); @@ -164,7 +155,7 @@ AffineTransform at, BasicStroke bs, boolean thin, - boolean normalize, + NormMode normalize, boolean antialias, LineSink lsink) { @@ -181,6 +172,7 @@ strokeTo(src, at, lw, + normalize, bs.getEndCap(), bs.getLineJoin(), bs.getMiterLimit(), @@ -258,6 +250,7 @@ void strokeTo(Shape src, AffineTransform at, float width, + NormMode normalize, int caps, int join, float miterlimit, @@ -265,36 +258,139 @@ float dashphase, LineSink lsink) { - Transform4 t4; - - if (at == null || at.isIdentity()) { - t4 = IdentT4; + float a00 = 1f, a01 = 0f, a10 = 0f, a11 = 1f; + if (at != null && !at.isIdentity()) { + a00 = (float)at.getScaleX(); + a01 = (float)at.getShearX(); + a10 = (float)at.getShearY(); + a11 = (float)at.getScaleY(); + } + lsink = new Stroker(lsink, width, caps, join, miterlimit, a00, a01, a10, a11); + if (dashes != null) { + lsink = new Dasher(lsink, dashes, dashphase, a00, a01, a10, a11); + } + PathIterator pi; + if (normalize != NormMode.OFF) { + pi = new FlatteningPathIterator( + new NormalizingPathIterator(src.getPathIterator(at), normalize), + defaultFlat); } else { - t4 = new Transform4(FloatToS15_16((float) at.getScaleX()), - FloatToS15_16((float) at.getShearX()), - FloatToS15_16((float) at.getShearY()), - FloatToS15_16((float) at.getScaleY())); + pi = src.getPathIterator(at, defaultFlat); + } + pathTo(pi, lsink); + } + + private static class NormalizingPathIterator implements PathIterator { + + private final PathIterator src; + + // the adjustment applied to the current position. + private float curx_adjust, cury_adjust; + // the adjustment applied to the last moveTo position. + private float movx_adjust, movy_adjust; + + // constants used in normalization computations + private final float lval, rval; + + NormalizingPathIterator(PathIterator src, NormMode mode) { + this.src = src; + switch (mode) { + case ON_NO_AA: + // round to nearest (0.25, 0.25) pixel + lval = rval = 0.25f; + break; + case ON_WITH_AA: + // round to nearest pixel center + lval = 0f; + rval = 0.5f; + break; + case OFF: + throw new InternalError("A NormalizingPathIterator should " + + "not be created if no normalization is being done"); + default: + throw new InternalError("Unrecognized normalization mode"); + } } - lsink = new Stroker(lsink, - FloatToS15_16(width), - caps, - join, - FloatToS15_16(miterlimit), - t4); - if (dashes != null) { - int fdashes[] = new int[dashes.length]; - for (int i = 0; i < dashes.length; i++) { - fdashes[i] = FloatToS15_16(dashes[i]); + public int currentSegment(float[] coords) { + int type = src.currentSegment(coords); + + int lastCoord; + switch(type) { + case PathIterator.SEG_CUBICTO: + lastCoord = 4; + break; + case PathIterator.SEG_QUADTO: + lastCoord = 2; + break; + case PathIterator.SEG_LINETO: + case PathIterator.SEG_MOVETO: + lastCoord = 0; + break; + case PathIterator.SEG_CLOSE: + // we don't want to deal with this case later. We just exit now + curx_adjust = movx_adjust; + cury_adjust = movy_adjust; + return type; + default: + throw new InternalError("Unrecognized curve type"); } - lsink = new Dasher(lsink, - fdashes, - FloatToS15_16(dashphase), - t4); + + // normalize endpoint + float x_adjust = (float)Math.floor(coords[lastCoord] + lval) + rval - + coords[lastCoord]; + float y_adjust = (float)Math.floor(coords[lastCoord+1] + lval) + rval - + coords[lastCoord + 1]; + + coords[lastCoord ] += x_adjust; + coords[lastCoord + 1] += y_adjust; + + // now that the end points are done, normalize the control points + switch(type) { + case PathIterator.SEG_CUBICTO: + coords[0] += curx_adjust; + coords[1] += cury_adjust; + coords[2] += x_adjust; + coords[3] += y_adjust; + break; + case PathIterator.SEG_QUADTO: + coords[0] += (curx_adjust + x_adjust) / 2; + coords[1] += (cury_adjust + y_adjust) / 2; + break; + case PathIterator.SEG_LINETO: + break; + case PathIterator.SEG_MOVETO: + movx_adjust = x_adjust; + movy_adjust = y_adjust; + break; + case PathIterator.SEG_CLOSE: + throw new InternalError("This should be handled earlier."); + } + curx_adjust = x_adjust; + cury_adjust = y_adjust; + return type; } - PathIterator pi = src.getPathIterator(at, defaultFlat); - pathTo(pi, lsink); + public int currentSegment(double[] coords) { + float[] tmp = new float[6]; + int type = this.currentSegment(tmp); + for (int i = 0; i < 6; i++) { + coords[i] = (float) tmp[i]; + } + return type; + } + + public int getWindingRule() { + return src.getWindingRule(); + } + + public boolean isDone() { + return src.isDone(); + } + + public void next() { + src.next(); + } } void pathTo(PathIterator pi, LineSink lsink) { @@ -302,13 +398,11 @@ while (!pi.isDone()) { switch (pi.currentSegment(coords)) { case PathIterator.SEG_MOVETO: - lsink.moveTo(FloatToS15_16(coords[0]), - FloatToS15_16(coords[1])); + lsink.moveTo(coords[0], coords[1]); break; case PathIterator.SEG_LINETO: lsink.lineJoin(); - lsink.lineTo(FloatToS15_16(coords[0]), - FloatToS15_16(coords[1])); + lsink.lineTo(coords[0], coords[1]); break; case PathIterator.SEG_CLOSE: lsink.lineJoin(); @@ -378,18 +472,28 @@ int bbox[]) { PiscesCache pc = PiscesCache.createInstance(); - Renderer r = new Renderer(); - r.setCache(pc); - r.setAntialiasing(3, 3); - r.beginRendering(clip.getLoX(), clip.getLoY(), - clip.getWidth(), clip.getHeight()); + Renderer r; + NormMode norm = (normalize) ? NormMode.ON_WITH_AA : NormMode.OFF; if (bs == null) { - PathIterator pi = s.getPathIterator(at, defaultFlat); - r.setWindingRule(pi.getWindingRule()); + PathIterator pi; + if (normalize) { + pi = new FlatteningPathIterator( + new NormalizingPathIterator(s.getPathIterator(at), norm), + defaultFlat); + } else { + pi = s.getPathIterator(at, defaultFlat); + } + r = new Renderer(3, 3, + clip.getLoX(), clip.getLoY(), + clip.getWidth(), clip.getHeight(), + pi.getWindingRule(), pc); pathTo(pi, r); } else { - r.setWindingRule(PathIterator.WIND_NON_ZERO); - strokeTo(s, at, bs, thin, normalize, true, r); + r = new Renderer(3, 3, + clip.getLoX(), clip.getLoY(), + clip.getWidth(), clip.getHeight(), + PathIterator.WIND_NON_ZERO, pc); + strokeTo(s, at, bs, thin, norm, true, r); } r.endRendering(); PiscesTileGenerator ptg = new PiscesTileGenerator(pc, r.MAX_AA_ALPHA); @@ -420,3 +524,4 @@ } } } +
--- a/src/share/classes/sun/java2d/pisces/Renderer.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/java2d/pisces/Renderer.java Thu Sep 02 22:11:05 2010 -0700 @@ -25,446 +25,440 @@ package sun.java2d.pisces; -public class Renderer extends LineSink { +import java.util.Arrays; + +public class Renderer implements LineSink { + +/////////////////////////////////////////////////////////////////////////////// +// Scan line iterator and edge crossing data. +////////////////////////////////////////////////////////////////////////////// + + private int[] crossings; + + // This is an array of indices into the edge array. It is initialized to + // [i * SIZEOF_STRUCT_EDGE for i in range(0, edgesSize/SIZEOF_STRUCT_EDGE)] + // (where range(i, j) is i,i+1,...,j-1 -- just like in python). + // The reason for keeping this is because we need the edges array sorted + // by y0, but we don't want to move all that data around, so instead we + // sort the indices into the edge array, and use edgeIndices to access + // the edges array. This is meant to simulate a pointer array (hence the name) + private int[] edgePtrs; + + // crossing bounds. The bounds are not necessarily tight (the scan line + // at minY, for example, might have no crossings). The x bounds will + // be accumulated as crossings are computed. + private int minY, maxY; + private int minX, maxX; + private int nextY; + + // indices into the edge pointer list. They indicate the "active" sublist in + // the edge list (the portion of the list that contains all the edges that + // cross the next scan line). + private int lo, hi; + + private static final int INIT_CROSSINGS_SIZE = 50; + private void ScanLineItInitialize() { + crossings = new int[INIT_CROSSINGS_SIZE]; + edgePtrs = new int[edgesSize / SIZEOF_STRUCT_EDGE]; + for (int i = 0; i < edgePtrs.length; i++) { + edgePtrs[i] = i * SIZEOF_STRUCT_EDGE; + } + + qsort(0, edgePtrs.length - 1); + + // We don't care if we clip some of the line off with ceil, since + // no scan line crossings will be eliminated (in fact, the ceil is + // the y of the first scan line crossing). + nextY = minY = Math.max(boundsMinY, (int)Math.ceil(edgeMinY)); + maxY = Math.min(boundsMaxY, (int)Math.ceil(edgeMaxY)); + + for (lo = 0; lo < edgePtrs.length && edges[edgePtrs[lo]+Y1] <= nextY; lo++) + ; + for (hi = lo; hi < edgePtrs.length && edges[edgePtrs[hi]+CURY] <= nextY; hi++) + ; // the active list is *edgePtrs[lo] (inclusive) *edgePtrs[hi] (exclusive) + for (int i = lo; i < hi; i++) { + setCurY(edgePtrs[i], nextY); + } + + // We accumulate X in the iterator because accumulating it in addEdge + // like we do with Y does not do much good: if there's an edge + // (0,0)->(1000,10000), and if y gets clipped to 1000, then the x + // bound should be 100, but the accumulator from addEdge would say 1000, + // so we'd still have to accumulate the X bounds as we add crossings. + minX = boundsMinX; + maxX = boundsMaxX; + } + + private int ScanLineItCurrentY() { + return nextY - 1; + } + + private int ScanLineItGoToNextYAndComputeCrossings() { + // we go through the active list and remove the ones that don't cross + // the nextY scanline. + int crossingIdx = 0; + for (int i = lo; i < hi; i++) { + if (edges[edgePtrs[i]+Y1] <= nextY) { + edgePtrs[i] = edgePtrs[lo++]; + } + } + if (hi - lo > crossings.length) { + int newSize = Math.max(hi - lo, crossings.length * 2); + crossings = Arrays.copyOf(crossings, newSize); + } + // Now every edge between lo and hi crosses nextY. Compute it's + // crossing and put it in the crossings array. + for (int i = lo; i < hi; i++) { + addCrossing(nextY, getCurCrossing(edgePtrs[i]), (int)edges[edgePtrs[i]+OR], crossingIdx); + gotoNextY(edgePtrs[i]); + crossingIdx++; + } + + nextY++; + // Expand active list to include new edges. + for (; hi < edgePtrs.length && edges[edgePtrs[hi]+CURY] <= nextY; hi++) { + setCurY(edgePtrs[hi], nextY); + } + + Arrays.sort(crossings, 0, crossingIdx); + return crossingIdx; + } + + private boolean ScanLineItHasNext() { + return nextY < maxY; + } + + private void addCrossing(int y, int x, int or, int idx) { + if (x < minX) { + minX = x; + } + if (x > maxX) { + maxX = x; + } + x <<= 1; + crossings[idx] = ((or == 1) ? (x | 0x1) : x); + } + + + // quicksort implementation for sorting the edge indices ("pointers") + // by increasing y0. first, last are indices into the "pointer" array + // It sorts the pointer array from first (inclusive) to last (inclusive) + private void qsort(int first, int last) { + if (last > first) { + int p = partition(first, last); + if (first < p - 1) { + qsort(first, p - 1); + } + if (p < last) { + qsort(p, last); + } + } + } + + // i, j are indices into edgePtrs. + private int partition(int i, int j) { + int pivotVal = edgePtrs[i]; + while (i <= j) { + // edges[edgePtrs[i]+1] is equivalent to (*(edgePtrs[i])).y0 in C + while (edges[edgePtrs[i]+CURY] < edges[pivotVal+CURY]) { i++; } + while (edges[edgePtrs[j]+CURY] > edges[pivotVal+CURY]) { j--; } + if (i <= j) { + int tmp = edgePtrs[i]; + edgePtrs[i] = edgePtrs[j]; + edgePtrs[j] = tmp; + i++; + j--; + } + } + return i; + } + +//============================================================================ + + +////////////////////////////////////////////////////////////////////////////// +// EDGE LIST +////////////////////////////////////////////////////////////////////////////// + + private static final int INIT_NUM_EDGES = 1000; + private static final int SIZEOF_STRUCT_EDGE = 5; + + // The following array is a poor man's struct array: + // it simulates a struct array by having + // edges[SIZEOF_STRUCT_EDGE * i + j] be the jth field in the ith element + // of an array of edge structs. + private float[] edges; + private int edgesSize; // size of the edge list. + private static final int Y1 = 0; + private static final int SLOPE = 1; + private static final int OR = 2; // the orientation. This can be -1 or 1. + // -1 means up, 1 means down. + private static final int CURY = 3; // j = 5 corresponds to the "current Y". + // Each edge keeps track of the last scanline + // crossing it computed, and this is the y coord of + // that scanline. + private static final int CURX = 4; //the x coord of the current crossing. + + // Note that while the array is declared as a float[] not all of it's + // elements should be floats. currentY and Orientation should be ints (or int and + // byte respectively), but they all need to be the same type. This isn't + // really a problem because floats can represent exactly all 23 bit integers, + // which should be more than enough. + // Note, also, that we only need x1 for slope computation, so we don't need + // to store it. x0, y0 don't need to be stored either. They can be put into + // curx, cury, and it's ok if they're lost when curx and cury are changed. + // We take this undeniably ugly and error prone approach (instead of simply + // making an Edge class) for performance reasons. Also, it would probably be nicer + // to have one array for each field, but that would defeat the purpose because + // it would make poor use of the processor cache, since we tend to access + // all the fields for one edge at a time. + + private float edgeMinY; + private float edgeMaxY; + + + private void addEdge(float x0, float y0, float x1, float y1) { + float or = (y0 < y1) ? 1f : -1f; // orientation: 1 = UP; -1 = DOWN + if (or == -1) { + float tmp = y0; + y0 = y1; + y1 = tmp; + tmp = x0; + x0 = x1; + x1 = tmp; + } + // skip edges that don't cross a scanline + if (Math.ceil(y0) >= Math.ceil(y1)) { + return; + } + + int newSize = edgesSize + SIZEOF_STRUCT_EDGE; + if (edges.length < newSize) { + edges = Arrays.copyOf(edges, newSize * 2); + } + edges[edgesSize+CURX] = x0; + edges[edgesSize+CURY] = y0; + edges[edgesSize+Y1] = y1; + edges[edgesSize+SLOPE] = (x1 - x0) / (y1 - y0); + edges[edgesSize+OR] = or; + // the crossing values can't be initialized meaningfully yet. This + // will have to wait until setCurY is called + edgesSize += SIZEOF_STRUCT_EDGE; + + // Accumulate edgeMinY and edgeMaxY + if (y0 < edgeMinY) { edgeMinY = y0; } + if (y1 > edgeMaxY) { edgeMaxY = y1; } + } + + // As far as the following methods care, this edges extends to infinity. + // They can compute the x intersect of any horizontal line. + // precondition: idx is the index to the start of the desired edge. + // So, if the ith edge is wanted, idx should be SIZEOF_STRUCT_EDGE * i + private void setCurY(int idx, int y) { + // compute the x crossing of edge at idx and horizontal line y + // currentXCrossing = (y - y0)*slope + x0 + edges[idx + CURX] = (y - edges[idx + CURY]) * edges[idx + SLOPE] + edges[idx+CURX]; + edges[idx + CURY] = (float)y; + } + + private void gotoNextY(int idx) { + edges[idx + CURY] += 1f; // i.e. curY += 1 + edges[idx + CURX] += edges[idx + SLOPE]; // i.e. curXCrossing += slope + } + + private int getCurCrossing(int idx) { + return (int)edges[idx + CURX]; + } +//==================================================================================== + public static final int WIND_EVEN_ODD = 0; public static final int WIND_NON_ZERO = 1; - // Initial edge list size - // IMPL_NOTE - restore size after growth - public static final int INITIAL_EDGES = 1000; - - // Recommended maximum scratchpad sizes. The arrays will grow - // larger if needed, but when finished() is called they will be released - // if they have grown larger than these sizes. - public static final int DEFAULT_INDICES_SIZE = 8192; - public static final int DEFAULT_CROSSINGS_SIZE = 32*1024; - // Antialiasing - private int SUBPIXEL_LG_POSITIONS_X; - private int SUBPIXEL_LG_POSITIONS_Y; - private int SUBPIXEL_MASK_X; - private int SUBPIXEL_MASK_Y; - private int SUBPIXEL_POSITIONS_X; - private int SUBPIXEL_POSITIONS_Y; - int MAX_AA_ALPHA; - private int MAX_AA_ALPHA_DENOM; - private int HALF_MAX_AA_ALPHA_DENOM; - private int XSHIFT; - private int YSHIFT; - private int YSTEP; - private int HYSTEP; - private int YMASK; - - private static final int MIN_QUAD_OPT_WIDTH = 100 << 16; + final private int SUBPIXEL_LG_POSITIONS_X; + final private int SUBPIXEL_LG_POSITIONS_Y; + final private int SUBPIXEL_POSITIONS_X; + final private int SUBPIXEL_POSITIONS_Y; + final private int SUBPIXEL_MASK_X; + final private int SUBPIXEL_MASK_Y; + final int MAX_AA_ALPHA; // Cache to store RLE-encoded coverage mask of the current primitive - PiscesCache cache; + final PiscesCache cache; - // Bounds of the drawing region, at S15.16 precsion - private int boundsMinX, boundsMinY, boundsMaxX, boundsMaxY; - - // Bounds of the current primitive, at subsample precision - private int rasterMinX, rasterMaxX, rasterMinY, rasterMaxY; + // Bounds of the drawing region, at subpixel precision. + final private int boundsMinX, boundsMinY, boundsMaxX, boundsMaxY; // Pixel bounding box for current primitive - private int bboxX0, bboxY0, bboxX1, bboxY1; + private int pix_bboxX0, pix_bboxY0, pix_bboxX1, pix_bboxY1; // Current winding rule - private int windingRule; + final private int windingRule; // Current drawing position, i.e., final point of last segment - private int x0, y0; + private float x0, y0; // Position of most recent 'moveTo' command - private int sx0, sy0; - - // Buffer to be filled with one row's worth of alpha values - private byte[] rowAA; // needs to be short if 16x16 subsampling + private float pix_sx0, pix_sy0; - // Track the number of vertical extrema of the incoming edge list - // in order to determine the maximum number of crossings of a - // scanline - private int firstOrientation; - private int lastOrientation; - private int flips; - - // Parameters for emitRow - private int alphaWidth; - - public Renderer() { - } - - public void setAntialiasing(int subpixelLgPositionsX, - int subpixelLgPositionsY) { + public Renderer(int subpixelLgPositionsX, int subpixelLgPositionsY, + int pix_boundsX, int pix_boundsY, + int pix_boundsWidth, int pix_boundsHeight, + int windingRule, + PiscesCache cache) { this.SUBPIXEL_LG_POSITIONS_X = subpixelLgPositionsX; this.SUBPIXEL_LG_POSITIONS_Y = subpixelLgPositionsY; + this.SUBPIXEL_MASK_X = (1 << (SUBPIXEL_LG_POSITIONS_X)) - 1; + this.SUBPIXEL_MASK_Y = (1 << (SUBPIXEL_LG_POSITIONS_Y)) - 1; + this.SUBPIXEL_POSITIONS_X = 1 << (SUBPIXEL_LG_POSITIONS_X); + this.SUBPIXEL_POSITIONS_Y = 1 << (SUBPIXEL_LG_POSITIONS_Y); + this.MAX_AA_ALPHA = (SUBPIXEL_POSITIONS_X * SUBPIXEL_POSITIONS_Y); - this.SUBPIXEL_MASK_X = - (1 << (SUBPIXEL_LG_POSITIONS_X)) - 1; - this.SUBPIXEL_MASK_Y = - (1 << (SUBPIXEL_LG_POSITIONS_Y)) - 1; - this.SUBPIXEL_POSITIONS_X = - 1 << (SUBPIXEL_LG_POSITIONS_X); - this.SUBPIXEL_POSITIONS_Y = - 1 << (SUBPIXEL_LG_POSITIONS_Y); - this.MAX_AA_ALPHA = - (SUBPIXEL_POSITIONS_X*SUBPIXEL_POSITIONS_Y); - this.MAX_AA_ALPHA_DENOM = 255*MAX_AA_ALPHA; - this.HALF_MAX_AA_ALPHA_DENOM = MAX_AA_ALPHA_DENOM/2; - this.XSHIFT = 16 - SUBPIXEL_LG_POSITIONS_X; - this.YSHIFT = 16 - SUBPIXEL_LG_POSITIONS_Y; - this.YSTEP = 1 << YSHIFT; - this.HYSTEP = 1 << (YSHIFT - 1); - this.YMASK = ~(YSTEP - 1); - } + this.edges = new float[SIZEOF_STRUCT_EDGE * INIT_NUM_EDGES]; + edgeMinY = Float.POSITIVE_INFINITY; + edgeMaxY = Float.NEGATIVE_INFINITY; + edgesSize = 0; + + this.windingRule = windingRule; + this.cache = cache; - public int getSubpixelLgPositionsX() { - return SUBPIXEL_LG_POSITIONS_X; - } + this.boundsMinX = pix_boundsX * SUBPIXEL_POSITIONS_X; + this.boundsMinY = pix_boundsY * SUBPIXEL_POSITIONS_Y; + this.boundsMaxX = (pix_boundsX + pix_boundsWidth) * SUBPIXEL_POSITIONS_X; + this.boundsMaxY = (pix_boundsY + pix_boundsHeight) * SUBPIXEL_POSITIONS_Y; - public int getSubpixelLgPositionsY() { - return SUBPIXEL_LG_POSITIONS_Y; - } - - public void setWindingRule(int windingRule) { - this.windingRule = windingRule; - } - - public int getWindingRule() { - return windingRule; + this.pix_bboxX0 = pix_boundsX; + this.pix_bboxY0 = pix_boundsY; + this.pix_bboxX1 = pix_boundsX + pix_boundsWidth; + this.pix_bboxY1 = pix_boundsY + pix_boundsHeight; } - public void beginRendering(int boundsX, int boundsY, - int boundsWidth, int boundsHeight) { - lastOrientation = 0; - flips = 0; - - resetEdges(); - - this.boundsMinX = boundsX << 16; - this.boundsMinY = boundsY << 16; - this.boundsMaxX = (boundsX + boundsWidth) << 16; - this.boundsMaxY = (boundsY + boundsHeight) << 16; - - this.bboxX0 = boundsX; - this.bboxY0 = boundsY; - this.bboxX1 = boundsX + boundsWidth; - this.bboxY1 = boundsY + boundsHeight; + private float tosubpixx(float pix_x) { + return pix_x * SUBPIXEL_POSITIONS_X; + } + private float tosubpixy(float pix_y) { + return pix_y * SUBPIXEL_POSITIONS_Y; } - public void moveTo(int x0, int y0) { - // System.out.println("Renderer: moveTo " + x0/65536.0 + " " + y0/65536.0); + public void moveTo(float pix_x0, float pix_y0) { close(); - this.sx0 = this.x0 = x0; - this.sy0 = this.y0 = y0; - this.lastOrientation = 0; + this.pix_sx0 = pix_x0; + this.pix_sy0 = pix_y0; + this.y0 = tosubpixy(pix_y0); + this.x0 = tosubpixx(pix_x0); } - public void lineJoin() { - // System.out.println("Renderer: lineJoin"); - // do nothing - } + public void lineJoin() { /* do nothing */ } - public void lineTo(int x1, int y1) { - // System.out.println("Renderer: lineTo " + x1/65536.0 + " " + y1/65536.0); + public void lineTo(float pix_x1, float pix_y1) { + float x1 = tosubpixx(pix_x1); + float y1 = tosubpixy(pix_y1); // Ignore horizontal lines - // Next line will count flip if (y0 == y1) { this.x0 = x1; return; } - int orientation = (y0 < y1) ? 1 : -1; - if (lastOrientation == 0) { - firstOrientation = orientation; - } else if (orientation != lastOrientation) { - ++flips; - } - lastOrientation = orientation; - - // Bias Y by 1 ULP so endpoints never lie on a scanline - addEdge(x0, y0 | 0x1, x1, y1 | 0x1); + addEdge(x0, y0, x1, y1); this.x0 = x1; this.y0 = y1; } public void close() { - // System.out.println("Renderer: close"); - - int orientation = lastOrientation; - if (y0 != sy0) { - orientation = (y0 < sy0) ? 1 : -1; - } - if (orientation != firstOrientation) { - ++flips; - } - lineTo(sx0, sy0); + // lineTo expects its input in pixel coordinates. + lineTo(pix_sx0, pix_sy0); } public void end() { close(); - // System.out.println("Renderer: end"); - // do nothing - } - - // Scan convert a single edge - private void computeCrossingsForEdge(int index, - int boundsMinY, int boundsMaxY) { - int iy0 = edges[index + 1]; - int iy1 = edges[index + 3]; - - // Clip to valid Y range - int clipy0 = (iy0 > boundsMinY) ? iy0 : boundsMinY; - int clipy1 = (iy1 < boundsMaxY) ? iy1 : boundsMaxY; - - int minY = ((clipy0 + HYSTEP) & YMASK) + HYSTEP; - int maxY = ((clipy1 - HYSTEP) & YMASK) + HYSTEP; - - // IMPL_NOTE - If line falls outside the valid X range, could - // draw a vertical line instead - - // Exit if no scanlines are crossed - if (minY > maxY) { - return; - } - - // Scan convert line using a DDA approach - - int ix0 = edges[index]; - int ix1 = edges[index + 2]; - long dx = ((long) ix1) - ix0; - long dy = ((long) iy1) - iy0; - - // Compute first crossing point at y = minY - int orientation = edges[index + 4]; - int y = minY; - long lx = (((long) y) - iy0)*dx/dy + ix0; - addCrossing(y >> YSHIFT, (int)(lx >> XSHIFT), orientation); - - // Advance y to next scanline, exit if past endpoint - y += YSTEP; - if (y > maxY) { - return; - } - - // Compute xstep only if additional scanlines are crossed - // For each scanline, add xstep to lx and YSTEP to y and - // emit the new crossing - long xstep = ((long)YSTEP*dx)/dy; - for (; y <= maxY; y += YSTEP) { - lx += xstep; - addCrossing(y >> YSHIFT, (int)(lx >> XSHIFT), orientation); - } - } - - private void computeBounds() { - rasterMinX = crossingMinX & ~SUBPIXEL_MASK_X; - rasterMaxX = crossingMaxX | SUBPIXEL_MASK_X; - rasterMinY = crossingMinY & ~SUBPIXEL_MASK_Y; - rasterMaxY = crossingMaxY | SUBPIXEL_MASK_Y; - - // If nothing was drawn, we have: - // minX = Integer.MAX_VALUE and maxX = Integer.MIN_VALUE - // so nothing to render - if (rasterMinX > rasterMaxX || rasterMinY > rasterMaxY) { - rasterMinX = 0; - rasterMaxX = -1; - rasterMinY = 0; - rasterMaxY = -1; - return; - } - - if (rasterMinX < boundsMinX >> XSHIFT) { - rasterMinX = boundsMinX >> XSHIFT; - } - if (rasterMinY < boundsMinY >> YSHIFT) { - rasterMinY = boundsMinY >> YSHIFT; - } - if (rasterMaxX > boundsMaxX >> XSHIFT) { - rasterMaxX = boundsMaxX >> XSHIFT; - } - if (rasterMaxY > boundsMaxY >> YSHIFT) { - rasterMaxY = boundsMaxY >> YSHIFT; - } - } - - private int clamp(int x, int min, int max) { - if (x < min) { - return min; - } else if (x > max) { - return max; - } - return x; } private void _endRendering() { - if (flips == 0) { - bboxX0 = bboxY0 = 0; - bboxX1 = bboxY1 = -1; - return; - } + // Mask to determine the relevant bit of the crossing sum + // 0x1 if EVEN_ODD, all bits if NON_ZERO + int mask = (windingRule == WIND_EVEN_ODD) ? 0x1 : ~0x0; + + // add 1 to better deal with the last pixel in a pixel row. + int width = ((boundsMaxX - boundsMinX) >> SUBPIXEL_LG_POSITIONS_X) + 1; + byte[] alpha = new byte[width+1]; - // Special case for filling a single rect with a flat, opaque color - // REMIND: This special case was not originally written to fill a - // cache object and called directly to a Blit - it needs some code - // to fill the cache instead to be useful for this usage... - if (false /* Does not work with cache (yet?) */ && - edgeIdx == 10 && - edges[0] == edges[2] && - edges[1] == edges[6] && - edges[3] == edges[8] && - edges[5] == edges[7] && - Math.abs(edges[0] - edges[5]) > MIN_QUAD_OPT_WIDTH) - { + // Now we iterate through the scanlines. We must tell emitRow the coord + // of the first non-transparent pixel, so we must keep accumulators for + // the first and last pixels of the section of the current pixel row + // that we will emit. + // We also need to accumulate pix_bbox*, but the iterator does it + // for us. We will just get the values from it once this loop is done + int pix_maxX = Integer.MIN_VALUE; + int pix_minX = Integer.MAX_VALUE; - int x0 = edges[0] >> XSHIFT; - int y0 = edges[1] >> YSHIFT; - int x1 = edges[5] >> XSHIFT; - int y1 = edges[3] >> YSHIFT; + int y = boundsMinY; // needs to be declared here so we emit the last row properly. + ScanLineItInitialize(); + for ( ; ScanLineItHasNext(); ) { + int numCrossings = ScanLineItGoToNextYAndComputeCrossings(); + y = ScanLineItCurrentY(); - if (x0 > x1) { - int tmp = x0; - x0 = x1; - x1 = tmp; - } - if (y0 > y1) { - int tmp = y0; - y0 = y1; - y1 = tmp; + if (numCrossings > 0) { + int lowx = crossings[0] >> 1; + int highx = crossings[numCrossings - 1] >> 1; + int x0 = Math.max(lowx, boundsMinX); + int x1 = Math.min(highx, boundsMaxX); + + pix_minX = Math.min(pix_minX, x0 >> SUBPIXEL_LG_POSITIONS_X); + pix_maxX = Math.max(pix_maxX, x1 >> SUBPIXEL_LG_POSITIONS_X); } - int bMinX = this.boundsMinX >> XSHIFT; - int bMinY = this.boundsMinY >> YSHIFT; - int bMaxX = this.boundsMaxX >> XSHIFT; - int bMaxY = this.boundsMaxY >> YSHIFT; + int sum = 0; + int prev = boundsMinX; + for (int i = 0; i < numCrossings; i++) { + int curxo = crossings[i]; + int curx = curxo >> 1; + int crorientation = ((curxo & 0x1) == 0x1) ? 1 : -1; + if ((sum & mask) != 0) { + int x0 = Math.max(prev, boundsMinX); + int x1 = Math.min(curx, boundsMaxX); + if (x0 < x1) { + x0 -= boundsMinX; // turn x0, x1 from coords to indeces + x1 -= boundsMinX; // in the alpha array. - // Clip to image bounds in supersampled coordinates - x0 = clamp(x0, bMinX, bMaxX); - x1 = clamp(x1, bMinX, bMaxX); - y0 = clamp(y0, bMinY, bMaxY); - y1 = clamp(y1, bMinY, bMaxY); + int pix_x = x0 >> SUBPIXEL_LG_POSITIONS_X; + int pix_xmaxm1 = (x1 - 1) >> SUBPIXEL_LG_POSITIONS_X; - /* - * REMIND: Need to fill the cache here instead... - Blit.fillRectSrcOver(this, - imageData, imageType, - imageOffset, - imageScanlineStride, imagePixelStride, - width, height, - x0, y0, x1, y1, - cred, cgreen, cblue); - */ + if (pix_x == pix_xmaxm1) { + // Start and end in same pixel + alpha[pix_x] += (x1 - x0); + alpha[pix_x+1] -= (x1 - x0); + } else { + int pix_xmax = x1 >> SUBPIXEL_LG_POSITIONS_X; + alpha[pix_x] += SUBPIXEL_POSITIONS_X - (x0 & SUBPIXEL_MASK_X); + alpha[pix_x+1] += (x0 & SUBPIXEL_MASK_X); + alpha[pix_xmax] -= SUBPIXEL_POSITIONS_X - (x1 & SUBPIXEL_MASK_X); + alpha[pix_xmax+1] -= (x1 & SUBPIXEL_MASK_X); + } + } + } + sum += crorientation; + prev = curx; + } - bboxX0 = x0 >> SUBPIXEL_LG_POSITIONS_X; - bboxY0 = y0 >> SUBPIXEL_LG_POSITIONS_Y; - bboxX1 = (x1 + SUBPIXEL_POSITIONS_X - 1) - >> SUBPIXEL_LG_POSITIONS_X; - bboxY1 = (y1 + SUBPIXEL_POSITIONS_Y - 1) - >> SUBPIXEL_LG_POSITIONS_Y; - - return; - } - - int minY = (edgeMinY > boundsMinY) ? edgeMinY : boundsMinY; - int maxY = (edgeMaxY < boundsMaxY) ? edgeMaxY : boundsMaxY; - - // Check for empty intersection of primitive with the drawing area - if (minY > maxY) { - bboxX0 = bboxY0 = 0; - bboxX1 = bboxY1 = -1; - return; + if ((y & SUBPIXEL_MASK_Y) == SUBPIXEL_MASK_Y) { + emitRow(alpha, y >> SUBPIXEL_LG_POSITIONS_Y, pix_minX, pix_maxX); + pix_minX = Integer.MAX_VALUE; + pix_maxX = Integer.MIN_VALUE; + } } - // Compute Y extent in subpixel coordinates - int iminY = (minY >> YSHIFT) & ~SUBPIXEL_MASK_Y; - int imaxY = (maxY >> YSHIFT) | SUBPIXEL_MASK_Y; - int yextent = (imaxY - iminY) + 1; - - // Maximum number of crossings - int size = flips*yextent; - - int bmax = (boundsMaxY >> YSHIFT) - 1; - if (imaxY > bmax) { - imaxY = bmax; + // Emit final row + if (pix_maxX >= pix_minX) { + emitRow(alpha, y >> SUBPIXEL_LG_POSITIONS_Y, pix_minX, pix_maxX); } - - // Initialize X bounds, will be refined for each strip - bboxX0 = Integer.MAX_VALUE; - bboxX1 = Integer.MIN_VALUE; - - // Set Y bounds - bboxY0 = iminY >> SUBPIXEL_LG_POSITIONS_Y; - bboxY1 = (imaxY + SUBPIXEL_POSITIONS_Y - 1) >> SUBPIXEL_LG_POSITIONS_Y; - - // Compute number of rows that can be processing using - // a crossings table no larger than DEFAULT_CROSSINGS_SIZE. - // However, we must process at least one row, so we grow the table - // temporarily if needed. This would require an object with a - // huge number of flips. - int rows = DEFAULT_CROSSINGS_SIZE/(flips*SUBPIXEL_POSITIONS_Y); - rows = Math.min(rows, yextent); - rows = Math.max(rows, 1); - for (int i = iminY; i <= imaxY; i += rows*SUBPIXEL_POSITIONS_Y) { - // Compute index of last scanline to be processed in this pass - int last = Math.min(i + rows*SUBPIXEL_POSITIONS_Y - 1, imaxY); - setCrossingsExtents(i, last, flips); - - int bminY = i << YSHIFT; - int bmaxY = (last << YSHIFT) | ~YMASK; + pix_bboxX0 = minX >> SUBPIXEL_LG_POSITIONS_X; + pix_bboxX1 = maxX >> SUBPIXEL_LG_POSITIONS_X; + pix_bboxY0 = minY >> SUBPIXEL_LG_POSITIONS_Y; + pix_bboxY1 = maxY >> SUBPIXEL_LG_POSITIONS_Y; + } - // Process edges from the edge list - int maxIdx = edgeIdx; - for (int index = 0; index < maxIdx; index += 5) { - // Test y1 < min: - // - // If edge lies entirely above current strip, - // discard it - if (edges[index + 3] < bminY) { - // Overwrite the edge with the last edge - edgeIdx -= 5; - int fidx = edgeIdx; - int tidx = index; - edges[tidx++] = edges[fidx++]; - edges[tidx++] = edges[fidx++]; - edges[tidx++] = edges[fidx++]; - edges[tidx++] = edges[fidx++]; - edges[tidx ] = edges[fidx ]; - - maxIdx -= 5; - index -= 5; - continue; - } - - // Test y0 > max: - // - // If edge lies entirely below current strip, - // skip it for now - if (edges[index + 1] > bmaxY) { - continue; - } - - computeCrossingsForEdge(index, bminY, bmaxY); - } - - computeBounds(); - if (rasterMaxX < rasterMinX) { - continue; - } - - bboxX0 = Math.min(bboxX0, - rasterMinX >> SUBPIXEL_LG_POSITIONS_X); - bboxX1 = Math.max(bboxX1, - (rasterMaxX + SUBPIXEL_POSITIONS_X - 1) - >> SUBPIXEL_LG_POSITIONS_X); - renderStrip(); - } - - // Free up any unusually large scratchpad memory used by the - // preceding primitive - crossingListFinished(); - } public void endRendering() { // Set up the cache to accumulate the bounding box @@ -478,176 +472,31 @@ _endRendering(); } - public void getBoundingBox(int[] bbox) { - bbox[0] = bboxX0; - bbox[1] = bboxY0; - bbox[2] = bboxX1 - bboxX0; - bbox[3] = bboxY1 - bboxY0; + public void getBoundingBox(int[] pix_bbox) { + pix_bbox[0] = pix_bboxX0; + pix_bbox[1] = pix_bboxY0; + pix_bbox[2] = pix_bboxX1 - pix_bboxX0; + pix_bbox[3] = pix_bboxY1 - pix_bboxY0; } - private void renderStrip() { - // Grow rowAA according to the raster width - int width = (rasterMaxX - rasterMinX + 1) >> SUBPIXEL_LG_POSITIONS_X; - alphaWidth = width; - - // Allocate one extra entry in rowAA to avoid a conditional in - // the rendering loop - int bufLen = width + 1; - if (this.rowAA == null || this.rowAA.length < bufLen) { - this.rowAA = new byte[bufLen]; - } - - // Mask to determine the relevant bit of the crossing sum - // 0x1 if EVEN_ODD, all bits if NON_ZERO - int mask = (windingRule == WIND_EVEN_ODD) ? 0x1 : ~0x0; - - int y = 0; - int prevY = rasterMinY - 1; - - int minX = Integer.MAX_VALUE; - int maxX = Integer.MIN_VALUE; - - iterateCrossings(); - while (hasMoreCrossingRows()) { - y = crossingY; - - // Emit any skipped rows - for (int j = prevY + 1; j < y; j++) { - if (((j & SUBPIXEL_MASK_Y) == SUBPIXEL_MASK_Y) || - (j == rasterMaxY)) { - emitRow(j >> SUBPIXEL_LG_POSITIONS_Y, 0, -1); - } - } - prevY = y; - - if (crossingRowIndex < crossingRowCount) { - int lx = crossings[crossingRowOffset + crossingRowIndex]; - lx >>= 1; - int hx = crossings[crossingRowOffset + crossingRowCount - 1]; - hx >>= 1; - int x0 = lx > rasterMinX ? lx : rasterMinX; - int x1 = hx < rasterMaxX ? hx : rasterMaxX; - x0 -= rasterMinX; - x1 -= rasterMinX; - - minX = Math.min(minX, x0 >> SUBPIXEL_LG_POSITIONS_X); - maxX = Math.max(maxX, x1 >> SUBPIXEL_LG_POSITIONS_X); - } - - int sum = 0; - int prev = rasterMinX; - while (crossingRowIndex < crossingRowCount) { - int crxo = crossings[crossingRowOffset + crossingRowIndex]; - crossingRowIndex++; - - int crx = crxo >> 1; - int crorientation = ((crxo & 0x1) == 0x1) ? 1 : -1; - - if ((sum & mask) != 0) { - // Clip to active X range, if x1 < x0 loop will - // have no effect - int x0 = prev > rasterMinX ? prev : rasterMinX; - int x1 = crx < rasterMaxX ? crx : rasterMaxX; - - // Empty spans - if (x1 > x0) { - x0 -= rasterMinX; - x1 -= rasterMinX; - - // Accumulate alpha, equivalent to: - // for (int x = x0; x < x1; x++) { - // ++rowAA[x >> SUBPIXEL_LG_POSITIONS_X]; - // } - // - // In the middle of the span, we can update a full - // pixel at a time (i.e., SUBPIXEL_POSITIONS_X - // subpixels) - - int x = x0 >> SUBPIXEL_LG_POSITIONS_X; - int xmaxm1 = (x1 - 1) >> SUBPIXEL_LG_POSITIONS_X; - if (x == xmaxm1) { - // Start and end in same pixel - rowAA[x] += x1 - x0; - } else { - // Start and end in different pixels - rowAA[x++] += SUBPIXEL_POSITIONS_X - - (x0 & SUBPIXEL_MASK_X); - int xmax = x1 >> SUBPIXEL_LG_POSITIONS_X; - while (x < xmax) { - rowAA[x++] += SUBPIXEL_POSITIONS_X; - } - // Note - at this point it is possible that - // x == width, which implies that - // x1 & SUBPIXEL_MASK_X == 0. We allocate - // one extra entry in rowAA so this - // assignment will be harmless. The alternative - // is an extra conditional here, or some other - // scheme to deal with the last pixel better. - rowAA[x] += x1 & SUBPIXEL_MASK_X; - } - } - } - sum += crorientation; - prev = crx; - } - - // Every SUBPIXEL_POSITIONS rows, output an antialiased row - if (((y & SUBPIXEL_MASK_Y) == SUBPIXEL_MASK_Y) || - (y == rasterMaxY)) { - emitRow(y >> SUBPIXEL_LG_POSITIONS_Y, minX, maxX); - minX = Integer.MAX_VALUE; - maxX = Integer.MIN_VALUE; - } - } - - // Emit final row - for (int j = prevY + 1; j <= rasterMaxY; j++) { - if (((j & SUBPIXEL_MASK_Y) == SUBPIXEL_MASK_Y) || - (j == rasterMaxY)) { - emitRow(j >> SUBPIXEL_LG_POSITIONS_Y, minX, maxX); - minX = Integer.MAX_VALUE; - maxX = Integer.MIN_VALUE; - } - } - } - - private void clearAlpha(byte[] alpha, - int width, - int minX, int maxX) { - if (maxX >= minX) { - int w = maxX - minX + 1; - if (w + minX > width) { - w = width - minX; - } - - int aidx = minX; - for (int i = 0; i < w; i++, aidx++) { - alpha[aidx] = (byte)0; - } - } - } - - private void emitRow(int y, int minX, int maxX) { + private void emitRow(byte[] alphaRow, int pix_y, int pix_from, int pix_to) { // Copy rowAA data into the cache if one is present if (cache != null) { - if (maxX >= minX) { - int x0 = minX + (rasterMinX >> SUBPIXEL_LG_POSITIONS_X); - int x1 = maxX + (rasterMinX >> SUBPIXEL_LG_POSITIONS_X); + if (pix_to >= pix_from) { + cache.startRow(pix_y, pix_from, pix_to); - cache.startRow(y, x0, x1); - int srcIdx = minX; + // Perform run-length encoding and store results in the cache + int from = pix_from - (boundsMinX >> SUBPIXEL_LG_POSITIONS_X); + int to = pix_to - (boundsMinX >> SUBPIXEL_LG_POSITIONS_X); - // Perform run-length encoding - // and store results in the cache - byte startVal = rowAA[srcIdx++]; int runLen = 1; - while (srcIdx <= maxX) { - byte nextVal = rowAA[srcIdx++]; + byte startVal = alphaRow[from]; + for (int i = from + 1; i <= to; i++) { + byte nextVal = (byte)(startVal + alphaRow[i]); if (nextVal == startVal && runLen < 255) { - ++runLen; + runLen++; } else { cache.addRLERun(startVal, runLen); - runLen = 1; startVal = nextVal; } @@ -656,190 +505,6 @@ cache.addRLERun((byte)0, 0); } } - - clearAlpha(rowAA, - alphaWidth, - minX, maxX); - } - - public void setCache(PiscesCache cache) { - this.cache = cache; - } - - // Edge list data - - private int[] edges = new int[5*INITIAL_EDGES]; - private int edgeIdx = 0; - private int edgeMinY = Integer.MAX_VALUE; - private int edgeMaxY = Integer.MIN_VALUE; - - private void addEdge(int x0, int y0, int x1, int y1) { - int newLen = edgeIdx + 5; - if (edges.length < newLen) { - int[] tmp = new int[Math.max(11*edges.length/10, newLen)]; - System.arraycopy(edges, 0, tmp, 0, edgeIdx); - this.edges = tmp; - } - - int orientation = 1; - if (y0 > y1) { - int tmp = y0; - y0 = y1; - y1 = tmp; - - orientation = -1; - } - - // Skip edges that don't cross a subsampled scanline - int eminY = ((y0 + HYSTEP) & YMASK); - int emaxY = ((y1 - HYSTEP) & YMASK); - if (eminY > emaxY) { - return; - } - - if (orientation == -1) { - int tmp = x0; - x0 = x1; - x1 = tmp; - } - - edges[edgeIdx++] = x0; - edges[edgeIdx++] = y0; - edges[edgeIdx++] = x1; - edges[edgeIdx++] = y1; - edges[edgeIdx++] = orientation; - - // Update Y bounds of primitive - if (y0 < edgeMinY) { - edgeMinY = y0; - } - if (y1 > edgeMaxY) { - edgeMaxY = y1; - } - } - - private void resetEdges() { - this.edgeIdx = 0; - this.edgeMinY = Integer.MAX_VALUE; - this.edgeMaxY = Integer.MIN_VALUE; - } - - // Crossing list data - - private int[] crossingIndices; - private int[] crossings; - private int crossingMinY; - private int crossingMaxY; - private int crossingMinX = Integer.MAX_VALUE; - private int crossingMaxX = Integer.MIN_VALUE; - private int crossingMaxXEntries; - private int numCrossings = 0; - private boolean crossingsSorted = false; - - private int crossingY; - private int crossingRowCount; - private int crossingRowOffset; - private int crossingRowIndex; - - private void setCrossingsExtents(int minY, int maxY, int maxXEntries) { - int yextent = maxY - minY + 1; - - // Grow indices array as needed - if (crossingIndices == null || crossingIndices.length < yextent) { - this.crossingIndices = - new int[Math.max(yextent, DEFAULT_INDICES_SIZE)]; - } - // Grow crossings array as needed - if (crossings == null || crossings.length < yextent*maxXEntries) { - this.crossings = new int[Math.max(yextent*maxXEntries, - DEFAULT_CROSSINGS_SIZE)]; - } - this.crossingMinY = minY; - this.crossingMaxY = maxY; - this.crossingMaxXEntries = maxXEntries; - resetCrossings(); - } - - private void resetCrossings() { - int yextent = crossingMaxY - crossingMinY + 1; - int start = 0; - for (int i = 0; i < yextent; i++) { - crossingIndices[i] = start; - start += crossingMaxXEntries; - } - crossingMinX = Integer.MAX_VALUE; - crossingMaxX = Integer.MIN_VALUE; - numCrossings = 0; - crossingsSorted = false; - } - - // Free sorting arrays if larger than maximum size - private void crossingListFinished() { - if (crossings != null && crossings.length > DEFAULT_CROSSINGS_SIZE) { - crossings = new int[DEFAULT_CROSSINGS_SIZE]; - } - if (crossingIndices != null && - crossingIndices.length > DEFAULT_INDICES_SIZE) - { - crossingIndices = new int[DEFAULT_INDICES_SIZE]; - } - } - - private void sortCrossings(int[] x, int off, int len) { - for (int i = off + 1; i < off + len; i++) { - int j = i; - int xj = x[j]; - int xjm1; - - while (j > off && (xjm1 = x[j - 1]) > xj) { - x[j] = xjm1; - x[j - 1] = xj; - j--; - } - } - } - - private void sortCrossings() { - int start = 0; - for (int i = 0; i <= crossingMaxY - crossingMinY; i++) { - sortCrossings(crossings, start, crossingIndices[i] - start); - start += crossingMaxXEntries; - } - } - - private void addCrossing(int y, int x, int orientation) { - if (x < crossingMinX) { - crossingMinX = x; - } - if (x > crossingMaxX) { - crossingMaxX = x; - } - - int index = crossingIndices[y - crossingMinY]++; - x <<= 1; - crossings[index] = (orientation == 1) ? (x | 0x1) : x; - - ++numCrossings; - } - - private void iterateCrossings() { - if (!crossingsSorted) { - sortCrossings(); - crossingsSorted = true; - } - crossingY = crossingMinY - 1; - crossingRowOffset = -crossingMaxXEntries; - } - - private boolean hasMoreCrossingRows() { - if (++crossingY <= crossingMaxY) { - crossingRowOffset += crossingMaxXEntries; - int y = crossingY - crossingMinY; - crossingRowCount = crossingIndices[y] - y*crossingMaxXEntries; - crossingRowIndex = 0; - return true; - } else { - return false; - } + java.util.Arrays.fill(alphaRow, (byte)0); } }
--- a/src/share/classes/sun/java2d/pisces/Stroker.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/java2d/pisces/Stroker.java Thu Sep 02 22:11:05 2010 -0700 @@ -25,7 +25,7 @@ package sun.java2d.pisces; -public class Stroker extends LineSink { +public class Stroker implements LineSink { private static final int MOVE_TO = 0; private static final int LINE_TO = 1; @@ -61,19 +61,15 @@ */ public static final int CAP_SQUARE = 2; - LineSink output; + private final LineSink output; - int lineWidth; - int capStyle; - int joinStyle; - int miterLimit; + private final int capStyle; + private final int joinStyle; - Transform4 transform; - int m00, m01; - int m10, m11; + private final float m00, m01, m10, m11, det; - int lineWidth2; - long scaledLineWidth2; + private final float lineWidth2; + private final float scaledLineWidth2; // For any pen offset (pen_dx, pen_dy) that does not depend on // the line orientation, the pen should be transformed so that: @@ -88,143 +84,86 @@ // // pen_dx'(r, theta) = r*(m00*cos(theta) + m01*sin(theta)) // pen_dy'(r, theta) = r*(m10*cos(theta) + m11*sin(theta)) - int numPenSegments; - int[] pen_dx; - int[] pen_dy; - boolean[] penIncluded; - int[] join; + private int numPenSegments; + private final float[] pen_dx; + private final float[] pen_dy; + private boolean[] penIncluded; + private final float[] join; - int[] offset = new int[2]; - int[] reverse = new int[100]; - int[] miter = new int[2]; - long miterLimitSq; + private final float[] offset = new float[2]; + private float[] reverse = new float[100]; + private final float[] miter = new float[2]; + private final float miterLimitSq; - int prev; - int rindex; - boolean started; - boolean lineToOrigin; - boolean joinToOrigin; - - int sx0, sy0, sx1, sy1, x0, y0, x1, y1; - int mx0, my0, mx1, my1, omx, omy; - int lx0, ly0, lx1, ly1, lx0p, ly0p, px0, py0; + private int prev; + private int rindex; + private boolean started; + private boolean lineToOrigin; + private boolean joinToOrigin; - double m00_2_m01_2; - double m10_2_m11_2; - double m00_m10_m01_m11; + private float sx0, sy0, sx1, sy1, x0, y0, px0, py0; + private float mx0, my0, omx, omy; - /** - * Empty constructor. <code>setOutput</code> and - * <code>setParameters</code> must be called prior to calling any - * other methods. - */ - public Stroker() {} + private float m00_2_m01_2; + private float m10_2_m11_2; + private float m00_m10_m01_m11; /** * Constructs a <code>Stroker</code>. * * @param output an output <code>LineSink</code>. - * @param lineWidth the desired line width in pixels, in S15.16 - * format. + * @param lineWidth the desired line width in pixels * @param capStyle the desired end cap style, one of * <code>CAP_BUTT</code>, <code>CAP_ROUND</code> or * <code>CAP_SQUARE</code>. * @param joinStyle the desired line join style, one of * <code>JOIN_MITER</code>, <code>JOIN_ROUND</code> or * <code>JOIN_BEVEL</code>. - * @param miterLimit the desired miter limit, in S15.16 format. + * @param miterLimit the desired miter limit * @param transform a <code>Transform4</code> object indicating * the transform that has been previously applied to all incoming * coordinates. This is required in order to produce consistently * shaped end caps and joins. */ public Stroker(LineSink output, - int lineWidth, + float lineWidth, int capStyle, int joinStyle, - int miterLimit, - Transform4 transform) { - setOutput(output); - setParameters(lineWidth, capStyle, joinStyle, miterLimit, transform); - } - - /** - * Sets the output <code>LineSink</code> of this - * <code>Stroker</code>. - * - * @param output an output <code>LineSink</code>. - */ - public void setOutput(LineSink output) { + float miterLimit, + float m00, float m01, float m10, float m11) { this.output = output; - } - /** - * Sets the parameters of this <code>Stroker</code>. - * @param lineWidth the desired line width in pixels, in S15.16 - * format. - * @param capStyle the desired end cap style, one of - * <code>CAP_BUTT</code>, <code>CAP_ROUND</code> or - * <code>CAP_SQUARE</code>. - * @param joinStyle the desired line join style, one of - * <code>JOIN_MITER</code>, <code>JOIN_ROUND</code> or - * <code>JOIN_BEVEL</code>. - * @param miterLimit the desired miter limit, in S15.16 format. - * @param transform a <code>Transform4</code> object indicating - * the transform that has been previously applied to all incoming - * coordinates. This is required in order to produce consistently - * shaped end caps and joins. - */ - public void setParameters(int lineWidth, - int capStyle, - int joinStyle, - int miterLimit, - Transform4 transform) { - this.lineWidth = lineWidth; - this.lineWidth2 = lineWidth >> 1; - this.scaledLineWidth2 = ((long)transform.m00*lineWidth2) >> 16; + this.lineWidth2 = lineWidth / 2; + this.scaledLineWidth2 = m00 * lineWidth2; this.capStyle = capStyle; this.joinStyle = joinStyle; - this.miterLimit = miterLimit; - this.transform = transform; - this.m00 = transform.m00; - this.m01 = transform.m01; - this.m10 = transform.m10; - this.m11 = transform.m11; - - this.m00_2_m01_2 = (double)m00*m00 + (double)m01*m01; - this.m10_2_m11_2 = (double)m10*m10 + (double)m11*m11; - this.m00_m10_m01_m11 = (double)m00*m10 + (double)m01*m11; + m00_2_m01_2 = m00*m00 + m01*m01; + m10_2_m11_2 = m10*m10 + m11*m11; + m00_m10_m01_m11 = m00*m10 + m01*m11; - double dm00 = m00/65536.0; - double dm01 = m01/65536.0; - double dm10 = m10/65536.0; - double dm11 = m11/65536.0; - double determinant = dm00*dm11 - dm01*dm10; + this.m00 = m00; + this.m01 = m01; + this.m10 = m10; + this.m11 = m11; + det = m00*m11 - m01*m10; - if (joinStyle == JOIN_MITER) { - double limit = - (miterLimit/65536.0)*(lineWidth2/65536.0)*determinant; - double limitSq = limit*limit; - this.miterLimitSq = (long)(limitSq*65536.0*65536.0); - } + float limit = miterLimit * lineWidth2 * det; + this.miterLimitSq = limit*limit; - this.numPenSegments = (int)(3.14159f*lineWidth/65536.0f); - if (pen_dx == null || pen_dx.length < numPenSegments) { - this.pen_dx = new int[numPenSegments]; - this.pen_dy = new int[numPenSegments]; - this.penIncluded = new boolean[numPenSegments]; - this.join = new int[2*numPenSegments]; - } + this.numPenSegments = (int)(3.14159f * lineWidth); + this.pen_dx = new float[numPenSegments]; + this.pen_dy = new float[numPenSegments]; + this.penIncluded = new boolean[numPenSegments]; + this.join = new float[2*numPenSegments]; for (int i = 0; i < numPenSegments; i++) { - double r = lineWidth/2.0; - double theta = (double)i*2.0*Math.PI/numPenSegments; + double theta = (i * 2.0 * Math.PI)/numPenSegments; double cos = Math.cos(theta); double sin = Math.sin(theta); - pen_dx[i] = (int)(r*(dm00*cos + dm01*sin)); - pen_dy[i] = (int)(r*(dm10*cos + dm11*sin)); + pen_dx[i] = (float)(lineWidth2 * (m00*cos + m01*sin)); + pen_dy[i] = (float)(lineWidth2 * (m10*cos + m11*sin)); } prev = CLOSE; @@ -233,32 +172,31 @@ lineToOrigin = false; } - private void computeOffset(int x0, int y0, int x1, int y1, int[] m) { - long lx = (long)x1 - (long)x0; - long ly = (long)y1 - (long)y0; + private void computeOffset(float x0, float y0, + float x1, float y1, float[] m) { + float lx = x1 - x0; + float ly = y1 - y0; - int dx, dy; + float dx, dy; if (m00 > 0 && m00 == m11 && m01 == 0 & m10 == 0) { - long ilen = PiscesMath.hypot(lx, ly); + float ilen = (float)Math.hypot(lx, ly); if (ilen == 0) { dx = dy = 0; } else { - dx = (int)( (ly*scaledLineWidth2)/ilen); - dy = (int)(-(lx*scaledLineWidth2)/ilen); + dx = (ly * scaledLineWidth2)/ilen; + dy = -(lx * scaledLineWidth2)/ilen; } } else { - double dlx = x1 - x0; - double dly = y1 - y0; - double det = (double)m00*m11 - (double)m01*m10; int sdet = (det > 0) ? 1 : -1; - double a = dly*m00 - dlx*m10; - double b = dly*m01 - dlx*m11; - double dh = PiscesMath.hypot(a, b); - double div = sdet*lineWidth2/(65536.0*dh); - double ddx = dly*m00_2_m01_2 - dlx*m00_m10_m01_m11; - double ddy = dly*m00_m10_m01_m11 - dlx*m10_2_m11_2; - dx = (int)(ddx*div); - dy = (int)(ddy*div); + float a = ly * m00 - lx * m10; + float b = ly * m01 - lx * m11; + float dh = (float)Math.hypot(a, b); + float div = sdet * lineWidth2/dh; + + float ddx = ly * m00_2_m01_2 - lx * m00_m10_m01_m11; + float ddy = ly * m00_m10_m01_m11 - lx * m10_2_m11_2; + dx = ddx*div; + dy = ddy*div; } m[0] = dx; @@ -267,58 +205,43 @@ private void ensureCapacity(int newrindex) { if (reverse.length < newrindex) { - int[] tmp = new int[Math.max(newrindex, 6*reverse.length/5)]; - System.arraycopy(reverse, 0, tmp, 0, rindex); - this.reverse = tmp; + reverse = java.util.Arrays.copyOf(reverse, 6*reverse.length/5); } } - private boolean isCCW(int x0, int y0, - int x1, int y1, - int x2, int y2) { - int dx0 = x1 - x0; - int dy0 = y1 - y0; - int dx1 = x2 - x1; - int dy1 = y2 - y1; - return (long)dx0*dy1 < (long)dy0*dx1; + private boolean isCCW(float x0, float y0, + float x1, float y1, + float x2, float y2) { + return (x1 - x0) * (y2 - y1) < (y1 - y0) * (x2 - x1); } - private boolean side(int x, int y, int x0, int y0, int x1, int y1) { - long lx = x; - long ly = y; - long lx0 = x0; - long ly0 = y0; - long lx1 = x1; - long ly1 = y1; - - return (ly0 - ly1)*lx + (lx1 - lx0)*ly + (lx0*ly1 - lx1*ly0) > 0; + private boolean side(float x, float y, + float x0, float y0, + float x1, float y1) { + return (y0 - y1)*x + (x1 - x0)*y + (x0*y1 - x1*y0) > 0; } - private int computeRoundJoin(int cx, int cy, - int xa, int ya, - int xb, int yb, + private int computeRoundJoin(float cx, float cy, + float xa, float ya, + float xb, float yb, int side, boolean flip, - int[] join) { - int px, py; + float[] join) { + float px, py; int ncoords = 0; boolean centerSide; if (side == 0) { centerSide = side(cx, cy, xa, ya, xb, yb); } else { - centerSide = (side == 1) ? true : false; + centerSide = (side == 1); } for (int i = 0; i < numPenSegments; i++) { px = cx + pen_dx[i]; py = cy + pen_dy[i]; boolean penSide = side(px, py, xa, ya, xb, yb); - if (penSide != centerSide) { - penIncluded[i] = true; - } else { - penIncluded[i] = false; - } + penIncluded[i] = (penSide != centerSide); } int start = -1, end = -1; @@ -338,10 +261,10 @@ } if (start != -1 && end != -1) { - long dxa = cx + pen_dx[start] - xa; - long dya = cy + pen_dy[start] - ya; - long dxb = cx + pen_dx[start] - xb; - long dyb = cy + pen_dy[start] - yb; + float dxa = cx + pen_dx[start] - xa; + float dya = cy + pen_dy[start] - ya; + float dxb = cx + pen_dx[start] - xb; + float dyb = cy + pen_dy[start] - yb; boolean rev = (dxa*dxa + dya*dya > dxb*dxb + dyb*dyb); int i = rev ? end : start; @@ -362,22 +285,25 @@ return ncoords/2; } - private static final long ROUND_JOIN_THRESHOLD = 1000L; - private static final long ROUND_JOIN_INTERNAL_THRESHOLD = 1000000000L; + // pisces used to use fixed point arithmetic with 16 decimal digits. I + // didn't want to change the values of the constants below when I converted + // it to floating point, so that's why the divisions by 2^16 are there. + private static final float ROUND_JOIN_THRESHOLD = 1000/65536f; + private static final float ROUND_JOIN_INTERNAL_THRESHOLD = 1000000000/65536f; - private void drawRoundJoin(int x, int y, - int omx, int omy, int mx, int my, + private void drawRoundJoin(float x, float y, + float omx, float omy, float mx, float my, int side, boolean flip, boolean rev, - long threshold) { + float threshold) { if ((omx == 0 && omy == 0) || (mx == 0 && my == 0)) { return; } - long domx = (long)omx - mx; - long domy = (long)omy - my; - long len = domx*domx + domy*domy; + float domx = omx - mx; + float domy = omy - my; + float len = domx*domx + domy*domy; if (len < threshold) { return; } @@ -389,10 +315,10 @@ my = -my; } - int bx0 = x + omx; - int by0 = y + omy; - int bx1 = x + mx; - int by1 = y + my; + float bx0 = x + omx; + float by0 = y + omy; + float bx1 = x + mx; + float by1 = y + my; int npoints = computeRoundJoin(x, y, bx0, by0, bx1, by1, side, flip, @@ -404,40 +330,30 @@ // Return the intersection point of the lines (ix0, iy0) -> (ix1, iy1) // and (ix0p, iy0p) -> (ix1p, iy1p) in m[0] and m[1] - private void computeMiter(int ix0, int iy0, int ix1, int iy1, - int ix0p, int iy0p, int ix1p, int iy1p, - int[] m) { - long x0 = ix0; - long y0 = iy0; - long x1 = ix1; - long y1 = iy1; + private void computeMiter(float x0, float y0, float x1, float y1, + float x0p, float y0p, float x1p, float y1p, + float[] m) { + float x10 = x1 - x0; + float y10 = y1 - y0; + float x10p = x1p - x0p; + float y10p = y1p - y0p; - long x0p = ix0p; - long y0p = iy0p; - long x1p = ix1p; - long y1p = iy1p; - - long x10 = x1 - x0; - long y10 = y1 - y0; - long x10p = x1p - x0p; - long y10p = y1p - y0p; - - long den = (x10*y10p - x10p*y10) >> 16; + float den = x10*y10p - x10p*y10; if (den == 0) { - m[0] = ix0; - m[1] = iy0; + m[0] = x0; + m[1] = y0; return; } - long t = (x1p*(y0 - y0p) - x0*y10p + x0p*(y1p - y0)) >> 16; - m[0] = (int)(x0 + (t*x10)/den); - m[1] = (int)(y0 + (t*y10)/den); + float t = x1p*(y0 - y0p) - x0*y10p + x0p*(y1p - y0); + m[0] = x0 + (t*x10)/den; + m[1] = y0 + (t*y10)/den; } - private void drawMiter(int px0, int py0, - int x0, int y0, - int x1, int y1, - int omx, int omy, int mx, int my, + private void drawMiter(float px0, float py0, + float x0, float y0, + float x1, float y1, + float omx, float omy, float mx, float my, boolean rev) { if (mx == omx && my == omy) { return; @@ -461,11 +377,11 @@ miter); // Compute miter length in untransformed coordinates - long dx = (long)miter[0] - x0; - long dy = (long)miter[1] - y0; - long a = (dy*m00 - dx*m10) >> 16; - long b = (dy*m01 - dx*m11) >> 16; - long lenSq = a*a + b*b; + float dx = miter[0] - x0; + float dy = miter[1] - y0; + float a = dy*m00 - dx*m10; + float b = dy*m01 - dx*m11; + float lenSq = a*a + b*b; if (lenSq < miterLimitSq) { emitLineTo(miter[0], miter[1], rev); @@ -473,7 +389,7 @@ } - public void moveTo(int x0, int y0) { + public void moveTo(float x0, float y0) { // System.out.println("Stroker.moveTo(" + x0/65536.0 + ", " + y0/65536.0 + ")"); if (lineToOrigin) { @@ -501,7 +417,7 @@ this.joinSegment = true; } - public void lineTo(int x1, int y1) { + public void lineTo(float x1, float y1) { // System.out.println("Stroker.lineTo(" + x1/65536.0 + ", " + y1/65536.0 + ")"); if (lineToOrigin) { @@ -526,10 +442,10 @@ joinSegment = false; } - private void lineToImpl(int x1, int y1, boolean joinSegment) { + private void lineToImpl(float x1, float y1, boolean joinSegment) { computeOffset(x0, y0, x1, y1, offset); - int mx = offset[0]; - int my = offset[1]; + float mx = offset[0]; + float my = offset[1]; if (!started) { emitMoveTo(x0 + mx, y0 + my); @@ -567,10 +483,6 @@ emitLineTo(x0 - mx, y0 - my, true); emitLineTo(x1 - mx, y1 - my, true); - lx0 = x1 + mx; ly0 = y1 + my; - lx0p = x1 - mx; ly0p = y1 - my; - lx1 = x1; ly1 = y1; - this.omx = mx; this.omy = my; this.px0 = x0; @@ -594,8 +506,8 @@ } computeOffset(x0, y0, sx0, sy0, offset); - int mx = offset[0]; - int my = offset[1]; + float mx = offset[0]; + float my = offset[1]; // Draw penultimate join boolean ccw = isCCW(px0, py0, x0, y0, sx0, sy0); @@ -678,12 +590,10 @@ this.prev = MOVE_TO; } - long lineLength(long ldx, long ldy) { - long ldet = ((long)m00*m11 - (long)m01*m10) >> 16; - long la = ((long)ldy*m00 - (long)ldx*m10)/ldet; - long lb = ((long)ldy*m01 - (long)ldx*m11)/ldet; - long llen = (int)PiscesMath.hypot(la, lb); - return llen; + double userSpaceLineLength(double dx, double dy) { + double a = (dy*m00 - dx*m10)/det; + double b = (dy*m01 - dx*m11)/det; + return Math.hypot(a, b); } private void finish() { @@ -692,13 +602,13 @@ omx, omy, -omx, -omy, 1, false, false, ROUND_JOIN_THRESHOLD); } else if (capStyle == CAP_SQUARE) { - long ldx = (long)(px0 - x0); - long ldy = (long)(py0 - y0); - long llen = lineLength(ldx, ldy); - long s = (long)lineWidth2*65536/llen; + float dx = px0 - x0; + float dy = py0 - y0; + float len = (float)userSpaceLineLength(dx, dy); + float s = lineWidth2/len; - int capx = x0 - (int)(ldx*s >> 16); - int capy = y0 - (int)(ldy*s >> 16); + float capx = x0 - dx*s; + float capy = y0 - dy*s; emitLineTo(capx + omx, capy + omy); emitLineTo(capx - omx, capy - omy); @@ -714,13 +624,13 @@ -mx0, -my0, mx0, my0, 1, false, false, ROUND_JOIN_THRESHOLD); } else if (capStyle == CAP_SQUARE) { - long ldx = (long)(sx1 - sx0); - long ldy = (long)(sy1 - sy0); - long llen = lineLength(ldx, ldy); - long s = (long)lineWidth2*65536/llen; + float dx = sx1 - sx0; + float dy = sy1 - sy0; + float len = (float)userSpaceLineLength(dx, dy); + float s = lineWidth2/len; - int capx = sx0 - (int)(ldx*s >> 16); - int capy = sy0 - (int)(ldy*s >> 16); + float capx = sx0 - dx*s; + float capy = sy0 - dy*s; emitLineTo(capx - mx0, capy - my0); emitLineTo(capx + mx0, capy + my0); @@ -730,17 +640,17 @@ this.joinSegment = false; } - private void emitMoveTo(int x0, int y0) { + private void emitMoveTo(float x0, float y0) { // System.out.println("Stroker.emitMoveTo(" + x0/65536.0 + ", " + y0/65536.0 + ")"); output.moveTo(x0, y0); } - private void emitLineTo(int x1, int y1) { + private void emitLineTo(float x1, float y1) { // System.out.println("Stroker.emitLineTo(" + x0/65536.0 + ", " + y0/65536.0 + ")"); output.lineTo(x1, y1); } - private void emitLineTo(int x1, int y1, boolean rev) { + private void emitLineTo(float x1, float y1, boolean rev) { if (rev) { ensureCapacity(rindex + 2); reverse[rindex++] = x1; @@ -755,3 +665,4 @@ output.close(); } } +
--- a/src/share/classes/sun/java2d/pisces/Transform4.java Wed Sep 01 17:37:45 2010 -0700 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,84 +0,0 @@ -/* - * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package sun.java2d.pisces; - -public class Transform4 { - - public int m00, m01, m10, m11; -// double det; // det*65536 - - public Transform4() { - this(1 << 16, 0, 0, 1 << 16); - } - - public Transform4(int m00, int m01, - int m10, int m11) { - this.m00 = m00; - this.m01 = m01; - this.m10 = m10; - this.m11 = m11; - -// this.det = (double)m00*m11 - (double)m01*m10; - } - -// public Transform4 createInverse() { -// double dm00 = m00/65536.0; -// double dm01 = m01/65536.0; -// double dm10 = m10/65536.0; -// double dm11 = m11/65536.0; - -// double invdet = 65536.0/(dm00*dm11 - dm01*dm10); - -// int im00 = (int)( dm11*invdet); -// int im01 = (int)(-dm01*invdet); -// int im10 = (int)(-dm10*invdet); -// int im11 = (int)( dm00*invdet); - -// return new Transform4(im00, im01, im10, im11); -// } - -// public void transform(int[] point) { -// } - -// /** -// * Returns the length of the line segment obtained by inverse -// * transforming the points <code>(x0, y0)</code> and <code>(x1, -// * y1)</code>. -// */ -// public int getTransformedLength(int x0, int x1, int y0, int y1) { -// int lx = x1 - x0; -// int ly = y1 - y0; - -// double a = (double)m00*ly - (double)m10*lx; -// double b = (double)m01*ly - (double)m11*lx; -// double len = PiscesMath.sqrt((a*a + b*b)/(det*det)); -// return (int)(len*65536.0); -// } - -// public int getType() { -// } - -}
--- a/src/share/classes/sun/tools/jconsole/resources/JConsoleResources.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/tools/jconsole/resources/JConsoleResources.java Thu Sep 02 22:11:05 2010 -0700 @@ -46,8 +46,6 @@ */ public class JConsoleResources extends ListResourceBundle { - private static final String cr = System.getProperty("line.separator"); - /** * Returns the contents of this <code>ResourceBundle</code>. * @@ -56,8 +54,8 @@ * @return the contents of this <code>ResourceBundle</code>. */ protected Object[][] getContents0() { - return new Object[][] { - // NOTE 1: The value strings in this file containing "{0}" are + Object[][] temp = new Object[][] { + // NOTE 1: The value strings in this file containing "{0}" are // processed by the java.text.MessageFormat class. Any // single quotes appearing in these strings need to be // doubled up. @@ -98,7 +96,7 @@ {"Attributes","Attributes"}, {"Blank", "Blank"}, {"BlockedCount WaitedCount", - "Total blocked: {0} Total waited: {1}" + cr}, + "Total blocked: {0} Total waited: {1}\n"}, {"Boot class path","Boot class path"}, {"BorderedComponent.moreOrLessButton.toolTip", "Toggle to show more or less information"}, {"CPU Usage","CPU Usage"}, @@ -271,21 +269,21 @@ {"Minimize All.mnemonic", 'M'}, {"Minus Version", "This is {0} version {1}"}, {"Monitor locked", - " - locked {0}" + cr}, + " - locked {0}\n"}, {"Motif","Motif"}, {"Name Build and Mode","{0} (build {1}, {2})"}, {"Name and Build","{0} (build {1})"}, {"Name","Name"}, {"Name: ","Name: "}, {"Name State", - "Name: {0}" + cr + - "State: {1}" + cr}, + "Name: {0}\n" + + "State: {1}\n"}, {"Name State LockName", - "Name: {0}" + cr + - "State: {1} on {2}" + cr}, + "Name: {0}\n" + + "State: {1} on {2}\n"}, {"Name State LockName LockOwner", - "Name: {0}" + cr + - "State: {1} on {2} owned by: {3}" + cr}, + "Name: {0}\n" + + "State: {1} on {2} owned by: {3}\n"}, {"New Connection...", "New Connection..."}, {"New Connection....mnemonic", 'N'}, {"New value applied","New value applied"}, @@ -351,7 +349,7 @@ {"Size Mb","{0} Mb"}, {"Source","Source"}, {"Stack trace", - cr + "Stack trace: " + cr}, + "\nStack trace: \n"}, {"Success:","Success:"}, // Note: SummaryTab.headerDateTimeFormat can be one the following: // 1. A combination of two styles for date and time, using the @@ -433,22 +431,27 @@ {"plot", "plot"}, {"visualize","visualize"}, {"zz usage text", - "Usage: {0} [ -interval=n ] [ -notile ] [ -pluginpath <path> ] [ -version ] [ connection ... ]" + cr + - cr + - " -interval Set the update interval to n seconds (default is 4 seconds)" + cr + - " -notile Do not tile windows initially (for two or more connections)" + cr + - " -pluginpath Specify the path that jconsole uses to look up the plugins" + cr + - " -version Print program version" + cr + - cr + - " connection = pid || host:port || JMX URL (service:jmx:<protocol>://...)" + cr + - " pid The process id of a target process" + cr + - " host A remote host name or IP address" + cr + - " port The port number for the remote connection" + cr + - cr + - " -J Specify the input arguments to the Java virtual machine" + cr + + "Usage: {0} [ -interval=n ] [ -notile ] [ -pluginpath <path> ] [ -version ] [ connection ... ]\n\n" + + " -interval Set the update interval to n seconds (default is 4 seconds)\n" + + " -notile Do not tile windows initially (for two or more connections)\n" + + " -pluginpath Specify the path that jconsole uses to look up the plugins\n\n" + + " -version Print program version\n" + + " connection = pid || host:port || JMX URL (service:jmx:<protocol>://...)\n" + + " pid The process id of a target process\n" + + " host A remote host name or IP address\n" + + " port The port number for the remote connection\n\n" + + " -J Specify the input arguments to the Java virtual machine\n" + " on which jconsole is running"}, // END OF MATERIAL TO LOCALIZE }; + + String ls = System.getProperty("line.separator"); + for(int i=0;i<temp.length;i++) { + temp[i][1] = temp[i][1].toString().replaceAll("\n",ls); + } + + return temp; + } public synchronized Object[][] getContents() {
--- a/src/share/classes/sun/tools/native2ascii/resources/MsgNative2ascii.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/tools/native2ascii/resources/MsgNative2ascii.java Thu Sep 02 22:11:05 2010 -0700 @@ -30,12 +30,14 @@ public class MsgNative2ascii extends ListResourceBundle { public Object[][] getContents() { - return new Object[][] { + Object[][] temp = new Object[][] { {"err.bad.arg", "-encoding requires argument"}, {"err.cannot.read", "{0} could not be read."}, {"err.cannot.write", "{0} could not be written."}, {"usage", "Usage: native2ascii" + " [-reverse] [-encoding encoding] [inputfile [outputfile]]"}, }; + + return temp; } }
--- a/src/share/classes/sun/util/resources/TimeZoneNames.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "Central European Summer Time", "CEST"}; String CHAST[] = new String[] {"Chatham Standard Time", "CHAST", "Chatham Daylight Time", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"Central Indonesia Time", "CIT", "Central Indonesia Summer Time", "CIST"}; String CLT[] = new String[] {"Chile Time", "CLT", @@ -153,6 +155,8 @@ "Pitcairn Daylight Time", "PDT"}; String PKT[] = new String[] {"Pakistan Time", "PKT", "Pakistan Summer Time", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}; String RST[] = new String[] {"Eastern Standard Time", "EST", @@ -169,8 +173,6 @@ "Eastern Summer Time (Tasmania)", "EST"}; String TMT[] = new String[] {"Turkmenistan Time", "TMT", "Turkmenistan Summer Time", "TMST"}; - String TRUT[] = new String[] {"Truk Time", "TRUT", - "Truk Summer Time", "TRUST"}; String ULAT[]= new String[] {"Ulaanbaatar Time", "ULAT", "Ulaanbaatar Summer Time", "ULAST"}; String WART[] = new String[] {"Western Argentine Time", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -755,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"Vanuatu Time", "VUT", "Vanuatu Summer Time", "VUST"}}, @@ -793,8 +797,8 @@ {"Pacific/Palau", new String[] {"Palau Time", "PWT", "Palau Summer Time", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Ponape Time", "PONT", - "Ponape Summer Time", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"Papua New Guinea Time", "PGT", "Papua New Guinea Summer Time", "PGST"}}, {"Pacific/Rarotonga", new String[] {"Cook Is. Time", "CKT", @@ -807,12 +811,12 @@ "Gilbert Is. Summer Time", "GILST"}}, {"Pacific/Tongatapu", new String[] {"Tonga Time", "TOT", "Tonga Summer Time", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"Wake Time", "WAKT", "Wake Summer Time", "WAKST"}}, {"Pacific/Wallis", new String[] {"Wallis & Futuna Time", "WFT", "Wallis & Futuna Summer Time", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_de.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_de.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "Mitteleurop\u00e4ische Sommerzeit", "MESZ"}; String CHAST[] = new String[] {"Chatham Normalzeit", "CHAST", "Chatham Sommerzeit", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"Zentralindonesische Zeit", "CIT", "Zentralindonesische Sommerzeit", "CIST"}; String CLT[] = new String[] {"Chilenische Zeit", "CLT", @@ -153,6 +155,8 @@ "Pitcairn Sommerzeit", "PDT"}; String PKT[] = new String[] {"Pakistanische Zeit", "PKT", "Pakistanische Sommerzeit", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"Pazifische Normalzeit", "PST", "Pazifische Sommerzeit", "PDT"}; String RST[] = new String[] {"\u00d6stliche Normalzeit", "EST", @@ -169,8 +173,6 @@ "\u00d6stliche Sommerzeit (Tasmanien)", "EST"}; String TMT[] = new String[] {"Turkmenische Zeit", "TMT", "Turkmenische Sommerzeit", "TMST"}; - String TRUT[] = new String[] {"Truk Zeit", "TRUT", - "Truk Sommerzeit", "TRUST"}; String ULAT[]= new String[] {"Ulaanbaatar Zeit", "ULAT", "Ulaanbaatar Sommerzeit", "ULAST"}; String WART[] = new String[] {"Westargentinische Zeit", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"Davis Zeit", "DAVT", "Davis Sommerzeit", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"Dumont-d'Urville Zeit", "DDUT", "Dumont-d'Urville Sommerzeit", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"Mawson Zeit", "MAWT", "Mawson Sommerzeit", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -752,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"Vanuatu Zeit", "VUT", "Vanuatu Sommerzeit", "VUST"}}, @@ -790,8 +797,8 @@ {"Pacific/Palau", new String[] {"Palau Zeit", "PWT", "Palau Sommerzeit", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Ponape Zeit", "PONT", - "Ponape Sommerzeit", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"Papua-Neuguinea Zeit", "PGT", "Papua-Neuguinea Sommerzeit", "PGST"}}, {"Pacific/Rarotonga", new String[] {"Cook-Inseln Zeit", "CKT", @@ -804,12 +811,12 @@ "Gilbert-Inseln Sommerzeit", "GILST"}}, {"Pacific/Tongatapu", new String[] {"Tonga Zeit", "TOT", "Tonga Sommerzeit", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"Wake Zeit", "WAKT", "Wake Sommerzeit", "WAKST"}}, {"Pacific/Wallis", new String[] {"Wallis u. Futuna Zeit", "WFT", "Wallis u. Futuna Sommerzeit", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_es.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_es.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "Hora de verano de Europa Central", "CEST"}; String CHAST[] = new String[] {"Hora est\u00e1ndar de Chatham", "CHAST", "Hora de verano de Chatham", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"Hora de Indonesia Central", "CIT", "Hora de verano de Indonesia Central", "CIST"}; String CLT[] = new String[] {"Hora de Chile", "CLT", @@ -153,6 +155,8 @@ "Hora de verano de Pitcairn", "PDT"}; String PKT[] = new String[] {"Hora de Pakist\u00e1n", "PKT", "Hora de verano de Pakist\u00e1n", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"Hora est\u00e1ndar del Pac\u00edfico", "PST", "Hora de verano del Pac\u00edfico", "PDT"}; String RST[] = new String[] {"Hora est\u00e1ndar Oriental", "EST", @@ -169,8 +173,6 @@ "Hora de verano del Este (Tasmania)", "EST"}; String TMT[] = new String[] {"Hora de Turkmenist\u00e1n", "TMT", "Hora de verano de Turkmenist\u00e1n", "TMST"}; - String TRUT[] =new String[] {"Hora de Truk", "TRUT", - "Hora de verano de Truk", "TRUST"}; String ULAT[]= new String[] {"Hora de Ulan Bator", "ULAT", "Hora de verano de Ulan Bator", "ULAST"}; String WART[] = new String[] {"Hora de Argentina Occidental", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"Hora de Davis", "DAVT", "Hora de verano de Davis", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"Hora de Dumont-d'Urville", "DDUT", "Hora de verano de Dumont-d'Urville", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"Hora de Mawson", "MAWT", "Hora de verano de Mawson", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -533,7 +539,6 @@ "Hora de verano de Filipinas", "PHST"}}, {"Asia/Muscat", GST}, {"Asia/Nicosia", EET}, - {"Asia/Novokuznetsk", NOVT}, {"Asia/Novosibirsk", NOVT}, {"Asia/Oral", new String[] {"Hora de Uralsk", "ORAT", @@ -753,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"Hora de Vanuatu", "VUT", "Hora de verano de Vanuatu", "VUST"}}, @@ -791,8 +797,8 @@ {"Pacific/Palau", new String[] {"Hora de Palau", "PWT", "Hora de verano de Palau", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Hora de Ponape", "PONT", - "Hora de verano de Ponape", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"Hora de Pap\u00faa-Nueva Guinea", "PGT", "Hora de verano de Pap\u00faa-Nueva Guinea", "PGST"}}, {"Pacific/Rarotonga", new String[] {"Hora de las islas Cook", "CKT", @@ -805,12 +811,12 @@ "Hora de verano de las islas Gilbert", "GILST"}}, {"Pacific/Tongatapu", new String[] {"Hora de Tonga", "TOT", "Hora de verano de Tonga", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"Hora de Wake", "WAKT", "Hora de verano de Wake", "WAKST"}}, {"Pacific/Wallis", new String[] {"Hora de Wallis y Futuna", "WFT", "Hora de verano de Wallis y Futuna", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_fr.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_fr.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "Heure d'\u00e9t\u00e9 d'Europe centrale", "CEST"} ; String CHAST[] = new String[] {"Heure standard de Chatham", "CHAST", "Heure avanc\u00e9e de Chatham", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"Heure d'Indon\u00e9sie centrale", "CIT", "Heure d'\u00e9t\u00e9 d'Indon\u00e9sie centrale", "CIST"}; String CLT[] = new String[] {"Heure du Chili", "CLT", @@ -153,6 +155,8 @@ "heure avanc\u00e9e des Pitcairn", "PDT"}; String PKT[] = new String[] {"Heure du Pakistan", "PKT", "Heure d'\u00e9t\u00e9 du Pakistan", "PKST"} ; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"Heure normale du Pacifique", "PST", "Heure avanc\u00e9e du Pacifique", "PDT"} ; String RST[] = new String[] {"Heure normale de l'Est", "EST", @@ -169,8 +173,6 @@ "Heure d'\u00e9t\u00e9 d'Australie orientale (Tasmanie)", "EST"}; String TMT[] = new String[] {"Heure du Turkm\u00e9nistan", "TMT", "Heure d'\u00e9t\u00e9 du Turkm\u00e9nistan", "TMST"} ; - String TRUT[] = new String[] {"Heure de Truk", "TRUT", - "Heure d'\u00e9t\u00e9 de Truk", "TRUST"}; String ULAT[]= new String[] {"Heure de l'Ulaanbaatar", "ULAT", "Heure d'\u00e9t\u00e9 de l'Ulaanbaatar", "ULAST"} ; String WART[] = new String[] {"Heure D'Argentine de l'Ouest", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"Heure de Davis", "DAVT", "Heure d'\u00e9t\u00e9 de Davis", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"Heure de Dumont-d'Urville", "DDUT", "Heure d'\u00e9t\u00e9 de Dumont-d'Urville", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"Heure de Mawson", "MAWT", "Heure d'\u00e9t\u00e9 de Mawson", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -752,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"Heure du Vanuatu", "VUT", "Heure d'\u00e9t\u00e9 du Vanuatu", "VUST"}}, @@ -790,8 +797,8 @@ {"Pacific/Palau", new String[] {"Heure de Palaos", "PWT", "Heure d'\u00e9t\u00e9 de Palaos", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Heure de Ponap\u00e9", "PONT", - "Heure d'\u00e9t\u00e9 de Ponap\u00e9", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"Heure de Papouasie-Nouvelle-Guin\u00e9e", "PGT", "Heure d'\u00e9t\u00e9 de de Papouasie-Nouvelle-Guin\u00e9e", "PGST"}}, {"Pacific/Rarotonga", new String[] {"Heure des \u00celes Cook", "CKT", @@ -804,12 +811,12 @@ "Heure d'\u00e9t\u00e9 de Kiribati", "GILST"}}, {"Pacific/Tongatapu", new String[] {"Heure de Tonga", "TOT", "Heure d'\u00e9t\u00e9 de Tonga", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"Heure de Wake", "WAKT", "Heure d'\u00e9t\u00e9 de Wake", "WAKST"}}, {"Pacific/Wallis", new String[] {"Heure de Wallis et Futuna", "WFT", "Heure d'\u00e9t\u00e9 de Wallis et Futuna", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_it.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_it.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "Ora estiva dell'Europa centrale", "CEST"}; String CHAST[] = new String[] {"Ora di Chatham standard", "CHAST", "Ora legale di Chatham", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"Ora dell'Indonesia centrale", "CIT", "Ora estiva dell'Indonesia centrale", "CIST"}; String CLT[] = new String[] {"Ora del Cile", "CLT", @@ -153,6 +155,8 @@ "Ora legale di Pitcairn", "PDT"}; String PKT[] = new String[] {"Ora del Pakistan", "PKT", "Ora estiva del Pakistan", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"Ora solare della costa occidentale USA", "PST", "Ora legale della costa occidentale USA", "PDT"}; String RST[] = new String[] {"Ora solare USA orientale", "EST", @@ -169,8 +173,6 @@ "Ora estiva orientale (Tasmania)", "EST"}; String TMT[] = new String[] {"Ora del Turkmenistan", "TMT", "Ora estiva del Turkmenistan", "TMST"}; - String TRUT[] = new String[] {"Ora di Truk", "TRUT", - "Ora estiva di Truk", "TRUST"}; String ULAT[]= new String[] {"Ora di Ulaanbaatar", "ULAT", "Ora estiva di Ulaanbaatar", "ULAST"}; String WART[] = new String[] {"Ora dell'Argentina occidentale", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"Ora di Davis", "DAVT", "Ora estiva di Davis", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"Ora di Dumont-d'Urville", "DDUT", "Ora estiva di Dumont-d'Urville", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"Ora di Mawson", "MAWT", "Ora estiva di Mawson", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -752,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"Ora di Vanuatu", "VUT", "Ora estiva di Vanuatu", "VUST"}}, @@ -790,8 +797,8 @@ {"Pacific/Palau", new String[] {"Ora di Palau", "PWT", "Ora estiva di Palau", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Ora di Ponape", "PONT", - "Ora estiva di Ponape", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"Ora di Papua Nuova Guinea", "PGT", "Ora estiva di Papua Nuova Guinea", "PGST"}}, {"Pacific/Rarotonga", new String[] {"Ora delle Isole Cook", "CKT", @@ -804,12 +811,12 @@ "Ora estiva delle Isole Gilbert", "GILST"}}, {"Pacific/Tongatapu", new String[] {"Ora di Tonga", "TOT", "Ora estiva di Tonga", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"Ora di Wake", "WAKT", "Ora estiva di Wake", "WAKST"}}, {"Pacific/Wallis", new String[] {"Ora di Wallis e Futuna", "WFT", "Ora estiva di Wallis e Futuna", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_ja.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_ja.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "\u4e2d\u90e8\u30e8\u30fc\u30ed\u30c3\u30d1\u590f\u6642\u9593", "CEST"}; String CHAST[] = new String[] {"\u30c1\u30e3\u30bf\u30e0\u6a19\u6e96\u6642", "CHAST", "\u30c1\u30e3\u30bf\u30e0\u590f\u6642\u9593", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"\u4e2d\u592e\u30a4\u30f3\u30c9\u30cd\u30b7\u30a2\u6642\u9593", "CIT", "\u4e2d\u592e\u30a4\u30f3\u30c9\u30cd\u30b7\u30a2\u590f\u6642\u9593", "CIST"}; String CLT[] = new String[] {"\u30c1\u30ea\u6642\u9593", "CLT", @@ -153,6 +155,8 @@ "\u30d4\u30c8\u30b1\u30eb\u30f3\u5cf6\u590f\u6642\u9593", "PDT"}; String PKT[] = new String[] {"\u30d1\u30ad\u30b9\u30bf\u30f3\u6642\u9593", "PKT", "\u30d1\u30ad\u30b9\u30bf\u30f3\u590f\u6642\u9593", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"\u592a\u5e73\u6d0b\u6a19\u6e96\u6642", "PST", "\u592a\u5e73\u6d0b\u590f\u6642\u9593", "PDT"}; String RST[] = new String[] {"\u6771\u90e8\u6a19\u6e96\u6642", "EST", @@ -169,8 +173,6 @@ "\u6771\u90e8\u590f\u6642\u9593 (\u30bf\u30b9\u30de\u30cb\u30a2)", "EST"}; String TMT[] = new String[] {"\u30c8\u30eb\u30af\u30e1\u30cb\u30b9\u30bf\u30f3\u6642\u9593", "TMT", "\u30c8\u30eb\u30af\u30e1\u30cb\u30b9\u30bf\u30f3\u590f\u6642\u9593", "TMST"}; - String TRUT[] = new String[] {"\u30c8\u30e9\u30c3\u30af\u6642\u9593", "TRUT", - "\u30c8\u30e9\u30c3\u30af\u590f\u6642\u9593", "TRUST"}; String ULAT[]= new String[] {"\u30a6\u30e9\u30fc\u30f3\u30d0\u30fc\u30c8\u30eb\u6642\u9593", "ULAT", "\u30a6\u30e9\u30fc\u30f3\u30d0\u30fc\u30c8\u30eb\u590f\u6642\u9593", "ULAST"}; String WART[] = new String[] {"\u897f\u30a2\u30eb\u30bc\u30f3\u30c1\u30f3\u6642\u9593", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"\u30c7\u30a4\u30d3\u30b9\u6642\u9593", "DAVT", "\u30c7\u30a4\u30d3\u30b9\u590f\u6642\u9593", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"\u30c7\u30e5\u30e2\u30f3\u30c7\u30e5\u30eb\u30f4\u30a3\u30eb\u6642\u9593", "DDUT", "\u30c7\u30e5\u30e2\u30f3\u30c7\u30e5\u30eb\u30f4\u30a3\u30eb\u590f\u6642\u9593", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"\u30e2\u30fc\u30bd\u30f3\u6642\u9593", "MAWT", "\u30e2\u30fc\u30bd\u30f3\u590f\u6642\u9593", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -752,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"\u30d0\u30cc\u30a2\u30c4\u6642\u9593", "VUT", "\u30d0\u30cc\u30a2\u30c4\u590f\u6642\u9593", "VUST"}}, @@ -790,8 +797,8 @@ {"Pacific/Palau", new String[] {"\u30d1\u30e9\u30aa\u6642\u9593", "PWT", "\u30d1\u30e9\u30aa\u590f\u6642\u9593", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"\u30dd\u30ca\u30da\u6642\u9593", "PONT", - "\u30dd\u30ca\u30da\u590f\u6642\u9593", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"\u30d1\u30d7\u30a2\u30cb\u30e5\u30fc\u30ae\u30cb\u30a2\u6642\u9593", "PGT", "\u30d1\u30d7\u30a2\u30cb\u30e5\u30fc\u30ae\u30cb\u30a2\u590f\u6642\u9593", "PGST"}}, {"Pacific/Rarotonga", new String[] {"\u30af\u30c3\u30af\u8af8\u5cf6\u6642\u9593", "CKT", @@ -804,12 +811,12 @@ "\u30ae\u30eb\u30d0\u30fc\u30c8\u8af8\u5cf6\u590f\u6642\u9593", "GILST"}}, {"Pacific/Tongatapu", new String[] {"\u30c8\u30f3\u30ac\u6642\u9593", "TOT", "\u30c8\u30f3\u30ac\u590f\u6642\u9593", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"\u30a6\u30a7\u30fc\u30af\u6642\u9593", "WAKT", "\u30a6\u30a7\u30fc\u30af\u590f\u6642\u9593", "WAKST"}}, {"Pacific/Wallis", new String[] {"\u30ef\u30ea\u30b9\u53ca\u3073\u30d5\u30c4\u30ca\u6642\u9593", "WFT", "\u30ef\u30ea\u30b9\u53ca\u3073\u30d5\u30c4\u30ca\u590f\u6642\u9593", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_ko.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_ko.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "\uc911\uc559 \uc720\ub7fd \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "CEST"}; String CHAST[] = new String[] {"Chatham \ud45c\uc900\uc2dc", "CHAST", "Chatham \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"\uc911\uc559 \uc778\ub3c4\ub124\uc2dc\uc544 \uc2dc\uac04", "CIT", "\uc911\uc559 \uc778\ub3c4\ub124\uc2dc\uc544 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "CIST"}; String CLT[] = new String[] {"\uce60\ub808 \uc2dc\uac04", "CLT", @@ -153,6 +155,8 @@ "Pitcairn \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "PDT"}; String PKT[] = new String[] {"\ud30c\ud0a4\uc2a4\ud0c4 \uc2dc\uac04", "PKT", "\ud30c\ud0a4\uc2a4\ud0c4 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"\ud0dc\ud3c9\uc591 \ud45c\uc900\uc2dc", "PST", "\ud0dc\ud3c9\uc591 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "PDT"}; String RST[] = new String[] {"\ub3d9\ubd80 \ud45c\uc900\uc2dc", "EST", @@ -169,8 +173,6 @@ "\ub3d9\ubd80 \uc77c\uad11\uc808\uc57d\uc2dc\uac04(\ud0dc\uc988\uba54\uc774\ub2c8\uc544)", "EST"}; String TMT[] = new String[] {"\ud22c\ub974\ud06c\uba54\ub2c8\uc2a4\ud0c4 \uc2dc\uac04", "TMT", "\ud22c\ub974\ud06c\uba54\ub2c8\uc2a4\ud0c4 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "TMST"}; - String TRUT[] = new String[] {"\ud2b8\ub8e8\ud06c \uc2dc\uac04", "TRUT", - "\ud2b8\ub8e8\ud06c \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "TRUST"}; String ULAT[]= new String[] {"\uc6b8\ub780\ubc14\ud0c0\ub974 \uc2dc\uac04", "ULAT", "\uc6b8\ub780\ubc14\ud0c0\ub974 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "ULAST"}; String WART[] = new String[] {"\uc11c\ubd80 \uc544\ub974\ud5e8\ud2f0\ub098 \uc2dc\uac04", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"Davis \uc2dc\uac04", "DAVT", "Davis \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"\ub4a4\ubabd \ub4a4\ub974\ube4c \uc2dc\uac04", "DDUT", "\ub4a4\ubabd \ub4a4\ub974\ube4c \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"\ubaa8\uc2a8 \uc2dc\uac04", "MAWT", "\ubaa8\uc2a8 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -752,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"\ube44\ub204\uc544\ud22c \uc2dc\uac04", "VUT", "\ubc14\ub204\uc544\ud22c \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "VUST"}}, @@ -790,8 +797,8 @@ {"Pacific/Palau", new String[] {"\ud314\ub77c\uc6b0 \uc2dc\uac04", "PWT", "\ud314\ub77c\uc6b0 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"\ud3ec\ub098\ud504 \uc2dc\uac04", "PONT", - "\ud3ec\ub098\ud504 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"\ud30c\ud478\uc544\ub274\uae30\ub2c8 \uc2dc\uac04", "PGT", "\ud30c\ud478\uc544\ub274\uae30\ub2c8 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "PGST"}}, {"Pacific/Rarotonga", new String[] {"\ucfe0\ud06c \uad70\ub3c4 \uc2dc\uac04", "CKT", @@ -804,12 +811,12 @@ "\uae38\ubc84\ud2b8 \uad70\ub3c4 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "GILST"}}, {"Pacific/Tongatapu", new String[] {"\ud1b5\uac00 \uc2dc\uac04", "TOT", "\ud1b5\uac00 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"\uc6e8\uc774\ud06c \uc2dc\uac04", "WAKT", "\uc6e8\uc774\ud06c \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "WAKST"}}, {"Pacific/Wallis", new String[] {"\uc6d4\ub9ac\uc2a4 \ud6c4\ud22c\ub098 \uc2dc\uac04", "WFT", "\uc6d4\ub9ac\uc2a4 \ud6c4\ud2b8\ub098 \uc77c\uad11\uc808\uc57d\uc2dc\uac04", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_sv.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_sv.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "Centraleuropeisk sommartid", "CEST"}; String CHAST[] = new String[] {"Chatham, normaltid", "CHAST", "Chatham, sommartid", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"Centralindonesisk tid", "CIT", "Centralindonesisk sommartid", "CIST"}; String CLT[] = new String[] {"Chile, normaltid", "CLT", @@ -153,6 +155,8 @@ "Pitcairn, sommartid", "PDT"}; String PKT[] = new String[] {"Pakistan, normaltid", "PKT", "Pakistan, sommartid", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"Stilla havet, normaltid", "PST", "Stilla havet, sommartid", "PDT"}; String RST[] = new String[] {"Eastern, normaltid", "EST", @@ -169,8 +173,6 @@ "Eastern, sommartid (Tasmanien)", "EST"}; String TMT[] = new String[] {"Turkmenistan, normaltid", "TMT", "Turkmenistan, sommartid", "TMST"}; - String TRUT[] = new String[] {"Truk, normaltid", "TRUT", - "Truk, sommartid", "TRUST"}; String ULAT[]= new String[] {"Ulaanbaatar, normaltid", "ULAT", "Ulaanbaatar, sommartid", "ULAST"}; String WART[] = new String[] {"V\u00e4stargentina, normaltid", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"Davis, normaltid", "DAVT", "Davis, sommartid", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"Dumont-d'Urville, normaltid", "DDUT", "Dumont-d'Urville, sommartid", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"Mawson, normaltid", "MAWT", "Mawson, sommartid", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -752,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"Vanuatu, normaltid", "VUT", "Vanuatu, sommartid", "VUST"}}, @@ -790,8 +797,8 @@ {"Pacific/Palau", new String[] {"Palau, normaltid", "PWT", "Palau, sommartid", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Ponape, normaltid", "PONT", - "Ponape, sommartid", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"Papua Nya Guinea, normaltid", "PGT", "Papua Nya Guinea, sommartid", "PGST"}}, {"Pacific/Rarotonga", new String[] {"Cook\u00f6arna, normaltid", "CKT", @@ -804,12 +811,12 @@ "Gilbert\u00f6arna, sommartid", "GILST"}}, {"Pacific/Tongatapu", new String[] {"Tonga, normaltid", "TOT", "Tonga, sommartid", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"Wake, normaltid", "WAKT", "Wake, sommartid", "WAKST"}}, {"Pacific/Wallis", new String[] {"Wallis & Futuna, normaltid", "WFT", "Wallis & Futuna, sommartid", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_zh_CN.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_zh_CN.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "\u4e2d\u6b27\u590f\u4ee4\u65f6", "CEST"}; String CHAST[] = new String[] {"\u67e5\u8428\u59c6\u6807\u51c6\u65f6\u95f4", "CHAST", "\u67e5\u8428\u59c6\u590f\u4ee4\u65f6", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"\u4e2d\u90e8\u5370\u5ea6\u5c3c\u897f\u4e9a\u65f6\u95f4", "CIT", "\u4e2d\u90e8\u5370\u5ea6\u5c3c\u897f\u4e9a\u590f\u4ee4\u65f6", "CIST"}; String CLT[] = new String[] {"\u667a\u5229\u65f6\u95f4", "CLT", @@ -153,6 +155,8 @@ "\u76ae\u7279\u5eb7\u5c9b\u590f\u4ee4\u65f6", "PDT"}; String PKT[] = new String[] {"\u5df4\u57fa\u65af\u5766\u65f6\u95f4", "PKT", "\u5df4\u57fa\u65af\u5766\u590f\u4ee4\u65f6", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"\u592a\u5e73\u6d0b\u6807\u51c6\u65f6\u95f4", "PST", "\u592a\u5e73\u6d0b\u590f\u4ee4\u65f6", "PDT"}; String RST[] = new String[] {"\u4e1c\u90e8\u6807\u51c6\u65f6\u95f4", "EST", @@ -169,8 +173,6 @@ "\u4e1c\u90e8\u590f\u4ee4\u65f6\uff08\u5854\u65af\u9a6c\u5c3c\u4e9a\uff09", "EST"}; String TMT[] = new String[] {"\u571f\u5e93\u66fc\u65f6\u95f4", "TMT", "\u571f\u5e93\u66fc\u590f\u4ee4\u65f6", "TMST"}; - String TRUT[] = new String[] {"\u7279\u9c81\u514b\u65f6\u95f4", "TRUT", - "\u7279\u9c81\u514b\u590f\u4ee4\u65f6", "TRUST"}; String ULAT[]= new String[] {"\u5e93\u4f26\u65f6\u95f4", "ULAT", "\u5e93\u4f26\u590f\u4ee4\u65f6", "ULAST"}; String WART[] = new String[] {"\u897f\u963f\u6839\u5ef7\u65f6\u95f4", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"\u6234\u7ef4\u65af\u65f6\u95f4", "DAVT", "\u6234\u7ef4\u65af\u590f\u4ee4\u65f6", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"Dumont-d'Urville \u65f6\u95f4", "DDUT", "Dumont-d'Urville \u590f\u4ee4\u65f6", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"\u83ab\u68ee\u65f6\u95f4", "MAWT", "\u83ab\u68ee\u590f\u4ee4\u65f6", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -752,6 +758,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"\u74e6\u5974\u963f\u56fe\u65f6\u95f4", "VUT", "\u74e6\u5974\u963f\u56fe\u590f\u4ee4\u65f6", "VUST"}}, @@ -790,8 +797,8 @@ {"Pacific/Palau", new String[] {"\u5e1b\u7409\u65f6\u95f4", "PWT", "\u5e1b\u7409\u590f\u4ee4\u65f6", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Ponape \u65f6\u95f4", "PONT", - "Ponape \u590f\u4ee4\u65f6", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"\u5df4\u5e03\u4e9a\u65b0\u51e0\u5185\u4e9a\u65f6\u95f4", "PGT", "\u5df4\u5e03\u4e9a\u65b0\u51e0\u5185\u4e9a\u590f\u4ee4\u65f6", "PGST"}}, {"Pacific/Rarotonga", new String[] {"\u5e93\u514b\u7fa4\u5c9b\u65f6\u95f4", "CKT", @@ -804,12 +811,12 @@ "\u5409\u4f2f\u7279\u7fa4\u5c9b\u590f\u4ee4\u65f6", "GILST"}}, {"Pacific/Tongatapu", new String[] {"\u4e1c\u52a0\u65f6\u95f4", "TOT", "\u4e1c\u52a0\u590f\u4ee4\u65f6", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"\u5a01\u514b\u65f6\u95f4", "WAKT", "\u5a01\u514b\u590f\u4ee4\u65f6", "WAKST"}}, {"Pacific/Wallis", new String[] {"\u74e6\u5229\u65af\u53ca\u798f\u675c\u7eb3\u7fa4\u5c9b\u65f6\u95f4", "WFT", "\u74e6\u5229\u65af\u53ca\u798f\u675c\u7eb3\u7fa4\u5c9b\u590f\u4ee4\u65f6", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},
--- a/src/share/classes/sun/util/resources/TimeZoneNames_zh_TW.java Wed Sep 01 17:37:45 2010 -0700 +++ b/src/share/classes/sun/util/resources/TimeZoneNames_zh_TW.java Thu Sep 02 22:11:05 2010 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -75,6 +75,8 @@ "\u4e2d\u6b50\u590f\u4ee4\u6642\u9593", "CEST"}; String CHAST[] = new String[] {"\u67e5\u5766\u6a19\u6e96\u6642\u9593", "CHAST", "\u67e5\u5766\u65e5\u5149\u7bc0\u7d04\u6642\u9593", "CHADT"}; + String CHUT[] = new String[] {"Chuuk Time", "CHUT", + "Chuuk Summer Time", "CHUST"}; String CIT[] = new String[] {"\u4e2d\u5370\u5ea6\u5c3c\u897f\u4e9e\u6642\u9593", "CIT", "\u4e2d\u5370\u5ea6\u5c3c\u897f\u4e9e\u590f\u4ee4\u6642\u9593", "CIST"}; String CLT[] = new String[] {"\u667a\u5229\u6642\u9593", "CLT", @@ -153,6 +155,8 @@ "\u76ae\u7279\u5eb7\u65e5\u5149\u7bc0\u7d04\u6642\u9593", "PDT"}; String PKT[] = new String[] {"\u5df4\u57fa\u65af\u5766\u6642\u9593", "PKT", "\u5df4\u57fa\u65af\u5766\u590f\u4ee4\u6642\u9593", "PKST"}; + String PONT[] = new String[] {"Pohnpei Time", "PONT", + "Pohnpei Summer Time", "PONST"}; String PST[] = new String[] {"\u592a\u5e73\u6d0b\u6a19\u6e96\u6642\u9593", "PST", "\u592a\u5e73\u6d0b\u65e5\u5149\u7bc0\u7d04\u6642\u9593", "PDT"}; String RST[] = new String[] {"\u6771\u65b9\u6a19\u6e96\u6642\u9593", "EST", @@ -169,8 +173,6 @@ "\u6771\u90e8\u590f\u4ee4\u6642\u9593 (\u5854\u65af\u6885\u5c3c\u4e9e\u5cf6)", "EST"}; String TMT[] = new String[] {"\u571f\u5eab\u66fc\u6642\u9593", "TMT", "\u571f\u5eab\u66fc\u590f\u4ee4\u6642\u9593", "TMST"}; - String TRUT[] = new String[] {"\u7279\u9b6f\u514b\u6642\u9593", "TRUT", - "\u7279\u9b6f\u514b\u590f\u4ee4\u6642\u9593", "TRUST"}; String ULAT[]= new String[] {"\u5eab\u502b\u6642\u9593", "ULAT", "\u5eab\u502b\u590f\u4ee4\u6642\u9593", "ULAST"}; String WART[] = new String[] {"\u897f\u963f\u6839\u5ef7\u6642\u9593", "WART", @@ -309,6 +311,7 @@ {"America/Atikokan", EST}, {"America/Atka", HAST}, {"America/Bahia", BRT}, + {"America/Bahia_Banderas", CST}, {"America/Barbados", AST}, {"America/Belem", BRT}, {"America/Belize", CST}, @@ -446,10 +449,13 @@ {"America/Winnipeg", CST}, {"America/Yakutat", AKST}, {"America/Yellowknife", MST}, + {"Antarctica/Casey", WST_AUS}, {"Antarctica/Davis", new String[] {"\u81fa\u7dad\u65af\u6642\u9593", "DAVT", "\u81fa\u7dad\u65af\u590f\u4ee4\u6642\u9593", "DAVST"}}, {"Antarctica/DumontDUrville", new String[] {"Dumont-d'Urville \u6642\u9593", "DDUT", "Dumont-d'Urville \u590f\u4ee4\u6642\u9593", "DDUST"}}, + {"Antarctica/Macquarie", new String[] {"Macquarie Island Time", "MIST", + "Macquarie Island Summer Time", "MIST"}}, {"Antarctica/Mawson", new String[] {"\u83ab\u68ee\u6642\u9593", "MAWT", "\u83ab\u68ee\u590f\u4ee4\u6642\u9593", "MAWST"}}, {"Antarctica/McMurdo", NZST}, @@ -753,6 +759,7 @@ {"Pacific/Apia", WST_SAMOA}, {"Pacific/Auckland", NZST}, {"Pacific/Chatham", CHAST}, + {"Pacific/Chuuk", CHUT}, {"Pacific/Easter", EASTER}, {"Pacific/Efate", new String[] {"\u74e6\u5974\u963f\u5716\u6642\u9593", "VUT", "\u74e6\u5974\u963f\u5716\u590f\u4ee4\u6642\u9593", "VUST"}}, @@ -791,8 +798,8 @@ {"Pacific/Palau", new String[] {"\u5e1b\u7409\u6642\u9593", "PWT", "\u5e1b\u7409\u590f\u4ee4\u6642\u9593", "PWST"}}, {"Pacific/Pitcairn", PITCAIRN}, - {"Pacific/Ponape", new String[] {"Ponape \u6642\u9593", "PONT", - "Ponape \u590f\u4ee4\u6642\u9593", "PONST"}}, + {"Pacific/Pohnpei", PONT}, + {"Pacific/Ponape", PONT}, {"Pacific/Port_Moresby", new String[] {"\u5df4\u5e03\u4e9e\u65b0\u5e7e\u5167\u4e9e\u6642\u9593", "PGT", "\u5df4\u5e03\u4e9e\u65b0\u5e7e\u5167\u4e9e\u590f\u4ee4\u6642\u9593", "PGST"}}, {"Pacific/Rarotonga", new String[] {"\u5eab\u514b\u7fa4\u5cf6\u6642\u9593", "CKT", @@ -805,12 +812,12 @@ "\u5409\u4f2f\u7279\u7fa4\u5cf6\u590f\u4ee4\u6642\u9593", "GILST"}}, {"Pacific/Tongatapu", new String[] {"\u6771\u52a0\u6642\u9593", "TOT", "\u6771\u52a0\u590f\u4ee4\u6642\u9593", "TOST"}}, - {"Pacific/Truk", TRUT}, + {"Pacific/Truk", CHUT}, {"Pacific/Wake", new String[] {"\u5a01\u514b\u6642\u9593", "WAKT", "\u5a01\u514b\u590f\u4ee4\u6642\u9593", "WAKST"}}, {"Pacific/Wallis", new String[] {"\u74e6\u5229\u65af\u53ca\u798f\u675c\u7d0d\u7fa4\u5cf6\u6642\u9593", "WFT", "\u74e6\u5229\u65af\u53ca\u798f\u675c\u7d0d\u7fa4\u5cf6\u590f\u4ee4\u6642\u9593", "WFST"}}, - {"Pacific/Yap", TRUT}, + {"Pacific/Yap", CHUT}, {"Poland", CET}, {"PRC", CTT}, {"PST8PDT", PST},