diff options
author | Kevin Ferrare <kevin@rockbox.org> | 2007-08-04 03:01:46 +0000 |
---|---|---|
committer | Kevin Ferrare <kevin@rockbox.org> | 2007-08-04 03:01:46 +0000 |
commit | 93b2f9fd447b73fff736d71826880ef9ac64bd94 (patch) | |
tree | 1a4f54016c312738d66fb9dd2348ea0ef14f1255 | |
parent | ffbbc60f38ddc8aeadc9cea1102077e22ca84a1a (diff) | |
download | rockbox-93b2f9fd447b73fff736d71826880ef9ac64bd94.tar.gz rockbox-93b2f9fd447b73fff736d71826880ef9ac64bd94.zip |
Rewrote the clock plugin in a cleaner and more modular way so that it can scale on remote screens. Use left-right keys to change the type of clock displayed (analogic, digital, binary) and up/downto change the look of the clock
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@14174 a1c6a512-1295-4272-9138-f99709370657
56 files changed, 1967 insertions, 1744 deletions
diff --git a/apps/plugin.h b/apps/plugin.h index 5146e18139..61cfe96e8d 100644 --- a/apps/plugin.h +++ b/apps/plugin.h | |||
@@ -112,12 +112,12 @@ | |||
112 | #define PLUGIN_MAGIC 0x526F634B /* RocK */ | 112 | #define PLUGIN_MAGIC 0x526F634B /* RocK */ |
113 | 113 | ||
114 | /* increase this every time the api struct changes */ | 114 | /* increase this every time the api struct changes */ |
115 | #define PLUGIN_API_VERSION 68 | 115 | #define PLUGIN_API_VERSION 69 |
116 | 116 | ||
117 | /* update this to latest version if a change to the api struct breaks | 117 | /* update this to latest version if a change to the api struct breaks |
118 | backwards compatibility (and please take the opportunity to sort in any | 118 | backwards compatibility (and please take the opportunity to sort in any |
119 | new function which are "waiting" at the end of the function table) */ | 119 | new function which are "waiting" at the end of the function table) */ |
120 | #define PLUGIN_MIN_API_VERSION 68 | 120 | #define PLUGIN_MIN_API_VERSION 69 |
121 | 121 | ||
122 | /* plugin return codes */ | 122 | /* plugin return codes */ |
123 | enum plugin_status { | 123 | enum plugin_status { |
diff --git a/apps/plugins/SOURCES b/apps/plugins/SOURCES index 96a7ebec2d..31d94d5811 100644 --- a/apps/plugins/SOURCES +++ b/apps/plugins/SOURCES | |||
@@ -82,7 +82,6 @@ vu_meter.c | |||
82 | wormlet.c | 82 | wormlet.c |
83 | 83 | ||
84 | #if CONFIG_RTC | 84 | #if CONFIG_RTC |
85 | clock.c | ||
86 | #if CONFIG_KEYPAD == RECORDER_PAD /* Recorder models only for now */ | 85 | #if CONFIG_KEYPAD == RECORDER_PAD /* Recorder models only for now */ |
87 | calendar.c | 86 | calendar.c |
88 | #endif | 87 | #endif |
diff --git a/apps/plugins/SUBDIRS b/apps/plugins/SUBDIRS index 6665f41e4e..3f0fc9051b 100644 --- a/apps/plugins/SUBDIRS +++ b/apps/plugins/SUBDIRS | |||
@@ -3,6 +3,11 @@ | |||
3 | /* For all targets */ | 3 | /* For all targets */ |
4 | 4 | ||
5 | /* For various targets... */ | 5 | /* For various targets... */ |
6 | |||
7 | #if CONFIG_RTC | ||
8 | clock | ||
9 | #endif | ||
10 | |||
6 | #if (CONFIG_KEYPAD == RECORDER_PAD) || defined(HAVE_LCD_COLOR) \ | 11 | #if (CONFIG_KEYPAD == RECORDER_PAD) || defined(HAVE_LCD_COLOR) \ |
7 | || defined(IRIVER_H100_SERIES) || defined(IAUDIO_M5) | 12 | || defined(IRIVER_H100_SERIES) || defined(IAUDIO_M5) |
8 | rockboy | 13 | rockboy |
diff --git a/apps/plugins/bitmaps/native/SOURCES b/apps/plugins/bitmaps/native/SOURCES index 05029c430c..93939c95f7 100644 --- a/apps/plugins/bitmaps/native/SOURCES +++ b/apps/plugins/bitmaps/native/SOURCES | |||
@@ -112,6 +112,7 @@ chessbox_pieces.64x64x1.bmp | |||
112 | 112 | ||
113 | /* Clock */ | 113 | /* Clock */ |
114 | #if (LCD_WIDTH >= 320) && (LCD_HEIGHT >= 240) && (LCD_DEPTH >= 16) | 114 | #if (LCD_WIDTH >= 320) && (LCD_HEIGHT >= 240) && (LCD_DEPTH >= 16) |
115 | clock_binary.320x240x16.bmp | ||
115 | clock_digits.320x240x16.bmp | 116 | clock_digits.320x240x16.bmp |
116 | clock_smalldigits.320x240x16.bmp | 117 | clock_smalldigits.320x240x16.bmp |
117 | clock_segments.320x240x16.bmp | 118 | clock_segments.320x240x16.bmp |
@@ -119,6 +120,7 @@ clock_smallsegments.320x240x16.bmp | |||
119 | clock_logo.320x240x16.bmp | 120 | clock_logo.320x240x16.bmp |
120 | clock_messages.320x240x16.bmp | 121 | clock_messages.320x240x16.bmp |
121 | #elif (LCD_WIDTH >= 220) && (LCD_HEIGHT >= 176) && (LCD_DEPTH >= 16) | 122 | #elif (LCD_WIDTH >= 220) && (LCD_HEIGHT >= 176) && (LCD_DEPTH >= 16) |
123 | clock_binary.220x176x16.bmp | ||
122 | clock_digits.220x176x16.bmp | 124 | clock_digits.220x176x16.bmp |
123 | clock_smalldigits.220x176x16.bmp | 125 | clock_smalldigits.220x176x16.bmp |
124 | clock_segments.220x176x16.bmp | 126 | clock_segments.220x176x16.bmp |
@@ -126,6 +128,7 @@ clock_smallsegments.220x176x16.bmp | |||
126 | clock_logo.220x176x16.bmp | 128 | clock_logo.220x176x16.bmp |
127 | clock_messages.220x176x16.bmp | 129 | clock_messages.220x176x16.bmp |
128 | #elif (LCD_WIDTH >= 176) && (LCD_HEIGHT >= 132) && (LCD_DEPTH >= 16) | 130 | #elif (LCD_WIDTH >= 176) && (LCD_HEIGHT >= 132) && (LCD_DEPTH >= 16) |
131 | clock_binary.160x128x16.bmp | ||
129 | clock_digits.160x128x16.bmp | 132 | clock_digits.160x128x16.bmp |
130 | clock_smalldigits.160x128x16.bmp | 133 | clock_smalldigits.160x128x16.bmp |
131 | clock_segments.160x128x16.bmp | 134 | clock_segments.160x128x16.bmp |
@@ -133,6 +136,7 @@ clock_smallsegments.160x128x16.bmp | |||
133 | clock_logo.176x132x16.bmp | 136 | clock_logo.176x132x16.bmp |
134 | clock_messages.176x132x16.bmp | 137 | clock_messages.176x132x16.bmp |
135 | #elif (LCD_WIDTH >= 160) && (LCD_HEIGHT >= 128) && (LCD_DEPTH >= 16) | 138 | #elif (LCD_WIDTH >= 160) && (LCD_HEIGHT >= 128) && (LCD_DEPTH >= 16) |
139 | clock_binary.160x128x16.bmp | ||
136 | clock_digits.160x128x16.bmp | 140 | clock_digits.160x128x16.bmp |
137 | clock_smalldigits.160x128x16.bmp | 141 | clock_smalldigits.160x128x16.bmp |
138 | clock_segments.160x128x16.bmp | 142 | clock_segments.160x128x16.bmp |
@@ -140,6 +144,7 @@ clock_smallsegments.160x128x16.bmp | |||
140 | clock_logo.160x128x16.bmp | 144 | clock_logo.160x128x16.bmp |
141 | clock_messages.160x128x16.bmp | 145 | clock_messages.160x128x16.bmp |
142 | #elif (LCD_WIDTH >= 128) && (LCD_HEIGHT >= 128) && (LCD_DEPTH >= 16) | 146 | #elif (LCD_WIDTH >= 128) && (LCD_HEIGHT >= 128) && (LCD_DEPTH >= 16) |
147 | clock_binary.128x128x16.bmp | ||
143 | clock_digits.128x128x16.bmp | 148 | clock_digits.128x128x16.bmp |
144 | clock_smalldigits.128x128x16.bmp | 149 | clock_smalldigits.128x128x16.bmp |
145 | clock_segments.128x128x16.bmp | 150 | clock_segments.128x128x16.bmp |
@@ -147,6 +152,7 @@ clock_smallsegments.128x128x16.bmp | |||
147 | clock_logo.128x128x16.bmp | 152 | clock_logo.128x128x16.bmp |
148 | clock_messages.128x128x16.bmp | 153 | clock_messages.128x128x16.bmp |
149 | #elif (LCD_WIDTH >= 160) && (LCD_HEIGHT >= 128) && (LCD_DEPTH >= 2) | 154 | #elif (LCD_WIDTH >= 160) && (LCD_HEIGHT >= 128) && (LCD_DEPTH >= 2) |
155 | clock_binary.160x128x2.bmp | ||
150 | clock_digits.160x128x2.bmp | 156 | clock_digits.160x128x2.bmp |
151 | clock_smalldigits.160x128x2.bmp | 157 | clock_smalldigits.160x128x2.bmp |
152 | clock_segments.160x128x2.bmp | 158 | clock_segments.160x128x2.bmp |
@@ -154,6 +160,7 @@ clock_smallsegments.160x128x2.bmp | |||
154 | clock_logo.160x128x2.bmp | 160 | clock_logo.160x128x2.bmp |
155 | clock_messages.160x128x2.bmp | 161 | clock_messages.160x128x2.bmp |
156 | #elif (LCD_WIDTH >= 138) && (LCD_HEIGHT >= 110) && (LCD_DEPTH >= 2) | 162 | #elif (LCD_WIDTH >= 138) && (LCD_HEIGHT >= 110) && (LCD_DEPTH >= 2) |
163 | clock_binary.138x110x2.bmp | ||
157 | clock_digits.138x110x2.bmp | 164 | clock_digits.138x110x2.bmp |
158 | clock_smalldigits.160x128x2.bmp | 165 | clock_smalldigits.160x128x2.bmp |
159 | clock_segments.138x110x2.bmp | 166 | clock_segments.138x110x2.bmp |
@@ -161,6 +168,7 @@ clock_smallsegments.160x128x2.bmp | |||
161 | clock_logo.138x110x2.bmp | 168 | clock_logo.138x110x2.bmp |
162 | clock_messages.138x110x2.bmp | 169 | clock_messages.138x110x2.bmp |
163 | #elif (LCD_WIDTH >= 112) && (LCD_HEIGHT >= 64) && (LCD_DEPTH >= 1) | 170 | #elif (LCD_WIDTH >= 112) && (LCD_HEIGHT >= 64) && (LCD_DEPTH >= 1) |
171 | clock_binary.112x64x1.bmp | ||
164 | clock_digits.112x64x1.bmp | 172 | clock_digits.112x64x1.bmp |
165 | clock_smalldigits.112x64x1.bmp | 173 | clock_smalldigits.112x64x1.bmp |
166 | clock_segments.112x64x1.bmp | 174 | clock_segments.112x64x1.bmp |
diff --git a/apps/plugins/bitmaps/native/clock_binary.112x64x1.bmp b/apps/plugins/bitmaps/native/clock_binary.112x64x1.bmp new file mode 100644 index 0000000000..a42401c293 --- /dev/null +++ b/apps/plugins/bitmaps/native/clock_binary.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_binary.128x128x16.bmp b/apps/plugins/bitmaps/native/clock_binary.128x128x16.bmp new file mode 100644 index 0000000000..9f98dc2753 --- /dev/null +++ b/apps/plugins/bitmaps/native/clock_binary.128x128x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_binary.138x110x2.bmp b/apps/plugins/bitmaps/native/clock_binary.138x110x2.bmp new file mode 100644 index 0000000000..0596c71e3c --- /dev/null +++ b/apps/plugins/bitmaps/native/clock_binary.138x110x2.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_binary.160x128x16.bmp b/apps/plugins/bitmaps/native/clock_binary.160x128x16.bmp new file mode 100644 index 0000000000..d1982ba94a --- /dev/null +++ b/apps/plugins/bitmaps/native/clock_binary.160x128x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_binary.160x128x2.bmp b/apps/plugins/bitmaps/native/clock_binary.160x128x2.bmp new file mode 100644 index 0000000000..9808694a6c --- /dev/null +++ b/apps/plugins/bitmaps/native/clock_binary.160x128x2.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_binary.220x176x16.bmp b/apps/plugins/bitmaps/native/clock_binary.220x176x16.bmp new file mode 100644 index 0000000000..3cc2bd15cb --- /dev/null +++ b/apps/plugins/bitmaps/native/clock_binary.220x176x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_binary.320x240x16.bmp b/apps/plugins/bitmaps/native/clock_binary.320x240x16.bmp new file mode 100644 index 0000000000..158ac90ae9 --- /dev/null +++ b/apps/plugins/bitmaps/native/clock_binary.320x240x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_digits.112x64x1.bmp b/apps/plugins/bitmaps/native/clock_digits.112x64x1.bmp index c8738029cb..cd4a3ba152 100644 --- a/apps/plugins/bitmaps/native/clock_digits.112x64x1.bmp +++ b/apps/plugins/bitmaps/native/clock_digits.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_digits.128x128x16.bmp b/apps/plugins/bitmaps/native/clock_digits.128x128x16.bmp index 87694982c9..c9edb25dd0 100644 --- a/apps/plugins/bitmaps/native/clock_digits.128x128x16.bmp +++ b/apps/plugins/bitmaps/native/clock_digits.128x128x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_digits.138x110x2.bmp b/apps/plugins/bitmaps/native/clock_digits.138x110x2.bmp index d3a3ea15a4..69a2fef25b 100644 --- a/apps/plugins/bitmaps/native/clock_digits.138x110x2.bmp +++ b/apps/plugins/bitmaps/native/clock_digits.138x110x2.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_digits.160x128x16.bmp b/apps/plugins/bitmaps/native/clock_digits.160x128x16.bmp index 6b2b41c496..7fccf93928 100644 --- a/apps/plugins/bitmaps/native/clock_digits.160x128x16.bmp +++ b/apps/plugins/bitmaps/native/clock_digits.160x128x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_digits.160x128x2.bmp b/apps/plugins/bitmaps/native/clock_digits.160x128x2.bmp index 6a82bb05d0..75abec3fa4 100644 --- a/apps/plugins/bitmaps/native/clock_digits.160x128x2.bmp +++ b/apps/plugins/bitmaps/native/clock_digits.160x128x2.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_digits.220x176x16.bmp b/apps/plugins/bitmaps/native/clock_digits.220x176x16.bmp index 41fef2bc1e..c18e7aeb35 100644 --- a/apps/plugins/bitmaps/native/clock_digits.220x176x16.bmp +++ b/apps/plugins/bitmaps/native/clock_digits.220x176x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/native/clock_digits.320x240x16.bmp b/apps/plugins/bitmaps/native/clock_digits.320x240x16.bmp index 0da719cd54..8a6ea68d43 100644 --- a/apps/plugins/bitmaps/native/clock_digits.320x240x16.bmp +++ b/apps/plugins/bitmaps/native/clock_digits.320x240x16.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/remote_native/SOURCES b/apps/plugins/bitmaps/remote_native/SOURCES index d59621d686..a884ebb24a 100644 --- a/apps/plugins/bitmaps/remote_native/SOURCES +++ b/apps/plugins/bitmaps/remote_native/SOURCES | |||
@@ -4,3 +4,14 @@ osx.dummy.bmp | |||
4 | 4 | ||
5 | /* Jackpot */ | 5 | /* Jackpot */ |
6 | jackpot_slots_remote.15x210x1.bmp | 6 | jackpot_slots_remote.15x210x1.bmp |
7 | |||
8 | clock_logo_remote.112x64x1.bmp | ||
9 | clock_messages_remote.112x64x1.bmp | ||
10 | |||
11 | clock_binary_remote.112x64x1.bmp | ||
12 | |||
13 | clock_digits_remote.112x64x1.bmp | ||
14 | clock_smalldigits_remote.112x64x1.bmp | ||
15 | |||
16 | clock_segments_remote.112x64x1.bmp | ||
17 | clock_smallsegments_remote.112x64x1.bmp | ||
diff --git a/apps/plugins/bitmaps/remote_native/clock_binary_remote.112x64x1.bmp b/apps/plugins/bitmaps/remote_native/clock_binary_remote.112x64x1.bmp new file mode 100644 index 0000000000..a42401c293 --- /dev/null +++ b/apps/plugins/bitmaps/remote_native/clock_binary_remote.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/remote_native/clock_digits_remote.112x64x1.bmp b/apps/plugins/bitmaps/remote_native/clock_digits_remote.112x64x1.bmp new file mode 100644 index 0000000000..cd4a3ba152 --- /dev/null +++ b/apps/plugins/bitmaps/remote_native/clock_digits_remote.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/remote_native/clock_logo_remote.112x64x1.bmp b/apps/plugins/bitmaps/remote_native/clock_logo_remote.112x64x1.bmp new file mode 100644 index 0000000000..47b6cddf73 --- /dev/null +++ b/apps/plugins/bitmaps/remote_native/clock_logo_remote.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/remote_native/clock_messages_remote.112x64x1.bmp b/apps/plugins/bitmaps/remote_native/clock_messages_remote.112x64x1.bmp new file mode 100644 index 0000000000..8cdc43155f --- /dev/null +++ b/apps/plugins/bitmaps/remote_native/clock_messages_remote.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/remote_native/clock_segments_remote.112x64x1.bmp b/apps/plugins/bitmaps/remote_native/clock_segments_remote.112x64x1.bmp new file mode 100644 index 0000000000..15caccec22 --- /dev/null +++ b/apps/plugins/bitmaps/remote_native/clock_segments_remote.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/remote_native/clock_smalldigits_remote.112x64x1.bmp b/apps/plugins/bitmaps/remote_native/clock_smalldigits_remote.112x64x1.bmp new file mode 100644 index 0000000000..54a0802d20 --- /dev/null +++ b/apps/plugins/bitmaps/remote_native/clock_smalldigits_remote.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/bitmaps/remote_native/clock_smallsegments_remote.112x64x1.bmp b/apps/plugins/bitmaps/remote_native/clock_smallsegments_remote.112x64x1.bmp new file mode 100644 index 0000000000..767e25556e --- /dev/null +++ b/apps/plugins/bitmaps/remote_native/clock_smallsegments_remote.112x64x1.bmp | |||
Binary files differ | |||
diff --git a/apps/plugins/clock.c b/apps/plugins/clock.c deleted file mode 100644 index 71415c03d4..0000000000 --- a/apps/plugins/clock.c +++ /dev/null | |||
@@ -1,1673 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2003 Zakk Roberts | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | /***************************** | ||
21 | * RELEASE NOTES | ||
22 | |||
23 | ***** VERSION 4.00 ** | ||
24 | New almost entirely bitmap based display. Scales to all resolutions. Combined | ||
25 | Digital and LCD modes into one. Use Rockbox menu code for the menu. Removed | ||
26 | count-down option. A couple new options. Source code reworked, improved, cleaned | ||
27 | up. | ||
28 | |||
29 | ***** VERSION 3.10 ** | ||
30 | Drawing now scales for the display - still needs updated bitmaps for the binary | ||
31 | and plain mode. The Time's Up logo could also be updated. | ||
32 | |||
33 | ***** VERSION 3.00 ** | ||
34 | New, simpler UI - every screen can be accessed from the new Main Menu. | ||
35 | Huge code cleanup - many major functions rewritten and optimized, | ||
36 | targeting scalability. Number of variables reduced majorly. | ||
37 | New clock mode: Plain (simple, large text). ON now controls counter | ||
38 | (press toggle/hold reset). Fancier credits roll. New logo. iRiver and iPod ports | ||
39 | are working but not yet scaled to fit their LCDs. | ||
40 | |||
41 | ***** VERSION 2.60 ** | ||
42 | Fixed general settings typo, split up settings function, added cursor animations, | ||
43 | and updated cursor look (rounded edges). | ||
44 | |||
45 | ***** VERSION 2.51 ** | ||
46 | "Show Counter" option is now saved to disk | ||
47 | |||
48 | ***** VERSION 2.50 ** | ||
49 | New general settings mode added, reworked options screen, cleaned up a few | ||
50 | things and removed redundant code, faster load_settings(), fixed a | ||
51 | help-screen bug (thanks to zeekoe) | ||
52 | |||
53 | ***** VERSION 2.40 ** | ||
54 | Cleaned and optimized code, removed unused code/bitmaps, credits screen updated, | ||
55 | centered text all over, general settings added at ON+F3, | ||
56 | new arrow bitmap for general settings and mode selector, | ||
57 | bugfix: 12:00AM is no longer 00:00AM | ||
58 | |||
59 | ***** VERSION 2.31 ** | ||
60 | Fixed credits roll - now displays all names. Features | ||
61 | improved animations. Also revised release notes. | ||
62 | |||
63 | ***** VERSION 2.30 ** | ||
64 | Tab indentation removed, and Counter screen added | ||
65 | at ON+F2, with countdown options | ||
66 | |||
67 | ***** VERSION 2.22 ** | ||
68 | Fixed two bugs: | ||
69 | Digital settings are now independent of LCD settings | ||
70 | 12/24h "Analog" settings are now displayed correctly. | ||
71 | |||
72 | ***** VERSION 2.21 ** | ||
73 | -Changed the behaviour of F2 | ||
74 | |||
75 | ***** VERSION 2.20 ** | ||
76 | Few small bugs taken care of. New features: | ||
77 | New binary mode, new mode selector, "counter", and redesigned help screen. | ||
78 | |||
79 | ***** VERSION 2.10 ** | ||
80 | New bug fixes, and some new features: | ||
81 | an LCD imitation mode, and American and European date modes. | ||
82 | |||
83 | ***** VERSION 2.00 ** | ||
84 | Major update, lots of bugfixes and new features. | ||
85 | Fullscreen mode introduced, modes have independent settings, credit roll | ||
86 | added, options screen reworked, logo selector, and -much- cleaner code. | ||
87 | |||
88 | ***** VERSION 1.0 ** | ||
89 | Original release, featuring analog/digital modes and a few options. | ||
90 | *****************************/ | ||
91 | #include "plugin.h" | ||
92 | #include "time.h" | ||
93 | #include "checkbox.h" | ||
94 | #include "xlcd.h" | ||
95 | #include "oldmenuapi.h" | ||
96 | #include "fixedpoint.h" | ||
97 | #include "pluginlib_actions.h" | ||
98 | |||
99 | PLUGIN_HEADER | ||
100 | |||
101 | /* External bitmap references */ | ||
102 | #include "clock_digits.h" | ||
103 | #include "clock_smalldigits.h" | ||
104 | #include "clock_smallsegments.h" | ||
105 | #include "clock_messages.h" | ||
106 | #include "clock_logo.h" | ||
107 | #include "clock_segments.h" | ||
108 | |||
109 | /* Bitmap positions/deltas, per LCD size */ | ||
110 | #if (LCD_WIDTH >= 112) && (LCD_HEIGHT >= 64) && (LCD_DEPTH >= 1) /* Archos */ | ||
111 | #define LCD_OFFSET 1 | ||
112 | #define HAND_W 2 | ||
113 | #else | ||
114 | #define LCD_OFFSET 1.5 | ||
115 | #define HAND_W 3 | ||
116 | #endif | ||
117 | |||
118 | #define DIGIT_WIDTH BMPWIDTH_clock_digits | ||
119 | #define DIGIT_HEIGHT (BMPHEIGHT_clock_digits/15) | ||
120 | #define SMALLDIGIT_WIDTH BMPWIDTH_clock_smalldigits | ||
121 | #define SMALLDIGIT_HEIGHT (BMPHEIGHT_clock_smalldigits/13) | ||
122 | #define SMALLSEG_WIDTH BMPWIDTH_clock_smallsegments | ||
123 | #define SMALLSEG_HEIGHT (BMPHEIGHT_clock_smallsegments/13) | ||
124 | #define MESSAGE_WIDTH BMPWIDTH_clock_messages | ||
125 | #define MESSAGE_HEIGHT (BMPHEIGHT_clock_messages/6) | ||
126 | #define LOGO_WIDTH BMPWIDTH_clock_logo | ||
127 | #define LOGO_HEIGHT BMPHEIGHT_clock_logo | ||
128 | |||
129 | /* Parts of larger bitmaps */ | ||
130 | #define COLON 10 | ||
131 | #define DOT_FILLED 11 | ||
132 | #define DOT_EMPTY 12 | ||
133 | #define ICON_PM 13 | ||
134 | #define ICON_AM 14 | ||
135 | #define SEGMENT_AM 11 | ||
136 | #define SEGMENT_PM 12 | ||
137 | #define SLASH 11 | ||
138 | #define PERIOD 12 | ||
139 | |||
140 | /* Message names/values */ | ||
141 | #define MESSAGE_LOADING 0 | ||
142 | #define MESSAGE_LOADED 1 | ||
143 | #define MESSAGE_ERRLOAD 2 | ||
144 | #define MESSAGE_SAVING 3 | ||
145 | #define MESSAGE_SAVED 4 | ||
146 | #define MESSAGE_ERRSAVE 5 | ||
147 | |||
148 | /* Some macros to simplify drawing et al */ | ||
149 | #define draw_digit( num, x, y )\ | ||
150 | rb->lcd_bitmap_part( clock_digits, 0, num * DIGIT_HEIGHT, \ | ||
151 | DIGIT_WIDTH, x, y, DIGIT_WIDTH, DIGIT_HEIGHT ) | ||
152 | #define draw_smalldigit( num, x, y )\ | ||
153 | rb->lcd_bitmap_part( clock_smalldigits, 0, num * SMALLDIGIT_HEIGHT, \ | ||
154 | SMALLDIGIT_WIDTH, x, y, SMALLDIGIT_WIDTH, SMALLDIGIT_HEIGHT ) | ||
155 | #define draw_segment( num, x, y )\ | ||
156 | rb->lcd_bitmap_part( clock_segments, 0, num * DIGIT_HEIGHT, \ | ||
157 | DIGIT_WIDTH, x, y, DIGIT_WIDTH, DIGIT_HEIGHT ) | ||
158 | #define draw_smallsegment( num, x, y )\ | ||
159 | rb->lcd_bitmap_part( clock_smallsegments, 0, num * SMALLSEG_HEIGHT, \ | ||
160 | SMALLSEG_WIDTH, x, y, SMALLSEG_WIDTH, SMALLSEG_HEIGHT ) | ||
161 | #define draw_message( msg, ypos )\ | ||
162 | rb->lcd_bitmap_part( clock_messages, 0, msg*MESSAGE_HEIGHT, MESSAGE_WIDTH, \ | ||
163 | 0, LCD_HEIGHT-(MESSAGE_HEIGHT*ypos), MESSAGE_WIDTH, MESSAGE_HEIGHT ) | ||
164 | #define DIGIT_XOFS(x) (LCD_WIDTH-x*DIGIT_WIDTH)/2 | ||
165 | #define DIGIT_YOFS(x) (LCD_HEIGHT-x*DIGIT_HEIGHT)/2 | ||
166 | #define SMALLDIGIT_XOFS(x) (LCD_WIDTH-x*SMALLDIGIT_WIDTH)/2 | ||
167 | #define SMALLDIGIT_YOFS(x) (LCD_HEIGHT-x*SMALLDIGIT_HEIGHT)/2 | ||
168 | #define SMALLSEG_XOFS(x) (LCD_WIDTH-x*SMALLSEG_WIDTH)/2 | ||
169 | #define SMALLSEG_YOFS(x) (LCD_HEIGHT-x*SMALLSEG_HEIGHT)/2 | ||
170 | |||
171 | /* Keymaps */ | ||
172 | const struct button_mapping* plugin_contexts[]={ | ||
173 | generic_actions, | ||
174 | generic_directions | ||
175 | }; | ||
176 | |||
177 | #define ACTION_COUNTER_TOGGLE PLA_FIRE | ||
178 | #define ACTION_COUNTER_RESET PLA_FIRE_REPEAT | ||
179 | #define ACTION_MENU PLA_MENU | ||
180 | #define ACTION_EXIT PLA_QUIT | ||
181 | #define ACTION_MODE_NEXT PLA_RIGHT | ||
182 | #define ACTION_MODE_PREV PLA_LEFT | ||
183 | |||
184 | /************ | ||
185 | * Prototypes | ||
186 | ***********/ | ||
187 | void save_settings(bool interface); | ||
188 | |||
189 | /******************** | ||
190 | * Misc counter stuff | ||
191 | *******************/ | ||
192 | int start_tick = 0; | ||
193 | int passed_time = 0; | ||
194 | int counter = 0; | ||
195 | int displayed_value = 0; | ||
196 | int count_h, count_m, count_s; | ||
197 | bool counting = false; | ||
198 | |||
199 | /******************** | ||
200 | * Everything else... | ||
201 | *******************/ | ||
202 | bool idle_poweroff = true; /* poweroff activated or not? */ | ||
203 | bool exit_clock = false; /* when true, the main plugin loop will exit */ | ||
204 | |||
205 | static struct plugin_api* rb; | ||
206 | |||
207 | /*********************************************************************** | ||
208 | * Used for hands to define lengths at a given time, analog + fullscreen | ||
209 | **********************************************************************/ | ||
210 | unsigned int xminute[61]; | ||
211 | unsigned int yminute[61]; | ||
212 | unsigned int yhour[61]; | ||
213 | unsigned int xhour[61]; | ||
214 | unsigned int xminute_full[61]; | ||
215 | unsigned int yminute_full[61]; | ||
216 | unsigned int xhour_full[61]; | ||
217 | unsigned int yhour_full[61]; | ||
218 | |||
219 | /* settings are saved to this location */ | ||
220 | static const char default_filename[] = "/.rockbox/rocks/.clock_settings"; | ||
221 | |||
222 | /********************************************************* | ||
223 | * Some arrays/definitions for drawing settings/menu text. | ||
224 | ********************************************************/ | ||
225 | #define ANALOG 1 | ||
226 | #define FULLSCREEN 2 | ||
227 | #define DIGITAL 3 | ||
228 | #define PLAIN 4 | ||
229 | #define BINARY 5 | ||
230 | #define CLOCK_MODES 5 | ||
231 | |||
232 | #define analog_date 0 | ||
233 | #define analog_secondhand 1 | ||
234 | #define analog_time 2 | ||
235 | #define digital_seconds 0 | ||
236 | #define digital_date 1 | ||
237 | #define digital_blinkcolon 2 | ||
238 | #define digital_format 3 | ||
239 | #define fullscreen_border 0 | ||
240 | #define fullscreen_secondhand 1 | ||
241 | #define binary_mode 0 | ||
242 | #define plain_format 0 | ||
243 | #define plain_seconds 1 | ||
244 | #define plain_date 2 | ||
245 | #define plain_blinkcolon 3 | ||
246 | #define general_counter 0 | ||
247 | #define general_savesetting 1 | ||
248 | #define general_backlight 2 | ||
249 | |||
250 | /* Option structs (possible selections per each option) */ | ||
251 | static const struct opt_items noyes_text[] = { | ||
252 | { "No", -1 }, | ||
253 | { "Yes", -1 } | ||
254 | }; | ||
255 | |||
256 | static const struct opt_items backlight_settings_text[] = { | ||
257 | { "Always Off", -1 }, | ||
258 | { "Rockbox setting", -1 }, | ||
259 | { "Always On", -1 } | ||
260 | }; | ||
261 | static const struct opt_items idle_poweroff_text[] = { | ||
262 | { "Disabled", -1 }, | ||
263 | { "Enabled", -1 } | ||
264 | }; | ||
265 | static const struct opt_items counting_direction_text[] = { | ||
266 | {"Down", -1}, | ||
267 | {"Up", -1} | ||
268 | }; | ||
269 | static const struct opt_items date_format_text[] = { | ||
270 | { "No", -1 }, | ||
271 | { "American format", -1 }, | ||
272 | { "European format", -1 } | ||
273 | }; | ||
274 | |||
275 | static const struct opt_items analog_time_text[] = { | ||
276 | { "No", -1 }, | ||
277 | { "24-hour Format", -1 }, | ||
278 | { "12-hour Format", -1 } | ||
279 | }; | ||
280 | |||
281 | static const struct opt_items time_format_text[] = { | ||
282 | { "24-hour Format", -1 }, | ||
283 | { "12-hour Format", -1 } | ||
284 | }; | ||
285 | |||
286 | static const struct opt_items binary_mode_text[] = { | ||
287 | { "Numbers", -1 }, | ||
288 | { "Dots", -1 } | ||
289 | }; | ||
290 | |||
291 | /***************************************** | ||
292 | * All settings, saved to default_filename | ||
293 | ****************************************/ | ||
294 | struct saved_settings | ||
295 | { | ||
296 | int clock; /* clock mode */ | ||
297 | int general[4]; /* general settings*/ | ||
298 | int analog[3]; | ||
299 | int digital[4]; | ||
300 | int fullscreen[2]; | ||
301 | int binary[1]; | ||
302 | int plain[4]; | ||
303 | } clock_settings; | ||
304 | |||
305 | /************************ | ||
306 | * Setting default values | ||
307 | ***********************/ | ||
308 | void reset_settings(void) | ||
309 | { | ||
310 | clock_settings.clock = 1; | ||
311 | clock_settings.general[general_counter] = 1; | ||
312 | clock_settings.general[general_savesetting] = 1; | ||
313 | clock_settings.general[general_backlight] = 2; | ||
314 | clock_settings.analog[analog_date] = 0; | ||
315 | clock_settings.analog[analog_secondhand] = true; | ||
316 | clock_settings.analog[analog_time] = false; | ||
317 | clock_settings.digital[digital_seconds] = 1; | ||
318 | clock_settings.digital[digital_date] = 1; | ||
319 | clock_settings.digital[digital_blinkcolon] = false; | ||
320 | clock_settings.digital[digital_format] = true; | ||
321 | clock_settings.fullscreen[fullscreen_border] = true; | ||
322 | clock_settings.fullscreen[fullscreen_secondhand] = true; | ||
323 | clock_settings.plain[plain_format] = true; | ||
324 | clock_settings.plain[plain_seconds] = true; | ||
325 | clock_settings.plain[plain_date] = 1; | ||
326 | clock_settings.plain[plain_blinkcolon] = false; | ||
327 | } | ||
328 | |||
329 | /************************************************************** | ||
330 | * Simple function to check if we're switching to digital mode, | ||
331 | * and if so, set bg/fg colors appropriately. | ||
332 | *************************************************************/ | ||
333 | void set_digital_colors(void) | ||
334 | { | ||
335 | #ifdef HAVE_LCD_COLOR /* color LCDs.. */ | ||
336 | if(clock_settings.clock == DIGITAL) | ||
337 | { | ||
338 | rb->lcd_set_foreground(LCD_WHITE); | ||
339 | rb->lcd_set_background(LCD_BLACK); | ||
340 | } | ||
341 | else | ||
342 | { | ||
343 | rb->lcd_set_foreground(LCD_BLACK); | ||
344 | rb->lcd_set_background(LCD_RGBPACK(180,200,230)); | ||
345 | } | ||
346 | #elif LCD_DEPTH >= 2 | ||
347 | if(clock_settings.clock == DIGITAL) | ||
348 | { | ||
349 | rb->lcd_set_foreground(LCD_WHITE); | ||
350 | rb->lcd_set_background(LCD_BLACK); | ||
351 | } | ||
352 | else | ||
353 | { | ||
354 | rb->lcd_set_foreground(LCD_BLACK); | ||
355 | rb->lcd_set_background(LCD_WHITE); | ||
356 | } | ||
357 | #endif | ||
358 | } | ||
359 | |||
360 | /************************************************************* | ||
361 | * Simple function to set standard black-on-light blue colors. | ||
362 | ************************************************************/ | ||
363 | void set_standard_colors(void) | ||
364 | { | ||
365 | #ifdef HAVE_LCD_COLOR /* color LCDs only.. */ | ||
366 | rb->lcd_set_foreground(LCD_BLACK); | ||
367 | rb->lcd_set_background(LCD_RGBPACK(180,200,230)); | ||
368 | #elif LCD_DEPTH >= 2 | ||
369 | rb->lcd_set_foreground(LCD_BLACK); | ||
370 | rb->lcd_set_background(LCD_WHITE); | ||
371 | #endif | ||
372 | } | ||
373 | |||
374 | /************************** | ||
375 | * Cleanup on plugin return | ||
376 | *************************/ | ||
377 | void cleanup(void *parameter) | ||
378 | { | ||
379 | (void)parameter; | ||
380 | |||
381 | if(clock_settings.general[general_savesetting] == 1) | ||
382 | save_settings(true); | ||
383 | |||
384 | /* restore set backlight timeout */ | ||
385 | rb->backlight_set_timeout(rb->global_settings->backlight_timeout); | ||
386 | } | ||
387 | |||
388 | /**************** | ||
389 | * Shows the logo | ||
390 | ***************/ | ||
391 | void show_clock_logo(void) | ||
392 | { | ||
393 | #ifdef HAVE_LCD_COLOR | ||
394 | rb->lcd_set_foreground(LCD_BLACK); | ||
395 | rb->lcd_set_background(LCD_RGBPACK(180,200,230)); | ||
396 | #endif | ||
397 | |||
398 | rb->lcd_clear_display();; | ||
399 | |||
400 | rb->lcd_bitmap(clock_logo, 0, 0, LOGO_WIDTH, LOGO_HEIGHT); | ||
401 | |||
402 | rb->lcd_update(); | ||
403 | } | ||
404 | |||
405 | /******************************** | ||
406 | * Saves "saved_settings" to disk | ||
407 | *******************************/ | ||
408 | void save_settings(bool interface) | ||
409 | { | ||
410 | int fd; | ||
411 | |||
412 | if(interface) | ||
413 | { | ||
414 | rb->lcd_clear_display(); | ||
415 | show_clock_logo(); | ||
416 | |||
417 | draw_message(MESSAGE_SAVING, 1); | ||
418 | |||
419 | rb->lcd_update(); | ||
420 | } | ||
421 | |||
422 | fd = rb->creat(default_filename); /* create the settings file */ | ||
423 | |||
424 | if(fd >= 0) /* file exists, save successful */ | ||
425 | { | ||
426 | rb->write (fd, &clock_settings, sizeof(struct saved_settings)); | ||
427 | rb->close(fd); | ||
428 | |||
429 | if(interface) | ||
430 | { | ||
431 | rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
432 | rb->lcd_fillrect(0, LCD_HEIGHT-MESSAGE_HEIGHT, LCD_WIDTH, MESSAGE_HEIGHT); | ||
433 | rb->lcd_set_drawmode(DRMODE_SOLID); | ||
434 | draw_message(MESSAGE_SAVED, 1); | ||
435 | } | ||
436 | } | ||
437 | else /* couldn't save for some reason */ | ||
438 | { | ||
439 | if(interface) | ||
440 | { | ||
441 | rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
442 | rb->lcd_fillrect(0, LCD_HEIGHT-MESSAGE_HEIGHT, LCD_WIDTH, MESSAGE_HEIGHT); | ||
443 | rb->lcd_set_drawmode(DRMODE_SOLID); | ||
444 | draw_message(MESSAGE_ERRSAVE, 1); | ||
445 | } | ||
446 | } | ||
447 | |||
448 | if(interface) | ||
449 | { | ||
450 | rb->lcd_update(); | ||
451 | rb->sleep(HZ); /* pause a second */ | ||
452 | } | ||
453 | } | ||
454 | |||
455 | /********************************** | ||
456 | * Loads "saved_settings" from disk | ||
457 | *********************************/ | ||
458 | void load_settings(void) | ||
459 | { | ||
460 | /* open the settings file */ | ||
461 | int fd; | ||
462 | fd = rb->open(default_filename, O_RDONLY); | ||
463 | |||
464 | rb->lcd_clear_display(); | ||
465 | show_clock_logo(); | ||
466 | |||
467 | draw_message(MESSAGE_LOADING, 1); | ||
468 | |||
469 | rb->lcd_update(); | ||
470 | |||
471 | if(fd >= 0) /* does file exist? */ | ||
472 | { | ||
473 | if(rb->filesize(fd) == sizeof(struct saved_settings)) /* if so, is it the right size? */ | ||
474 | { | ||
475 | rb->read(fd, &clock_settings, sizeof(struct saved_settings)); | ||
476 | rb->close(fd); | ||
477 | |||
478 | rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
479 | rb->lcd_fillrect(0, LCD_HEIGHT-MESSAGE_HEIGHT, LCD_WIDTH, MESSAGE_HEIGHT); | ||
480 | rb->lcd_set_drawmode(DRMODE_SOLID); | ||
481 | draw_message(MESSAGE_LOADED, 1); | ||
482 | } | ||
483 | else /* must be invalid, bail out */ | ||
484 | { | ||
485 | rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
486 | rb->lcd_fillrect(0, LCD_HEIGHT-MESSAGE_HEIGHT, LCD_WIDTH, MESSAGE_HEIGHT); | ||
487 | rb->lcd_set_drawmode(DRMODE_SOLID); | ||
488 | draw_message(MESSAGE_ERRLOAD, 1); | ||
489 | |||
490 | reset_settings(); | ||
491 | } | ||
492 | } | ||
493 | else /* must be missing, bail out */ | ||
494 | { | ||
495 | rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
496 | rb->lcd_fillrect(0, LCD_HEIGHT-MESSAGE_HEIGHT, LCD_WIDTH, MESSAGE_HEIGHT); | ||
497 | rb->lcd_set_drawmode(DRMODE_SOLID); | ||
498 | draw_message(MESSAGE_ERRLOAD, 1); | ||
499 | |||
500 | reset_settings(); | ||
501 | } | ||
502 | |||
503 | rb->lcd_update(); | ||
504 | |||
505 | #ifndef SIMULATOR | ||
506 | rb->ata_sleep(); | ||
507 | #endif | ||
508 | |||
509 | rb->sleep(HZ); | ||
510 | } | ||
511 | |||
512 | void polar_to_cartesian(int a, int r, int* x, int* y) | ||
513 | { | ||
514 | *x = (sin_int(a) * r) >> 14; | ||
515 | *y = (sin_int(a-90) * r) >> 14; | ||
516 | } | ||
517 | |||
518 | void polar_to_cartesian_screen_centered(struct screen * display, | ||
519 | int a, int r, int* x, int* y) | ||
520 | { | ||
521 | polar_to_cartesian(a, r, x, y); | ||
522 | *x+=display->width/2; | ||
523 | *y+=display->height/2; | ||
524 | } | ||
525 | |||
526 | void angle_to_square(struct screen * display, | ||
527 | int square_width, int square_height, | ||
528 | int a, int* x, int* y) | ||
529 | { | ||
530 | a = (a+360-90)%360; | ||
531 | if(a>45 && a<=135){/* top line */ | ||
532 | a-=45; | ||
533 | *x=square_width-(square_width*2*a)/90; | ||
534 | *y=square_height; | ||
535 | }else if(a>135 && a<=225){/* left line */ | ||
536 | a-=135; | ||
537 | *x=-square_width; | ||
538 | *y=square_height-(square_height*2*a)/90; | ||
539 | }else if(a>225 && a<=315){/* bottom line */ | ||
540 | a-=225; | ||
541 | *x=(square_width*2*a)/90-square_width; | ||
542 | *y=-square_height; | ||
543 | }else if(a>315 || a<=45){/* right line */ | ||
544 | if(a>315) | ||
545 | a-=315; | ||
546 | else | ||
547 | a+=45; | ||
548 | *x=square_width; | ||
549 | *y=(square_height*2*a)/90-square_height; | ||
550 | } | ||
551 | /* recenter */ | ||
552 | *x+=display->width/2; | ||
553 | *y+=display->height/2; | ||
554 | } | ||
555 | |||
556 | /******************************* | ||
557 | * Init clock, set up x/y tables | ||
558 | ******************************/ | ||
559 | void init_clock(void) | ||
560 | { | ||
561 | #define ANALOG_VALUES 60 | ||
562 | #define ANALOG_YCENTER (LCD_HEIGHT/2) | ||
563 | #define ANALOG_XCENTER (LCD_WIDTH/2) | ||
564 | #define ANALOG_MIN_RADIUS MIN(LCD_HEIGHT/2 -10, LCD_WIDTH/2 -10) | ||
565 | #define ANALOG_HR_RADIUS ((2 * ANALOG_MIN_RADIUS)/3) | ||
566 | |||
567 | #define PI 3.141592 | ||
568 | int i; | ||
569 | |||
570 | rb->lcd_setfont(FONT_SYSFIXED); /* universal font */ | ||
571 | |||
572 | load_settings(); | ||
573 | |||
574 | /* set backlight timeout */ | ||
575 | if(clock_settings.general[general_backlight] == 0) | ||
576 | rb->backlight_set_timeout(0); | ||
577 | else if(clock_settings.general[general_backlight] == 1) | ||
578 | rb->backlight_set_timeout(rb->global_settings->backlight_timeout); | ||
579 | else if(clock_settings.general[general_backlight] == 2) | ||
580 | rb->backlight_set_timeout(1); | ||
581 | |||
582 | for(i=0; i<ANALOG_VALUES; i++) | ||
583 | { | ||
584 | int angle=360 * i / ANALOG_VALUES; | ||
585 | polar_to_cartesian_screen_centered( | ||
586 | rb->screens[0], angle, ANALOG_MIN_RADIUS, | ||
587 | &(xminute[i]), &(yminute[i])); | ||
588 | polar_to_cartesian_screen_centered( | ||
589 | rb->screens[0], angle, ANALOG_HR_RADIUS, | ||
590 | &(xhour[i]), &(yhour[i])); | ||
591 | |||
592 | /* Fullscreen initialization */ | ||
593 | angle_to_square(rb->screens[0], LCD_WIDTH/2, LCD_HEIGHT/2, angle, | ||
594 | &(xminute_full[i]), &(yminute_full[i])); | ||
595 | angle_to_square(rb->screens[0], LCD_WIDTH/3, LCD_HEIGHT/3, angle, | ||
596 | &(xhour_full[i]), &(yhour_full[i])); | ||
597 | } | ||
598 | } | ||
599 | |||
600 | /******************* | ||
601 | * Analog clock mode | ||
602 | ******************/ | ||
603 | void analog_clock(int hour, int minute, int second) | ||
604 | { | ||
605 | if(hour >= 12) | ||
606 | hour -= 12; | ||
607 | |||
608 | int i; | ||
609 | int hourpos = (hour*5) + (minute/12); | ||
610 | |||
611 | /* Crappy fake antialiasing (color LCDs only)! | ||
612 | * how this works is we draw a large mid-gray hr/min/sec hand, | ||
613 | * then the actual (slightly smaller) hand on top of those. | ||
614 | * End result: mid-gray edges to the black hands, smooths them out. */ | ||
615 | #ifdef HAVE_LCD_COLOR | ||
616 | rb->lcd_set_foreground(LCD_RGBPACK(100,110,125)); | ||
617 | |||
618 | /* second hand */ | ||
619 | if(clock_settings.analog[analog_secondhand]) | ||
620 | { | ||
621 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-2, LCD_WIDTH/2, LCD_HEIGHT/2+2, | ||
622 | xminute[second], yminute[second]); | ||
623 | xlcd_filltriangle(LCD_WIDTH/2-2, LCD_HEIGHT/2, LCD_WIDTH/2+2, LCD_HEIGHT/2, | ||
624 | xminute[second], yminute[second]); | ||
625 | } | ||
626 | |||
627 | /* minute hand */ | ||
628 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-4, LCD_WIDTH/2, LCD_HEIGHT/2+4, | ||
629 | xminute[minute], yminute[minute]); | ||
630 | xlcd_filltriangle(LCD_WIDTH/2-4, LCD_HEIGHT/2, LCD_WIDTH/2+4, LCD_HEIGHT/2, | ||
631 | xminute[minute], yminute[minute]); | ||
632 | |||
633 | /* hour hand */ | ||
634 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-4, LCD_WIDTH/2, LCD_HEIGHT/2+4, | ||
635 | xhour[hourpos], yhour[hourpos]); | ||
636 | xlcd_filltriangle(LCD_WIDTH/2-4, LCD_HEIGHT/2, LCD_WIDTH/2+4, LCD_HEIGHT/2, | ||
637 | xhour[hourpos], yhour[hourpos]); | ||
638 | |||
639 | rb->lcd_set_foreground(LCD_BLACK); | ||
640 | #endif | ||
641 | |||
642 | /* second hand, if needed */ | ||
643 | if(clock_settings.analog[analog_secondhand]) | ||
644 | { | ||
645 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-1, LCD_WIDTH/2, LCD_HEIGHT/2+1, | ||
646 | xminute[second], yminute[second]); | ||
647 | xlcd_filltriangle(LCD_WIDTH/2-1, LCD_HEIGHT/2, LCD_WIDTH/2+1, LCD_HEIGHT/2, | ||
648 | xminute[second], yminute[second]); | ||
649 | } | ||
650 | |||
651 | /* minute hand */ | ||
652 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-HAND_W, LCD_WIDTH/2, | ||
653 | LCD_HEIGHT/2+HAND_W, xminute[minute], yminute[minute]); | ||
654 | xlcd_filltriangle(LCD_WIDTH/2-HAND_W, LCD_HEIGHT/2, LCD_WIDTH/2 | ||
655 | +HAND_W, LCD_HEIGHT/2, xminute[minute], yminute[minute]); | ||
656 | |||
657 | /* hour hand */ | ||
658 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-HAND_W, LCD_WIDTH/2, | ||
659 | LCD_HEIGHT/2+HAND_W, xhour[hourpos], yhour[hourpos]); | ||
660 | xlcd_filltriangle(LCD_WIDTH/2-HAND_W, LCD_HEIGHT/2, LCD_WIDTH/2 | ||
661 | +HAND_W, LCD_HEIGHT/2, xhour[hourpos], yhour[hourpos]); | ||
662 | |||
663 | /* Draw the circle */ | ||
664 | for(i=0; i < 60; i+=5) | ||
665 | rb->lcd_fillrect(xminute[i]-1, yminute[i]-1, 3, 3); | ||
666 | |||
667 | /* Draw the cover over the center */ | ||
668 | rb->lcd_drawline((LCD_WIDTH/2)-1, (LCD_HEIGHT/2)+3, | ||
669 | (LCD_WIDTH/2)+1, (LCD_HEIGHT/2)+3); | ||
670 | rb->lcd_drawline((LCD_WIDTH/2)-3, (LCD_HEIGHT/2)+2, | ||
671 | (LCD_WIDTH/2)+3, (LCD_HEIGHT/2)+2); | ||
672 | rb->lcd_drawline((LCD_WIDTH/2)-4, (LCD_HEIGHT/2)+1, | ||
673 | (LCD_WIDTH/2)+4, (LCD_HEIGHT/2)+1); | ||
674 | rb->lcd_drawline((LCD_WIDTH/2)-4, LCD_HEIGHT/2, | ||
675 | (LCD_WIDTH/2)+4, LCD_HEIGHT/2); | ||
676 | rb->lcd_drawline((LCD_WIDTH/2)-4, (LCD_HEIGHT/2)-1, | ||
677 | (LCD_WIDTH/2)+4, (LCD_HEIGHT/2)-1); | ||
678 | rb->lcd_drawline((LCD_WIDTH/2)-3, (LCD_HEIGHT/2)-2, | ||
679 | (LCD_WIDTH/2)+3, (LCD_HEIGHT/2)-2); | ||
680 | rb->lcd_drawline((LCD_WIDTH/2)-1, (LCD_HEIGHT/2)-3, | ||
681 | (LCD_WIDTH/2)+1, (LCD_HEIGHT/2)-3); | ||
682 | } | ||
683 | |||
684 | /******************** | ||
685 | * Digital clock mode | ||
686 | *******************/ | ||
687 | void digital_clock(int hour, int minute, int second, bool colon) | ||
688 | { | ||
689 | int x_ofs=0; | ||
690 | |||
691 | /* this basically detects if we draw an AM or PM bitmap. | ||
692 | * if we don't, we center the hh:mm display. */ | ||
693 | if(!clock_settings.digital[digital_format]) | ||
694 | x_ofs=DIGIT_WIDTH/2; | ||
695 | |||
696 | #if LCD_DEPTH == 1 | ||
697 | rb->lcd_fillrect(0,0,112,64); | ||
698 | #endif | ||
699 | |||
700 | if(clock_settings.digital[digital_format]) | ||
701 | { | ||
702 | /* draw the AM or PM bitmap */ | ||
703 | if(hour<12) | ||
704 | draw_segment(SEGMENT_AM,DIGIT_XOFS(6)+DIGIT_WIDTH*5, 0); | ||
705 | else | ||
706 | draw_segment(SEGMENT_PM,DIGIT_XOFS(6)+DIGIT_WIDTH*5, 0); | ||
707 | |||
708 | /* and then readjust the hour to 12-hour format | ||
709 | * ( 13:00+ -> 1:00+ ) */ | ||
710 | if(hour>12) | ||
711 | hour -= 12; | ||
712 | } | ||
713 | |||
714 | /* hour */ | ||
715 | draw_segment(hour/10, DIGIT_XOFS(6)+x_ofs, 0); | ||
716 | draw_segment(hour%10, DIGIT_XOFS(6)+DIGIT_WIDTH+x_ofs, 0); | ||
717 | |||
718 | /* colon */ | ||
719 | if(colon) | ||
720 | draw_segment(COLON, DIGIT_XOFS(6)+2*DIGIT_WIDTH+x_ofs, 0); | ||
721 | |||
722 | /* minutes */ | ||
723 | draw_segment(minute/10, DIGIT_XOFS(6)+3*DIGIT_WIDTH+x_ofs, 0); | ||
724 | draw_segment(minute%10, DIGIT_XOFS(6)+4*DIGIT_WIDTH+x_ofs, 0); | ||
725 | |||
726 | if(clock_settings.digital[digital_seconds]) | ||
727 | { | ||
728 | draw_segment(second/10, DIGIT_XOFS(2), DIGIT_HEIGHT); | ||
729 | draw_segment(second%10, DIGIT_XOFS(2)+DIGIT_WIDTH, DIGIT_HEIGHT); | ||
730 | } | ||
731 | } | ||
732 | |||
733 | /*********************** | ||
734 | * Fullscreen clock mode | ||
735 | **********************/ | ||
736 | void fullscreen_clock(int hour, int minute, int second) | ||
737 | { | ||
738 | if(hour >= 12) | ||
739 | hour -= 12; | ||
740 | |||
741 | int i; | ||
742 | int hourpos = (hour*5) + (minute/12); | ||
743 | |||
744 | /* Crappy fake antialiasing (color LCDs only)! | ||
745 | * how this works is we draw a large mid-gray hr/min/sec hand, | ||
746 | * then the actual (slightly smaller) hand on top of those. | ||
747 | * End result: mid-gray edges to the black hands, smooths them out. */ | ||
748 | #ifdef HAVE_LCD_COLOR | ||
749 | rb->lcd_set_foreground(LCD_RGBPACK(100,110,125)); | ||
750 | |||
751 | /* second hand */ | ||
752 | if(clock_settings.analog[analog_secondhand]) | ||
753 | { | ||
754 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-2, LCD_WIDTH/2, LCD_HEIGHT/2+2, | ||
755 | xminute_full[second], yminute_full[second]); | ||
756 | xlcd_filltriangle(LCD_WIDTH/2-2, LCD_HEIGHT/2, LCD_WIDTH/2+2, LCD_HEIGHT/2, | ||
757 | xminute_full[second], yminute_full[second]); | ||
758 | } | ||
759 | |||
760 | /* minute hand */ | ||
761 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-4, LCD_WIDTH/2, LCD_HEIGHT/2+4, | ||
762 | xminute_full[minute], yminute_full[minute]); | ||
763 | xlcd_filltriangle(LCD_WIDTH/2-4, LCD_HEIGHT/2, LCD_WIDTH/2+4, LCD_HEIGHT/2, | ||
764 | xminute_full[minute], yminute_full[minute]); | ||
765 | |||
766 | /* hour hand */ | ||
767 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-4, LCD_WIDTH/2, LCD_HEIGHT/2+4, | ||
768 | xhour_full[hourpos], yhour_full[hourpos]); | ||
769 | xlcd_filltriangle(LCD_WIDTH/2-4, LCD_HEIGHT/2, LCD_WIDTH/2+4, LCD_HEIGHT/2, | ||
770 | xhour_full[hourpos], yhour_full[hourpos]); | ||
771 | |||
772 | rb->lcd_set_foreground(LCD_BLACK); | ||
773 | #endif | ||
774 | |||
775 | /* second hand, if needed */ | ||
776 | if(clock_settings.analog[analog_secondhand]) | ||
777 | { | ||
778 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-1, LCD_WIDTH/2, LCD_HEIGHT/2+1, | ||
779 | xminute_full[second], yminute_full[second]); | ||
780 | xlcd_filltriangle(LCD_WIDTH/2-1, LCD_HEIGHT/2, LCD_WIDTH/2+1, LCD_HEIGHT/2, | ||
781 | xminute_full[second], yminute_full[second]); | ||
782 | } | ||
783 | |||
784 | /* minute hand */ | ||
785 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-3, LCD_WIDTH/2, LCD_HEIGHT/2+3, | ||
786 | xminute_full[minute], yminute_full[minute]); | ||
787 | xlcd_filltriangle(LCD_WIDTH/2-3, LCD_HEIGHT/2, LCD_WIDTH/2+3, LCD_HEIGHT/2, | ||
788 | xminute_full[minute], yminute_full[minute]); | ||
789 | |||
790 | /* hour hand */ | ||
791 | xlcd_filltriangle(LCD_WIDTH/2, LCD_HEIGHT/2-3, LCD_WIDTH/2, LCD_HEIGHT/2+3, | ||
792 | xhour_full[hourpos], yhour_full[hourpos]); | ||
793 | xlcd_filltriangle(LCD_WIDTH/2-3, LCD_HEIGHT/2, LCD_WIDTH/2+3, LCD_HEIGHT/2, | ||
794 | xhour_full[hourpos], yhour_full[hourpos]); | ||
795 | |||
796 | /* Draw the circle */ | ||
797 | for(i=0; i < 60; i+=5) | ||
798 | rb->lcd_fillrect(xminute_full[i]-1, yminute_full[i]-1, 3, 3); | ||
799 | |||
800 | /* Draw the cover over the center */ | ||
801 | rb->lcd_drawline((LCD_WIDTH/2)-1, (LCD_HEIGHT/2)+3, | ||
802 | (LCD_WIDTH/2)+1, (LCD_HEIGHT/2)+3); | ||
803 | rb->lcd_drawline((LCD_WIDTH/2)-3, (LCD_HEIGHT/2)+2, | ||
804 | (LCD_WIDTH/2)+3, (LCD_HEIGHT/2)+2); | ||
805 | rb->lcd_drawline((LCD_WIDTH/2)-4, (LCD_HEIGHT/2)+1, | ||
806 | (LCD_WIDTH/2)+4, (LCD_HEIGHT/2)+1); | ||
807 | rb->lcd_drawline((LCD_WIDTH/2)-4, LCD_HEIGHT/2, | ||
808 | (LCD_WIDTH/2)+4, LCD_HEIGHT/2); | ||
809 | rb->lcd_drawline((LCD_WIDTH/2)-4, (LCD_HEIGHT/2)-1, | ||
810 | (LCD_WIDTH/2)+4, (LCD_HEIGHT/2)-1); | ||
811 | rb->lcd_drawline((LCD_WIDTH/2)-3, (LCD_HEIGHT/2)-2, | ||
812 | (LCD_WIDTH/2)+3, (LCD_HEIGHT/2)-2); | ||
813 | rb->lcd_drawline((LCD_WIDTH/2)-1, (LCD_HEIGHT/2)-3, | ||
814 | (LCD_WIDTH/2)+1, (LCD_HEIGHT/2)-3); | ||
815 | } | ||
816 | |||
817 | /******************* | ||
818 | * Binary clock mode | ||
819 | ******************/ | ||
820 | void binary_clock(int hour, int minute, int second) | ||
821 | { | ||
822 | int i, xpos=0; | ||
823 | int mode_var[3]; /* pointers to h, m, s arguments */ | ||
824 | int mode; /* 0 = hour, 1 = minute, 2 = second */ | ||
825 | |||
826 | mode_var[0] = hour; | ||
827 | mode_var[1] = minute; | ||
828 | mode_var[2] = second; | ||
829 | |||
830 | for(mode = 0; mode < 3; mode++) | ||
831 | { | ||
832 | for(i = 32; i > 0; i /= 2) | ||
833 | { | ||
834 | if(mode_var[mode] >= i) | ||
835 | { | ||
836 | if(clock_settings.binary[binary_mode]) | ||
837 | draw_digit(DOT_FILLED, xpos*DIGIT_WIDTH+DIGIT_XOFS(6), DIGIT_HEIGHT*mode+DIGIT_YOFS(3)); | ||
838 | else | ||
839 | draw_digit(1, xpos*DIGIT_WIDTH+DIGIT_XOFS(6), DIGIT_HEIGHT*mode+DIGIT_YOFS(3)); | ||
840 | mode_var[mode] -= i; | ||
841 | } | ||
842 | else | ||
843 | { | ||
844 | if(clock_settings.binary[binary_mode]) | ||
845 | draw_digit(DOT_EMPTY, xpos*DIGIT_WIDTH+DIGIT_XOFS(6), DIGIT_HEIGHT*mode+DIGIT_YOFS(3)); | ||
846 | else | ||
847 | draw_digit(0, xpos*DIGIT_WIDTH+DIGIT_XOFS(6), DIGIT_HEIGHT*mode+DIGIT_YOFS(3)); | ||
848 | } | ||
849 | |||
850 | xpos++; | ||
851 | } | ||
852 | |||
853 | xpos=0; /* reset the x-pos for next mode */ | ||
854 | } | ||
855 | } | ||
856 | |||
857 | /****************** | ||
858 | * Plain clock mode | ||
859 | *****************/ | ||
860 | void plain_clock(int hour, int minute, int second, bool colon) | ||
861 | { | ||
862 | |||
863 | int x_ofs=0; | ||
864 | |||
865 | /* this basically detects if we draw an AM or PM bitmap. | ||
866 | * if we don't, we center the hh:mm display. */ | ||
867 | if(!clock_settings.plain[plain_format]) | ||
868 | x_ofs=DIGIT_WIDTH/2; | ||
869 | |||
870 | if(clock_settings.plain[plain_format]) | ||
871 | { | ||
872 | /* draw the AM or PM bitmap */ | ||
873 | if(hour<12) | ||
874 | draw_digit(ICON_AM, DIGIT_XOFS(6)+(DIGIT_WIDTH*5)+x_ofs, 0); | ||
875 | else | ||
876 | draw_digit(ICON_PM, DIGIT_XOFS(6)+(DIGIT_WIDTH*5)+x_ofs, 0); | ||
877 | |||
878 | /* and then readjust the hour to 12-hour format | ||
879 | * ( 13:00+ -> 1:00+ ) */ | ||
880 | if(hour>12) | ||
881 | hour -= 12; | ||
882 | } | ||
883 | |||
884 | |||
885 | draw_digit(hour/10, DIGIT_XOFS(6)+(DIGIT_WIDTH*0)+x_ofs, 0); | ||
886 | draw_digit(hour%10, DIGIT_XOFS(6)+(DIGIT_WIDTH*1)+x_ofs, 0); | ||
887 | |||
888 | if(colon) | ||
889 | draw_digit(COLON, DIGIT_XOFS(6)+(DIGIT_WIDTH*2)+x_ofs, 0); | ||
890 | |||
891 | draw_digit(minute/10, DIGIT_XOFS(6)+(DIGIT_WIDTH*3)+x_ofs, 0); | ||
892 | draw_digit(minute%10, DIGIT_XOFS(6)+(DIGIT_WIDTH*4)+x_ofs, 0); | ||
893 | |||
894 | if(clock_settings.plain[plain_seconds]) | ||
895 | { | ||
896 | draw_digit(second/10, DIGIT_XOFS(2), DIGIT_HEIGHT); | ||
897 | draw_digit(second%10, DIGIT_XOFS(2)+(DIGIT_WIDTH), DIGIT_HEIGHT); | ||
898 | } | ||
899 | } | ||
900 | |||
901 | |||
902 | |||
903 | /**************************************** | ||
904 | * Draws the extras, IE border, digits... | ||
905 | ***************************************/ | ||
906 | void draw_extras(int year, int day, int month, int hour, int minute, int second) | ||
907 | { | ||
908 | int i; | ||
909 | |||
910 | struct tm* current_time = rb->get_time(); | ||
911 | |||
912 | char moday[8]; | ||
913 | char dateyr[6]; | ||
914 | char tmhrmin[7]; | ||
915 | char tmsec[3]; | ||
916 | |||
917 | /* american date readout */ | ||
918 | if(clock_settings.analog[analog_date] == 1) | ||
919 | rb->snprintf(moday, sizeof(moday), "%02d/%02d", month, day); | ||
920 | else | ||
921 | rb->snprintf(moday, sizeof(moday), "%02d.%02d", day, month); | ||
922 | rb->snprintf(dateyr, sizeof(dateyr), "%d", year); | ||
923 | rb->snprintf(tmhrmin, sizeof(tmhrmin), "%02d:%02d", hour, minute); | ||
924 | rb->snprintf(tmsec, sizeof(tmsec), "%02d", second); | ||
925 | |||
926 | /* Analog Extras */ | ||
927 | if(clock_settings.clock == ANALOG) | ||
928 | { | ||
929 | if(clock_settings.analog[analog_time] != 0) /* Digital readout */ | ||
930 | { | ||
931 | draw_smalldigit(hour/10, SMALLDIGIT_WIDTH*0, 0); | ||
932 | draw_smalldigit(hour%10, SMALLDIGIT_WIDTH*1, 0); | ||
933 | draw_smalldigit(COLON, SMALLDIGIT_WIDTH*2, 0); | ||
934 | draw_smalldigit(minute/10, SMALLDIGIT_WIDTH*3, 0); | ||
935 | draw_smalldigit(minute%10, SMALLDIGIT_WIDTH*4, 0); | ||
936 | |||
937 | draw_smalldigit(second/10, SMALLDIGIT_WIDTH*1.5, SMALLDIGIT_HEIGHT); | ||
938 | draw_smalldigit(second%10, SMALLDIGIT_WIDTH*2.5, SMALLDIGIT_HEIGHT); | ||
939 | |||
940 | /* AM/PM indicator */ | ||
941 | if(clock_settings.analog[analog_time] == 2) | ||
942 | { | ||
943 | if(current_time->tm_hour > 12) /* PM */ | ||
944 | draw_digit(ICON_PM, LCD_WIDTH-DIGIT_WIDTH, DIGIT_HEIGHT/2-DIGIT_HEIGHT); | ||
945 | else /* AM */ | ||
946 | draw_digit(ICON_AM, LCD_WIDTH-DIGIT_WIDTH, DIGIT_HEIGHT/2-DIGIT_HEIGHT); | ||
947 | } | ||
948 | } | ||
949 | if(clock_settings.analog[analog_date] != 0) /* Date readout */ | ||
950 | { | ||
951 | if(clock_settings.analog[analog_date] == 1) | ||
952 | { | ||
953 | draw_smalldigit(month/10, SMALLDIGIT_WIDTH*0, | ||
954 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
955 | draw_smalldigit(month%10, SMALLDIGIT_WIDTH*1, | ||
956 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
957 | draw_smalldigit(SLASH, SMALLDIGIT_WIDTH*2, | ||
958 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
959 | draw_smalldigit(day/10, SMALLDIGIT_WIDTH*3, | ||
960 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
961 | draw_smalldigit(day%10, SMALLDIGIT_WIDTH*4, | ||
962 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
963 | draw_smalldigit(year/1000, SMALLDIGIT_WIDTH*0.5, | ||
964 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
965 | draw_smalldigit(year%1000/100, SMALLDIGIT_WIDTH*1.5, | ||
966 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
967 | draw_smalldigit(year%100/10, SMALLDIGIT_WIDTH*2.5, | ||
968 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
969 | draw_smalldigit(year%10, SMALLDIGIT_WIDTH*3.5, | ||
970 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
971 | } | ||
972 | else if(clock_settings.analog[analog_date] == 2) | ||
973 | { | ||
974 | |||
975 | draw_smalldigit(day/10, SMALLDIGIT_WIDTH*0, | ||
976 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
977 | draw_smalldigit(day%10, SMALLDIGIT_WIDTH*1, | ||
978 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
979 | draw_smalldigit(PERIOD, SMALLDIGIT_WIDTH*2, | ||
980 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
981 | draw_smalldigit(month/10, SMALLDIGIT_WIDTH*3, | ||
982 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
983 | draw_smalldigit(month%10, SMALLDIGIT_WIDTH*4, | ||
984 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
985 | draw_smalldigit(year/1000, SMALLDIGIT_WIDTH*0.5, | ||
986 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
987 | draw_smalldigit(year%1000/100, SMALLDIGIT_WIDTH*1.5, | ||
988 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
989 | draw_smalldigit(year%100/10, SMALLDIGIT_WIDTH*2.5, | ||
990 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
991 | draw_smalldigit(year%10, SMALLDIGIT_WIDTH*3.5, | ||
992 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
993 | } | ||
994 | } | ||
995 | } | ||
996 | else if(clock_settings.clock == DIGITAL) | ||
997 | { | ||
998 | /* Date readout */ | ||
999 | if(clock_settings.digital[digital_date] == 1) /* american mode */ | ||
1000 | { | ||
1001 | draw_smallsegment(month/10, SMALLSEG_WIDTH*0+SMALLSEG_XOFS(10), | ||
1002 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1003 | draw_smallsegment(month%10, SMALLSEG_WIDTH*1+SMALLSEG_XOFS(10), | ||
1004 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1005 | draw_smallsegment(SLASH, SMALLSEG_WIDTH*2+SMALLSEG_XOFS(10), | ||
1006 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1007 | draw_smallsegment(day/10, SMALLSEG_WIDTH*3+SMALLSEG_XOFS(10), | ||
1008 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1009 | draw_smallsegment(day%10, SMALLSEG_WIDTH*4+SMALLSEG_XOFS(10), | ||
1010 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1011 | draw_smallsegment(SLASH, SMALLSEG_WIDTH*5+SMALLSEG_XOFS(10), | ||
1012 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1013 | draw_smallsegment(year/1000, SMALLSEG_WIDTH*6+SMALLSEG_XOFS(10), | ||
1014 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1015 | draw_smallsegment(year%1000/100, SMALLSEG_WIDTH*7+SMALLSEG_XOFS(10), | ||
1016 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1017 | draw_smallsegment(year%100/10, SMALLSEG_WIDTH*8+SMALLSEG_XOFS(10), | ||
1018 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1019 | draw_smallsegment(year%10, SMALLSEG_WIDTH*9+SMALLSEG_XOFS(10), | ||
1020 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1021 | } | ||
1022 | else if(clock_settings.digital[digital_date] == 2) /* european mode */ | ||
1023 | { | ||
1024 | draw_smallsegment(day/10, SMALLSEG_WIDTH*0+SMALLSEG_XOFS(10), | ||
1025 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1026 | draw_smallsegment(day%10, SMALLSEG_WIDTH*1+SMALLSEG_XOFS(10), | ||
1027 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1028 | draw_smallsegment(PERIOD, SMALLSEG_WIDTH*2+SMALLSEG_XOFS(10), | ||
1029 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1030 | draw_smallsegment(month/10, SMALLSEG_WIDTH*3+SMALLSEG_XOFS(10), | ||
1031 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1032 | draw_smallsegment(month%10, SMALLSEG_WIDTH*4+SMALLSEG_XOFS(10), | ||
1033 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1034 | draw_smallsegment(PERIOD, SMALLSEG_WIDTH*5+SMALLSEG_XOFS(10), | ||
1035 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1036 | draw_smallsegment(year/1000, SMALLSEG_WIDTH*6+SMALLSEG_XOFS(10), | ||
1037 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1038 | draw_smallsegment(year%1000/100, SMALLSEG_WIDTH*7+SMALLSEG_XOFS(10), | ||
1039 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1040 | draw_smallsegment(year%100/10, SMALLSEG_WIDTH*8+SMALLSEG_XOFS(10), | ||
1041 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1042 | draw_smallsegment(year%10, SMALLSEG_WIDTH*9+SMALLSEG_XOFS(10), | ||
1043 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET*2); | ||
1044 | } | ||
1045 | } | ||
1046 | else if(clock_settings.clock == FULLSCREEN) /* Fullscreen mode */ | ||
1047 | { | ||
1048 | if(clock_settings.fullscreen[fullscreen_border]) | ||
1049 | { | ||
1050 | for(i=0; i < 60; i+=5) /* Draw the circle */ | ||
1051 | rb->lcd_fillrect(xminute_full[i]-1, yminute_full[i]-1, 3, 3); | ||
1052 | } | ||
1053 | } | ||
1054 | else if(clock_settings.clock == PLAIN) /* Plain mode */ | ||
1055 | { | ||
1056 | /* Date readout */ | ||
1057 | if(clock_settings.plain[plain_date] == 1) /* american mode */ | ||
1058 | { | ||
1059 | draw_smalldigit(month/10, SMALLDIGIT_WIDTH*0+SMALLDIGIT_XOFS(10), | ||
1060 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1061 | draw_smalldigit(month%10, SMALLDIGIT_WIDTH*1+SMALLDIGIT_XOFS(10), | ||
1062 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1063 | draw_smalldigit(SLASH, SMALLDIGIT_WIDTH*2+SMALLDIGIT_XOFS(10), | ||
1064 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1065 | draw_smalldigit(day/10, SMALLDIGIT_WIDTH*3+SMALLDIGIT_XOFS(10), | ||
1066 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1067 | draw_smalldigit(day%10, SMALLDIGIT_WIDTH*4+SMALLDIGIT_XOFS(10), | ||
1068 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1069 | draw_smalldigit(SLASH, SMALLDIGIT_WIDTH*5+SMALLDIGIT_XOFS(10), | ||
1070 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1071 | draw_smalldigit(year/1000, SMALLDIGIT_WIDTH*6+SMALLDIGIT_XOFS(10), | ||
1072 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1073 | draw_smalldigit(year%1000/100, SMALLDIGIT_WIDTH*7+SMALLDIGIT_XOFS(10), | ||
1074 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1075 | draw_smalldigit(year%100/10, SMALLDIGIT_WIDTH*8+SMALLDIGIT_XOFS(10), | ||
1076 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1077 | draw_smalldigit(year%10, SMALLDIGIT_WIDTH*9+SMALLDIGIT_XOFS(10), | ||
1078 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1079 | } | ||
1080 | else if(clock_settings.plain[plain_date] == 2) /* european mode */ | ||
1081 | { | ||
1082 | draw_smalldigit(day/10, SMALLDIGIT_WIDTH*0+SMALLDIGIT_XOFS(10), | ||
1083 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1084 | draw_smalldigit(day%10, SMALLDIGIT_WIDTH*1+SMALLDIGIT_XOFS(10), | ||
1085 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1086 | draw_smalldigit(PERIOD, SMALLDIGIT_WIDTH*2+SMALLDIGIT_XOFS(10), | ||
1087 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1088 | draw_smalldigit(month/10, SMALLDIGIT_WIDTH*3+SMALLDIGIT_XOFS(10), | ||
1089 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1090 | draw_smalldigit(month%10, SMALLDIGIT_WIDTH*4+SMALLDIGIT_XOFS(10), | ||
1091 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1092 | draw_smalldigit(PERIOD, SMALLDIGIT_WIDTH*5+SMALLDIGIT_XOFS(10), | ||
1093 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1094 | draw_smalldigit(year/1000, SMALLDIGIT_WIDTH*6+SMALLDIGIT_XOFS(10), | ||
1095 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1096 | draw_smalldigit(year%1000/100, SMALLDIGIT_WIDTH*7+SMALLDIGIT_XOFS(10), | ||
1097 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1098 | draw_smalldigit(year%100/10, SMALLDIGIT_WIDTH*8+SMALLDIGIT_XOFS(10), | ||
1099 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1100 | draw_smalldigit(year%10, SMALLDIGIT_WIDTH*9+SMALLDIGIT_XOFS(10), | ||
1101 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET*2); | ||
1102 | } | ||
1103 | } | ||
1104 | } | ||
1105 | |||
1106 | /********************* | ||
1107 | * Display the counter | ||
1108 | ********************/ | ||
1109 | void show_counter(void) | ||
1110 | { | ||
1111 | |||
1112 | /* increment counter */ | ||
1113 | if(counting) | ||
1114 | passed_time = *rb->current_tick - start_tick; | ||
1115 | else | ||
1116 | passed_time = 0; | ||
1117 | |||
1118 | displayed_value = counter + passed_time; | ||
1119 | displayed_value = displayed_value / HZ; | ||
1120 | |||
1121 | /* these are the REAL displayed values */ | ||
1122 | count_s = displayed_value % 60; | ||
1123 | count_m = displayed_value % 3600 / 60; | ||
1124 | count_h = displayed_value / 3600; | ||
1125 | |||
1126 | if(clock_settings.general[general_counter]) | ||
1127 | { | ||
1128 | if(clock_settings.clock == ANALOG) | ||
1129 | { | ||
1130 | draw_smalldigit(count_h/10, LCD_WIDTH-SMALLDIGIT_WIDTH*5, | ||
1131 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
1132 | draw_smalldigit(count_h%10, LCD_WIDTH-SMALLDIGIT_WIDTH*4, | ||
1133 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
1134 | draw_smalldigit(COLON, LCD_WIDTH-SMALLDIGIT_WIDTH*3, | ||
1135 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
1136 | draw_smalldigit(count_m/10, LCD_WIDTH-SMALLDIGIT_WIDTH*2, | ||
1137 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
1138 | draw_smalldigit(count_m%10, LCD_WIDTH-SMALLDIGIT_WIDTH, | ||
1139 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*2); | ||
1140 | draw_smalldigit(count_s/10, LCD_WIDTH-SMALLDIGIT_WIDTH*3.5, | ||
1141 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
1142 | draw_smalldigit(count_s%10, LCD_WIDTH-SMALLDIGIT_WIDTH*2.5, | ||
1143 | LCD_HEIGHT-SMALLDIGIT_HEIGHT); | ||
1144 | } | ||
1145 | else if(clock_settings.clock == DIGITAL) | ||
1146 | { | ||
1147 | draw_smallsegment(count_h/10, SMALLSEG_WIDTH*0+SMALLSEG_XOFS(8), | ||
1148 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1149 | draw_smallsegment(count_h%10, SMALLSEG_WIDTH*1+SMALLSEG_XOFS(8), | ||
1150 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1151 | draw_smallsegment(COLON, SMALLSEG_WIDTH*2+SMALLSEG_XOFS(8), | ||
1152 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1153 | draw_smallsegment(count_m/10, SMALLSEG_WIDTH*3+SMALLSEG_XOFS(8), | ||
1154 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1155 | draw_smallsegment(count_m%10, SMALLSEG_WIDTH*4+SMALLSEG_XOFS(8), | ||
1156 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1157 | draw_smallsegment(COLON, SMALLSEG_WIDTH*5+SMALLSEG_XOFS(8), | ||
1158 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1159 | draw_smallsegment(count_s/10, SMALLSEG_WIDTH*6+SMALLSEG_XOFS(8), | ||
1160 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1161 | draw_smallsegment(count_s%10, SMALLSEG_WIDTH*7+SMALLSEG_XOFS(8), | ||
1162 | LCD_HEIGHT-SMALLSEG_HEIGHT*LCD_OFFSET); | ||
1163 | } | ||
1164 | else if(clock_settings.clock == FULLSCREEN) | ||
1165 | { | ||
1166 | |||
1167 | draw_smalldigit(count_h/10, SMALLDIGIT_WIDTH*0+SMALLDIGIT_XOFS(8), | ||
1168 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1169 | draw_smalldigit(count_h%10, SMALLDIGIT_WIDTH*1+SMALLDIGIT_XOFS(8), | ||
1170 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1171 | draw_smalldigit(COLON, SMALLDIGIT_WIDTH*2+SMALLDIGIT_XOFS(8), | ||
1172 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1173 | draw_smalldigit(count_m/10, SMALLDIGIT_WIDTH*3+SMALLDIGIT_XOFS(8), | ||
1174 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1175 | draw_smalldigit(count_m%10, SMALLDIGIT_WIDTH*4+SMALLDIGIT_XOFS(8), | ||
1176 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1177 | draw_smalldigit(COLON, SMALLDIGIT_WIDTH*5+SMALLDIGIT_XOFS(8), | ||
1178 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1179 | draw_smalldigit(count_s/10, SMALLDIGIT_WIDTH*6+SMALLDIGIT_XOFS(8), | ||
1180 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1181 | draw_smalldigit(count_s%10, SMALLDIGIT_WIDTH*7+SMALLDIGIT_XOFS(8), | ||
1182 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*1.5); | ||
1183 | } | ||
1184 | else if(clock_settings.clock == PLAIN) | ||
1185 | { | ||
1186 | draw_smalldigit(count_h/10, SMALLDIGIT_WIDTH*0+SMALLDIGIT_XOFS(8), | ||
1187 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1188 | draw_smalldigit(count_h%10, SMALLDIGIT_WIDTH*1+SMALLDIGIT_XOFS(8), | ||
1189 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1190 | draw_smalldigit(COLON, SMALLDIGIT_WIDTH*2+SMALLDIGIT_XOFS(8), | ||
1191 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1192 | draw_smalldigit(count_m/10, SMALLDIGIT_WIDTH*3+SMALLDIGIT_XOFS(8), | ||
1193 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1194 | draw_smalldigit(count_m%10, SMALLDIGIT_WIDTH*4+SMALLDIGIT_XOFS(8), | ||
1195 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1196 | draw_smalldigit(COLON, SMALLDIGIT_WIDTH*5+SMALLDIGIT_XOFS(8), | ||
1197 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1198 | draw_smalldigit(count_s/10, SMALLDIGIT_WIDTH*6+SMALLDIGIT_XOFS(8), | ||
1199 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1200 | draw_smalldigit(count_s%10, SMALLDIGIT_WIDTH*7+SMALLDIGIT_XOFS(8), | ||
1201 | LCD_HEIGHT-SMALLDIGIT_HEIGHT*LCD_OFFSET); | ||
1202 | } | ||
1203 | } | ||
1204 | } | ||
1205 | |||
1206 | /* Menus */ | ||
1207 | |||
1208 | /*************** | ||
1209 | * Select a mode | ||
1210 | **************/ | ||
1211 | bool menu_mode_selector(void) | ||
1212 | { | ||
1213 | int selection=clock_settings.clock-1; | ||
1214 | |||
1215 | set_standard_colors(); | ||
1216 | |||
1217 | MENUITEM_STRINGLIST(menu,"Mode Selector",NULL, "Analog", "Full-screen", | ||
1218 | "Digital/LCD","Plain","Binary"); | ||
1219 | |||
1220 | /* check for this, so if the user exits the menu without | ||
1221 | * making a selection, it won't change to some weird value. */ | ||
1222 | if(rb->do_menu(&menu, &selection) >=0){ | ||
1223 | clock_settings.clock = selection+1; | ||
1224 | return(true); | ||
1225 | } | ||
1226 | return(false); | ||
1227 | } | ||
1228 | |||
1229 | /********************** | ||
1230 | * Analog settings menu | ||
1231 | *********************/ | ||
1232 | void menu_analog_settings(void) | ||
1233 | { | ||
1234 | int selection=0, result=0; | ||
1235 | |||
1236 | MENUITEM_STRINGLIST(menu,"Analog Mode Settings",NULL,"Show Date", | ||
1237 | "Show Second Hand","Show Time Readout"); | ||
1238 | |||
1239 | while(result>=0) | ||
1240 | { | ||
1241 | result=rb->do_menu(&menu, &selection); | ||
1242 | switch(result) | ||
1243 | { | ||
1244 | case 0: | ||
1245 | rb->set_option("Show Date", &clock_settings.analog[analog_date], | ||
1246 | INT, date_format_text, 3, NULL); | ||
1247 | break; | ||
1248 | case 1: | ||
1249 | rb->set_option("Show Second Hand", &clock_settings.analog[analog_secondhand], | ||
1250 | INT, noyes_text, 2, NULL); | ||
1251 | break; | ||
1252 | case 2: | ||
1253 | rb->set_option("Show Time", &clock_settings.analog[analog_time], | ||
1254 | INT, analog_time_text, 3, NULL); | ||
1255 | break; | ||
1256 | } | ||
1257 | } | ||
1258 | } | ||
1259 | |||
1260 | /*********************** | ||
1261 | * Digital settings menu | ||
1262 | **********************/ | ||
1263 | void menu_digital_settings(void) | ||
1264 | { | ||
1265 | int selection=0, result=0; | ||
1266 | |||
1267 | MENUITEM_STRINGLIST(menu,"Digital/LCD Mode Settings",NULL,"Show Date", | ||
1268 | "Show Seconds","Blinking Colon","Time Format"); | ||
1269 | |||
1270 | while(result>=0) | ||
1271 | { | ||
1272 | result=rb->do_menu(&menu, &selection); | ||
1273 | switch(result) | ||
1274 | { | ||
1275 | case 0: | ||
1276 | rb->set_option("Show Date", &clock_settings.digital[digital_date], | ||
1277 | INT, date_format_text, 3, NULL); | ||
1278 | break; | ||
1279 | case 1: | ||
1280 | rb->set_option("Show Seconds", &clock_settings.digital[digital_seconds], | ||
1281 | INT, noyes_text, 2, NULL); | ||
1282 | break; | ||
1283 | case 2: | ||
1284 | rb->set_option("Blinking Colon", &clock_settings.digital[digital_blinkcolon], | ||
1285 | INT, noyes_text, 2, NULL); | ||
1286 | break; | ||
1287 | case 3: | ||
1288 | rb->set_option("Time Format", &clock_settings.digital[digital_format], | ||
1289 | INT, time_format_text, 2, NULL); | ||
1290 | break; | ||
1291 | } | ||
1292 | } | ||
1293 | } | ||
1294 | |||
1295 | /************************** | ||
1296 | * Fullscreen settings menu | ||
1297 | *************************/ | ||
1298 | void menu_fullscreen_settings(void) | ||
1299 | { | ||
1300 | int selection=0, result=0; | ||
1301 | |||
1302 | MENUITEM_STRINGLIST(menu,"Fullscreen Mode Settings",NULL, | ||
1303 | "Show Border","Show Second Hand"); | ||
1304 | |||
1305 | while(result>=0) | ||
1306 | { | ||
1307 | result=rb->do_menu(&menu, &selection); | ||
1308 | switch(result) | ||
1309 | { | ||
1310 | case 0: | ||
1311 | rb->set_option("Show Border", &clock_settings.fullscreen[fullscreen_border], | ||
1312 | INT, noyes_text, 2, NULL); | ||
1313 | break; | ||
1314 | case 1: | ||
1315 | rb->set_option("Show Second Hand", &clock_settings.fullscreen[fullscreen_secondhand], | ||
1316 | INT, noyes_text, 2, NULL); | ||
1317 | break; | ||
1318 | } | ||
1319 | } | ||
1320 | } | ||
1321 | |||
1322 | /********************** | ||
1323 | * Binary settings menu | ||
1324 | *********************/ | ||
1325 | void menu_binary_settings(void) | ||
1326 | { | ||
1327 | int selection=0, result=0; | ||
1328 | |||
1329 | MENUITEM_STRINGLIST(menu,"Binary Mode Settings",NULL,"Display Mode"); | ||
1330 | |||
1331 | while(result>=0) | ||
1332 | { | ||
1333 | result=rb->do_menu(&menu, &selection); | ||
1334 | switch(result) | ||
1335 | { | ||
1336 | case 0: | ||
1337 | rb->set_option("Display Mode", &clock_settings.binary[binary_mode], | ||
1338 | INT, binary_mode_text, 2, NULL); | ||
1339 | } | ||
1340 | |||
1341 | } | ||
1342 | } | ||
1343 | |||
1344 | /********************* | ||
1345 | * Plain settings menu | ||
1346 | ********************/ | ||
1347 | void menu_plain_settings(void) | ||
1348 | { | ||
1349 | int selection=0, result=0; | ||
1350 | |||
1351 | MENUITEM_STRINGLIST(menu,"Plain Mode Settings",NULL,"Show Date", | ||
1352 | "Show Seconds","Blinking Colon","Time Format"); | ||
1353 | |||
1354 | while(result>=0) | ||
1355 | { | ||
1356 | result=rb->do_menu(&menu, &selection); | ||
1357 | switch(result) | ||
1358 | { | ||
1359 | case 0: | ||
1360 | rb->set_option("Show Date", &clock_settings.plain[plain_date], | ||
1361 | INT, date_format_text, 3, NULL); | ||
1362 | break; | ||
1363 | case 1: | ||
1364 | rb->set_option("Show Seconds", &clock_settings.plain[plain_seconds], | ||
1365 | INT, noyes_text, 2, NULL); | ||
1366 | break; | ||
1367 | case 2: | ||
1368 | rb->set_option("Blinking Colon", &clock_settings.plain[plain_blinkcolon], | ||
1369 | INT, noyes_text, 2, NULL); | ||
1370 | break; | ||
1371 | case 3: | ||
1372 | rb->set_option("Time Format", &clock_settings.plain[plain_format], | ||
1373 | INT, time_format_text, 2, NULL); | ||
1374 | break; | ||
1375 | } | ||
1376 | } | ||
1377 | } | ||
1378 | |||
1379 | /*********************************************************** | ||
1380 | * Confirm resetting of settings, used in general_settings() | ||
1381 | **********************************************************/ | ||
1382 | void confirm_reset(void) | ||
1383 | { | ||
1384 | int result=0; | ||
1385 | |||
1386 | rb->set_option("Reset all settings?", &result, INT, noyes_text, 2, NULL); | ||
1387 | |||
1388 | if(result == 1) /* reset! */ | ||
1389 | { | ||
1390 | reset_settings(); | ||
1391 | rb->splash(HZ, "Settings reset!"); | ||
1392 | } | ||
1393 | else | ||
1394 | rb->splash(HZ, "Settings NOT reset."); | ||
1395 | } | ||
1396 | |||
1397 | /************************************ | ||
1398 | * General settings. Reset, save, etc | ||
1399 | ***********************************/ | ||
1400 | void menu_general_settings(void) | ||
1401 | { | ||
1402 | int selection=0, result=0; | ||
1403 | |||
1404 | MENUITEM_STRINGLIST(menu,"General Settings",NULL,"Reset Settings", | ||
1405 | "Save Settings Now","Save On Exit","Show Counter", | ||
1406 | "Backlight Settings","Idle Poweroff (temporary)"); | ||
1407 | |||
1408 | while(result>=0) | ||
1409 | { | ||
1410 | result=rb->do_menu(&menu, &selection); | ||
1411 | switch(result) | ||
1412 | { | ||
1413 | case 0: | ||
1414 | confirm_reset(); | ||
1415 | break; | ||
1416 | |||
1417 | case 1: | ||
1418 | save_settings(false); | ||
1419 | rb->splash(HZ, "Settings saved"); | ||
1420 | break; | ||
1421 | |||
1422 | case 2: | ||
1423 | rb->set_option("Save On Exit", &clock_settings.general[general_savesetting], | ||
1424 | INT, noyes_text, 2, NULL); | ||
1425 | |||
1426 | /* if we no longer save on exit, we better save now to remember that */ | ||
1427 | if(clock_settings.general[general_savesetting] == 0) | ||
1428 | save_settings(false); | ||
1429 | break; | ||
1430 | |||
1431 | case 3: | ||
1432 | rb->set_option("Show Counter", &clock_settings.general[general_counter], | ||
1433 | INT, noyes_text, 2, NULL); | ||
1434 | break; | ||
1435 | |||
1436 | case 4: | ||
1437 | rb->set_option("Backlight Settings", &clock_settings.general[general_backlight], | ||
1438 | INT, backlight_settings_text, 3, NULL); | ||
1439 | break; | ||
1440 | |||
1441 | case 5: | ||
1442 | rb->set_option("Idle Poweroff (temporary)", &idle_poweroff, | ||
1443 | BOOL, idle_poweroff_text, 2, NULL); | ||
1444 | break; | ||
1445 | } | ||
1446 | |||
1447 | } | ||
1448 | } | ||
1449 | |||
1450 | /*********** | ||
1451 | * Main menu | ||
1452 | **********/ | ||
1453 | void main_menu(void) | ||
1454 | { | ||
1455 | int selection=0; | ||
1456 | bool done = false; | ||
1457 | |||
1458 | set_standard_colors(); | ||
1459 | |||
1460 | MENUITEM_STRINGLIST(menu,"Clock Menu",NULL,"View Clock","Mode Selector", | ||
1461 | "Mode Settings","General Settings","Quit"); | ||
1462 | |||
1463 | while(!done) | ||
1464 | { | ||
1465 | switch(rb->do_menu(&menu, &selection)) | ||
1466 | { | ||
1467 | case 0: | ||
1468 | rb->lcd_setfont(FONT_SYSFIXED); | ||
1469 | done = true; | ||
1470 | break; | ||
1471 | |||
1472 | case 1: | ||
1473 | done=menu_mode_selector(); | ||
1474 | break; | ||
1475 | |||
1476 | case 2: | ||
1477 | switch(clock_settings.clock) | ||
1478 | { | ||
1479 | case ANALOG: menu_analog_settings();break; | ||
1480 | case DIGITAL: menu_digital_settings();break; | ||
1481 | case FULLSCREEN: menu_fullscreen_settings();break; | ||
1482 | case BINARY: menu_binary_settings();break; | ||
1483 | case PLAIN: menu_plain_settings();break; | ||
1484 | } | ||
1485 | break; | ||
1486 | |||
1487 | case 3: | ||
1488 | menu_general_settings(); | ||
1489 | break; | ||
1490 | |||
1491 | case 4: | ||
1492 | exit_clock = true; | ||
1493 | done = true; | ||
1494 | break; | ||
1495 | |||
1496 | default: | ||
1497 | done=true; | ||
1498 | break; | ||
1499 | } | ||
1500 | } | ||
1501 | |||
1502 | rb->lcd_setfont(FONT_SYSFIXED); | ||
1503 | set_digital_colors(); | ||
1504 | } | ||
1505 | |||
1506 | /********************************************************************** | ||
1507 | * Plugin starts here | ||
1508 | **********************************************************************/ | ||
1509 | enum plugin_status plugin_start(struct plugin_api* api, void* parameter) | ||
1510 | { | ||
1511 | int button; | ||
1512 | |||
1513 | /* time/date ints */ | ||
1514 | int hour, minute, second; | ||
1515 | int temphour; | ||
1516 | int last_second = -1; | ||
1517 | int year, day, month; | ||
1518 | |||
1519 | bool counter_btn_held = false; | ||
1520 | |||
1521 | struct tm* current_time; | ||
1522 | |||
1523 | (void)parameter; | ||
1524 | rb = api; | ||
1525 | |||
1526 | #if LCD_DEPTH > 1 | ||
1527 | rb->lcd_set_backdrop(NULL); | ||
1528 | #endif | ||
1529 | |||
1530 | init_clock(); | ||
1531 | |||
1532 | /* init xlcd functions */ | ||
1533 | xlcd_init(rb); | ||
1534 | |||
1535 | set_digital_colors(); | ||
1536 | |||
1537 | while(!exit_clock) | ||
1538 | { | ||
1539 | /********************* | ||
1540 | * Time info | ||
1541 | *********************/ | ||
1542 | current_time = rb->get_time(); | ||
1543 | hour = current_time->tm_hour; | ||
1544 | minute = current_time->tm_min; | ||
1545 | second = current_time->tm_sec; | ||
1546 | temphour = current_time->tm_hour; | ||
1547 | |||
1548 | /********************* | ||
1549 | * Date info | ||
1550 | *********************/ | ||
1551 | year = current_time->tm_year + 1900; | ||
1552 | day = current_time->tm_mday; | ||
1553 | month = current_time->tm_mon + 1; | ||
1554 | |||
1555 | if(second != last_second) | ||
1556 | { | ||
1557 | rb->lcd_clear_display(); | ||
1558 | |||
1559 | /* Analog mode */ | ||
1560 | if(clock_settings.clock == ANALOG) | ||
1561 | analog_clock(hour, minute, second); | ||
1562 | /* Digital mode */ | ||
1563 | else if(clock_settings.clock == DIGITAL) | ||
1564 | { | ||
1565 | if(clock_settings.digital[digital_blinkcolon]) | ||
1566 | digital_clock(hour, minute, second, second & 1); | ||
1567 | else | ||
1568 | digital_clock(hour, minute, second, true); | ||
1569 | } | ||
1570 | /* Fullscreen mode */ | ||
1571 | else if(clock_settings.clock == FULLSCREEN) | ||
1572 | fullscreen_clock(hour, minute, second); | ||
1573 | /* Binary mode */ | ||
1574 | else if(clock_settings.clock == BINARY) | ||
1575 | binary_clock(hour, minute, second); | ||
1576 | /* Plain mode */ | ||
1577 | else if(clock_settings.clock == PLAIN) | ||
1578 | { | ||
1579 | if(clock_settings.plain[plain_blinkcolon]) | ||
1580 | plain_clock(hour, minute, second, second & 1); | ||
1581 | else | ||
1582 | plain_clock(hour, minute, second, true); | ||
1583 | } | ||
1584 | |||
1585 | /* show counter */ | ||
1586 | show_counter(); | ||
1587 | } | ||
1588 | |||
1589 | if(clock_settings.analog[analog_time] == 2 && temphour == 0) | ||
1590 | temphour = 12; | ||
1591 | if(clock_settings.analog[analog_time] == 2 && temphour > 12) | ||
1592 | temphour -= 12; | ||
1593 | |||
1594 | /* all the "extras" - readouts/displays */ | ||
1595 | draw_extras(year, day, month, temphour, minute, second); | ||
1596 | |||
1597 | if(!idle_poweroff) | ||
1598 | rb->reset_poweroff_timer(); | ||
1599 | |||
1600 | rb->lcd_update(); | ||
1601 | |||
1602 | /************************* | ||
1603 | * Scan for button presses | ||
1604 | ************************/ | ||
1605 | button = pluginlib_getaction(rb, HZ/10, plugin_contexts, 2); | ||
1606 | switch (button) | ||
1607 | { | ||
1608 | case ACTION_COUNTER_TOGGLE: /* start/stop counter */ | ||
1609 | if(clock_settings.general[general_counter]) | ||
1610 | { | ||
1611 | if(!counter_btn_held) /* Ignore if the counter was reset */ | ||
1612 | { | ||
1613 | if(counting) | ||
1614 | { | ||
1615 | counting = false; | ||
1616 | counter += passed_time; | ||
1617 | } | ||
1618 | else | ||
1619 | { | ||
1620 | counting = true; | ||
1621 | start_tick = *rb->current_tick; | ||
1622 | } | ||
1623 | } | ||
1624 | counter_btn_held = false; | ||
1625 | } | ||
1626 | break; | ||
1627 | |||
1628 | case ACTION_COUNTER_RESET: /* reset counter */ | ||
1629 | if(clock_settings.general[general_counter]) | ||
1630 | { | ||
1631 | counter_btn_held = true; /* Ignore the release event */ | ||
1632 | counter = 0; | ||
1633 | start_tick = *rb->current_tick; | ||
1634 | } | ||
1635 | break; | ||
1636 | |||
1637 | case ACTION_MODE_NEXT: | ||
1638 | if(clock_settings.clock < CLOCK_MODES) | ||
1639 | clock_settings.clock++; | ||
1640 | else | ||
1641 | clock_settings.clock = 1; | ||
1642 | |||
1643 | set_digital_colors(); | ||
1644 | break; | ||
1645 | |||
1646 | case ACTION_MODE_PREV: | ||
1647 | if(clock_settings.clock > 1) | ||
1648 | clock_settings.clock--; | ||
1649 | else | ||
1650 | clock_settings.clock = CLOCK_MODES; | ||
1651 | |||
1652 | set_digital_colors(); | ||
1653 | break; | ||
1654 | |||
1655 | case ACTION_MENU: | ||
1656 | main_menu(); | ||
1657 | break; | ||
1658 | |||
1659 | case ACTION_EXIT: | ||
1660 | exit_clock=true; | ||
1661 | break; | ||
1662 | |||
1663 | default: | ||
1664 | if(rb->default_event_handler_ex(button, cleanup, NULL) | ||
1665 | == SYS_USB_CONNECTED) | ||
1666 | return PLUGIN_USB_CONNECTED; | ||
1667 | break; | ||
1668 | } | ||
1669 | } | ||
1670 | |||
1671 | cleanup(NULL); | ||
1672 | return PLUGIN_OK; | ||
1673 | } | ||
diff --git a/apps/plugins/clock/Makefile b/apps/plugins/clock/Makefile new file mode 100644 index 0000000000..0481d3e1c2 --- /dev/null +++ b/apps/plugins/clock/Makefile | |||
@@ -0,0 +1,112 @@ | |||
1 | # __________ __ ___. | ||
2 | # Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
3 | # Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
4 | # Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
5 | # Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
6 | # \/ \/ \/ \/ \/ | ||
7 | # $$Id: $$ | ||
8 | # | ||
9 | |||
10 | INCLUDES = -I$(APPSDIR) -I.. -I. -I$(APPSDIR)/plugins/lib \ | ||
11 | $(TARGET_INC) -I$(FIRMDIR)/include -I$(FIRMDIR)/export \ | ||
12 | -I$(FIRMDIR)/common -I$(FIRMDIR)/drivers -I$(OUTDIR) -I$(BUILDDIR) \ | ||
13 | -I$(BUILDDIR)/pluginbitmaps | ||
14 | CFLAGS = $(INCLUDES) $(GCCOPTS) $(TARGET) $(EXTRA_DEFINES) \ | ||
15 | -DTARGET_ID=$(TARGET_ID) -DMEM=${MEMORYSIZE} -DPLUGIN | ||
16 | |||
17 | ifdef APPEXTRA | ||
18 | INCLUDES += $(patsubst %,-I$(APPSDIR)/%,$(subst :, ,$(APPEXTRA))) | ||
19 | endif | ||
20 | |||
21 | LINKFILE := $(OBJDIR)/link.lds | ||
22 | DEPFILE = $(OBJDIR)/dep-clock | ||
23 | |||
24 | # This sets up 'SRC' based on the files mentioned in SOURCES | ||
25 | include $(TOOLSDIR)/makesrc.inc | ||
26 | |||
27 | SOURCES = $(SRC) | ||
28 | OBJS := $(SRC:%.c=$(OBJDIR)/%.o) | ||
29 | DIRS = . | ||
30 | |||
31 | ifndef SIMVER | ||
32 | LDS := ../plugin.lds | ||
33 | OUTPUT = $(OUTDIR)/clock.rock | ||
34 | else ## simulators | ||
35 | OUTPUT = $(OUTDIR)/clock.rock | ||
36 | endif | ||
37 | |||
38 | all: $(OUTPUT) | ||
39 | |||
40 | ifndef SIMVER | ||
41 | $(OBJDIR)/clock.elf: $(OBJS) $(LINKFILE) $(BITMAPLIBS) | ||
42 | $(call PRINTS,LD $(@F))$(CC) $(GCCOPTS) -O -nostdlib -o $@ $(OBJS) -L$(BUILDDIR) -lplugin -lgcc \ | ||
43 | $(LINKBITMAPS) -T$(LINKFILE) -Wl,-Map,$(OBJDIR)/clock.map | ||
44 | |||
45 | $(OUTPUT): $(OBJDIR)/clock.elf | ||
46 | $(call PRINTS,OBJCOPY $(@F))$(OC) -O binary $< $@ | ||
47 | else | ||
48 | |||
49 | ifeq ($(SIMVER), x11) | ||
50 | ################################################### | ||
51 | # This is the X11 simulator version | ||
52 | |||
53 | $(OUTPUT): $(OBJS) | ||
54 | $(call PRINTS,LD $(@F))$(CC) $(CFLAGS) $(SHARED_FLAG) $(OBJS) -L$(BUILDDIR) -lplugin $(LINKBITMAPS) -o $@ | ||
55 | ifeq ($(findstring CYGWIN,$(UNAME)),CYGWIN) | ||
56 | # 'x' must be kept or you'll have "Win32 error 5" | ||
57 | # $ fgrep 5 /usr/include/w32api/winerror.h | head -1 | ||
58 | # #define ERROR_ACCESS_DENIED 5L | ||
59 | else | ||
60 | @chmod -x $@ | ||
61 | endif | ||
62 | |||
63 | else # end of x11-simulator | ||
64 | ifeq ($(SIMVER), sdl) | ||
65 | ################################################### | ||
66 | # This is the SDL simulator version | ||
67 | |||
68 | $(OUTPUT): $(OBJS) | ||
69 | $(call PRINTS,LD $(@F))$(CC) $(CFLAGS) $(SHARED_FLAG) $(OBJS) -L$(BUILDDIR) -lplugin $(LINKBITMAPS) -o $@ | ||
70 | ifeq ($(findstring CYGWIN,$(UNAME)),CYGWIN) | ||
71 | # 'x' must be kept or you'll have "Win32 error 5" | ||
72 | # $ fgrep 5 /usr/include/w32api/winerror.h | head -1 | ||
73 | # #define ERROR_ACCESS_DENIED 5L | ||
74 | else | ||
75 | @chmod -x $@ | ||
76 | endif | ||
77 | |||
78 | else # end of sdl-simulator | ||
79 | ################################################### | ||
80 | # This is the win32 simulator version | ||
81 | DLLTOOLFLAGS = --export-all | ||
82 | DLLWRAPFLAGS = -s --entry _DllMain@12 --target=i386-mingw32 -mno-cygwin | ||
83 | |||
84 | $(OUTPUT): $(OBJS) | ||
85 | $(call PRINTS,DLL $(@F))$(DLLTOOL) $(DLLTOOLFLAGS) -z $(OBJDIR)/$*.def $(OBJS) | ||
86 | $(SILENT)$(DLLWRAP) $(DLLWRAPFLAGS) --def $(OBJDIR)/$*.def $(OBJS) \ | ||
87 | $(BUILDDIR)/libplugin.a $(BITMAPLIBS) -o $@ | ||
88 | ifeq ($(findstring CYGWIN,$(UNAME)),CYGWIN) | ||
89 | # 'x' must be kept or you'll have "Win32 error 5" | ||
90 | # $ fgrep 5 /usr/include/w32api/winerror.h | head -1 | ||
91 | # #define ERROR_ACCESS_DENIED 5L | ||
92 | else | ||
93 | @chmod -x $@ | ||
94 | endif | ||
95 | endif # end of win32-simulator | ||
96 | endif | ||
97 | endif # end of simulator section | ||
98 | |||
99 | |||
100 | include $(TOOLSDIR)/make.inc | ||
101 | |||
102 | # MEMORYSIZE should be passed on to this makefile with the chosen memory size | ||
103 | # given in number of MB | ||
104 | $(LINKFILE): $(LDS) | ||
105 | $(call PRINTS,build $(@F))cat $< | $(CC) -DMEMORYSIZE=$(MEMORYSIZE) $(INCLUDES) $(TARGET) \ | ||
106 | $(DEFINES) -E -P - >$@ | ||
107 | |||
108 | clean: | ||
109 | $(call PRINTS,cleaning clock)rm -rf $(OBJDIR)/clock | ||
110 | $(SILENT)rm -f $(OBJDIR)/clock.* $(DEPFILE) | ||
111 | |||
112 | -include $(DEPFILE) | ||
diff --git a/apps/plugins/clock/SOURCES b/apps/plugins/clock/SOURCES new file mode 100644 index 0000000000..28fae83093 --- /dev/null +++ b/apps/plugins/clock/SOURCES | |||
@@ -0,0 +1,10 @@ | |||
1 | clock.c | ||
2 | clock_bitmaps.c | ||
3 | clock_bitmap_strings.c | ||
4 | clock_counter.c | ||
5 | clock_draw.c | ||
6 | clock_draw_analog.c | ||
7 | clock_draw_binary.c | ||
8 | clock_draw_digital.c | ||
9 | clock_menu.c | ||
10 | clock_settings.c | ||
diff --git a/apps/plugins/clock/clock.c b/apps/plugins/clock/clock.c new file mode 100644 index 0000000000..46d167ba54 --- /dev/null +++ b/apps/plugins/clock/clock.c | |||
@@ -0,0 +1,199 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: clock.c 14095 2007-07-31 10:53:53Z nls $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "plugin.h" | ||
21 | #include "time.h" | ||
22 | #include "pluginlib_actions.h" | ||
23 | #include "xlcd.h" | ||
24 | |||
25 | #include "clock.h" | ||
26 | #include "clock_counter.h" | ||
27 | #include "clock_draw.h" | ||
28 | #include "clock_menu.h" | ||
29 | #include "clock_settings.h" | ||
30 | |||
31 | PLUGIN_HEADER | ||
32 | |||
33 | /* Keymaps */ | ||
34 | const struct button_mapping* plugin_contexts[]={ | ||
35 | generic_actions, | ||
36 | generic_directions, | ||
37 | #if NB_SCREENS == 2 | ||
38 | remote_directions | ||
39 | #endif | ||
40 | }; | ||
41 | #define NB_ACTION_CONTEXTS sizeof(plugin_contexts)/sizeof(plugin_contexts[0]) | ||
42 | #define ACTION_COUNTER_TOGGLE PLA_FIRE | ||
43 | #define ACTION_COUNTER_RESET PLA_FIRE_REPEAT | ||
44 | #define ACTION_MENU PLA_MENU | ||
45 | #define ACTION_EXIT PLA_QUIT | ||
46 | #define ACTION_MODE_NEXT PLA_RIGHT | ||
47 | #define ACTION_MODE_PREV PLA_LEFT | ||
48 | #define ACTION_SKIN_NEXT PLA_UP | ||
49 | #define ACTION_SKIN_PREV PLA_DOWN | ||
50 | |||
51 | extern struct plugin_api* rb; | ||
52 | |||
53 | /************************** | ||
54 | * Cleanup on plugin return | ||
55 | *************************/ | ||
56 | void cleanup(void *parameter) | ||
57 | { | ||
58 | (void)parameter; | ||
59 | clock_draw_restore_colors(); | ||
60 | if(clock_settings.general.save_settings == 1) | ||
61 | save_settings(); | ||
62 | |||
63 | /* restore set backlight timeout */ | ||
64 | rb->backlight_set_timeout(rb->global_settings->backlight_timeout); | ||
65 | } | ||
66 | |||
67 | /* puts the current time into the time struct */ | ||
68 | void clock_update_time( struct time* time){ | ||
69 | struct tm* current_time = rb->get_time(); | ||
70 | time->hour = current_time->tm_hour; | ||
71 | time->minute = current_time->tm_min; | ||
72 | time->second = current_time->tm_sec; | ||
73 | |||
74 | /********************* | ||
75 | * Date info | ||
76 | *********************/ | ||
77 | time->year = current_time->tm_year + 1900; | ||
78 | time->day = current_time->tm_mday; | ||
79 | time->month = current_time->tm_mon + 1; | ||
80 | |||
81 | } | ||
82 | |||
83 | void format_date(char* buffer, struct time* time, enum date_format format){ | ||
84 | switch(format){ | ||
85 | case JAPANESE: | ||
86 | rb->snprintf(buffer, 20, "%04d/%02d/%02d", | ||
87 | time->year, time->month, time->day); | ||
88 | break; | ||
89 | case EUROPEAN: | ||
90 | rb->snprintf(buffer, 20, "%02d/%02d/%04d", | ||
91 | time->day, time->month, time->year); | ||
92 | break; | ||
93 | case ENGLISH: | ||
94 | rb->snprintf(buffer, 20, "%02d/%02d/%04d", | ||
95 | time->month, time->day, time->year); | ||
96 | break; | ||
97 | case NONE: | ||
98 | default: | ||
99 | break; | ||
100 | } | ||
101 | } | ||
102 | |||
103 | /********************************************************************** | ||
104 | * Plugin starts here | ||
105 | **********************************************************************/ | ||
106 | enum plugin_status plugin_start(struct plugin_api* api, void* parameter){ | ||
107 | int button; | ||
108 | int last_second = -1; | ||
109 | bool redraw=true; | ||
110 | int i; | ||
111 | struct time time; | ||
112 | struct counter counter; | ||
113 | bool exit_clock = false; | ||
114 | (void)parameter; | ||
115 | rb = api; | ||
116 | |||
117 | #if LCD_DEPTH > 1 | ||
118 | rb->lcd_set_backdrop(NULL); | ||
119 | #endif | ||
120 | |||
121 | load_settings(); | ||
122 | |||
123 | /* init xlcd functions */ | ||
124 | xlcd_init(rb); | ||
125 | counter_init(&counter); | ||
126 | clock_draw_set_colors(); | ||
127 | |||
128 | while(!exit_clock){ | ||
129 | clock_update_time(&time); | ||
130 | |||
131 | if(!clock_settings.general.idle_poweroff) | ||
132 | rb->reset_poweroff_timer(); | ||
133 | |||
134 | /************************* | ||
135 | * Scan for button presses | ||
136 | ************************/ | ||
137 | button = pluginlib_getaction(rb, HZ/10, plugin_contexts, NB_ACTION_CONTEXTS); | ||
138 | redraw=true;/* we'll set it to false afterwards if there was no action */ | ||
139 | switch (button){ | ||
140 | case ACTION_COUNTER_TOGGLE: /* start/stop counter */ | ||
141 | if(clock_settings.general.show_counter) | ||
142 | counter_toggle(&counter); | ||
143 | break; | ||
144 | |||
145 | case ACTION_COUNTER_RESET: /* reset counter */ | ||
146 | if(clock_settings.general.show_counter) | ||
147 | counter_reset(&counter); | ||
148 | break; | ||
149 | |||
150 | case ACTION_MODE_NEXT: | ||
151 | clock_settings.mode++; | ||
152 | if(clock_settings.mode >= NB_CLOCK_MODES) | ||
153 | clock_settings.mode = 0; | ||
154 | break; | ||
155 | |||
156 | case ACTION_MODE_PREV: | ||
157 | clock_settings.mode--; | ||
158 | if(clock_settings.mode < 0) | ||
159 | clock_settings.mode = NB_CLOCK_MODES-1; | ||
160 | break; | ||
161 | case ACTION_SKIN_PREV: | ||
162 | clock_settings_skin_next(&clock_settings); | ||
163 | break; | ||
164 | case ACTION_SKIN_NEXT: | ||
165 | clock_settings_skin_previous(&clock_settings); | ||
166 | break; | ||
167 | case ACTION_MENU: | ||
168 | clock_draw_restore_colors(); | ||
169 | exit_clock=main_menu(); | ||
170 | break; | ||
171 | |||
172 | case ACTION_EXIT: | ||
173 | /*clock_draw_restore_colors(); | ||
174 | exit_clock=main_menu();*/ | ||
175 | exit_clock=true; | ||
176 | break; | ||
177 | |||
178 | default: | ||
179 | redraw=false; | ||
180 | if(rb->default_event_handler_ex(button, cleanup, NULL) | ||
181 | == SYS_USB_CONNECTED) | ||
182 | return PLUGIN_USB_CONNECTED; | ||
183 | break; | ||
184 | } | ||
185 | if(time.second != last_second){ | ||
186 | last_second=time.second; | ||
187 | redraw=true; | ||
188 | } | ||
189 | if(redraw){ | ||
190 | clock_draw_set_colors(); | ||
191 | FOR_NB_SCREENS(i) | ||
192 | clock_draw(rb->screens[i], &time, &counter); | ||
193 | redraw=false; | ||
194 | } | ||
195 | } | ||
196 | |||
197 | cleanup(NULL); | ||
198 | return PLUGIN_OK; | ||
199 | } | ||
diff --git a/apps/plugins/clock/clock.h b/apps/plugins/clock/clock.h new file mode 100644 index 0000000000..bd5b74fa56 --- /dev/null +++ b/apps/plugins/clock/clock.h | |||
@@ -0,0 +1,32 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _CLOCK_ | ||
21 | #define _CLOCK_ | ||
22 | #include "clock_settings.h" | ||
23 | extern struct plugin_api* rb; | ||
24 | |||
25 | struct time{ | ||
26 | int year, day, month; | ||
27 | int hour, minute, second; | ||
28 | }; | ||
29 | |||
30 | void format_date(char* buffer, struct time* time, enum date_format format); | ||
31 | |||
32 | #endif /* _CLOCK_ */ | ||
diff --git a/apps/plugins/clock/clock_bitmap_strings.c b/apps/plugins/clock/clock_bitmap_strings.c new file mode 100644 index 0000000000..f2bef78f12 --- /dev/null +++ b/apps/plugins/clock/clock_bitmap_strings.c | |||
@@ -0,0 +1,46 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "clock.h" | ||
21 | #include "clock_bitmap_strings.h" | ||
22 | |||
23 | void draw_string(struct screen* display, const struct picture* bitmaps, | ||
24 | char* str, int x, int y){ | ||
25 | int i, bitmap_pos; | ||
26 | char c; | ||
27 | for(i=0;(c=str[i]);i++){ | ||
28 | bitmap_pos=-1; | ||
29 | if(c>='0'&&c<='9') | ||
30 | bitmap_pos=c-'0'; | ||
31 | else if(c==':') | ||
32 | bitmap_pos=10; | ||
33 | else if(c=='A' || c=='/')/* 'AM' in digits, '/' in smalldigits */ | ||
34 | bitmap_pos=11; | ||
35 | else if(c=='P' || c=='.')/* 'PM' in digits, '.' in smalldigits */ | ||
36 | bitmap_pos=12; | ||
37 | if(bitmap_pos>=0) | ||
38 | vertical_picture_draw_sprite(display, bitmaps, bitmap_pos, | ||
39 | x+i*bitmaps->width, y); | ||
40 | } | ||
41 | } | ||
42 | |||
43 | void getstringsize(const struct picture* bitmaps, char* str, int *w, int *h ){ | ||
44 | *h=bitmaps->height; | ||
45 | *w=rb->strlen(str)*bitmaps->width; | ||
46 | } | ||
diff --git a/apps/plugins/clock/clock_bitmap_strings.h b/apps/plugins/clock/clock_bitmap_strings.h new file mode 100644 index 0000000000..61f5ac5953 --- /dev/null +++ b/apps/plugins/clock/clock_bitmap_strings.h | |||
@@ -0,0 +1,31 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | |||
21 | #ifndef _CLOCK_BITMAP_STRINGS_ | ||
22 | #define _CLOCK_BITMAP_STRINGS_ | ||
23 | #include "plugin.h" | ||
24 | #include "picture.h" | ||
25 | |||
26 | void draw_string(struct screen* display, const struct picture* bitmaps, | ||
27 | char* str, int x, int y); | ||
28 | |||
29 | void getstringsize(const struct picture* bitmaps, char* str, int *w, int *h ); | ||
30 | |||
31 | #endif /* _CLOCK_BITMAP_STRINGS_ */ | ||
diff --git a/apps/plugins/clock/clock_bitmaps.c b/apps/plugins/clock/clock_bitmaps.c new file mode 100644 index 0000000000..c8550d180a --- /dev/null +++ b/apps/plugins/clock/clock_bitmaps.c | |||
@@ -0,0 +1,105 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | |||
21 | #include "clock_bitmaps.h" | ||
22 | |||
23 | /* bitmaps */ | ||
24 | #include "clock_binary.h" | ||
25 | #include "clock_digits.h" | ||
26 | #include "clock_smalldigits.h" | ||
27 | #include "clock_segments.h" | ||
28 | #include "clock_smallsegments.h" | ||
29 | |||
30 | #include "clock_logo.h" | ||
31 | #include "clock_messages.h" | ||
32 | |||
33 | #if NB_SCREENS==2 | ||
34 | #include "clock_binary_remote.h" | ||
35 | #include "clock_digits_remote.h" | ||
36 | #include "clock_smalldigits_remote.h" | ||
37 | #include "clock_segments_remote.h" | ||
38 | #include "clock_smallsegments_remote.h" | ||
39 | |||
40 | #include "clock_logo_remote.h" | ||
41 | #include "clock_messages_remote.h" | ||
42 | |||
43 | #endif | ||
44 | |||
45 | |||
46 | const struct picture logos[]={ | ||
47 | {clock_logo, BMPWIDTH_clock_logo, BMPHEIGHT_clock_logo}, | ||
48 | #if NB_SCREENS==2 | ||
49 | {clock_logo_remote,BMPWIDTH_clock_logo_remote,BMPHEIGHT_clock_logo_remote} | ||
50 | #endif | ||
51 | }; | ||
52 | |||
53 | const struct picture messages[]={ | ||
54 | {clock_messages,BMPWIDTH_clock_messages, | ||
55 | BMPHEIGHT_clock_messages/6}, | ||
56 | #if NB_SCREENS==2 | ||
57 | {clock_messages_remote,BMPWIDTH_clock_messages_remote, | ||
58 | BMPHEIGHT_clock_messages_remote/6} | ||
59 | #endif | ||
60 | }; | ||
61 | |||
62 | const struct picture binary[]={ | ||
63 | {clock_binary, | ||
64 | BMPWIDTH_clock_binary, BMPHEIGHT_clock_binary/2 }, | ||
65 | #if NB_SCREENS==2 | ||
66 | {clock_binary_remote, | ||
67 | BMPWIDTH_clock_binary_remote,BMPHEIGHT_clock_binary_remote/2} | ||
68 | #endif | ||
69 | }; | ||
70 | |||
71 | const struct picture digits[]={ | ||
72 | {clock_digits, | ||
73 | BMPWIDTH_clock_digits, BMPHEIGHT_clock_digits/13 }, | ||
74 | #if NB_SCREENS==2 | ||
75 | {clock_digits_remote, | ||
76 | BMPWIDTH_clock_digits_remote,BMPHEIGHT_clock_digits_remote/13} | ||
77 | #endif | ||
78 | }; | ||
79 | |||
80 | const struct picture smalldigits[]={ | ||
81 | {clock_smalldigits, | ||
82 | BMPWIDTH_clock_smalldigits, BMPHEIGHT_clock_smalldigits/13 }, | ||
83 | #if NB_SCREENS==2 | ||
84 | {clock_smalldigits_remote, | ||
85 | BMPWIDTH_clock_smalldigits_remote,BMPHEIGHT_clock_smalldigits_remote/13} | ||
86 | #endif | ||
87 | }; | ||
88 | |||
89 | const struct picture segments[]={ | ||
90 | {clock_segments, | ||
91 | BMPWIDTH_clock_segments, BMPHEIGHT_clock_segments/13 }, | ||
92 | #if NB_SCREENS==2 | ||
93 | {clock_segments_remote, | ||
94 | BMPWIDTH_clock_segments_remote,BMPHEIGHT_clock_segments_remote/13} | ||
95 | #endif | ||
96 | }; | ||
97 | |||
98 | const struct picture smallsegments[]={ | ||
99 | {clock_smallsegments, | ||
100 | BMPWIDTH_clock_smallsegments, BMPHEIGHT_clock_smallsegments/13 }, | ||
101 | #if NB_SCREENS==2 | ||
102 | {clock_smallsegments_remote, | ||
103 | BMPWIDTH_clock_smallsegments_remote,BMPHEIGHT_clock_smallsegments_remote/13} | ||
104 | #endif | ||
105 | }; | ||
diff --git a/apps/plugins/clock/clock_bitmaps.h b/apps/plugins/clock/clock_bitmaps.h new file mode 100644 index 0000000000..a3986f3b4f --- /dev/null +++ b/apps/plugins/clock/clock_bitmaps.h | |||
@@ -0,0 +1,33 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _CLOCK_BITMAPS_ | ||
21 | #define _CLOCK_BITMAPS_ | ||
22 | #include "picture.h" | ||
23 | |||
24 | extern const struct picture logos[]; | ||
25 | extern const struct picture messages[]; | ||
26 | |||
27 | extern const struct picture binary[]; | ||
28 | extern const struct picture digits[]; | ||
29 | extern const struct picture smalldigits[]; | ||
30 | extern const struct picture segments[]; | ||
31 | extern const struct picture smallsegments[]; | ||
32 | |||
33 | #endif | ||
diff --git a/apps/plugins/clock/clock_counter.c b/apps/plugins/clock/clock_counter.c new file mode 100644 index 0000000000..7137eeaf38 --- /dev/null +++ b/apps/plugins/clock/clock_counter.c | |||
@@ -0,0 +1,42 @@ | |||
1 | #include "clock_counter.h" | ||
2 | #include "clock_bitmap_strings.h" | ||
3 | |||
4 | void counter_init(struct counter* counter){ | ||
5 | counter->ticks_since_started=0; | ||
6 | counter->ticks_at_last_unpause=0; | ||
7 | counter->paused=true; | ||
8 | } | ||
9 | |||
10 | int counter_get_ticks_since_last_pause(struct counter* counter){ | ||
11 | if(!counter->paused) | ||
12 | return(*rb->current_tick - counter->ticks_at_last_unpause); | ||
13 | return(0); | ||
14 | } | ||
15 | |||
16 | void counter_toggle(struct counter* counter){ | ||
17 | counter_pause(counter, !counter->paused); | ||
18 | } | ||
19 | |||
20 | void counter_pause(struct counter* counter, bool pause){ | ||
21 | if(pause){ | ||
22 | counter->ticks_since_started+=counter_get_ticks_since_last_pause(counter); | ||
23 | }else{ | ||
24 | counter->ticks_at_last_unpause=*rb->current_tick; | ||
25 | } | ||
26 | counter->paused=pause; | ||
27 | } | ||
28 | |||
29 | void counter_get_elapsed_time(struct counter* counter, struct time* elapsed_time){ | ||
30 | int total_time=counter_get_ticks_since_last_pause(counter); | ||
31 | total_time+=counter->ticks_since_started; | ||
32 | total_time/=HZ;/* converts ticks to seconds */ | ||
33 | |||
34 | elapsed_time->second = total_time%60; | ||
35 | elapsed_time->minute = (total_time%3600) / 60; | ||
36 | elapsed_time->hour = total_time / 3600; | ||
37 | /* not yet ! */ | ||
38 | elapsed_time->day=0; | ||
39 | elapsed_time->month=0; | ||
40 | elapsed_time->year=0; | ||
41 | } | ||
42 | |||
diff --git a/apps/plugins/clock/clock_counter.h b/apps/plugins/clock/clock_counter.h new file mode 100644 index 0000000000..25523d45f6 --- /dev/null +++ b/apps/plugins/clock/clock_counter.h | |||
@@ -0,0 +1,19 @@ | |||
1 | #ifndef _CLOCK_MESSAGE_ | ||
2 | #define _CLOCK_MESSAGE_ | ||
3 | #include "clock.h" | ||
4 | #include "plugin.h" | ||
5 | #include "picture.h" | ||
6 | |||
7 | struct counter{ | ||
8 | int ticks_at_last_unpause;/* to count the time from last pause to now */ | ||
9 | int ticks_since_started;/* accumulated time */ | ||
10 | bool paused; | ||
11 | }; | ||
12 | |||
13 | void counter_init(struct counter* counter); | ||
14 | void counter_toggle(struct counter* counter); | ||
15 | #define counter_reset(counter) counter_init(counter) | ||
16 | void counter_pause(struct counter* counter, bool paused); | ||
17 | void counter_get_elapsed_time(struct counter* counter, struct time* elapsed_time); | ||
18 | |||
19 | #endif /* _CLOCK_MESSAGE_ */ | ||
diff --git a/apps/plugins/clock/clock_draw.c b/apps/plugins/clock/clock_draw.c new file mode 100644 index 0000000000..daf19f7363 --- /dev/null +++ b/apps/plugins/clock/clock_draw.c | |||
@@ -0,0 +1,103 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "clock.h" | ||
21 | #include "clock_draw.h" | ||
22 | #include "clock_draw_digital.h" | ||
23 | #include "clock_draw_analog.h" | ||
24 | #include "clock_draw_binary.h" | ||
25 | #include "clock_settings.h" | ||
26 | |||
27 | void black_background(struct screen* display){ | ||
28 | #if (LCD_DEPTH > 1) || (defined(LCD_REMOTE_DEPTH) && (LCD_REMOTE_DEPTH > 1)) | ||
29 | if(display->depth>1){ | ||
30 | display->set_background(LCD_BLACK); | ||
31 | display->clear_display(); | ||
32 | }else | ||
33 | #endif | ||
34 | { | ||
35 | display->clear_display(); | ||
36 | display->fillrect(0,0,display->width,display->height); | ||
37 | } | ||
38 | } | ||
39 | |||
40 | void white_background(struct screen* display){ | ||
41 | #if (LCD_DEPTH > 1) || (defined(LCD_REMOTE_DEPTH) && (LCD_REMOTE_DEPTH > 1)) | ||
42 | if(display->depth>1){ | ||
43 | #if defined(HAVE_LCD_COLOR) | ||
44 | if(display->is_color)/* restore to the bitmap's background */ | ||
45 | display->set_background(LCD_RGBPACK(180,200,230)); | ||
46 | else | ||
47 | #endif | ||
48 | display->set_background(LCD_WHITE); | ||
49 | } | ||
50 | #endif | ||
51 | display->clear_display(); | ||
52 | } | ||
53 | |||
54 | bool skin_require_black_background(int mode, int skin){ | ||
55 | return((mode==BINARY && skin==2) || (mode==DIGITAL && skin==1 )); | ||
56 | } | ||
57 | |||
58 | void skin_set_background(struct screen* display, int mode, int skin){ | ||
59 | if(skin_require_black_background(mode, skin) ) | ||
60 | black_background(display); | ||
61 | else | ||
62 | white_background(display); | ||
63 | } | ||
64 | |||
65 | void skin_restore_background(struct screen* display, int mode, int skin){ | ||
66 | if(skin_require_black_background(mode, skin) ) | ||
67 | white_background(display); | ||
68 | } | ||
69 | |||
70 | void clock_draw_set_colors(void){ | ||
71 | int i; | ||
72 | FOR_NB_SCREENS(i) | ||
73 | skin_set_background(rb->screens[i], | ||
74 | clock_settings.mode, | ||
75 | clock_settings.skin[clock_settings.mode]); | ||
76 | } | ||
77 | |||
78 | void clock_draw_restore_colors(void){ | ||
79 | int i; | ||
80 | FOR_NB_SCREENS(i){ | ||
81 | skin_restore_background(rb->screens[i], | ||
82 | clock_settings.mode, | ||
83 | clock_settings.skin[clock_settings.mode]); | ||
84 | rb->screens[i]->update(); | ||
85 | } | ||
86 | } | ||
87 | |||
88 | void clock_draw(struct screen* display, struct time* time, | ||
89 | struct counter* counter){ | ||
90 | if(!clock_settings.general.show_counter) | ||
91 | counter=0; | ||
92 | int skin=clock_settings.skin[clock_settings.mode]; | ||
93 | skin_set_background(display, clock_settings.mode, skin); | ||
94 | if(clock_settings.mode == ANALOG) | ||
95 | analog_clock_draw(display, time, &clock_settings, counter, skin); | ||
96 | |||
97 | else if(clock_settings.mode == DIGITAL) | ||
98 | digital_clock_draw(display, time, &clock_settings, counter, skin); | ||
99 | |||
100 | else if(clock_settings.mode == BINARY) | ||
101 | binary_clock_draw(display, time, skin); | ||
102 | display->update(); | ||
103 | } | ||
diff --git a/apps/plugins/clock/clock_draw.h b/apps/plugins/clock/clock_draw.h new file mode 100644 index 0000000000..b589b7ee0e --- /dev/null +++ b/apps/plugins/clock/clock_draw.h | |||
@@ -0,0 +1,32 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _CLOCK_DRAW_ | ||
21 | #define _CLOCK_DRAW_ | ||
22 | #include "plugin.h" | ||
23 | #include "clock.h" | ||
24 | #include "clock_counter.h" | ||
25 | |||
26 | void clock_draw_set_colors(void); | ||
27 | void clock_draw_restore_colors(void); | ||
28 | |||
29 | void clock_draw(struct screen* display, struct time* time, | ||
30 | struct counter* counter); | ||
31 | |||
32 | #endif /* _CLOCK_DRAW_ */ | ||
diff --git a/apps/plugins/clock/clock_draw_analog.c b/apps/plugins/clock/clock_draw_analog.c new file mode 100644 index 0000000000..1fd98773f2 --- /dev/null +++ b/apps/plugins/clock/clock_draw_analog.c | |||
@@ -0,0 +1,217 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare based on Zakk Roberts's work | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "clock_draw_analog.h" | ||
21 | #include "xlcd.h" | ||
22 | #include "fixedpoint.h" | ||
23 | #include "clock_bitmaps.h" | ||
24 | #include "clock_bitmap_strings.h" | ||
25 | |||
26 | #define ANALOG_SECOND_RADIUS(screen, round) \ | ||
27 | ANALOG_MINUTE_RADIUS(screen, round) | ||
28 | #define ANALOG_MINUTE_RADIUS(screen, round) \ | ||
29 | (round?MIN(screen->height/2 -10, screen->width/2 -10):screen->height/2) | ||
30 | #define ANALOG_HOUR_RADIUS(screen, round) \ | ||
31 | (ANALOG_MINUTE_RADIUS(screen, round)/2) | ||
32 | |||
33 | #define HOUR_ANGLE(hour, minute, second) (30*(hour) +(minute)/2) | ||
34 | #define MINUTE_ANGLE(minute, second) (6*(minute)+(second)/10) | ||
35 | #define SECOND_ANGLE(second) (6 * (second)) | ||
36 | |||
37 | void polar_to_cartesian(int a, int r, int* x, int* y){ | ||
38 | *x = (sin_int(a) * r) >> 14; | ||
39 | *y = (sin_int(a-90) * r) >> 14; | ||
40 | } | ||
41 | |||
42 | void polar_to_cartesian_screen_centered(struct screen * display, | ||
43 | int a, int r, int* x, int* y){ | ||
44 | polar_to_cartesian(a, r, x, y); | ||
45 | *x+=display->width/2; | ||
46 | *y+=display->height/2; | ||
47 | } | ||
48 | |||
49 | void angle_to_square(int square_width, int square_height, | ||
50 | int a, int* x, int* y){ | ||
51 | a = (a+360-90)%360; | ||
52 | if(a>45 && a<=135){/* top line */ | ||
53 | a-=45; | ||
54 | *x=square_width-(square_width*2*a)/90; | ||
55 | *y=square_height; | ||
56 | }else if(a>135 && a<=225){/* left line */ | ||
57 | a-=135; | ||
58 | *x=-square_width; | ||
59 | *y=square_height-(square_height*2*a)/90; | ||
60 | }else if(a>225 && a<=315){/* bottom line */ | ||
61 | a-=225; | ||
62 | *x=(square_width*2*a)/90-square_width; | ||
63 | *y=-square_height; | ||
64 | }else if(a>315 || a<=45){/* right line */ | ||
65 | if(a>315) | ||
66 | a-=315; | ||
67 | else | ||
68 | a+=45; | ||
69 | *x=square_width; | ||
70 | *y=(square_height*2*a)/90-square_height; | ||
71 | } | ||
72 | } | ||
73 | |||
74 | void angle_to_square_screen_centered(struct screen * display, | ||
75 | int square_width, int square_height, | ||
76 | int a, int* x, int* y){ | ||
77 | angle_to_square(square_width, square_height, a, x, y); | ||
78 | *x+=display->width/2; | ||
79 | *y+=display->height/2; | ||
80 | } | ||
81 | |||
82 | void draw_hand(struct screen* display, int angle, | ||
83 | int radius, int thickness, bool round){ | ||
84 | int x1, y1; /* the longest */ | ||
85 | int x2, y2, x3, y3; /* the base */ | ||
86 | if(round){/* round clock */ | ||
87 | polar_to_cartesian_screen_centered(display, angle, | ||
88 | radius, &x1, &y1); | ||
89 | }else{/* fullscreen clock, hands describes square motions */ | ||
90 | int square_width, square_height; | ||
91 | /* radius is defined smallest between width and height */ | ||
92 | square_height=radius; | ||
93 | square_width=(radius*display->width)/display->height; | ||
94 | angle_to_square_screen_centered( | ||
95 | display, square_width, square_height, angle, &x1, &y1); | ||
96 | } | ||
97 | polar_to_cartesian_screen_centered(display, (angle+120)%360, | ||
98 | radius/40+thickness, &x2, &y2); | ||
99 | polar_to_cartesian_screen_centered(display, (angle+240)%360, | ||
100 | radius/40+thickness, &x3, &y3); | ||
101 | xlcd_filltriangle_screen(display, x1, y1, x2, y2, x3, y3); | ||
102 | } | ||
103 | |||
104 | void draw_hands(struct screen* display, int hour, int minute, int second, | ||
105 | int thickness, bool round, bool draw_seconds){ | ||
106 | if(draw_seconds){ | ||
107 | draw_hand(display, SECOND_ANGLE(second), | ||
108 | ANALOG_SECOND_RADIUS(display, round), thickness, round); | ||
109 | } | ||
110 | draw_hand(display, MINUTE_ANGLE(minute, second), | ||
111 | ANALOG_MINUTE_RADIUS(display, round), thickness+2, round); | ||
112 | draw_hand(display, HOUR_ANGLE(hour, minute, second), | ||
113 | ANALOG_HOUR_RADIUS(display, round), thickness+2, round); | ||
114 | } | ||
115 | |||
116 | /******************* | ||
117 | * Analog clock mode | ||
118 | ******************/ | ||
119 | void analog_clock_draw(struct screen* display, struct time* time, | ||
120 | struct clock_settings* settings, | ||
121 | struct counter* counter, | ||
122 | int skin){ | ||
123 | int i; | ||
124 | const struct picture* smalldigits_bitmaps = | ||
125 | &(smalldigits[display->screen_type]); | ||
126 | int hour=time->hour; | ||
127 | if(hour >= 12) | ||
128 | hour -= 12; | ||
129 | |||
130 | /* show_date */ | ||
131 | /* show_digital_time*/ | ||
132 | |||
133 | /* Crappy fake antialiasing (color LCDs only)! | ||
134 | * how this works is we draw a large mid-gray hr/min/sec hand, | ||
135 | * then the actual (slightly smaller) hand on top of those. | ||
136 | * End result: mid-gray edges to the black hands, smooths them out. */ | ||
137 | #ifdef HAVE_LCD_COLOR | ||
138 | if(display->is_color){ | ||
139 | display->set_foreground(LCD_RGBPACK(100,110,125)); | ||
140 | draw_hands(display, hour, time->minute, time->second, 2, | ||
141 | skin, settings->analog.show_seconds); | ||
142 | display->set_foreground(LCD_BLACK); | ||
143 | } | ||
144 | #endif | ||
145 | draw_hands(display, hour, time->minute, time->second, 0, skin, | ||
146 | settings->analog.show_seconds); | ||
147 | |||
148 | if(settings->analog.show_border){ | ||
149 | /* Draws square dots every 5 minutes */ | ||
150 | int x, y; | ||
151 | int size=display->height/50;/* size of the square dots */ | ||
152 | if(size%2)/* a pair number */ | ||
153 | size++; | ||
154 | for(i=0; i < 60; i+=5){ | ||
155 | if(skin){ | ||
156 | polar_to_cartesian_screen_centered(display, MINUTE_ANGLE(i, 0), | ||
157 | ANALOG_MINUTE_RADIUS(display, skin), &x, &y); | ||
158 | }else{ | ||
159 | angle_to_square_screen_centered( | ||
160 | display, display->width/2-size/2, display->height/2-size/2, | ||
161 | MINUTE_ANGLE(i, 0), &x, &y); | ||
162 | } | ||
163 | display->fillrect(x-size/2, y-size/2, size, size); | ||
164 | } | ||
165 | } | ||
166 | |||
167 | if(counter){ | ||
168 | char buffer[10]; | ||
169 | int second_str_w, hour_str_w, str_h; | ||
170 | struct time counter_time; | ||
171 | counter_get_elapsed_time(counter, &counter_time); | ||
172 | rb->snprintf(buffer, 10, "%02d:%02d", | ||
173 | counter_time.hour, counter_time.minute); | ||
174 | getstringsize(smalldigits_bitmaps, buffer, &hour_str_w, &str_h); | ||
175 | draw_string(display, smalldigits_bitmaps, buffer, | ||
176 | display->width-hour_str_w, | ||
177 | display->height-2*str_h); | ||
178 | |||
179 | rb->snprintf(buffer, 10, "%02d", counter_time.second); | ||
180 | getstringsize(smalldigits_bitmaps, buffer, &second_str_w, &str_h); | ||
181 | draw_string(display, smalldigits_bitmaps, buffer, | ||
182 | display->width-(hour_str_w+second_str_w)/2, | ||
183 | display->height-str_h); | ||
184 | } | ||
185 | if(settings->analog.show_date && settings->general.date_format!=NONE){ | ||
186 | char buffer[10]; | ||
187 | int year_str_w, monthday_str_w, str_h; | ||
188 | if(settings->general.date_format==ENGLISH){ | ||
189 | rb->snprintf(buffer, 10, "%02d/%02d", time->month, time->day); | ||
190 | }else{ | ||
191 | rb->snprintf(buffer, 10, "%02d/%02d", time->day, time->month); | ||
192 | } | ||
193 | getstringsize(smalldigits_bitmaps, buffer, &monthday_str_w, &str_h); | ||
194 | draw_string(display, smalldigits_bitmaps, buffer, | ||
195 | 0, display->height-2*str_h); | ||
196 | rb->snprintf(buffer, 10, "%04d", time->year); | ||
197 | getstringsize(smalldigits_bitmaps, buffer, &year_str_w, &str_h); | ||
198 | draw_string(display, smalldigits_bitmaps, buffer, | ||
199 | (monthday_str_w-year_str_w)/2, display->height-str_h); | ||
200 | } | ||
201 | |||
202 | /* Draw the cover over the center */ | ||
203 | display->drawline((display->width/2)-1, (display->height/2)+3, | ||
204 | (display->width/2)+1, (display->height/2)+3); | ||
205 | display->drawline((display->width/2)-3, (display->height/2)+2, | ||
206 | (display->width/2)+3, (display->height/2)+2); | ||
207 | display->drawline((display->width/2)-4, (display->height/2)+1, | ||
208 | (display->width/2)+4, (display->height/2)+1); | ||
209 | display->drawline((display->width/2)-4, display->height/2, | ||
210 | (display->width/2)+4, display->height/2); | ||
211 | display->drawline((display->width/2)-4, (display->height/2)-1, | ||
212 | (display->width/2)+4, (display->height/2)-1); | ||
213 | display->drawline((display->width/2)-3, (display->height/2)-2, | ||
214 | (display->width/2)+3, (display->height/2)-2); | ||
215 | display->drawline((display->width/2)-1, (display->height/2)-3, | ||
216 | (display->width/2)+1, (display->height/2)-3); | ||
217 | } | ||
diff --git a/apps/plugins/clock/clock_draw_analog.h b/apps/plugins/clock/clock_draw_analog.h new file mode 100644 index 0000000000..4b8f3f8432 --- /dev/null +++ b/apps/plugins/clock/clock_draw_analog.h | |||
@@ -0,0 +1,32 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _ANALOG_CLOCK_ | ||
21 | #define _ANALOG_CLOCK_ | ||
22 | #include "plugin.h" | ||
23 | #include "clock.h" | ||
24 | #include "clock_counter.h" | ||
25 | #include "clock_settings.h" | ||
26 | |||
27 | void analog_clock_draw(struct screen* display, struct time* time, | ||
28 | struct clock_settings* settings, | ||
29 | struct counter* counter, | ||
30 | int skin); | ||
31 | |||
32 | #endif /* _ANALOG_CLOCK_ */ | ||
diff --git a/apps/plugins/clock/clock_draw_binary.c b/apps/plugins/clock/clock_draw_binary.c new file mode 100644 index 0000000000..5bc84f1583 --- /dev/null +++ b/apps/plugins/clock/clock_draw_binary.c | |||
@@ -0,0 +1,51 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | #include "clock_draw_binary.h" | ||
20 | #include "clock_bitmap_strings.h" | ||
21 | #include "clock_bitmaps.h" | ||
22 | #include "picture.h" | ||
23 | |||
24 | const struct picture* binary_skin[]={binary,digits,segments}; | ||
25 | |||
26 | void print_binary(char* buffer, int number, int nb_bits){ | ||
27 | int i; | ||
28 | int mask=1; | ||
29 | buffer[nb_bits]='\0'; | ||
30 | for(i=0; i<nb_bits; i++){ | ||
31 | if((number & mask) !=0) | ||
32 | buffer[nb_bits-i-1]='1'; | ||
33 | else | ||
34 | buffer[nb_bits-i-1]='0'; | ||
35 | mask=mask<<1; | ||
36 | } | ||
37 | } | ||
38 | |||
39 | void binary_clock_draw(struct screen* display, struct time* time, int skin){ | ||
40 | int lines_values[]={ | ||
41 | time->hour,time->minute,time->second | ||
42 | }; | ||
43 | char buffer[9]; | ||
44 | int i; | ||
45 | const struct picture* binary_bitmaps = &(binary_skin[skin][display->screen_type]); | ||
46 | for(i=0;i<3;i++){ | ||
47 | print_binary(buffer, lines_values[i], 6); | ||
48 | draw_string(display, binary_bitmaps, buffer, 0, | ||
49 | binary_bitmaps->height*i); | ||
50 | } | ||
51 | } | ||
diff --git a/apps/plugins/clock/clock_draw_binary.h b/apps/plugins/clock/clock_draw_binary.h new file mode 100644 index 0000000000..323a640442 --- /dev/null +++ b/apps/plugins/clock/clock_draw_binary.h | |||
@@ -0,0 +1,27 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _BINARY_CLOCK_ | ||
21 | #define _BINARY_CLOCK_ | ||
22 | #include "plugin.h" | ||
23 | #include "clock.h" | ||
24 | |||
25 | void binary_clock_draw(struct screen* display, struct time* time, int skin); | ||
26 | |||
27 | #endif /* _BINARY_CLOCK_ */ | ||
diff --git a/apps/plugins/clock/clock_draw_digital.c b/apps/plugins/clock/clock_draw_digital.c new file mode 100644 index 0000000000..9fff47c520 --- /dev/null +++ b/apps/plugins/clock/clock_draw_digital.c | |||
@@ -0,0 +1,87 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "clock.h" | ||
21 | #include "clock_draw_digital.h" | ||
22 | #include "clock_bitmap_strings.h" | ||
23 | #include "clock_bitmaps.h" | ||
24 | #include "picture.h" | ||
25 | |||
26 | const struct picture* digits_skin[]={digits,segments}; | ||
27 | const struct picture* smalldigits_skin[]={smalldigits,smallsegments}; | ||
28 | |||
29 | #define buffer_printf(buffer, buffer_pos, ... ) \ | ||
30 | buffer_pos+=rb->snprintf(&buffer[buffer_pos], sizeof(buffer)-buffer_pos, __VA_ARGS__); | ||
31 | |||
32 | void digital_clock_draw(struct screen* display, | ||
33 | struct time* time, | ||
34 | struct clock_settings* settings, | ||
35 | struct counter* counter, | ||
36 | int skin){ | ||
37 | bool display_colon; | ||
38 | const struct picture* digits_bitmaps = &(digits_skin[skin][display->screen_type]); | ||
39 | const struct picture* smalldigits_bitmaps = &(smalldigits_skin[skin][display->screen_type]); | ||
40 | int hour=time->hour; | ||
41 | int str_w, str_h; | ||
42 | char buffer[20]; | ||
43 | int buffer_pos=0; | ||
44 | |||
45 | if(settings->digital.blinkcolon){ | ||
46 | display_colon=(time->second%2==0); | ||
47 | } | ||
48 | else | ||
49 | display_colon=true; | ||
50 | |||
51 | if(settings->general.hour_format==H12){/* AM/PM format */ | ||
52 | if(hour>12){ | ||
53 | buffer_printf(buffer, buffer_pos, "P");/* AM */ | ||
54 | /* readjust the hour to 12-hour format | ||
55 | * ( 13:00+ -> 1:00+ ) */ | ||
56 | hour -= 12; | ||
57 | }else | ||
58 | buffer_printf(buffer, buffer_pos, "A");/* AM */ | ||
59 | } | ||
60 | buffer_printf(buffer, buffer_pos, "%02d", hour); | ||
61 | buffer_printf(buffer, buffer_pos, "%c", display_colon?':':' '); | ||
62 | buffer_printf(buffer, buffer_pos, "%02d", time->minute); | ||
63 | getstringsize(digits_bitmaps, buffer, &str_w, &str_h); | ||
64 | draw_string(display, digits_bitmaps, buffer, (display->width-str_w)/2, 0); | ||
65 | if(settings->digital.show_seconds){ | ||
66 | buffer_pos=0; | ||
67 | buffer_printf(buffer, buffer_pos, "%02d", time->second); | ||
68 | getstringsize(digits_bitmaps, buffer, &str_w, &str_h); | ||
69 | draw_string(display, digits_bitmaps, buffer, (display->width-str_w)/2, | ||
70 | digits_bitmaps->height); | ||
71 | } | ||
72 | if(settings->general.date_format!=NONE){ | ||
73 | format_date(buffer, time, settings->general.date_format); | ||
74 | getstringsize(smalldigits_bitmaps, buffer, &str_w, &str_h); | ||
75 | draw_string(display, smalldigits_bitmaps, buffer, (display->width-str_w)/2, | ||
76 | display->height-smalldigits_bitmaps->height*2); | ||
77 | } | ||
78 | if(counter){ | ||
79 | struct time counter_time; | ||
80 | counter_get_elapsed_time(counter, &counter_time); | ||
81 | rb->snprintf(buffer, 20, "%02d:%02d:%02d", | ||
82 | counter_time.hour, counter_time.minute, counter_time.second); | ||
83 | getstringsize(smalldigits_bitmaps, buffer, &str_w, &str_h); | ||
84 | draw_string(display, smalldigits_bitmaps, buffer, (display->width-str_w)/2, | ||
85 | display->height-str_h); | ||
86 | } | ||
87 | } | ||
diff --git a/apps/plugins/clock/clock_draw_digital.h b/apps/plugins/clock/clock_draw_digital.h new file mode 100644 index 0000000000..b967e67571 --- /dev/null +++ b/apps/plugins/clock/clock_draw_digital.h | |||
@@ -0,0 +1,31 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _DIGITAL_CLOCK_ | ||
21 | #define _DIGITAL_CLOCK_ | ||
22 | #include "plugin.h" | ||
23 | #include "clock.h" | ||
24 | #include "clock_counter.h" | ||
25 | #include "clock_settings.h" | ||
26 | |||
27 | void digital_clock_draw(struct screen* display, struct time* time, | ||
28 | struct clock_settings* settings, | ||
29 | struct counter* counter, int skin); | ||
30 | |||
31 | #endif /* _DIGITAL_CLOCK_ */ | ||
diff --git a/apps/plugins/clock/clock_menu.c b/apps/plugins/clock/clock_menu.c new file mode 100644 index 0000000000..3310dbf929 --- /dev/null +++ b/apps/plugins/clock/clock_menu.c | |||
@@ -0,0 +1,246 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2003 Zakk Roberts | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "clock.h" | ||
21 | #include "clock_bitmaps.h" | ||
22 | #include "clock_settings.h" | ||
23 | |||
24 | /* Option structs (possible selections per each option) */ | ||
25 | static const struct opt_items noyes_text[] = { | ||
26 | { "No", -1 }, | ||
27 | { "Yes", -1 } | ||
28 | }; | ||
29 | |||
30 | static const struct opt_items backlight_settings_text[] = { | ||
31 | { "Always Off", -1 }, | ||
32 | { "Rockbox setting", -1 }, | ||
33 | { "Always On", -1 } | ||
34 | }; | ||
35 | |||
36 | static const struct opt_items idle_poweroff_text[] = { | ||
37 | { "Disabled", -1 }, | ||
38 | { "Enabled", -1 } | ||
39 | }; | ||
40 | |||
41 | static const struct opt_items date_format_text[] = { | ||
42 | { "No date", -1 }, | ||
43 | { "English format", -1 }, | ||
44 | { "European format", -1 }, | ||
45 | { "Japanese format", -1 }, | ||
46 | }; | ||
47 | |||
48 | static const struct opt_items hour_format_text[] = { | ||
49 | { "24-hour Format", -1 }, | ||
50 | { "12-hour Format", -1 } | ||
51 | }; | ||
52 | |||
53 | /*************** | ||
54 | * Select a mode, returs true when the mode has been selected | ||
55 | * (we go back to clock display then) | ||
56 | **************/ | ||
57 | bool menu_mode_selector(void){ | ||
58 | MENUITEM_STRINGLIST(menu,"Mode Selector",NULL, "Analog", | ||
59 | "Digital", "Binary"); | ||
60 | if(rb->do_menu(&menu, &clock_settings.mode) >=0) | ||
61 | return(true); | ||
62 | return(false); | ||
63 | } | ||
64 | |||
65 | /********************** | ||
66 | * Analog settings menu | ||
67 | *********************/ | ||
68 | void menu_analog_settings(void) | ||
69 | { | ||
70 | int selection=0, result=0; | ||
71 | |||
72 | MENUITEM_STRINGLIST(menu,"Analog Mode Settings",NULL,"Show Date", | ||
73 | "Show Second Hand","Show Border"); | ||
74 | |||
75 | while(result>=0){ | ||
76 | result=rb->do_menu(&menu, &selection); | ||
77 | switch(result){ | ||
78 | case 0: | ||
79 | rb->set_option("Show Date", &clock_settings.analog.show_date, | ||
80 | BOOL, noyes_text, 2, NULL); | ||
81 | break; | ||
82 | case 1: | ||
83 | rb->set_option("Show Second Hand", | ||
84 | &clock_settings.analog.show_seconds, | ||
85 | BOOL, noyes_text, 2, NULL); | ||
86 | break; | ||
87 | case 2: | ||
88 | rb->set_option("Show Border", | ||
89 | &clock_settings.analog.show_border, | ||
90 | BOOL, noyes_text, 2, NULL); | ||
91 | break; | ||
92 | } | ||
93 | } | ||
94 | } | ||
95 | |||
96 | /*********************** | ||
97 | * Digital settings menu | ||
98 | **********************/ | ||
99 | void menu_digital_settings(void){ | ||
100 | int selection=0, result=0; | ||
101 | |||
102 | MENUITEM_STRINGLIST(menu,"Digital Mode Settings",NULL,"Show Seconds", | ||
103 | "Blinking Colon"); | ||
104 | |||
105 | while(result>=0){ | ||
106 | result=rb->do_menu(&menu, &selection); | ||
107 | switch(result){ | ||
108 | case 0: | ||
109 | rb->set_option("Show Seconds", | ||
110 | &clock_settings.digital.show_seconds, | ||
111 | BOOL, noyes_text, 2, NULL); | ||
112 | break; | ||
113 | case 1: | ||
114 | rb->set_option("Blinking Colon", | ||
115 | &clock_settings.digital.blinkcolon, | ||
116 | BOOL, noyes_text, 2, NULL); | ||
117 | break; | ||
118 | } | ||
119 | } | ||
120 | } | ||
121 | |||
122 | /*********************************************************** | ||
123 | * Confirm resetting of settings, used in general_settings() | ||
124 | **********************************************************/ | ||
125 | void confirm_reset(void){ | ||
126 | int result=0; | ||
127 | |||
128 | rb->set_option("Reset all settings?", &result, INT, noyes_text, 2, NULL); | ||
129 | |||
130 | if(result == 1){ /* reset! */ | ||
131 | clock_settings_reset(&clock_settings); | ||
132 | rb->splash(HZ, "Settings reset!"); | ||
133 | } | ||
134 | else | ||
135 | rb->splash(HZ, "Settings NOT reset."); | ||
136 | } | ||
137 | |||
138 | /************************************ | ||
139 | * General settings. Reset, save, etc | ||
140 | ***********************************/ | ||
141 | void menu_general_settings(void){ | ||
142 | int selection=0, result=0; | ||
143 | |||
144 | MENUITEM_STRINGLIST(menu,"General Settings",NULL, | ||
145 | "Hour format","Date format","Show Counter", | ||
146 | "Reset Settings","Save Settings Now", | ||
147 | "Save On Exit","Backlight Settings", | ||
148 | "Idle Poweroff (temporary)"); | ||
149 | |||
150 | while(result>=0){ | ||
151 | result=rb->do_menu(&menu, &selection); | ||
152 | switch(result){ | ||
153 | case 0: | ||
154 | rb->set_option("Hour format", | ||
155 | &clock_settings.general.hour_format, | ||
156 | INT, hour_format_text, 2, NULL); | ||
157 | break; | ||
158 | case 1: | ||
159 | rb->set_option("Date format", | ||
160 | &clock_settings.general.date_format, | ||
161 | INT, date_format_text, 4, NULL); | ||
162 | break; | ||
163 | case 2: | ||
164 | rb->set_option("Show Counter", &clock_settings.general.show_counter, | ||
165 | BOOL, noyes_text, 2, NULL); | ||
166 | break; | ||
167 | case 3: | ||
168 | confirm_reset(); | ||
169 | break; | ||
170 | |||
171 | case 4: | ||
172 | save_settings_wo_gui(); | ||
173 | rb->splash(HZ, "Settings saved"); | ||
174 | break; | ||
175 | |||
176 | case 5: | ||
177 | rb->set_option("Save On Exit", | ||
178 | &clock_settings.general.save_settings, | ||
179 | BOOL, noyes_text, 2, NULL); | ||
180 | |||
181 | /* if we no longer save on exit, | ||
182 | we better save now to remember that */ | ||
183 | if(!clock_settings.general.save_settings) | ||
184 | save_settings_wo_gui(); | ||
185 | break; | ||
186 | case 6: | ||
187 | rb->set_option("Backlight Settings", | ||
188 | &clock_settings.general.backlight, | ||
189 | INT, backlight_settings_text, 3, NULL); | ||
190 | apply_backlight_setting(clock_settings.general.backlight); | ||
191 | break; | ||
192 | |||
193 | case 7: | ||
194 | rb->set_option("Idle Poweroff (temporary)", | ||
195 | &clock_settings.general.idle_poweroff, | ||
196 | BOOL, idle_poweroff_text, 2, NULL); | ||
197 | break; | ||
198 | } | ||
199 | } | ||
200 | } | ||
201 | |||
202 | /*********** | ||
203 | * Main menu | ||
204 | **********/ | ||
205 | bool main_menu(void){ | ||
206 | int selection=0; | ||
207 | bool done = false; | ||
208 | bool exit_clock=false; | ||
209 | |||
210 | MENUITEM_STRINGLIST(menu,"Clock Menu",NULL,"View Clock","Mode Selector", | ||
211 | "Mode Settings","General Settings","Quit"); | ||
212 | |||
213 | while(!done){ | ||
214 | switch(rb->do_menu(&menu, &selection)){ | ||
215 | case 0: | ||
216 | done = true; | ||
217 | break; | ||
218 | |||
219 | case 1: | ||
220 | done=menu_mode_selector(); | ||
221 | break; | ||
222 | |||
223 | case 2: | ||
224 | switch(clock_settings.mode){ | ||
225 | case ANALOG: menu_analog_settings();break; | ||
226 | case DIGITAL: menu_digital_settings();break; | ||
227 | case BINARY: /* no settings */;break; | ||
228 | } | ||
229 | break; | ||
230 | |||
231 | case 3: | ||
232 | menu_general_settings(); | ||
233 | break; | ||
234 | |||
235 | case 4: | ||
236 | exit_clock = true; | ||
237 | done = true; | ||
238 | break; | ||
239 | |||
240 | default: | ||
241 | done=true; | ||
242 | break; | ||
243 | } | ||
244 | } | ||
245 | return(exit_clock); | ||
246 | } | ||
diff --git a/apps/plugins/clock/clock_menu.h b/apps/plugins/clock/clock_menu.h new file mode 100644 index 0000000000..c02a42ce2a --- /dev/null +++ b/apps/plugins/clock/clock_menu.h | |||
@@ -0,0 +1,7 @@ | |||
1 | |||
2 | #ifndef _CLOCK_MENU_ | ||
3 | #define _CLOCK_MENU_ | ||
4 | |||
5 | bool main_menu(void); | ||
6 | |||
7 | #endif /* _CLOCK_MENU_ */ | ||
diff --git a/apps/plugins/clock/clock_settings.c b/apps/plugins/clock/clock_settings.c new file mode 100644 index 0000000000..9bd7c90d3b --- /dev/null +++ b/apps/plugins/clock/clock_settings.c | |||
@@ -0,0 +1,200 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare based on Zakk Roberts's work | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "clock.h" | ||
21 | #include "clock_bitmaps.h" | ||
22 | #include "clock_draw.h" | ||
23 | #include "clock_settings.h" | ||
24 | #include "picture.h" | ||
25 | |||
26 | static int max_skin[]={ | ||
27 | [ANALOG]=2, | ||
28 | [BINARY]=3, | ||
29 | [DIGITAL]=2, | ||
30 | }; | ||
31 | |||
32 | enum message{ | ||
33 | MESSAGE_LOADING, | ||
34 | MESSAGE_LOADED, | ||
35 | MESSAGE_ERRLOAD, | ||
36 | MESSAGE_SAVING, | ||
37 | MESSAGE_SAVED, | ||
38 | MESSAGE_ERRSAVE | ||
39 | }; | ||
40 | |||
41 | enum settings_file_status{ | ||
42 | LOADED, ERRLOAD, | ||
43 | SAVED, ERRSAVE | ||
44 | }; | ||
45 | |||
46 | struct clock_settings clock_settings; | ||
47 | |||
48 | void clock_settings_reset(struct clock_settings* settings){ | ||
49 | settings->mode = ANALOG; | ||
50 | int i; | ||
51 | for(i=0;i<NB_CLOCK_MODES;i++){ | ||
52 | settings->skin[i]=0; | ||
53 | } | ||
54 | settings->general.hour_format = H12; | ||
55 | settings->general.date_format = EUROPEAN; | ||
56 | settings->general.show_counter = true; | ||
57 | settings->general.save_settings = true; | ||
58 | settings->general.idle_poweroff=true; | ||
59 | settings->general.backlight = ROCKBOX_SETTING; | ||
60 | |||
61 | settings->analog.show_date = false; | ||
62 | settings->analog.show_seconds = true; | ||
63 | settings->analog.show_border = true; | ||
64 | |||
65 | settings->digital.show_seconds = true; | ||
66 | settings->digital.blinkcolon = false; | ||
67 | apply_backlight_setting(settings->general.backlight); | ||
68 | } | ||
69 | |||
70 | void apply_backlight_setting(int backlight_setting) | ||
71 | { | ||
72 | if(backlight_setting == ALWAS_OFF) | ||
73 | rb->backlight_set_timeout(0); | ||
74 | else if(backlight_setting == ROCKBOX_SETTING) | ||
75 | rb->backlight_set_timeout(rb->global_settings->backlight_timeout); | ||
76 | else if(backlight_setting == ALWAYS_ON) | ||
77 | rb->backlight_set_timeout(1); | ||
78 | } | ||
79 | |||
80 | void clock_settings_skin_next(struct clock_settings* settings){ | ||
81 | settings->skin[settings->mode]++; | ||
82 | if(settings->skin[settings->mode]>=max_skin[settings->mode]) | ||
83 | settings->skin[settings->mode]=0; | ||
84 | } | ||
85 | |||
86 | void clock_settings_skin_previous(struct clock_settings* settings){ | ||
87 | settings->skin[settings->mode]--; | ||
88 | if(settings->skin[settings->mode]<0) | ||
89 | settings->skin[settings->mode]=max_skin[settings->mode]-1; | ||
90 | } | ||
91 | |||
92 | enum settings_file_status clock_settings_load(struct clock_settings* settings, | ||
93 | char* filename){ | ||
94 | int fd = rb->open(filename, O_RDONLY); | ||
95 | if(fd >= 0){ /* does file exist? */ | ||
96 | /* basic consistency check */ | ||
97 | if(rb->filesize(fd) == sizeof(*settings)){ | ||
98 | rb->read(fd, settings, sizeof(*settings)); | ||
99 | rb->close(fd); | ||
100 | apply_backlight_setting(settings->general.backlight); | ||
101 | return(LOADED); | ||
102 | } | ||
103 | } | ||
104 | /* Initializes the settings with default values at least */ | ||
105 | clock_settings_reset(settings); | ||
106 | return(ERRLOAD); | ||
107 | } | ||
108 | |||
109 | enum settings_file_status clock_settings_save(struct clock_settings* settings, | ||
110 | char* filename){ | ||
111 | int fd = rb->creat(filename); | ||
112 | if(fd >= 0){ /* does file exist? */ | ||
113 | rb->write (fd, settings, sizeof(*settings)); | ||
114 | rb->close(fd); | ||
115 | return(SAVED); | ||
116 | } | ||
117 | return(ERRSAVE); | ||
118 | } | ||
119 | |||
120 | void draw_logo(struct screen* display){ | ||
121 | #ifdef HAVE_LCD_COLOR | ||
122 | if(display->is_color){ | ||
123 | display->set_foreground(LCD_BLACK); | ||
124 | display->set_background(LCD_RGBPACK(180,200,230)); | ||
125 | } | ||
126 | #endif | ||
127 | |||
128 | const struct picture* logo = &(logos[display->screen_type]); | ||
129 | display->clear_display(); | ||
130 | picture_draw(display, logo, 0, 0); | ||
131 | } | ||
132 | |||
133 | void draw_message(struct screen* display, int msg, int y){ | ||
134 | const struct picture* message = &(messages[display->screen_type]); | ||
135 | display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
136 | display->fillrect(0, display->height-message->height, | ||
137 | display->width, message->height); | ||
138 | display->set_drawmode(DRMODE_SOLID); | ||
139 | vertical_picture_draw_sprite(display, message, msg, | ||
140 | 0, display->height-(message->height*y)); | ||
141 | } | ||
142 | |||
143 | void load_settings(void){ | ||
144 | int i; | ||
145 | struct screen* display; | ||
146 | FOR_NB_SCREENS(i){ | ||
147 | display=rb->screens[i]; | ||
148 | display->clear_display(); | ||
149 | draw_logo(display); | ||
150 | draw_message(display, MESSAGE_LOADING, 1); | ||
151 | display->update(); | ||
152 | } | ||
153 | |||
154 | enum settings_file_status load_status= | ||
155 | clock_settings_load(&clock_settings, settings_filename); | ||
156 | |||
157 | FOR_NB_SCREENS(i){ | ||
158 | display=rb->screens[i]; | ||
159 | if(load_status==LOADED) | ||
160 | draw_message(display, MESSAGE_LOADED, 1); | ||
161 | else | ||
162 | draw_message(display, MESSAGE_ERRLOAD, 1); | ||
163 | display->update(); | ||
164 | } | ||
165 | #ifndef SIMULATOR | ||
166 | rb->ata_sleep(); | ||
167 | #endif | ||
168 | rb->sleep(HZ); | ||
169 | } | ||
170 | |||
171 | void save_settings(void){ | ||
172 | int i; | ||
173 | struct screen* display; | ||
174 | FOR_NB_SCREENS(i){ | ||
175 | display=rb->screens[i]; | ||
176 | display->clear_display(); | ||
177 | draw_logo(display); | ||
178 | |||
179 | draw_message(display, MESSAGE_SAVING, 1); | ||
180 | |||
181 | display->update(); | ||
182 | } | ||
183 | enum settings_file_status load_status= | ||
184 | clock_settings_save(&clock_settings, settings_filename); | ||
185 | |||
186 | FOR_NB_SCREENS(i){ | ||
187 | display=rb->screens[i]; | ||
188 | |||
189 | if(load_status==SAVED) | ||
190 | draw_message(display, MESSAGE_SAVED, 1); | ||
191 | else | ||
192 | draw_message(display, MESSAGE_ERRSAVE, 1); | ||
193 | display->update(); | ||
194 | } | ||
195 | rb->sleep(HZ); | ||
196 | } | ||
197 | |||
198 | void save_settings_wo_gui(void){ | ||
199 | clock_settings_save(&clock_settings, settings_filename); | ||
200 | } | ||
diff --git a/apps/plugins/clock/clock_settings.h b/apps/plugins/clock/clock_settings.h new file mode 100644 index 0000000000..fadf3d5e63 --- /dev/null +++ b/apps/plugins/clock/clock_settings.h | |||
@@ -0,0 +1,91 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare based on Zakk Roberts's work | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _CLOCK_SETTINGS_ | ||
21 | #define _CLOCK_SETTINGS_ | ||
22 | #include "plugin.h" | ||
23 | |||
24 | enum date_format{ | ||
25 | NONE, | ||
26 | ENGLISH, | ||
27 | EUROPEAN, | ||
28 | JAPANESE, | ||
29 | }; | ||
30 | |||
31 | enum hour_format{ | ||
32 | H24, | ||
33 | H12 | ||
34 | }; | ||
35 | |||
36 | enum clock_modes{ | ||
37 | ANALOG, | ||
38 | DIGITAL, | ||
39 | BINARY, | ||
40 | NB_CLOCK_MODES | ||
41 | }; | ||
42 | |||
43 | enum backlight_handling{ | ||
44 | ALWAS_OFF, | ||
45 | ROCKBOX_SETTING, | ||
46 | ALWAYS_ON | ||
47 | }; | ||
48 | |||
49 | |||
50 | struct general_settings{ | ||
51 | int hour_format;/* 0:24h, 1:12h*/ | ||
52 | int date_format; | ||
53 | bool show_counter; | ||
54 | bool save_settings; | ||
55 | bool idle_poweroff; | ||
56 | int backlight; | ||
57 | }; | ||
58 | |||
59 | struct analog_settings{ | ||
60 | bool show_date; | ||
61 | bool show_seconds; | ||
62 | bool show_border; | ||
63 | }; | ||
64 | |||
65 | struct digital_settings{ | ||
66 | int show_seconds; | ||
67 | int blinkcolon; | ||
68 | }; | ||
69 | |||
70 | struct clock_settings{ | ||
71 | int mode; /* clock mode */ | ||
72 | int skin[NB_CLOCK_MODES];/* how does each mode looks like */ | ||
73 | struct general_settings general; | ||
74 | struct analog_settings analog; | ||
75 | struct digital_settings digital; | ||
76 | }; | ||
77 | |||
78 | extern struct clock_settings clock_settings; | ||
79 | |||
80 | /* settings are saved to this location */ | ||
81 | #define settings_filename "/.rockbox/rocks/.clock_settings" | ||
82 | |||
83 | void clock_settings_skin_next(struct clock_settings* settings); | ||
84 | void clock_settings_skin_previous(struct clock_settings* settings); | ||
85 | void apply_backlight_setting(int backlight_setting); | ||
86 | void clock_settings_reset(struct clock_settings* settings); | ||
87 | void load_settings(void); | ||
88 | void save_settings(void); | ||
89 | void save_settings_wo_gui(void); | ||
90 | |||
91 | #endif /* _CLOCK_SETTINGS_ */ | ||
diff --git a/apps/plugins/lib/SOURCES b/apps/plugins/lib/SOURCES index 03a990acda..88d362a670 100644 --- a/apps/plugins/lib/SOURCES +++ b/apps/plugins/lib/SOURCES | |||
@@ -21,6 +21,7 @@ profile_plugin.c | |||
21 | #endif | 21 | #endif |
22 | #ifdef HAVE_LCD_BITMAP | 22 | #ifdef HAVE_LCD_BITMAP |
23 | checkbox.c | 23 | checkbox.c |
24 | picture.c | ||
24 | xlcd_core.c | 25 | xlcd_core.c |
25 | xlcd_draw.c | 26 | xlcd_draw.c |
26 | xlcd_scroll.c | 27 | xlcd_scroll.c |
diff --git a/apps/plugins/lib/picture.c b/apps/plugins/lib/picture.c new file mode 100644 index 0000000000..f214dfcdfd --- /dev/null +++ b/apps/plugins/lib/picture.c | |||
@@ -0,0 +1,70 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #include "picture.h" | ||
21 | |||
22 | void picture_draw(struct screen* display, const struct picture* picture, | ||
23 | int x, int y){ | ||
24 | display->bitmap( | ||
25 | picture->data, | ||
26 | x, y, | ||
27 | picture->width, picture->height | ||
28 | ); | ||
29 | } | ||
30 | |||
31 | /** | ||
32 | * Draws a part of the given picture on the given screen | ||
33 | * Use it when the data contains multiple pictures from top to bottom. | ||
34 | * In that case, picture.height represents the height of one picture, | ||
35 | * not the whole set. | ||
36 | * @param display the screen where to display the picture | ||
37 | * @param picture the picture's data, only a part will be displayed | ||
38 | * @param yoffset display the data in the picture from yoffset to | ||
39 | * yoffset+picture.height | ||
40 | * @param x abscissa where to put the picture | ||
41 | * @param y ordinate where to put the picture | ||
42 | */ | ||
43 | void vertical_picture_draw_part(struct screen* display, const struct picture* picture, | ||
44 | int yoffset, | ||
45 | int x, int y){ | ||
46 | display->bitmap_part( | ||
47 | picture->data, | ||
48 | /*slice into picture->data */ | ||
49 | 0, yoffset, | ||
50 | picture->width, | ||
51 | /* Position on the screen */ | ||
52 | x, y, picture->width, picture->height | ||
53 | ); | ||
54 | } | ||
55 | |||
56 | /** | ||
57 | * Draws a part of the given picture on the given screen | ||
58 | * Use it when the data contains multiple pictures from top to bottom. | ||
59 | * | ||
60 | * @param display the screen where to display the picture | ||
61 | * @param picture the picture's data, only a part will be displayed | ||
62 | * @param sprite_no display that sprite in the picture | ||
63 | * @param x abscissa where to put the picture | ||
64 | * @param y ordinate where to put the picture | ||
65 | */ | ||
66 | void vertical_picture_draw_sprite(struct screen* display, const struct picture* picture, | ||
67 | int sprite_no, | ||
68 | int x, int y){ | ||
69 | vertical_picture_draw_part(display, picture, sprite_no*picture->height, x, y); | ||
70 | } | ||
diff --git a/apps/plugins/lib/picture.h b/apps/plugins/lib/picture.h new file mode 100644 index 0000000000..4bd550a2f3 --- /dev/null +++ b/apps/plugins/lib/picture.h | |||
@@ -0,0 +1,40 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: jackpot.c 14034 2007-07-28 05:42:55Z kevin $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Copyright Kévin Ferrare | ||
11 | * | ||
12 | * All files in this archive are subject to the GNU General Public License. | ||
13 | * See the file COPYING in the source tree root for full license agreement. | ||
14 | * | ||
15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
16 | * KIND, either express or implied. | ||
17 | * | ||
18 | ****************************************************************************/ | ||
19 | |||
20 | #ifndef _PICTURE_ | ||
21 | #define _PICTURE_ | ||
22 | #include "plugin.h" | ||
23 | |||
24 | struct picture{ | ||
25 | const void* data; | ||
26 | int width; | ||
27 | int height; | ||
28 | }; | ||
29 | |||
30 | void picture_draw(struct screen* display, const struct picture* picture, | ||
31 | int x, int y); | ||
32 | |||
33 | void vertical_picture_draw_part(struct screen* display, const struct picture* picture, | ||
34 | int yoffset, | ||
35 | int x, int y); | ||
36 | |||
37 | void vertical_picture_draw_sprite(struct screen* display, const struct picture* picture, | ||
38 | int sprite_no, | ||
39 | int x, int y); | ||
40 | #endif | ||
diff --git a/apps/plugins/lib/xlcd.h b/apps/plugins/lib/xlcd.h index 473c51c732..59a048228b 100644 --- a/apps/plugins/lib/xlcd.h +++ b/apps/plugins/lib/xlcd.h | |||
@@ -28,7 +28,8 @@ | |||
28 | 28 | ||
29 | void xlcd_init(struct plugin_api* newrb); | 29 | void xlcd_init(struct plugin_api* newrb); |
30 | void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3); | 30 | void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3); |
31 | 31 | void xlcd_filltriangle_screen(struct screen* display, | |
32 | int x1, int y1, int x2, int y2, int x3, int y3); | ||
32 | #if LCD_DEPTH >= 8 | 33 | #if LCD_DEPTH >= 8 |
33 | void xlcd_gray_bitmap_part(const unsigned char *src, int src_x, int src_y, | 34 | void xlcd_gray_bitmap_part(const unsigned char *src, int src_x, int src_y, |
34 | int stride, int x, int y, int width, int height); | 35 | int stride, int x, int y, int width, int height); |
diff --git a/apps/plugins/lib/xlcd_draw.c b/apps/plugins/lib/xlcd_draw.c index 3ccdea9139..accf3b4f4b 100644 --- a/apps/plugins/lib/xlcd_draw.c +++ b/apps/plugins/lib/xlcd_draw.c | |||
@@ -25,46 +25,58 @@ | |||
25 | #ifdef HAVE_LCD_BITMAP | 25 | #ifdef HAVE_LCD_BITMAP |
26 | #include "xlcd.h" | 26 | #include "xlcd.h" |
27 | 27 | ||
28 | #if (LCD_DEPTH >= 8) || (LCD_PIXELFORMAT == HORIZONTAL_PACKING) | 28 | /* sort the given coordinates by increasing x value */ |
29 | /* draw a filled triangle, using horizontal lines for speed */ | 29 | void sort_points_by_increasing_x(int* x1, int* y1, |
30 | void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3) | 30 | int* x2, int* y2, |
31 | int* x3, int* y3) | ||
31 | { | 32 | { |
32 | int x, y; | 33 | int x, y; |
33 | long fp_x1, fp_x2, fp_dx1, fp_dx2; | 34 | if (*x1 > *x3) |
34 | |||
35 | /* sort vertices by increasing y value */ | ||
36 | if (y1 > y3) | ||
37 | { | 35 | { |
38 | if (y2 < y3) /* y2 < y3 < y1 */ | 36 | if (*x2 < *x3) /* x2 < x3 < x1 */ |
39 | { | 37 | { |
40 | x = x1; x1 = x2; x2 = x3; x3 = x; | 38 | x = *x1; *x1 = *x2; *x2 = *x3; *x3 = x; |
41 | y = y1; y1 = y2; y2 = y3; y3 = y; | 39 | y = *y1; *y1 = *y2; *y2 = *y3; *y3 = y; |
42 | } | 40 | } |
43 | else if (y2 > y1) /* y3 < y1 < y2 */ | 41 | else if (*x2 > *x1) /* x3 < x1 < x2 */ |
44 | { | 42 | { |
45 | x = x1; x1 = x3; x3 = x2; x2 = x; | 43 | x = *x1; *x1 = *x3; *x3 = *x2; *x2 = x; |
46 | y = y1; y1 = y3; y3 = y2; y2 = y; | 44 | y = *y1; *y1 = *y3; *y3 = *y2; *y2 = y; |
47 | } | 45 | } |
48 | else /* y3 <= y2 <= y1 */ | 46 | else /* x3 <= x2 <= x1 */ |
49 | { | 47 | { |
50 | x = x1; x1 = x3; x3 = x; | 48 | x = *x1; *x1 = *x3; *x3 = x; |
51 | y = y1; y1 = y3; y3 = y; | 49 | y = *y1; *y1 = *y3; *y3 = y; |
52 | } | 50 | } |
53 | } | 51 | } |
54 | else | 52 | else |
55 | { | 53 | { |
56 | if (y2 < y1) /* y2 < y1 <= y3 */ | 54 | if (*x2 < *x1) /* x2 < x1 <= x3 */ |
57 | { | 55 | { |
58 | x = x1; x1 = x2; x2 = x; | 56 | x = *x1; *x1 = *x2; *x2 = x; |
59 | y = y1; y1 = y2; y2 = y; | 57 | y = *y1; *y1 = *y2; *y2 = y; |
60 | } | 58 | } |
61 | else if (y2 > y3) /* y1 <= y3 < y2 */ | 59 | else if (*x2 > *x3) /* x1 <= x3 < x2 */ |
62 | { | 60 | { |
63 | x = x2; x2 = x3; x3 = x; | 61 | x = *x2; *x2 = *x3; *x3 = x; |
64 | y = y2; y2 = y3; y3 = y; | 62 | y = *y2; *y2 = *y3; *y3 = y; |
65 | } | 63 | } |
66 | /* else already sorted */ | 64 | /* else already sorted */ |
67 | } | 65 | } |
66 | } | ||
67 | |||
68 | #define sort_points_by_increasing_y(x1, y1, x2, y2, x3, y3) \ | ||
69 | sort_points_by_increasing_x(y1, x1, y2, x2, y3, x3) | ||
70 | |||
71 | /* draw a filled triangle, using horizontal lines for speed */ | ||
72 | void xlcd_filltriangle_horizontal(struct screen* display, | ||
73 | int x1, int y1, | ||
74 | int x2, int y2, | ||
75 | int x3, int y3) | ||
76 | { | ||
77 | long fp_x1, fp_x2, fp_dx1, fp_dx2; | ||
78 | int y; | ||
79 | sort_points_by_increasing_y(&x1, &y1, &x2, &y2, &x3, &y3); | ||
68 | 80 | ||
69 | if (y1 < y3) /* draw */ | 81 | if (y1 < y3) /* draw */ |
70 | { | 82 | { |
@@ -72,12 +84,12 @@ void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3) | |||
72 | fp_x1 = (x1 << 16) + (1<<15) + (fp_dx1 >> 1); | 84 | fp_x1 = (x1 << 16) + (1<<15) + (fp_dx1 >> 1); |
73 | 85 | ||
74 | if (y1 < y2) /* first part */ | 86 | if (y1 < y2) /* first part */ |
75 | { | 87 | { |
76 | fp_dx2 = ((x2 - x1) << 16) / (y2 - y1); | 88 | fp_dx2 = ((x2 - x1) << 16) / (y2 - y1); |
77 | fp_x2 = (x1 << 16) + (1<<15) + (fp_dx2 >> 1); | 89 | fp_x2 = (x1 << 16) + (1<<15) + (fp_dx2 >> 1); |
78 | for (y = y1; y < y2; y++) | 90 | for (y = y1; y < y2; y++) |
79 | { | 91 | { |
80 | _xlcd_rb->lcd_hline(fp_x1 >> 16, fp_x2 >> 16, y); | 92 | display->hline(fp_x1 >> 16, fp_x2 >> 16, y); |
81 | fp_x1 += fp_dx1; | 93 | fp_x1 += fp_dx1; |
82 | fp_x2 += fp_dx2; | 94 | fp_x2 += fp_dx2; |
83 | } | 95 | } |
@@ -88,53 +100,23 @@ void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3) | |||
88 | fp_x2 = (x2 << 16) + (1<<15) + (fp_dx2 >> 1); | 100 | fp_x2 = (x2 << 16) + (1<<15) + (fp_dx2 >> 1); |
89 | for (y = y2; y < y3; y++) | 101 | for (y = y2; y < y3; y++) |
90 | { | 102 | { |
91 | _xlcd_rb->lcd_hline(fp_x1 >> 16, fp_x2 >> 16, y); | 103 | display->hline(fp_x1 >> 16, fp_x2 >> 16, y); |
92 | fp_x1 += fp_dx1; | 104 | fp_x1 += fp_dx1; |
93 | fp_x2 += fp_dx2; | 105 | fp_x2 += fp_dx2; |
94 | } | 106 | } |
95 | } | 107 | } |
96 | } | 108 | } |
97 | } | 109 | } |
98 | #else /* (LCD_DEPTH < 8) && (LCD_PIXELFORMAT == VERTICAL_PACKING) */ | 110 | |
99 | /* draw a filled triangle, using vertical lines for speed */ | 111 | /* draw a filled triangle, using vertical lines for speed */ |
100 | void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3) | 112 | void xlcd_filltriangle_vertical(struct screen* display, |
113 | int x1, int y1, | ||
114 | int x2, int y2, | ||
115 | int x3, int y3) | ||
101 | { | 116 | { |
102 | int x, y; | ||
103 | long fp_y1, fp_y2, fp_dy1, fp_dy2; | 117 | long fp_y1, fp_y2, fp_dy1, fp_dy2; |
104 | 118 | int x; | |
105 | /* sort vertices by increasing x value */ | 119 | sort_points_by_increasing_x(&x1, &y1, &x2, &y2, &x3, &y3); |
106 | if (x1 > x3) | ||
107 | { | ||
108 | if (x2 < x3) /* x2 < x3 < x1 */ | ||
109 | { | ||
110 | x = x1; x1 = x2; x2 = x3; x3 = x; | ||
111 | y = y1; y1 = y2; y2 = y3; y3 = y; | ||
112 | } | ||
113 | else if (x2 > x1) /* x3 < x1 < x2 */ | ||
114 | { | ||
115 | x = x1; x1 = x3; x3 = x2; x2 = x; | ||
116 | y = y1; y1 = y3; y3 = y2; y2 = y; | ||
117 | } | ||
118 | else /* x3 <= x2 <= x1 */ | ||
119 | { | ||
120 | x = x1; x1 = x3; x3 = x; | ||
121 | y = y1; y1 = y3; y3 = y; | ||
122 | } | ||
123 | } | ||
124 | else | ||
125 | { | ||
126 | if (x2 < x1) /* x2 < x1 <= x3 */ | ||
127 | { | ||
128 | x = x1; x1 = x2; x2 = x; | ||
129 | y = y1; y1 = y2; y2 = y; | ||
130 | } | ||
131 | else if (x2 > x3) /* x1 <= x3 < x2 */ | ||
132 | { | ||
133 | x = x2; x2 = x3; x3 = x; | ||
134 | y = y2; y2 = y3; y3 = y; | ||
135 | } | ||
136 | /* else already sorted */ | ||
137 | } | ||
138 | 120 | ||
139 | if (x1 < x3) /* draw */ | 121 | if (x1 < x3) /* draw */ |
140 | { | 122 | { |
@@ -142,12 +124,12 @@ void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3) | |||
142 | fp_y1 = (y1 << 16) + (1<<15) + (fp_dy1 >> 1); | 124 | fp_y1 = (y1 << 16) + (1<<15) + (fp_dy1 >> 1); |
143 | 125 | ||
144 | if (x1 < x2) /* first part */ | 126 | if (x1 < x2) /* first part */ |
145 | { | 127 | { |
146 | fp_dy2 = ((y2 - y1) << 16) / (x2 - x1); | 128 | fp_dy2 = ((y2 - y1) << 16) / (x2 - x1); |
147 | fp_y2 = (y1 << 16) + (1<<15) + (fp_dy2 >> 1); | 129 | fp_y2 = (y1 << 16) + (1<<15) + (fp_dy2 >> 1); |
148 | for (x = x1; x < x2; x++) | 130 | for (x = x1; x < x2; x++) |
149 | { | 131 | { |
150 | _xlcd_rb->lcd_vline(x, fp_y1 >> 16, fp_y2 >> 16); | 132 | display->vline(x, fp_y1 >> 16, fp_y2 >> 16); |
151 | fp_y1 += fp_dy1; | 133 | fp_y1 += fp_dy1; |
152 | fp_y2 += fp_dy2; | 134 | fp_y2 += fp_dy2; |
153 | } | 135 | } |
@@ -158,14 +140,33 @@ void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3) | |||
158 | fp_y2 = (y2 << 16) + (1<<15) + (fp_dy2 >> 1); | 140 | fp_y2 = (y2 << 16) + (1<<15) + (fp_dy2 >> 1); |
159 | for (x = x2; x < x3; x++) | 141 | for (x = x2; x < x3; x++) |
160 | { | 142 | { |
161 | _xlcd_rb->lcd_vline(x, fp_y1 >> 16, fp_y2 >> 16); | 143 | display->vline(x, fp_y1 >> 16, fp_y2 >> 16); |
162 | fp_y1 += fp_dy1; | 144 | fp_y1 += fp_dy1; |
163 | fp_y2 += fp_dy2; | 145 | fp_y2 += fp_dy2; |
164 | } | 146 | } |
165 | } | 147 | } |
166 | } | 148 | } |
167 | } | 149 | } |
168 | #endif /* LCD_DEPTH, LCD_PIXELFORMAT */ | 150 | |
151 | void xlcd_filltriangle(int x1, int y1, | ||
152 | int x2, int y2, | ||
153 | int x3, int y3) | ||
154 | { | ||
155 | /* default is main screen */ | ||
156 | xlcd_filltriangle_screen(_xlcd_rb->screens[SCREEN_MAIN], | ||
157 | x1, y1, x2, y2, x3, y3); | ||
158 | } | ||
159 | |||
160 | void xlcd_filltriangle_screen(struct screen* display, | ||
161 | int x1, int y1, | ||
162 | int x2, int y2, | ||
163 | int x3, int y3) | ||
164 | { | ||
165 | if(display->pixel_format==HORIZONTAL_PACKING || display->depth>=8) | ||
166 | xlcd_filltriangle_horizontal(display, x1, y1, x2, y2, x3, y3); | ||
167 | else | ||
168 | xlcd_filltriangle_vertical(display, x1, y1, x2, y2, x3, y3); | ||
169 | } | ||
169 | 170 | ||
170 | #if LCD_DEPTH >= 8 | 171 | #if LCD_DEPTH >= 8 |
171 | 172 | ||
diff --git a/apps/screen_access.c b/apps/screen_access.c index 2d2013ec2a..b5731cf33a 100644 --- a/apps/screen_access.c +++ b/apps/screen_access.c | |||
@@ -39,6 +39,7 @@ void screen_init(struct screen * screen, enum screen_type screen_type) | |||
39 | #ifdef HAVE_REMOTE_LCD | 39 | #ifdef HAVE_REMOTE_LCD |
40 | case SCREEN_REMOTE: | 40 | case SCREEN_REMOTE: |
41 | screen->is_color=false;/* No color remotes yet */ | 41 | screen->is_color=false;/* No color remotes yet */ |
42 | screen->pixel_format=LCD_REMOTE_PIXELFORMAT; | ||
42 | screen->depth=LCD_REMOTE_DEPTH; | 43 | screen->depth=LCD_REMOTE_DEPTH; |
43 | screen->has_disk_led=false; | 44 | screen->has_disk_led=false; |
44 | 45 | ||
@@ -118,6 +119,9 @@ void screen_init(struct screen * screen, enum screen_type screen_type) | |||
118 | #else | 119 | #else |
119 | screen->is_color=false; | 120 | screen->is_color=false; |
120 | #endif | 121 | #endif |
122 | #ifdef HAVE_LCD_BITMAP | ||
123 | screen->pixel_format=LCD_PIXELFORMAT; | ||
124 | #endif | ||
121 | screen->depth=LCD_DEPTH; | 125 | screen->depth=LCD_DEPTH; |
122 | #if (CONFIG_LED == LED_VIRTUAL) | 126 | #if (CONFIG_LED == LED_VIRTUAL) |
123 | screen->has_disk_led=false; | 127 | screen->has_disk_led=false; |
diff --git a/apps/screen_access.h b/apps/screen_access.h index 967bd55c02..822aab4a88 100644 --- a/apps/screen_access.h +++ b/apps/screen_access.h | |||
@@ -58,6 +58,9 @@ struct screen | |||
58 | enum screen_type screen_type; | 58 | enum screen_type screen_type; |
59 | int depth; | 59 | int depth; |
60 | bool is_color; | 60 | bool is_color; |
61 | #ifdef HAVE_LCD_BITMAP | ||
62 | int pixel_format; | ||
63 | #endif | ||
61 | int char_width; | 64 | int char_width; |
62 | int char_height; | 65 | int char_height; |
63 | #if (CONFIG_LED == LED_VIRTUAL) || defined(HAVE_REMOTE_LCD) | 66 | #if (CONFIG_LED == LED_VIRTUAL) || defined(HAVE_REMOTE_LCD) |