() {
62 | public Month createFromParcel(Parcel in) {
63 | return new Month(in);
64 | }
65 |
66 | public Month[] newArray(int size) {
67 | return new Month[size];
68 | }
69 | };
70 |
71 | /* generate working calendar */
72 | private Calendar generateWorkingCalendar(int year, int month, int day) {
73 | Calendar calendar = Calendar.getInstance();
74 | calendar.set(year, month, day);
75 |
76 | isMonthOfToday = isMonthOfToday(calendar);
77 | totalDays = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
78 | calendar.set(year, month, 1);
79 | int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
80 | delta = dayOfWeek - 1;
81 | calendar.add(Calendar.DATE, -delta);
82 |
83 | /* calculate total weeks to show in current month */
84 | totalWeeks =
85 | (totalDays + delta) / DAYS_IN_WEEK + ((totalDays + delta) % DAYS_IN_WEEK != 0 ? 1 : 0);
86 |
87 | return calendar;
88 | }
89 |
90 | /* add month day into list */
91 | private void addMonthDay(int year, int month, int day) {
92 | Calendar calendar = generateWorkingCalendar(year, month, day);
93 |
94 | for (int i = 0; i < totalWeeks; i++) {
95 | for (int j = 0; j < DAYS_IN_WEEK; j++) {
96 | MonthDay monthDay = new MonthDay(calendar);
97 | int currentDays = i * DAYS_IN_WEEK + j;
98 | monthDay.setCheckable(!(currentDays < delta || currentDays >= totalDays + delta));
99 | if (currentDays < delta) {
100 | monthDay.setDayFlag(MonthDay.PREV_MONTH_DAY);
101 | } else if (currentDays >= totalDays + delta) {
102 | monthDay.setDayFlag(MonthDay.NEXT_MONTH_DAY);
103 | }
104 | monthDayList.add(monthDay);
105 | calendar.add(Calendar.DATE, 1);
106 | }
107 | }
108 | }
109 |
110 | /* to check if current month is the month of today for given calendar */
111 | private boolean isMonthOfToday(Calendar calendar) {
112 | Calendar today = Calendar.getInstance();
113 | today.setTimeInMillis(System.currentTimeMillis());
114 |
115 | return calendar.get(Calendar.YEAR) == today.get(Calendar.YEAR)
116 | && calendar.get(Calendar.MONTH) == today.get(Calendar.MONTH);
117 | }
118 |
119 | /**
120 | * Get total weeks in current month.
121 | *
122 | * @return total weeks
123 | */
124 | protected int getWeeksInMonth() {
125 | return totalWeeks;
126 | }
127 |
128 | /**
129 | * Get {@link MonthDay} in current month according to index.
130 | *
131 | * @param index index in month view
132 | * @return {@link MonthDay}
133 | */
134 | protected MonthDay getMonthDay(int index) {
135 | return monthDayList.size() <= index ? null : monthDayList.get(index);
136 | }
137 |
138 | /**
139 | * Get {@link MonthDay} in current month according to x index and y index in month view.
140 | *
141 | * @param xIndex x index in month view
142 | * @param yIndex y index in month view
143 | * @return {@link MonthDay}
144 | */
145 | protected MonthDay getMonthDay(int xIndex, int yIndex) {
146 | return getMonthDay(xIndex * DAYS_IN_WEEK + yIndex);
147 | }
148 |
149 | /**
150 | * Get the year of current month.
151 | *
152 | * @return year
153 | */
154 | protected int getYear() {
155 | return year;
156 | }
157 |
158 | /**
159 | * Get current month.
160 | *
161 | * @return current month
162 | */
163 | protected int getMonth() {
164 | return month;
165 | }
166 |
167 | /**
168 | * To check if current month is the month of today.
169 | *
170 | * @return true if was, otherwise return false
171 | */
172 | protected boolean isMonthOfToday() {
173 | return isMonthOfToday;
174 | }
175 |
176 | /**
177 | * Get the index of day in current month.
178 | *
179 | * @param day the day in current month
180 | * @return the index of day
181 | */
182 | protected int getIndexOfDayInCurMonth(int day) {
183 | for (int i = 0; i < monthDayList.size(); i++) {
184 | MonthDay monthDay = monthDayList.get(i);
185 | if (monthDay.isCheckable() && monthDay.getCalendar().get(Calendar.DAY_OF_MONTH) == day) {
186 | return i;
187 | }
188 | }
189 |
190 | return -1;
191 | }
192 |
193 | /**
194 | * Get the index of today if today was in current month.
195 | *
196 | * @return the index of today if was in current month, otherwise return -1
197 | */
198 | protected int getIndexOfToday() {
199 | if (!isMonthOfToday) {
200 | return -1;
201 | }
202 |
203 | Calendar today = Calendar.getInstance();
204 | today.setTimeInMillis(System.currentTimeMillis());
205 | return getIndexOfDayInCurMonth(today.get(Calendar.DAY_OF_MONTH));
206 | }
207 | }
208 |
--------------------------------------------------------------------------------
/library/src/main/java/com/coolerfall/widget/lunar/MonthView.java:
--------------------------------------------------------------------------------
1 | package com.coolerfall.widget.lunar;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.content.Context;
5 | import android.graphics.Canvas;
6 | import android.graphics.Color;
7 | import android.graphics.Paint;
8 | import android.graphics.Rect;
9 | import android.graphics.Region;
10 | import android.graphics.drawable.Drawable;
11 | import android.view.MotionEvent;
12 | import android.view.View;
13 | import java.util.Calendar;
14 |
15 | /**
16 | * Display one month with solar and lunar date on a calendar.
17 | *
18 | * @author Vincent Cheung (coolingfall@gmail.com)
19 | */
20 | @SuppressLint("ViewConstructor") final class MonthView extends View {
21 | private static final int DAYS_IN_WEEK = 7;
22 |
23 | private int selectedIndex = -1;
24 |
25 | private float solarTextSize;
26 | private float lunarTextSize;
27 | private float lunarOffset;
28 | private float circleRadius;
29 |
30 | private Month month;
31 | private LunarView lunarView;
32 |
33 | private final Region[][] monthWithFourWeeks = new Region[4][DAYS_IN_WEEK];
34 | private final Region[][] monthWithFiveWeeks = new Region[5][DAYS_IN_WEEK];
35 | private final Region[][] monthWithSixWeeks = new Region[6][DAYS_IN_WEEK];
36 | private Paint paint;
37 |
38 | /**
39 | * The constructor of month view.
40 | *
41 | * @param context context to use
42 | * @param lunarView {@link LunarView}
43 | */
44 | public MonthView(Context context, Month month, LunarView lunarView) {
45 | super(context);
46 |
47 | this.month = month;
48 | this.lunarView = lunarView;
49 | init();
50 | }
51 |
52 | @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) {
53 | super.onSizeChanged(w, h, oldw, oldh);
54 |
55 | int dayWidth = (int) (w / 7f);
56 | int dayHeightInFourWeek = (int) (h / 4f);
57 | int dayHeightInFiveWeek = (int) (h / 5f);
58 | int dayHeightInSixWeek = (int) (h / 6f);
59 |
60 | circleRadius = dayWidth / 2.2f;
61 |
62 | solarTextSize = h / 15f;
63 | paint.setTextSize(solarTextSize);
64 | float solarHeight = paint.getFontMetrics().bottom - paint.getFontMetrics().top;
65 |
66 | lunarTextSize = solarTextSize / 2;
67 | paint.setTextSize(lunarTextSize);
68 | float lunarHeight = paint.getFontMetrics().bottom - paint.getFontMetrics().top;
69 |
70 | lunarOffset = (Math.abs(paint.ascent() + paint.descent()) + solarHeight + lunarHeight) / 3f;
71 |
72 | initMonthRegion(monthWithFourWeeks, dayWidth, dayHeightInFourWeek);
73 | initMonthRegion(monthWithFiveWeeks, dayWidth, dayHeightInFiveWeek);
74 | initMonthRegion(monthWithSixWeeks, dayWidth, dayHeightInSixWeek);
75 | }
76 |
77 | @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
78 | int measureWidth = MeasureSpec.getSize(widthMeasureSpec);
79 | setMeasuredDimension(measureWidth, (int) (measureWidth * 6f / 7f));
80 | }
81 |
82 | @Override protected void onDraw(Canvas canvas) {
83 | super.onDraw(canvas);
84 |
85 | if (month == null) {
86 | return;
87 | }
88 |
89 | canvas.save();
90 | int weeks = month.getWeeksInMonth();
91 | Region[][] monthRegion = getMonthRegion();
92 |
93 | for (int i = 0; i < weeks; i++) {
94 | for (int j = 0; j < DAYS_IN_WEEK; j++) {
95 | draw(canvas, monthRegion[i][j].getBounds(), i, j);
96 | }
97 | }
98 | canvas.restore();
99 | }
100 |
101 | @SuppressLint("ClickableViewAccessibility") @Override
102 | public boolean onTouchEvent(MotionEvent event) {
103 | switch (event.getAction()) {
104 | case MotionEvent.ACTION_DOWN:
105 | return true;
106 |
107 | case MotionEvent.ACTION_UP:
108 | handleClickEvent((int) event.getX(), (int) event.getY());
109 | return true;
110 |
111 | default:
112 | return super.onTouchEvent(event);
113 | }
114 | }
115 |
116 | /* init month view */
117 | private void init() {
118 | paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG | Paint.LINEAR_TEXT_FLAG);
119 | paint.setTextAlign(Paint.Align.CENTER);
120 |
121 | if (month.isMonthOfToday()) {
122 | selectedIndex = month.getIndexOfToday();
123 | }
124 |
125 | setBackgroundColor(lunarView.getMonthBackgroundColor());
126 | }
127 |
128 | /* init month region with the width and height of day */
129 | private void initMonthRegion(Region[][] monthRegion, int dayWidth, int dayHeight) {
130 | for (int i = 0; i < monthRegion.length; i++) {
131 | for (int j = 0; j < monthRegion[i].length; j++) {
132 | Region region = new Region();
133 | region.set(j * dayWidth, i * dayHeight, dayWidth + j * dayWidth, dayWidth + i * dayHeight);
134 | monthRegion[i][j] = region;
135 | }
136 | }
137 | }
138 |
139 | /* get month region for current month */
140 | private Region[][] getMonthRegion() {
141 | int weeks = month.getWeeksInMonth();
142 | Region[][] monthRegion;
143 | if (weeks == 4) {
144 | monthRegion = monthWithFourWeeks;
145 | } else if (weeks == 5) {
146 | monthRegion = monthWithFiveWeeks;
147 | } else {
148 | monthRegion = monthWithSixWeeks;
149 | }
150 |
151 | return monthRegion;
152 | }
153 |
154 | /* draw all the text in month view */
155 | private void draw(Canvas canvas, Rect rect, int xIndex, int yIndex) {
156 | MonthDay monthDay = month.getMonthDay(xIndex, yIndex);
157 |
158 | drawBackground(canvas, rect, monthDay, xIndex, yIndex);
159 | drawSolarText(canvas, rect, monthDay);
160 | drawLunarText(canvas, rect, monthDay);
161 | }
162 |
163 | /* draw solar text in month view */
164 | private void drawSolarText(Canvas canvas, Rect rect, MonthDay monthDay) {
165 | if (monthDay == null) {
166 | return;
167 | }
168 |
169 | if (!monthDay.isCheckable()) {
170 | paint.setColor(lunarView.getUnCheckableColor());
171 | } else if (monthDay.isWeekend()) {
172 | paint.setColor(lunarView.getHightlightColor());
173 | } else {
174 | paint.setColor(lunarView.getSolarTextColor());
175 | }
176 |
177 | paint.setTextSize(solarTextSize);
178 | canvas.drawText(monthDay.getSolarDay(), rect.centerX(), rect.centerY(), paint);
179 | }
180 |
181 | /* draw lunar text in month view */
182 | private void drawLunarText(Canvas canvas, Rect rect, MonthDay monthDay) {
183 | if (monthDay == null) {
184 | return;
185 | }
186 |
187 | if (!monthDay.isCheckable()) {
188 | paint.setColor(lunarView.getUnCheckableColor());
189 | } else if (monthDay.isHoliday()) {
190 | paint.setColor(lunarView.getHightlightColor());
191 | } else {
192 | paint.setColor(lunarView.getLunarTextColor());
193 | }
194 |
195 | paint.setTextSize(lunarTextSize);
196 | canvas.drawText(monthDay.getLunarDay(), rect.centerX(), rect.centerY() + lunarOffset, paint);
197 | }
198 |
199 | /* draw circle for selected day */
200 | private void drawBackground(Canvas canvas, Rect rect, MonthDay day, int xIndex, int yIndex) {
201 | if (day.isToday()) {
202 | Drawable background = lunarView.getTodayBackground();
203 | if (background == null) {
204 | drawRing(canvas, rect);
205 | } else {
206 | background.setBounds(rect);
207 | background.draw(canvas);
208 | }
209 |
210 | return;
211 | }
212 |
213 | /* not today was selected */
214 | if (selectedIndex == -1 && day.isFirstDay()) {
215 | selectedIndex = xIndex * DAYS_IN_WEEK + yIndex;
216 | }
217 |
218 | if (selectedIndex / DAYS_IN_WEEK != xIndex || selectedIndex % DAYS_IN_WEEK != yIndex) {
219 | return;
220 | }
221 |
222 | paint.setColor(lunarView.getCheckedDayBackgroundColor());
223 | canvas.drawCircle(rect.centerX(), rect.centerY(), circleRadius, paint);
224 | }
225 |
226 | /* draw ring as background of today */
227 | private void drawRing(Canvas canvas, Rect rect) {
228 | paint.setColor(Color.RED);
229 | canvas.drawCircle(rect.centerX(), rect.centerY(), circleRadius, paint);
230 | paint.setColor(lunarView.getMonthBackgroundColor());
231 | canvas.drawCircle(rect.centerX(), rect.centerY(), circleRadius - 4, paint);
232 | }
233 |
234 | /* handle date click event */
235 | private void handleClickEvent(int x, int y) {
236 | Region[][] monthRegion = getMonthRegion();
237 | for (int i = 0; i < monthRegion.length; i++) {
238 | for (int j = 0; j < DAYS_IN_WEEK; j++) {
239 | Region region = monthRegion[i][j];
240 | if (!region.contains(x, y)) {
241 | continue;
242 | }
243 |
244 | MonthDay monthDay = month.getMonthDay(i, j);
245 | if (monthDay == null) {
246 | return;
247 | }
248 |
249 | int day = monthDay.getCalendar().get(Calendar.DAY_OF_MONTH);
250 |
251 | if (monthDay.isCheckable()) {
252 | selectedIndex = i * DAYS_IN_WEEK + j;
253 | performDayClick();
254 | invalidate();
255 | } else {
256 | if (monthDay.getDayFlag() == MonthDay.PREV_MONTH_DAY) {
257 | lunarView.showPrevMonth(day);
258 | } else if (monthDay.getDayFlag() == MonthDay.NEXT_MONTH_DAY) {
259 | lunarView.showNextMonth(day);
260 | }
261 | }
262 | break;
263 | }
264 | }
265 | }
266 |
267 | /**
268 | * Perform day click event.
269 | */
270 | protected void performDayClick() {
271 | MonthDay monthDay = month.getMonthDay(selectedIndex);
272 | lunarView.dispatchDateClickListener(monthDay);
273 | }
274 |
275 | /**
276 | * Set selected day, the selected day will draw background.
277 | *
278 | * @param day selected day
279 | */
280 | protected void setSelectedDay(int day) {
281 | if (month.isMonthOfToday() && day == 0) {
282 | selectedIndex = month.getIndexOfToday();
283 | } else {
284 | int selectedDay = day == 0 ? 1 : day;
285 | selectedIndex = month.getIndexOfDayInCurMonth(selectedDay);
286 | }
287 |
288 | invalidate();
289 |
290 | if ((day == 0 && lunarView.getShouldPickOnMonthChange()) || day != 0) {
291 | performDayClick();
292 | }
293 | }
294 | }
295 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "{}"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright (C) 2015-2017 Vincent Cheung
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
203 |
--------------------------------------------------------------------------------
/library/src/main/java/com/coolerfall/widget/lunar/LunarView.java:
--------------------------------------------------------------------------------
1 | package com.coolerfall.widget.lunar;
2 |
3 | import android.content.Context;
4 | import android.content.res.TypedArray;
5 | import android.graphics.Color;
6 | import android.graphics.drawable.Drawable;
7 | import android.os.Build;
8 | import android.support.annotation.ColorInt;
9 | import android.support.annotation.ColorRes;
10 | import android.support.annotation.DrawableRes;
11 | import android.support.v4.content.ContextCompat;
12 | import android.support.v4.view.ViewPager;
13 | import android.util.AttributeSet;
14 | import android.view.View;
15 | import android.widget.LinearLayout;
16 | import java.util.Calendar;
17 |
18 | /**
19 | * This class is a calendar widget for displaying and selecting dates.
20 | *
21 | * @author Vincent Cheung (coolingfall@gmail.com)
22 | */
23 | public class LunarView extends LinearLayout {
24 | private int solarTextColor = 0xff454545;
25 | private int lunarTextColor = Color.GRAY;
26 | private int hightlistColor = 0xff03a9f4;
27 | private int uncheckableColor = 0xffb0b0b0;
28 | private int monthBackgroundColor = 0xfffafafa;
29 | private int weekLabelBackgroundColor = 0xfffafafa;
30 | private int checkedDayBackgroundColor = 0xffeaeaea;
31 | private Drawable todayBackground;
32 | private boolean shouldPickOnMonthChange = true;
33 |
34 | private ViewPager viewPager;
35 | private MonthPagerAdapter monthPagerAdapter;
36 | private WeekLabelView weekLabelView;
37 | private OnDatePickListener onDatePickListener;
38 | private boolean isChangedByUser;
39 |
40 | public LunarView(Context context) {
41 | this(context, null);
42 | }
43 |
44 | public LunarView(Context context, AttributeSet attrs) {
45 | this(context, attrs, 0);
46 | }
47 |
48 | public LunarView(Context context, AttributeSet attrs, int defStyleAttr) {
49 | super(context, attrs, defStyleAttr);
50 | init(attrs);
51 | }
52 |
53 | @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
54 | int measureWidth = MeasureSpec.getSize(widthMeasureSpec);
55 |
56 | for (int i = 0; i < getChildCount(); i++) {
57 | final View child = getChildAt(i);
58 |
59 | int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(measureWidth, MeasureSpec.EXACTLY);
60 | int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(measureWidth, MeasureSpec.EXACTLY);
61 | child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
62 | }
63 |
64 | int measureHeight = (int) (measureWidth * 6f / 7f) + weekLabelView.getMeasuredHeight();
65 | setMeasuredDimension(measureWidth, measureHeight);
66 | }
67 |
68 | /* init lunar view */
69 | private void init(AttributeSet attrs) {
70 | /* get custom attrs */
71 | TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.LunarView);
72 | monthBackgroundColor =
73 | a.getColor(R.styleable.LunarView_monthBackgroundColor, monthBackgroundColor);
74 | weekLabelBackgroundColor =
75 | a.getColor(R.styleable.LunarView_monthBackgroundColor, weekLabelBackgroundColor);
76 | solarTextColor = a.getColor(R.styleable.LunarView_solarTextColor, solarTextColor);
77 | lunarTextColor = a.getColor(R.styleable.LunarView_lunarTextColor, lunarTextColor);
78 | hightlistColor = a.getColor(R.styleable.LunarView_highlightColor, hightlistColor);
79 | uncheckableColor = a.getColor(R.styleable.LunarView_uncheckableColor, uncheckableColor);
80 | todayBackground = a.getDrawable(R.styleable.LunarView_todayBackground);
81 | checkedDayBackgroundColor =
82 | a.getColor(R.styleable.LunarView_checkedDayBackgroundColor, checkedDayBackgroundColor);
83 | shouldPickOnMonthChange =
84 | a.getBoolean(R.styleable.LunarView_shouldPickOnMonthChange, shouldPickOnMonthChange);
85 | a.recycle();
86 |
87 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
88 | /* if we're on good Android versions, turn off clipping for cool effects */
89 | setClipToPadding(false);
90 | setClipChildren(false);
91 | } else {
92 | /* old Android does not like _not_ clipping view pagers, we need to clip */
93 | setClipChildren(true);
94 | setClipToPadding(true);
95 | }
96 |
97 | /* set the orientation to vertical */
98 | setOrientation(VERTICAL);
99 |
100 | weekLabelView = new WeekLabelView(getContext());
101 | weekLabelView.setBackgroundColor(weekLabelBackgroundColor);
102 | addView(weekLabelView);
103 |
104 | viewPager = new ViewPager(getContext());
105 | viewPager.setOffscreenPageLimit(1);
106 | addView(viewPager);
107 |
108 | monthPagerAdapter = new MonthPagerAdapter(getContext(), this);
109 | viewPager.setAdapter(monthPagerAdapter);
110 | viewPager.addOnPageChangeListener(mPageListener);
111 | viewPager.setCurrentItem(monthPagerAdapter.getIndexOfCurrentMonth());
112 | viewPager.setPageTransformer(false, new ViewPager.PageTransformer() {
113 | @Override public void transformPage(View page, float position) {
114 | page.setAlpha(1 - Math.abs(position));
115 | }
116 | });
117 | }
118 |
119 | /* page change listener */
120 | private ViewPager.OnPageChangeListener mPageListener = new ViewPager.OnPageChangeListener() {
121 | @Override
122 | public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
123 |
124 | }
125 |
126 | @Override public void onPageSelected(int position) {
127 | if (isChangedByUser) {
128 | isChangedByUser = false;
129 | return;
130 | }
131 |
132 | monthPagerAdapter.resetSelectedDay(position);
133 | }
134 |
135 | @Override public void onPageScrollStateChanged(int state) {
136 |
137 | }
138 | };
139 |
140 | /* get color with given color resource id */
141 | private int getColor(@ColorRes int resId) {
142 | return ContextCompat.getColor(getContext(), resId);
143 | }
144 |
145 | /* get color with given drawable resource id */
146 | private Drawable getDrawable(@DrawableRes int resId) {
147 | return ContextCompat.getDrawable(getContext(), resId);
148 | }
149 |
150 | /**
151 | * Interface definition for a callback to be invoked when date picked.
152 | */
153 | public interface OnDatePickListener {
154 | /**
155 | * Invoked when date picked.
156 | *
157 | * @param view {@link LunarView}
158 | * @param monthDay {@link MonthDay}
159 | */
160 | void onDatePick(LunarView view, MonthDay monthDay);
161 | }
162 |
163 | /**
164 | * Get the color of month view background.
165 | *
166 | * @return color of month background
167 | */
168 | protected int getMonthBackgroundColor() {
169 | return monthBackgroundColor;
170 | }
171 |
172 | /**
173 | * Get the text color of solar day.
174 | *
175 | * @return text color of solar day
176 | */
177 | protected int getSolarTextColor() {
178 | return solarTextColor;
179 | }
180 |
181 | /**
182 | * Get the text color of lunar day.
183 | *
184 | * @return text color of lunar day
185 | */
186 | protected int getLunarTextColor() {
187 | return lunarTextColor;
188 | }
189 |
190 | /**
191 | * Get the highlight color.
192 | *
193 | * @return thighlight color
194 | */
195 | protected int getHightlightColor() {
196 | return hightlistColor;
197 | }
198 |
199 | /**
200 | * Get the color of uncheckable day.
201 | *
202 | * @return uncheckable color
203 | */
204 | protected int getUnCheckableColor() {
205 | return uncheckableColor;
206 | }
207 |
208 | /**
209 | * Get the background of today.
210 | *
211 | * @return background drawable
212 | */
213 | protected Drawable getTodayBackground() {
214 | return todayBackground;
215 | }
216 |
217 | /**
218 | * Get the color of checked day.
219 | *
220 | * @return color of checked day
221 | */
222 | int getCheckedDayBackgroundColor() {
223 | return checkedDayBackgroundColor;
224 | }
225 |
226 | /**
227 | * Auto pick date when month changed or not.
228 | *
229 | * @return true or false
230 | */
231 | protected boolean getShouldPickOnMonthChange() {
232 | return shouldPickOnMonthChange;
233 | }
234 |
235 | /**
236 | * Set the text color of solar day.
237 | *
238 | * @param color color
239 | */
240 | public void setSolarTextColor(@ColorInt int color) {
241 | solarTextColor = color;
242 | }
243 |
244 | /**
245 | * Set the text color resource of solar day.
246 | *
247 | * @param resId resource id
248 | */
249 | public void setSolarTextColorRes(@ColorRes int resId) {
250 | solarTextColor = getColor(resId);
251 | }
252 |
253 | /**
254 | * Set the text color of lunar day.
255 | *
256 | * @param color color
257 | */
258 | public void setLunarTextColor(@ColorInt int color) {
259 | lunarTextColor = color;
260 | }
261 |
262 | /**
263 | * Set the text color resource of lunar day.
264 | *
265 | * @param resId resource id
266 | */
267 | public void setLunarTextColorRes(@ColorRes int resId) {
268 | lunarTextColor = getColor(resId);
269 | }
270 |
271 | /**
272 | * Set the highlight color.
273 | *
274 | * @param color color
275 | */
276 | public void setHighlightColor(@ColorInt int color) {
277 | hightlistColor = color;
278 | }
279 |
280 | /**
281 | * Set the highlight color resource.
282 | *
283 | * @param resId resource id
284 | */
285 | public void setHighlightColorRes(@ColorRes int resId) {
286 | hightlistColor = getColor(resId);
287 | }
288 |
289 | /**
290 | * Set the text color resource of uncheckable day.
291 | *
292 | * @param resId resource id
293 | */
294 | public void setUncheckableColorRes(@ColorRes int resId) {
295 | uncheckableColor = getColor(resId);
296 | }
297 |
298 | /**
299 | * Set the text color of uncheckable day.
300 | *
301 | * @param color color
302 | */
303 | public void setUncheckableColor(@ColorInt int color) {
304 | uncheckableColor = color;
305 | }
306 |
307 | /**
308 | * Set the background drawable of today.
309 | *
310 | * @param resId drawable resource id
311 | */
312 | public void setTodayBackground(@DrawableRes int resId) {
313 | todayBackground = getDrawable(resId);
314 | }
315 |
316 | /**
317 | * Set on date click listener. This listener will be invoked
318 | * when a day in month was picked.
319 | *
320 | * @param l date pick listner
321 | */
322 | public void setOnDatePickListener(OnDatePickListener l) {
323 | onDatePickListener = l;
324 | }
325 |
326 | /**
327 | * Dispatch date pick listener. This will be invoked be {@link MonthView}
328 | *
329 | * @param monthDay month day
330 | */
331 | protected void dispatchDateClickListener(MonthDay monthDay) {
332 | if (onDatePickListener != null) {
333 | onDatePickListener.onDatePick(this, monthDay);
334 | }
335 | }
336 |
337 | /* show the month page with specified pager position and selected day */
338 | private void showMonth(int position, int selectedDay) {
339 | isChangedByUser = true;
340 | monthPagerAdapter.setSelectedDay(position, selectedDay);
341 | viewPager.setCurrentItem(position, true);
342 | }
343 |
344 | /**
345 | * Show previous month page with selected day.
346 | *
347 | * @param selectedDay selected day
348 | */
349 | protected void showPrevMonth(int selectedDay) {
350 | int position = viewPager.getCurrentItem() - 1;
351 | showMonth(position, selectedDay);
352 | }
353 |
354 | /**
355 | * Show next month page with selected day.
356 | *
357 | * @param selectedDay selected day
358 | */
359 | protected void showNextMonth(int selectedDay) {
360 | int position = viewPager.getCurrentItem() + 1;
361 | showMonth(position, selectedDay);
362 | }
363 |
364 | /**
365 | * Show previous month view.
366 | */
367 | public void showPrevMonth() {
368 | showPrevMonth(1);
369 | }
370 |
371 | /**
372 | * Show next month view.
373 | */
374 | public void showNextMonth() {
375 | showNextMonth(1);
376 | }
377 |
378 | /**
379 | * Go to the month with specified year and month.
380 | *
381 | * @param year the specified year
382 | * @param month the specified month
383 | */
384 | public void goToMonth(int year, int month) {
385 | showMonth(monthPagerAdapter.getIndexOfMonth(year, month), 1);
386 | }
387 |
388 | /**
389 | * Go to the month with specified year, month and day.
390 | *
391 | * @param year the specified year
392 | * @param month the specified month
393 | * @param day the specified day
394 | */
395 | public void goToMonthDay(int year, int month, int day) {
396 | showMonth(monthPagerAdapter.getIndexOfMonth(year, month), day);
397 | }
398 |
399 | /**
400 | * Go back to the month of today.
401 | */
402 | public void backToToday() {
403 | Calendar today = Calendar.getInstance();
404 | today.setTimeInMillis(System.currentTimeMillis());
405 | showMonth(monthPagerAdapter.getIndexOfCurrentMonth(), today.get(Calendar.DAY_OF_MONTH));
406 | }
407 |
408 | /**
409 | * Set the range of date.
410 | *
411 | * @param minYear min year
412 | * @param maxYear max year
413 | */
414 | public void setDateRange(int minYear, int maxYear) {
415 | Month min = new Month(minYear, 0, 1);
416 | Month max = new Month(maxYear, 11, 1);
417 | monthPagerAdapter.setDateRange(min, max);
418 | }
419 | }
420 |
--------------------------------------------------------------------------------
/library/src/main/java/com/coolerfall/widget/lunar/Lunar.java:
--------------------------------------------------------------------------------
1 | package com.coolerfall.widget.lunar;
2 |
3 | import java.util.Calendar;
4 | import java.util.Date;
5 | import java.util.GregorianCalendar;
6 | import java.util.TimeZone;
7 |
8 | /**
9 | * Lunar calendar in 200 years from 1900.
10 | *
11 | * @author Vincent Cheung (coolingfall@gmail.com)
12 | */
13 | public final class Lunar {
14 | /**
15 | * Lunar information in 200 years from 1900.
16 | *
17 | * | 0 - 11(bit) | 12 - 15(bit) |
18 | * month leap month
19 | * If last 4bit is 1111 or 0000 means no leap month.
20 | * If the last 4bit in next data is 1111, the days of leap month is 30 days,
21 | * otherwise, the days of leap month is 29days.
22 | */
23 | private static final int[] LUNR_INFO = {
24 | 0x4bd8, 0x4ae0, 0xa570, 0x54d5, 0xd260, 0xd950, 0x5554, 0x56af, 0x9ad0, 0x55d2, 0x4ae0,
25 | 0xa5b6, 0xa4d0, 0xd250, 0xd295, 0xb54f, 0xd6a0, 0xada2, 0x95b0, 0x4977, 0x497f, 0xa4b0,
26 | 0xb4b5, 0x6a50, 0x6d40, 0xab54, 0x2b6f, 0x9570, 0x52f2, 0x4970, 0x6566, 0xd4a0, 0xea50,
27 | 0x6a95, 0x5adf, 0x2b60, 0x86e3, 0x92ef, 0xc8d7, 0xc95f, 0xd4a0, 0xd8a6, 0xb55f, 0x56a0,
28 | 0xa5b4, 0x25df, 0x92d0, 0xd2b2, 0xa950, 0xb557, 0x6ca0, 0xb550, 0x5355, 0x4daf, 0xa5b0,
29 | 0x4573, 0x52bf, 0xa9a8, 0xe950, 0x6aa0, 0xaea6, 0xab50, 0x4b60, 0xaae4, 0xa570, 0x5260,
30 | 0xf263, 0xd950, 0x5b57, 0x56a0, 0x96d0, 0x4dd5, 0x4ad0, 0xa4d0, 0xd4d4, 0xd250, 0xd558,
31 | 0xb540, 0xb6a0, 0x95a6, 0x95bf, 0x49b0, 0xa974, 0xa4b0, 0xb27a, 0x6a50, 0x6d40, 0xaf46,
32 | 0xab60, 0x9570, 0x4af5, 0x4970, 0x64b0, 0x74a3, 0xea50, 0x6b58, 0x5ac0, 0xab60, 0x96d5,
33 | 0x92e0, 0xc960, 0xd954, 0xd4a0, 0xda50, 0x7552, 0x56a0, 0xabb7, 0x25d0, 0x92d0, 0xcab5,
34 | 0xa950, 0xb4a0, 0xbaa4, 0xad50, 0x55d9, 0x4ba0, 0xa5b0, 0x5176, 0x52bf, 0xa930, 0x7954,
35 | 0x6aa0, 0xad50, 0x5b52, 0x4b60, 0xa6e6, 0xa4e0, 0xd260, 0xea65, 0xd530, 0x5aa0, 0x76a3,
36 | 0x96d0, 0x4afb, 0x4ad0, 0xa4d0, 0xd0b6, 0xd25f, 0xd520, 0xdd45, 0xb5a0, 0x56d0, 0x55b2,
37 | 0x49b0, 0xa577, 0xa4b0, 0xaa50, 0xb255, 0x6d2f, 0xada0, 0x4b63, 0x937f, 0x49f8, 0x4970,
38 | 0x64b0, 0x68a6, 0xea5f, 0x6b20, 0xa6c4, 0xaaef, 0x92e0, 0xd2e3, 0xc960, 0xd557, 0xd4a0,
39 | 0xda50, 0x5d55, 0x56a0, 0xa6d0, 0x55d4, 0x52d0, 0xa9b8, 0xa950, 0xb4a0, 0xb6a6, 0xad50,
40 | 0x55a0, 0xaba4, 0xa5b0, 0x52b0, 0xb273, 0x6930, 0x7337, 0x6aa0, 0xad50, 0x4b55, 0x4b6f,
41 | 0xa570, 0x54e4, 0xd260, 0xe968, 0xd520, 0xdaa0, 0x6aa6, 0x56df, 0x4ae0, 0xa9d4, 0xa4d0,
42 | 0xd150, 0xf252, 0xd520
43 | };
44 |
45 | /* solar terms information */
46 | private static final int[] SOLAR_TERM_INFO = {
47 | 0, 21208, 42467, 63836, 85337, 107014, 128867, 150921, 173149, 195551, 218072, 240693, 263343,
48 | 285989, 308563, 331033, 353350, 375494, 397447, 419210, 440795, 462224, 483532, 504758
49 | };
50 |
51 | /* Heavenly Stems */
52 | private static final String[] HEAVENLY_STEMS = {
53 | "甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"
54 | };
55 |
56 | /* Earthly Branches */
57 | private static final String[] EARTHLY_BRANCHES = {
58 | "子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"
59 | };
60 |
61 | /* Chinese zodiac */
62 | private static final String[] ZODIAC = {
63 | "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"
64 | };
65 |
66 | /* solar terms */
67 | private static final String[] SOLAR_TERM = {
68 | "小寒", "大寒", "立春", "雨水", "惊蛰", "春分", "清明", "谷雨", "立夏", "小满", "芒种", "夏至", "小暑", "大暑", "立秋",
69 | "处暑", "白露", "秋分", "寒露", "霜降", "立冬", "小雪", "大雪", "冬至"
70 | };
71 |
72 | /* lunar string used in month and day */
73 | private static final String[] LUNAR_STRING = {
74 | "零", "一", "二", "三", "四", "五", "六", "七", "八", "九"
75 | };
76 |
77 | /* special lunar string */
78 | private static final String[] LUNAR_SPEC_STRING = {
79 | "初", "十", "廿", "卅", "正", "冬", "腊", "闰"
80 | };
81 |
82 | /* day of week in Chinese */
83 | private static final String[] DAY_OF_WEEK_IN_CHINESE = {
84 | "日", "一", "二", "三", "四", "五", "六",
85 | };
86 |
87 | /* all the lunar holidays */
88 | private final Holiday[] lunarHolidays = new Holiday[] {
89 | new Holiday(1, 1, "春节"), new Holiday(1, 15, "元宵节"), new Holiday(5, 5, "端午节"),
90 | new Holiday(7, 7, "七夕节"), new Holiday(7, 15, "中元节"), new Holiday(8, 15, "中秋节"),
91 | new Holiday(9, 9, "重阳节"), new Holiday(12, 8, "腊八节"), new Holiday(12, 23, "北方小年"),
92 | new Holiday(12, 24, "南方小年")
93 | };
94 |
95 | /* all the solar days */
96 | private final Holiday[] solarHolidays = new Holiday[] {
97 | new Holiday(1, 1, "元旦节"), new Holiday(2, 14, "情人节"), new Holiday(3, 8, "妇女节"),
98 | new Holiday(3, 12, "植树节"), new Holiday(3, 15, "消费者权益日"), new Holiday(3, 21, "世界森林日"),
99 | new Holiday(4, 1, "愚人节"), new Holiday(4, 7, "世界卫生日"), new Holiday(4, 22, "世界地球日"),
100 | new Holiday(5, 1, "劳动节"), new Holiday(5, 4, "青年节"), new Holiday(5, 31, "世界无烟日"),
101 | new Holiday(6, 1, "儿童节"), new Holiday(6, 26, "禁毒日"), new Holiday(7, 1, "建党节"),
102 | new Holiday(8, 1, "建军节"), new Holiday(8, 15, "抗战胜利"), new Holiday(9, 10, "教师节"),
103 | new Holiday(9, 28, "孔子诞辰"), new Holiday(10, 1, "国庆节"), new Holiday(12, 20, "澳门回归"),
104 | new Holiday(12, 24, "平安夜"), new Holiday(12, 25, "圣诞节"),
105 | };
106 |
107 | /* Pengzu hundred dread Heavenly Stems */
108 | private static final String[] PENG_ZU_HEAVENLY = {
109 | "甲不开仓\n财物耗亡", "乙不栽植\n千株不长", "丙不修灶\n必见灾殃", "丁不剃头\n头主生疮", "戊不受田\n田主不祥", "己不破券\n二比并亡",
110 | "庚不经络\n织机虚张", "辛不合酱\n主人不尝", "壬不决水\n更难提防", "癸不词讼\n理弱敌强",
111 | };
112 |
113 | /* Pengzu hundred dread Earthly Branches */
114 | private static final String[] PENG_ZU_EARTHLY = {
115 | "子不问卜\n自惹祸殃", "丑不冠带\n主不还乡", "寅不祭祀\n神鬼不尝", "卯不穿井\n水泉不香", "辰不哭泣\n必主重丧", "巳不远行\n财物伏藏",
116 | "午不苫盖\n屋主更张", "未不服药\n毒气入肠", "申不安床\n鬼祟入房", "酉不宴客\n醉坐颠狂", "戌不吃犬\n作怪上床", "亥不嫁娶\n不利新郎"
117 | };
118 |
119 | /* direction of evil spirit */
120 | private static final String[] EVIL_SPIRIT = {
121 | "南", "东", "北", "西"
122 | };
123 |
124 | /* fetus god */
125 | private static final String[] FETUS_GOD_DIRECTION = {
126 | "外东北", "外正东", "外东南", "外正南", "外西南", "外正西", "外西北", "外正北", "房内北", "房内南", "房内东"
127 | };
128 |
129 | /* fetus god position in Heavenlu Stems */
130 | private static final String[] FETUS_GOD_HEAVENLY = {
131 | "门", "碓磨", "厨灶", "仓库", "房床"
132 | };
133 |
134 | /* fetus god position in Earthly Braches */
135 | private static final String[] FETUS_GOD_EARTHLY = {
136 | "碓", "厕", "炉灶", "大门", "栖", "床"
137 | };
138 |
139 | /* twelve duty */
140 | private static final String[] TWELVE_DURY = {
141 | "开", "闭", "建", "除", "满", "平", "定", "执", "破", "危", "成", "收"
142 | };
143 |
144 | /* five elements */
145 | private static final String[] FIVE_ELEMENTS = {
146 | "海中金", "炉中火", "大林木", "路旁土", "剑锋金", "山头火", "涧下水", "城头土", "白蜡金", "杨柳木", "泉中水", "屋上土", "霹雳火",
147 | "松柏木", "长流水", "砂石金", "山下火", "平地木", "壁上土", "金箔金", "灯头火", "天河水", "大驿土", "钗钏金", "桑柘木", "大溪水",
148 | "沙中土", "天上火", "石榴木", "大海水"
149 | };
150 |
151 | /* twenty eight stars with direction and fortune */
152 | private final Star[][] mTwentyEightStars = new Star[][] {
153 | new Star[] {
154 | new Star("房日兔", "吉", "东方"), new Star("心月狐", "凶", "东方"), new Star("尾火虎", "吉", "东方"),
155 | new Star("箕水豹", "吉", "东方"), new Star("角木蛟", "吉", "东方"), new Star("亢金龙", "凶", "东方"),
156 | new Star("氐土貉", "凶", "东方"),
157 | },
158 |
159 | new Star[] {
160 | new Star("虚日鼠", "凶", "北方"), new Star("危月燕", "凶", "北方"), new Star("室火猪", "吉", "北方"),
161 | new Star("壁水貐", "吉", "北方"), new Star("斗木獬", "吉", "北方"), new Star("牛金牛", "凶", "北方"),
162 | new Star("女士蝠", "凶", "北方"),
163 | },
164 |
165 | new Star[] {
166 | new Star("昴日鸡", "凶", "西方"), new Star("毕月乌", "吉", "西方"), new Star("觜火猴", "凶", "西方"),
167 | new Star("参水猿", "凶", "西方"), new Star("奎水狼", "凶", "西方"), new Star("娄金狗", "吉", "西方"),
168 | new Star("胃土雉", "吉", "西方"),
169 | },
170 |
171 | new Star[] {
172 | new Star("星日马", "凶", "南方"), new Star("张月鹿", "吉", "南方"), new Star("翼火蛇", "凶", "南方"),
173 | new Star("轸水蚓", "吉", "南方"), new Star("井木犴", "吉", "南方"), new Star("鬼金羊", "凶", "南方"),
174 | new Star("柳土獐", "凶", "南方"),
175 | },
176 | };
177 |
178 | private Calendar solar;
179 | private GregorianCalendar gregorianCalendar;
180 | private int lunarYear;
181 | private int lunarMonth;
182 | private int lunarDay;
183 | private int daysInLuarMonth;
184 | private boolean isLeap;
185 | private int solarYear;
186 | private int solarMonth;
187 | private int solarDay;
188 | private int cyclicalYear = 0;
189 | private int cyclicalMonth = 0;
190 | private int cyclicalDay = 0;
191 |
192 | /**
193 | * Create a new instance of Lunar Calendar.
194 | *
195 | * @return new instance
196 | */
197 | public static synchronized Lunar newInstance() {
198 | return new Lunar();
199 | }
200 |
201 | /**
202 | * The default constructor of lunar, create an empty Lunar, don't
203 | * forget to use {@link #setDate} or {@link #setTimeInMillis}.
204 | */
205 | public Lunar() {
206 |
207 | }
208 |
209 | /**
210 | * The constructor of Lunar calendar.
211 | *
212 | * @param year the year
213 | * @param month the month
214 | * @param day the day
215 | */
216 | public Lunar(int year, int month, int day) {
217 | setDate(year, month, day);
218 | }
219 |
220 | /**
221 | * The constructor of Lunar calendar.
222 | *
223 | * @param millisec millisecond
224 | */
225 | public Lunar(long millisec) {
226 | init(millisec);
227 | }
228 |
229 | /* Twenty-eight stars class */
230 | private class Star {
231 | private String star;
232 | private String direction;
233 | private String fortune;
234 |
235 | public Star(String star, String fortune, String direction) {
236 | this.star = star;
237 | this.fortune = fortune;
238 | this.direction = direction;
239 | }
240 |
241 | public String getDirection() {
242 | return direction;
243 | }
244 |
245 | public String getFortune() {
246 | return fortune;
247 | }
248 |
249 | public String getStar() {
250 | return star;
251 | }
252 | }
253 |
254 | /* lunar or solar holiday */
255 | private class Holiday {
256 | private int month;
257 | private int day;
258 | private String name;
259 |
260 | public Holiday(int month, int day, String name) {
261 | this.month = month;
262 | this.day = day;
263 | this.name = name;
264 | }
265 |
266 | public int getDay() {
267 | return day;
268 | }
269 |
270 | public int getMonth() {
271 | return month;
272 | }
273 |
274 | public String getName() {
275 | return name;
276 | }
277 | }
278 |
279 | /* init lunar calendar with millisecond */
280 | private void init(long millisec) {
281 | gregorianCalendar = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
282 | solar = Calendar.getInstance();
283 | solar.setTimeInMillis(millisec);
284 | lunarYear = 1900;
285 |
286 | Calendar baseDate = new GregorianCalendar(1900, 0, 31);
287 | long offset = (millisec - baseDate.getTimeInMillis()) / 86400000;
288 |
289 | int daysInLunarYear = getLunarYearDays(lunarYear);
290 | /* get current lunar year */
291 | while (lunarYear < 2100 && offset >= daysInLunarYear) {
292 | offset -= daysInLunarYear;
293 | daysInLunarYear = getLunarYearDays(++lunarYear);
294 | }
295 |
296 | /* get current lunar month */
297 | int lunarMonth = 1;
298 | int leapMonth = getLunarLeapMonth(lunarYear);
299 | boolean leapDec = false;
300 | boolean isLeap = false;
301 | int daysInLunarMonth = 0;
302 |
303 | /* to get lunar year, month and day */
304 | while (lunarMonth < 13 && offset > 0) {
305 | if (isLeap && leapDec) {
306 | daysInLunarMonth = getLunarLeapDays(lunarYear);
307 | leapDec = false;
308 | } else {
309 | daysInLunarMonth = getLunarMonthDays(lunarYear, lunarMonth);
310 | }
311 |
312 | if (offset < daysInLunarMonth) {
313 | break;
314 | }
315 | offset -= daysInLunarMonth;
316 |
317 | if (leapMonth == lunarMonth && !isLeap) {
318 | leapDec = true;
319 | isLeap = true;
320 | } else {
321 | lunarMonth++;
322 | }
323 | }
324 |
325 | daysInLuarMonth = daysInLunarMonth;
326 | this.lunarMonth = lunarMonth;
327 | this.isLeap = (lunarMonth == leapMonth && isLeap);
328 | lunarDay = (int) offset + 1;
329 |
330 | getCyclicalData();
331 | }
332 |
333 | /* init with lunar date */
334 | private void initLunar(int lunarYear, int lunarMonth, int lunarDay, boolean isLeap) {
335 | int initYear = lunarYear;
336 | int initMonth = lunarMonth;
337 | long offset = lunarDay - 1;
338 |
339 | /* calculate month into days */
340 | while (--initMonth > 0) {
341 | offset += getLunarMonthDays(lunarYear, initMonth);
342 | }
343 |
344 | int leapMonth = getLunarLeapMonth(lunarYear);
345 | if (leapMonth <= lunarMonth) {
346 | offset += getLunarLeapDays(lunarYear);
347 | }
348 |
349 | /* calculate year into days */
350 | while (initYear > 1900) {
351 | offset += getLunarYearDays(--initYear);
352 | }
353 |
354 | /* init the all variable */
355 | this.lunarYear = lunarYear;
356 | this.lunarMonth = lunarMonth;
357 | this.lunarDay = lunarDay;
358 | gregorianCalendar = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
359 | Calendar baseDate = new GregorianCalendar(1900, 0, 31);
360 | solar = Calendar.getInstance();
361 | solar.setTimeInMillis(offset * 86400000 + baseDate.getTimeInMillis());
362 |
363 | getCyclicalData();
364 | }
365 |
366 | /**
367 | * Get the leap month in lunar year.
368 | *
369 | * @param lunarYear lunar year
370 | * @return the month in specified lunar year, otherwise return 0
371 | */
372 | private int getLunarLeapMonth(int lunarYear) {
373 | int leapMonth = LUNR_INFO[lunarYear - 1900] & 0xf;
374 | return leapMonth == 0xf ? 0 : leapMonth;
375 | }
376 |
377 | /**
378 | * Get total days of leap month in lunar year.
379 | *
380 | * @param lunarYear lunar year
381 | * @return total days of leap month, otherwise return 0 if no leap month.
382 | */
383 | private int getLunarLeapDays(int lunarYear) {
384 | return getLunarLeapMonth(lunarYear) > 0 ? ((LUNR_INFO[lunarYear - 1899] & 0xf) == 0xf ? 30 : 29)
385 | : 0;
386 | }
387 |
388 | /**
389 | * Get total days of lunar year.
390 | *
391 | * @param lunarYear lunar year
392 | * @return total days of lunar year
393 | */
394 | private int getLunarYearDays(int lunarYear) {
395 | /* lunar year has (12 * 29 =) 348 days at least */
396 | int totalDays = 348;
397 | for (int i = 0x8000; i > 0x8; i >>= 1) {
398 | totalDays += ((LUNR_INFO[lunarYear - 1900] & i) != 0) ? 1 : 0;
399 | }
400 |
401 | return totalDays + getLunarLeapDays(lunarYear);
402 | }
403 |
404 | /**
405 | * Get total days of lunar month in normal case.
406 | *
407 | * @param lunarYear lunar year
408 | * @param lunarMonth lunar month
409 | * @return total days
410 | */
411 | private int getLunarMonthDays(int lunarYear, int lunarMonth) {
412 | return ((LUNR_INFO[lunarYear - 1900] & (0x10000 >> lunarMonth)) != 0) ? 30 : 29;
413 | }
414 |
415 | /**
416 | * Get Coordinated Universal Time for given params.
417 | *
418 | * @param year the year to set
419 | * @param month the month to set
420 | * @param day the day to set
421 | * @param hour the hour to set
422 | * @param min the minute to set
423 | * @param sec the second to set
424 | * @return Coordinated Universal Time
425 | */
426 | private synchronized long getUTC(int year, int month, int day, int hour, int min, int sec) {
427 | synchronized (Lunar.class) {
428 | gregorianCalendar.clear();
429 | gregorianCalendar.set(year, month, day, hour, min, sec);
430 | return gregorianCalendar.getTimeInMillis();
431 | }
432 | }
433 |
434 | /**
435 | * Convert current date into Coordinated Universal Time.
436 | *
437 | * @param date current date
438 | * @return get day in Coordinated Universal Time
439 | */
440 | private synchronized int getUTCDay(Date date) {
441 | synchronized (Lunar.class) {
442 | gregorianCalendar.clear();
443 | gregorianCalendar.setTimeInMillis(date.getTime());
444 | return gregorianCalendar.get(Calendar.DAY_OF_MONTH);
445 | }
446 | }
447 |
448 | /**
449 | * Convert current date into Coordinated Universal Time.
450 | *
451 | * @param date current date
452 | * @return get month in Coordinated Universal Time
453 | */
454 | private synchronized int getUTCMonth(Date date) {
455 | synchronized (Lunar.class) {
456 | gregorianCalendar.clear();
457 | gregorianCalendar.setTimeInMillis(date.getTime());
458 | return gregorianCalendar.get(Calendar.MONTH);
459 | }
460 | }
461 |
462 | /**
463 | * Get the day of solar terms.
464 | *
465 | * @param solarYear the specified solar year
466 | * @param index the index of solar terms in {@link #SOLAR_TERM}
467 | * @return the day of solar terms
468 | */
469 | private int getSolarTermDay(int solarYear, int index) {
470 | long millisec = (long) 31556925974.7 * (solarYear - 1900) + SOLAR_TERM_INFO[index] * 60000L;
471 | return getUTCDay(new Date(millisec + getUTC(1900, 0, 6, 2, 5, 0)));
472 | }
473 |
474 | /**
475 | * Get the month of solar terms.
476 | *
477 | * @param solarYear the specified solar year
478 | * @param index the index of solar terms in {@link #SOLAR_TERM}
479 | * @return the month of solar terms
480 | */
481 | private int getSolarTermMonth(int solarYear, int index) {
482 | long millisec = (long) 31556925974.7 * (solarYear - 1900) + SOLAR_TERM_INFO[index] * 60000L;
483 | return getUTCMonth(new Date(millisec + getUTC(1900, 0, 6, 2, 5, 0)));
484 | }
485 |
486 | /* get Heavenly Stems and Earthly Branches data */
487 | private void getCyclicalData() {
488 | solarYear = solar.get(Calendar.YEAR);
489 | solarMonth = solar.get(Calendar.MONTH);
490 | solarDay = solar.get(Calendar.DAY_OF_MONTH);
491 |
492 | int cyclicalYear;
493 | int cyclicalMonth;
494 | int cyclicalDay;
495 |
496 | /* year in Heavenly Stems and Earthly Branches */
497 | int term = getSolarTermDay(solarYear, 2);
498 | if (solarMonth < 1 || (solarMonth == 1 && solarDay < term)) {
499 | cyclicalYear = (solarYear - 1900 + 36 - 1) % 60;
500 | } else {
501 | cyclicalYear = (solarYear - 1900 + 36) % 60;
502 | }
503 |
504 | /* month in Heavenly Stems and Earthly Branches */
505 | int firstNode = getSolarTermDay(solarYear, solarMonth * 2);
506 | if (solarDay < firstNode) {
507 | cyclicalMonth = ((solarYear - 1900) * 12 + solarMonth + 12) % 60;
508 | } else {
509 | cyclicalMonth = ((solarYear - 1900) * 12 + solarMonth + 13) % 60;
510 | }
511 |
512 | cyclicalDay =
513 | (int) (getUTC(solarYear, solarMonth, solarDay, 0, 0, 0) / 86400000 + 25567 + 10) % 60;
514 |
515 | this.cyclicalYear = cyclicalYear;
516 | this.cyclicalMonth = cyclicalMonth;
517 | this.cyclicalDay = cyclicalDay;
518 | }
519 |
520 | /**
521 | * Get Heavenly Stems with specified cyclical number.
522 | *
523 | * @param cyclicalNum cyclical number in Heavenly Stems and Earthly Branches
524 | * @return Heavenly stems index
525 | */
526 | private int getHeavenlyStems(int cyclicalNum) {
527 | return cyclicalNum % 10;
528 | }
529 |
530 | /**
531 | * Get Earthly Branches with specified cyclical number.
532 | *
533 | * @param cyclicalNum cyclical number in Heavenly Stems and Earthly Branches
534 | * @return Earthly Branches index
535 | */
536 | private int getEarthlyBranches(int cyclicalNum) {
537 | return cyclicalNum % 12;
538 | }
539 |
540 | /**
541 | * Get Heavenly Stems and Earthly Branches.
542 | *
543 | * @param cyclicalNum cyclical number in Heavenly Stems and Earthly Branches
544 | * @return Heavenly Stems and Earthly Branches string
545 | */
546 | private String getCyclical(int cyclicalNum) {
547 | return HEAVENLY_STEMS[getHeavenlyStems(cyclicalNum)] + EARTHLY_BRANCHES[getEarthlyBranches(
548 | cyclicalNum)];
549 | }
550 |
551 | /**
552 | * Set date to get lunar data.
553 | *
554 | * @param year the year
555 | * @param month the month
556 | * @param day the day
557 | */
558 | public void setDate(int year, int month, int day) {
559 | Calendar calendar = Calendar.getInstance();
560 | calendar.set(year, month, day);
561 | init(year == 0 ? System.currentTimeMillis() : calendar.getTimeInMillis());
562 | }
563 |
564 | /**
565 | * Set lunar date, so then can get GregorianCalendar date.
566 | *
567 | * @param year lunar year
568 | * @param month lunar month
569 | * @param day lunar day
570 | * @param isLeap the month is leap month or not
571 | */
572 | public void setLunarDate(int year, int month, int day, boolean isLeap) {
573 | initLunar(year, month, day, isLeap);
574 | }
575 |
576 | /**
577 | * Set time in millisecond.
578 | *
579 | * @param millisecond millisecond to set
580 | */
581 | public void setTimeInMillis(long millisecond) {
582 | init(millisecond);
583 | }
584 |
585 | /**
586 | * Get Chinese zodiac string.
587 | *
588 | * @return Chinese zodiac
589 | */
590 | public String getZodiac() {
591 | return ZODIAC[(lunarYear - 4) % 12];
592 | }
593 |
594 | /**
595 | * Get solar terms for current day.
596 | *
597 | * @return solar terms, otherwise return null if was not solar term.
598 | */
599 | public String getSolarTerm() {
600 | if (getSolarTermDay(solarYear, solarMonth * 2) == solarDay) {
601 | return SOLAR_TERM[solarMonth * 2];
602 | } else if (getSolarTermDay(solarYear, solarMonth * 2 + 1) == solarDay) {
603 | return SOLAR_TERM[solarMonth * 2 + 1];
604 | }
605 |
606 | return null;
607 | }
608 |
609 | /**
610 | * Get the index of current day in Heavenly Stems and Earthly Branches.
611 | *
612 | * @return the index
613 | */
614 | public int getHeavenlyAndEarthly() {
615 | return cyclicalDay;
616 | }
617 |
618 | /**
619 | * Get year in Heavenly Stems and Earthly Branches.
620 | *
621 | * @return year in Heavenly Stems and Earthly Branches
622 | */
623 | public String getCyclicalYear() {
624 | return getCyclical(cyclicalYear);
625 | }
626 |
627 | /**
628 | * Get month in Heavenly Stems and Earthly Branches.
629 | *
630 | * @return month in Heavenly Stems and Earthly Branches
631 | */
632 | public String getCyclicalMonth() {
633 | return getCyclical(cyclicalMonth);
634 | }
635 |
636 | /**
637 | * Get day in Heavenly Stems and Earthly Branches.
638 | *
639 | * @return day in Heavenly Stems and Earthly Branches
640 | */
641 | public String getCyclicalDay() {
642 | return getCyclical(cyclicalDay);
643 | }
644 |
645 | /**
646 | * Get year in lunar calendar.
647 | *
648 | * @return year in lunar calendar
649 | */
650 | public String getLunarYear() {
651 | return getCyclical(lunarYear - 1900 + 36);
652 | }
653 |
654 | /**
655 | * Get lunar month in Chinese according to lunar month numeric.
656 | *
657 | * @param lunarMonth lunar month numeric
658 | * @param isLeap is current month leap or not
659 | * @return lunar month in Chinese
660 | */
661 | public String getLunarMonth(int lunarMonth, boolean isLeap) {
662 | String lunarMonthStr = "";
663 | if (lunarMonth == 1) {
664 | lunarMonthStr = LUNAR_SPEC_STRING[4];
665 | } else {
666 | switch (lunarMonth) {
667 | case 10:
668 | lunarMonthStr = LUNAR_SPEC_STRING[1];
669 | break;
670 |
671 | case 11:
672 | lunarMonthStr = LUNAR_SPEC_STRING[5];
673 | break;
674 |
675 | case 12:
676 | lunarMonthStr = LUNAR_SPEC_STRING[6];
677 | break;
678 |
679 | default:
680 | lunarMonthStr += LUNAR_STRING[lunarMonth % 10];
681 | break;
682 | }
683 | }
684 |
685 | return (isLeap ? "闰" : "") + lunarMonthStr;
686 | }
687 |
688 | /**
689 | * Get month in Chinese of lunar calendar.
690 | *
691 | * @return month in lunar calendar
692 | */
693 | public String getLunarMonth() {
694 | return getLunarMonth(lunarMonth, isLeap);
695 | }
696 |
697 | /**
698 | * Get lunar day in Chinese according to lunar day numeric.
699 | *
700 | * @param lunarDay lunar day numeric
701 | * @return lunar day in Chinese
702 | */
703 | public String getLunarDay(int lunarDay) {
704 | if (lunarDay < 1 || lunarDay > 30) {
705 | return "";
706 | }
707 |
708 | int decade = lunarDay / 10;
709 | int unit = lunarDay % 10;
710 | String decadeStr = LUNAR_SPEC_STRING[decade];
711 | String unitStr = LUNAR_STRING[unit];
712 |
713 | if (lunarDay < 11) {
714 | decadeStr = LUNAR_SPEC_STRING[0];
715 | }
716 |
717 | if (unit == 0) {
718 | unitStr = LUNAR_SPEC_STRING[1];
719 | }
720 |
721 | return decadeStr + unitStr;
722 | }
723 |
724 | /**
725 | * Get day in lunar calendar.
726 | *
727 | * @return day in lunar calendar
728 | */
729 | public String getLunarDay() {
730 | return getLunarDay(lunarDay);
731 | }
732 |
733 | public int getLunarYearNum() {
734 | return lunarYear;
735 | }
736 |
737 | /**
738 | * Get lunar month in numeric.
739 | *
740 | * @return the numeric of lunar month
741 | */
742 | public int getLunarMonthNum() {
743 | return lunarMonth;
744 | }
745 |
746 | /**
747 | * Get lunar day in numeric.
748 | *
749 | * @return the numeric of lunar day
750 | */
751 | public int getLunarDayNum() {
752 | return lunarDay;
753 | }
754 |
755 | /**
756 | * Get max days in current lunar month.
757 | *
758 | * @return max days
759 | */
760 | public int getMaxDaysInLunarMonth() {
761 | return daysInLuarMonth;
762 | }
763 |
764 | /**
765 | * Get solar calendar.
766 | *
767 | * @return solar calendar
768 | */
769 | public Calendar getCalendar() {
770 | return solar;
771 | }
772 |
773 | /**
774 | * Get year in the Gregorian calendar.
775 | *
776 | * @return year in the Gregorian calendar
777 | */
778 | public int getSolarYear() {
779 | return solarYear;
780 | }
781 |
782 | /**
783 | * Get month in the Gregorian calendar, based-on 0.
784 | *
785 | * @return month in the Gregorian calendar
786 | */
787 | public int getSolarMonth() {
788 | return solarMonth;
789 | }
790 |
791 | /**
792 | * Get day in the Gregorian calendar.
793 | *
794 | * @return day in the Gregorian calendar
795 | */
796 | public int getSolarDay() {
797 | return solarDay;
798 | }
799 |
800 | /**
801 | * Get the day of week.
802 | *
803 | * @return day of week(1-Sunday, 7-Saturday).
804 | */
805 | public int getDayOfWeek() {
806 | return solar.get(Calendar.DAY_OF_WEEK);
807 | }
808 |
809 | /**
810 | * Get the week of year.
811 | *
812 | * @return week of year
813 | */
814 | public int getWeekOfYear() {
815 | return solar.get(Calendar.WEEK_OF_YEAR);
816 | }
817 |
818 | /**
819 | * Get day of week in Chinese.
820 | *
821 | * @return day of week in Chinese
822 | */
823 | public String getDayOfWeekInChinese() {
824 | return DAY_OF_WEEK_IN_CHINESE[getDayOfWeek() - 1];
825 | }
826 |
827 | /**
828 | * To check if current date is today.
829 | *
830 | * @return true if was today, otherwise return false
831 | */
832 | public boolean isToday() {
833 | Calendar calendar = Calendar.getInstance();
834 | return calendar.get(Calendar.YEAR) == solarYear
835 | && calendar.get(Calendar.MONTH) == solarMonth
836 | && calendar.get(Calendar.DAY_OF_MONTH) == solarDay;
837 | }
838 |
839 | /**
840 | * Get Pengzu one hundred dread.
841 | *
842 | * @return Pengzu one hundred dread
843 | */
844 | public String[] getPengzu() {
845 | String[] pengzu = new String[2];
846 | pengzu[0] = PENG_ZU_HEAVENLY[getHeavenlyStems(cyclicalDay)];
847 | pengzu[1] = PENG_ZU_EARTHLY[getEarthlyBranches(cyclicalDay)];
848 |
849 | return pengzu;
850 | }
851 |
852 | /**
853 | * Get lunar holidy if existed.
854 | *
855 | * @return lunar holiday, null if not existed
856 | */
857 | public String getLunarHoliday() {
858 | if (isLeap) {
859 | return null;
860 | }
861 |
862 | /* New Year's Eve is special, maybe 29, maybe 30 */
863 | if (lunarMonth == 12 && lunarDay == daysInLuarMonth) {
864 | return "除夕";
865 | }
866 |
867 | for (Holiday holiday : lunarHolidays) {
868 | if (holiday.getMonth() == lunarMonth && holiday.getDay() == lunarDay) {
869 | return holiday.getName();
870 | }
871 | }
872 |
873 | return null;
874 | }
875 |
876 | /**
877 | * Get solar holiday if existed.
878 | *
879 | * @return solar holiday, null if not existed
880 | */
881 | public String getSolarHolidy() {
882 | for (Holiday holiday : solarHolidays) {
883 | if (holiday.getMonth() == solarMonth + 1 && holiday.getDay() == solarDay) {
884 | return holiday.getName();
885 | }
886 | }
887 |
888 | return null;
889 | }
890 |
891 | /**
892 | * Get confilict evil spirit for current day.
893 | *
894 | * @return evil spirit
895 | */
896 | public String getConflictEvilSpirit() {
897 | int heavenlyIndex = getHeavenlyStems(cyclicalDay);
898 | int earthlyIndex = getEarthlyBranches(cyclicalDay);
899 | int conflictHeavenlyIndex;
900 | int conflictEarthlyIndex;
901 |
902 | if (heavenlyIndex < 6) {
903 | conflictHeavenlyIndex = heavenlyIndex + 4;
904 | } else {
905 | conflictHeavenlyIndex = heavenlyIndex - 6;
906 | }
907 |
908 | if (earthlyIndex < 6) {
909 | conflictEarthlyIndex = earthlyIndex + 6;
910 | } else {
911 | conflictEarthlyIndex = earthlyIndex - 6;
912 | }
913 |
914 | return "冲"
915 | + ZODIAC[conflictEarthlyIndex]
916 | + "("
917 | + HEAVENLY_STEMS[conflictHeavenlyIndex]
918 | + EARTHLY_BRANCHES[conflictEarthlyIndex]
919 | + ")"
920 | + "煞"
921 | + EVIL_SPIRIT[earthlyIndex % 4];
922 | }
923 |
924 | /**
925 | * Get star description for current day.
926 | *
927 | * @return star description
928 | */
929 | public String getTwentyEightStar() {
930 | int weekOfYear = (getWeekOfYear() - 1) % 4;
931 | int dayOfWeek = getDayOfWeek() - 1;
932 | Star star = mTwentyEightStars[weekOfYear][dayOfWeek];
933 |
934 | return star.getDirection() + star.getStar() + "-" + star.getFortune();
935 | }
936 |
937 | /**
938 | * Get the index of star duty.
939 | *
940 | * @return the index
941 | */
942 | public int getWielding() {
943 | int earthlyIndexOfMonth = getEarthlyBranches(cyclicalMonth);
944 | int earthlyIndexOfDay = getEarthlyBranches(cyclicalDay);
945 | int monthIndex = earthlyIndexOfMonth >= 2 ? earthlyIndexOfMonth - 2 : 12 - earthlyIndexOfMonth;
946 | int offset = 12 - (monthIndex == 0 ? 12 : monthIndex);
947 | if (earthlyIndexOfDay + offset < 12) {
948 | return earthlyIndexOfDay + offset;
949 | } else {
950 | return earthlyIndexOfDay + offset - 12;
951 | }
952 | }
953 |
954 | /**
955 | * Get five elements for current day.
956 | *
957 | * @return five elements description
958 | */
959 | public String getFiveElements() {
960 | return FIVE_ELEMENTS[cyclicalDay / 2] + " " + TWELVE_DURY[getWielding()] + "执位";
961 | }
962 |
963 | /**
964 | * Get the index of fetus god direction.
965 | *
966 | * @return the index
967 | */
968 | private int getFetusGodDirectionIndex() {
969 | if (cyclicalDay < 2 || cyclicalDay > 55) {
970 | return 2;
971 | } else if (cyclicalDay < 6) {
972 | return 3;
973 | } else if (cyclicalDay < 12) {
974 | return 4;
975 | } else if (cyclicalDay < 17) {
976 | return 5;
977 | } else if (cyclicalDay < 23) {
978 | return 6;
979 | } else if (cyclicalDay < 28) {
980 | return 7;
981 | } else if (cyclicalDay < 33) {
982 | return 8;
983 | } else if (cyclicalDay < 39) {
984 | return 9;
985 | } else if (cyclicalDay < 44) {
986 | return 10;
987 | } else if (cyclicalDay < 50) {
988 | return 0;
989 | } else {
990 | return 1;
991 | }
992 | }
993 |
994 | /**
995 | * Get the fetus god description for current day.
996 | *
997 | * @return fetus god description
998 | */
999 | public String getFetusGod() {
1000 | int heavenlyIndex = getHeavenlyStems(cyclicalDay);
1001 | int earthlyIndex = getEarthlyBranches(cyclicalDay);
1002 |
1003 | String fetusGod;
1004 | String heavenlyPosition = FETUS_GOD_HEAVENLY[heavenlyIndex % 5];
1005 | String earthlyPosition = FETUS_GOD_EARTHLY[earthlyIndex % 5];
1006 | if (heavenlyPosition.contains(earthlyPosition)) {
1007 | fetusGod = heavenlyPosition;
1008 | } else if (earthlyPosition.contains(heavenlyPosition)) {
1009 | fetusGod = earthlyPosition;
1010 | } else {
1011 | fetusGod = (heavenlyPosition + earthlyPosition);
1012 | }
1013 |
1014 | fetusGod = (fetusGod.length() <= 2 ? "占" : "") + fetusGod;
1015 | fetusGod += FETUS_GOD_DIRECTION[getFetusGodDirectionIndex()];
1016 |
1017 | return fetusGod;
1018 | }
1019 | }
1020 |
--------------------------------------------------------------------------------