2002-11-22 13:00:10 +00:00
|
|
|
/***************************************************************************
|
2013-07-12 16:03:20 +00:00
|
|
|
* __________ __ ___.
|
|
|
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
|
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
|
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
|
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
|
|
|
* \/ \/ \/ \/ \/
|
2002-11-22 13:00:10 +00:00
|
|
|
* $Id$
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2002 by Daniel Stenberg
|
|
|
|
|
*
|
2008-06-28 18:10:04 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-11-22 13:00:10 +00:00
|
|
|
*
|
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
|
* KIND, either express or implied.
|
|
|
|
|
*
|
|
|
|
|
****************************************************************************/
|
2004-09-19 21:58:37 +00:00
|
|
|
#include <stdlib.h>
|
2004-07-05 11:15:50 +00:00
|
|
|
#include <ctype.h>
|
2010-05-06 21:04:40 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdarg.h>
|
2010-05-03 15:12:19 +00:00
|
|
|
#include <errno.h>
|
2010-05-06 21:04:40 +00:00
|
|
|
#include "string-extra.h"
|
2008-03-26 23:35:34 +00:00
|
|
|
#include "config.h"
|
2008-08-28 12:49:38 +00:00
|
|
|
#include "misc.h"
|
2011-02-18 23:17:07 +00:00
|
|
|
#include "system.h"
|
2008-03-26 23:35:34 +00:00
|
|
|
#include "lcd.h"
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
#include "language.h" /* is_lang_rtl() */
|
|
|
|
|
|
Rewrite filesystem code (WIP)
This patch redoes the filesystem code from the FAT driver up to the
clipboard code in onplay.c.
Not every aspect of this is finished therefore it is still "WIP". I
don't wish to do too much at once (haha!). What is left to do is get
dircache back in the sim and find an implementation for the dircache
indicies in the tagcache and playlist code or do something else that
has the same benefit. Leaving these out for now does not make anything
unusable. All the basics are done.
Phone app code should probably get vetted (and app path handling
just plain rewritten as environment expansions); the SDL app and
Android run well.
Main things addressed:
1) Thread safety: There is none right now in the trunk code. Most of
what currently works is luck when multiple threads are involved or
multiple descriptors to the same file are open.
2) POSIX compliance: Many of the functions behave nothing like their
counterparts on a host system. This leads to inconsistent code or very
different behavior from native to hosted. One huge offender was
rename(). Going point by point would fill a book.
3) Actual running RAM usage: Many targets will use less RAM and less
stack space (some more RAM because I upped the number of cache buffers
for large memory). There's very little memory lying fallow in rarely-used
areas (see 'Key core changes' below). Also, all targets may open the same
number of directory streams whereas before those with less than 8MB RAM
were limited to 8, not 12 implying those targets will save slightly
less.
4) Performance: The test_disk plugin shows markedly improved performance,
particularly in the area of (uncached) directory scanning, due partly to
more optimal directory reading and to a better sector cache algorithm.
Uncached times tend to be better while there is a bit of a slowdown in
dircache due to it being a bit heavier of an implementation. It's not
noticeable by a human as far as I can say.
Key core changes:
1) Files and directories share core code and data structures.
2) The filesystem code knows which descriptors refer to same file.
This ensures that changes from one stream are appropriately reflected
in every open descriptor for that file (fileobj_mgr.c).
3) File and directory cache buffers are borrowed from the main sector
cache. This means that when they are not in use by a file, they are not
wasted, but used for the cache. Most of the time, only a few of them
are needed. It also means that adding more file and directory handles
is less expensive. All one must do in ensure a large enough cache to
borrow from.
4) Relative path components are supported and the namespace is unified.
It does not support full relative paths to an implied current directory;
what is does support is use of "." and "..". Adding the former would
not be very difficult. The namespace is unified in the sense that
volumes may be specified several times along with relative parts, e.g.:
"/<0>/foo/../../<1>/bar" :<=> "/<1>/bar".
5) Stack usage is down due to sharing of data, static allocation and
less duplication of strings on the stack. This requires more
serialization than I would like but since the number of threads is
limited to a low number, the tradoff in favor of the stack seems
reasonable.
6) Separates and heirarchicalizes (sic) the SIM and APP filesystem
code. SIM path and volume handling is just like the target. Some
aspects of the APP file code get more straightforward (e.g. no path
hashing is needed).
Dircache:
Deserves its own section. Dircache is new but pays homage to the old.
The old one was not compatible and so it, since it got redone, does
all the stuff it always should have done such as:
1) It may be update and used at any time during the build process.
No longer has one to wait for it to finish building to do basic file
management (create, remove, rename, etc.).
2) It does not need to be either fully scanned or completely disabled;
it can be incomplete (i.e. overfilled, missing paths), still be
of benefit and be correct.
3) Handles mounting and dismounting of individual volumes which means
a full rebuild is not needed just because you pop a new SD card in the
slot. Now, because it reuses its freed entry data, may rebuild only
that volume.
4) Much more fundamental to the file code. When it is built, it is
the keeper of the master file list whether enabled or not ("disabled"
is just a state of the cache). Its must always to ready to be started
and bind all streams opened prior to being enabled.
5) Maintains any short filenames in OEM format which means that it does
not need to be rebuilt when changing the default codepage.
Miscellaneous Compatibility:
1) Update any other code that would otherwise not work such as the
hotswap mounting code in various card drivers.
2) File management: Clipboard needed updating because of the behavioral
changes. Still needs a little more work on some finer points.
3) Remove now-obsolete functionality such as the mutex's "no preempt"
flag (which was only for the prior FAT driver).
4) struct dirinfo uses time_t rather than raw FAT directory entry
time fields. I plan to follow up on genericizing everything there
(i.e. no FAT attributes).
5) unicode.c needed some redoing so that the file code does not try
try to load codepages during a scan, which is actually a problem with
the current code. The default codepage, if any is required, is now
kept in RAM separarately (bufalloced) from codepages specified to
iso_decode() (which must not be bufalloced because the conversion
may be done by playback threads).
Brings with it some additional reusable core code:
1) Revised file functions: Reusable code that does things such as
safe path concatenation and parsing without buffer limitations or
data duplication. Variants that copy or alter the input path may be
based off these.
To do:
1) Put dircache functionality back in the sim. Treating it internally
as a different kind of file system seems the best approach at this
time.
2) Restore use of dircache indexes in the playlist and database or
something effectively the same. Since the cache doesn't have to be
complete in order to be used, not getting a hit on the cache doesn't
unambiguously say if the path exists or not.
Change-Id: Ia30f3082a136253e3a0eae0784e3091d138915c8
Reviewed-on: http://gerrit.rockbox.org/566
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested: Michael Sevakis <jethead71@rockbox.org>
2013-08-06 02:02:45 +00:00
|
|
|
#ifdef HAVE_DIRCACHE
|
|
|
|
|
#include "dircache.h"
|
|
|
|
|
#endif
|
2008-03-26 23:35:34 +00:00
|
|
|
#include "file.h"
|
2010-05-06 21:04:40 +00:00
|
|
|
#ifndef __PCTOOL__
|
Rewrite filesystem code (WIP)
This patch redoes the filesystem code from the FAT driver up to the
clipboard code in onplay.c.
Not every aspect of this is finished therefore it is still "WIP". I
don't wish to do too much at once (haha!). What is left to do is get
dircache back in the sim and find an implementation for the dircache
indicies in the tagcache and playlist code or do something else that
has the same benefit. Leaving these out for now does not make anything
unusable. All the basics are done.
Phone app code should probably get vetted (and app path handling
just plain rewritten as environment expansions); the SDL app and
Android run well.
Main things addressed:
1) Thread safety: There is none right now in the trunk code. Most of
what currently works is luck when multiple threads are involved or
multiple descriptors to the same file are open.
2) POSIX compliance: Many of the functions behave nothing like their
counterparts on a host system. This leads to inconsistent code or very
different behavior from native to hosted. One huge offender was
rename(). Going point by point would fill a book.
3) Actual running RAM usage: Many targets will use less RAM and less
stack space (some more RAM because I upped the number of cache buffers
for large memory). There's very little memory lying fallow in rarely-used
areas (see 'Key core changes' below). Also, all targets may open the same
number of directory streams whereas before those with less than 8MB RAM
were limited to 8, not 12 implying those targets will save slightly
less.
4) Performance: The test_disk plugin shows markedly improved performance,
particularly in the area of (uncached) directory scanning, due partly to
more optimal directory reading and to a better sector cache algorithm.
Uncached times tend to be better while there is a bit of a slowdown in
dircache due to it being a bit heavier of an implementation. It's not
noticeable by a human as far as I can say.
Key core changes:
1) Files and directories share core code and data structures.
2) The filesystem code knows which descriptors refer to same file.
This ensures that changes from one stream are appropriately reflected
in every open descriptor for that file (fileobj_mgr.c).
3) File and directory cache buffers are borrowed from the main sector
cache. This means that when they are not in use by a file, they are not
wasted, but used for the cache. Most of the time, only a few of them
are needed. It also means that adding more file and directory handles
is less expensive. All one must do in ensure a large enough cache to
borrow from.
4) Relative path components are supported and the namespace is unified.
It does not support full relative paths to an implied current directory;
what is does support is use of "." and "..". Adding the former would
not be very difficult. The namespace is unified in the sense that
volumes may be specified several times along with relative parts, e.g.:
"/<0>/foo/../../<1>/bar" :<=> "/<1>/bar".
5) Stack usage is down due to sharing of data, static allocation and
less duplication of strings on the stack. This requires more
serialization than I would like but since the number of threads is
limited to a low number, the tradoff in favor of the stack seems
reasonable.
6) Separates and heirarchicalizes (sic) the SIM and APP filesystem
code. SIM path and volume handling is just like the target. Some
aspects of the APP file code get more straightforward (e.g. no path
hashing is needed).
Dircache:
Deserves its own section. Dircache is new but pays homage to the old.
The old one was not compatible and so it, since it got redone, does
all the stuff it always should have done such as:
1) It may be update and used at any time during the build process.
No longer has one to wait for it to finish building to do basic file
management (create, remove, rename, etc.).
2) It does not need to be either fully scanned or completely disabled;
it can be incomplete (i.e. overfilled, missing paths), still be
of benefit and be correct.
3) Handles mounting and dismounting of individual volumes which means
a full rebuild is not needed just because you pop a new SD card in the
slot. Now, because it reuses its freed entry data, may rebuild only
that volume.
4) Much more fundamental to the file code. When it is built, it is
the keeper of the master file list whether enabled or not ("disabled"
is just a state of the cache). Its must always to ready to be started
and bind all streams opened prior to being enabled.
5) Maintains any short filenames in OEM format which means that it does
not need to be rebuilt when changing the default codepage.
Miscellaneous Compatibility:
1) Update any other code that would otherwise not work such as the
hotswap mounting code in various card drivers.
2) File management: Clipboard needed updating because of the behavioral
changes. Still needs a little more work on some finer points.
3) Remove now-obsolete functionality such as the mutex's "no preempt"
flag (which was only for the prior FAT driver).
4) struct dirinfo uses time_t rather than raw FAT directory entry
time fields. I plan to follow up on genericizing everything there
(i.e. no FAT attributes).
5) unicode.c needed some redoing so that the file code does not try
try to load codepages during a scan, which is actually a problem with
the current code. The default codepage, if any is required, is now
kept in RAM separarately (bufalloced) from codepages specified to
iso_decode() (which must not be bufalloced because the conversion
may be done by playback threads).
Brings with it some additional reusable core code:
1) Revised file functions: Reusable code that does things such as
safe path concatenation and parsing without buffer limitations or
data duplication. Variants that copy or alter the input path may be
based off these.
To do:
1) Put dircache functionality back in the sim. Treating it internally
as a different kind of file system seems the best approach at this
time.
2) Restore use of dircache indexes in the playlist and database or
something effectively the same. Since the cache doesn't have to be
complete in order to be used, not getting a hit on the cache doesn't
unambiguously say if the path exists or not.
Change-Id: Ia30f3082a136253e3a0eae0784e3091d138915c8
Reviewed-on: http://gerrit.rockbox.org/566
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested: Michael Sevakis <jethead71@rockbox.org>
2013-08-06 02:02:45 +00:00
|
|
|
#include "pathfuncs.h"
|
2004-07-24 21:26:41 +00:00
|
|
|
#include "lang.h"
|
2005-02-11 14:38:44 +00:00
|
|
|
#include "dir.h"
|
2012-01-07 19:35:46 +00:00
|
|
|
#ifdef HAVE_REMOTE_LCD
|
2005-09-02 05:39:09 +00:00
|
|
|
#include "lcd-remote.h"
|
2012-01-07 19:35:46 +00:00
|
|
|
#endif
|
2012-01-14 13:56:56 +00:00
|
|
|
#include "action.h"
|
2004-06-30 13:31:14 +00:00
|
|
|
#include "timefuncs.h"
|
2009-10-19 21:28:18 +00:00
|
|
|
#include "screens.h"
|
2009-10-19 21:19:30 +00:00
|
|
|
#include "usb_screen.h"
|
2005-01-31 00:39:20 +00:00
|
|
|
#include "talk.h"
|
2005-04-06 11:12:22 +00:00
|
|
|
#include "audio.h"
|
2004-07-24 21:26:41 +00:00
|
|
|
#include "settings.h"
|
2008-11-01 16:14:28 +00:00
|
|
|
#include "storage.h"
|
2006-11-09 12:36:50 +00:00
|
|
|
#include "ata_idle_notify.h"
|
2004-07-24 21:26:41 +00:00
|
|
|
#include "kernel.h"
|
|
|
|
|
#include "power.h"
|
2005-02-06 09:57:57 +00:00
|
|
|
#include "powermgmt.h"
|
2004-10-13 09:08:32 +00:00
|
|
|
#include "backlight.h"
|
2005-09-02 05:39:09 +00:00
|
|
|
#include "font.h"
|
2005-11-16 15:12:15 +00:00
|
|
|
#include "splash.h"
|
2006-04-16 17:32:54 +00:00
|
|
|
#include "tagcache.h"
|
2007-05-30 17:57:32 +00:00
|
|
|
#include "sound.h"
|
2008-05-01 10:13:12 +00:00
|
|
|
#include "playlist.h"
|
|
|
|
|
#include "yesno.h"
|
2008-12-31 05:59:26 +00:00
|
|
|
#include "viewport.h"
|
Lists can now be completly draw using the skin engine!
due to lack of user feedback the actual tags may change, hopefully not though.
The way it works is the skin specifies a rectangle and a viewport label. For each item in the list that is being displayed all viewports with the specified label are drawn. However, instead of the viewport x/y position being offset from the top left corner like normal they are offset from the rectangle position in the list (so think of them as child-viewports of the rectangle which moves).
Normally the rectangle will move down the screen to show a normal list, this can be changed to move across the screen in a grid pattern.
The UI viewport is used to bound the items (i.e %Vi() )
Scrolling is completly disabled in all items except the currently selected item.
This works well in combination with the %cs tag to show differently styled lists based on the current screen :)
New tags:
%LT - Get the current items text
%LI - Get the current items icon number
%Lc - Use as a conditional to determine if the current item is the selected item
%LB - BAR TAG to show the scroll bar, params/options like other bar types. It still needs a bit of work though. Use as a conditional to find out if the bar is actually needed
%Lb(viewport, width, height [,tile]) - specify the viewport label to draw for each item and the size of each item. if the last param is 'tile' it will form a grid instead of a list
example.sbs:
%?cs<%Lb(a,100,20)|>
%V(0,0,10,-,1)%Vf(aabbcc)
%?LB<%LB(0,0,10,185, invert)>
%Vi(-,10,0,-,-35,1)
%Vl(a,5,5,160,12,1)
%s%?Lc<%Vg(00ffaa, ff0000, 000000)%Vs(gradient)%>%>%>%ac>zzzzzzz %LT zzzzz%s%?Lc<%ar%<%<%<>
%V(0,185,-,-,1)
%s%LT
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30461 a1c6a512-1295-4272-9138-f99709370657
2011-09-06 13:49:41 +00:00
|
|
|
#include "list.h"
|
2017-09-18 10:00:05 +00:00
|
|
|
#include "fixedpoint.h"
|
2021-03-11 00:07:06 +00:00
|
|
|
#include "open_plugin.h"
|
2008-03-25 21:09:58 +00:00
|
|
|
|
2011-03-31 07:04:44 +00:00
|
|
|
#include "debug.h"
|
|
|
|
|
|
2010-10-17 08:49:25 +00:00
|
|
|
#if CONFIG_TUNER
|
2010-10-17 08:47:56 +00:00
|
|
|
#include "radio.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-12-25 01:46:16 +00:00
|
|
|
#ifdef IPOD_ACCESSORY_PROTOCOL
|
|
|
|
|
#include "iap.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-10-31 21:25:04 +00:00
|
|
|
#if (CONFIG_STORAGE & STORAGE_MMC)
|
2004-10-12 00:02:51 +00:00
|
|
|
#include "ata_mmc.h"
|
|
|
|
|
#endif
|
2005-09-14 09:07:05 +00:00
|
|
|
#include "tree.h"
|
2006-08-05 20:19:10 +00:00
|
|
|
#include "eeprom_settings.h"
|
2008-03-25 21:09:58 +00:00
|
|
|
#if defined(HAVE_RECORDING) && !defined(__PCTOOL__)
|
2007-08-25 15:53:54 +00:00
|
|
|
#include "recording.h"
|
|
|
|
|
#endif
|
2020-07-17 14:31:31 +00:00
|
|
|
#if !defined(__PCTOOL__)
|
2005-09-02 05:39:09 +00:00
|
|
|
#include "bmp.h"
|
|
|
|
|
#include "icons.h"
|
2020-07-17 14:31:31 +00:00
|
|
|
#endif /* !__PCTOOL__ */
|
2007-04-09 13:39:37 +00:00
|
|
|
#include "bookmark.h"
|
2009-08-03 04:43:34 +00:00
|
|
|
#include "wps.h"
|
2007-08-06 13:08:36 +00:00
|
|
|
#include "playback.h"
|
2011-04-27 04:00:48 +00:00
|
|
|
#include "voice_thread.h"
|
2006-11-06 18:07:30 +00:00
|
|
|
|
2007-03-30 21:54:48 +00:00
|
|
|
#ifdef BOOTFILE
|
2009-11-25 22:54:36 +00:00
|
|
|
#if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF) \
|
|
|
|
|
|| defined(HAVE_HOTSWAP_STORAGE_AS_MAIN)
|
2007-03-30 21:54:48 +00:00
|
|
|
#include "rolo.h"
|
|
|
|
|
#endif
|
2007-03-30 23:36:10 +00:00
|
|
|
#endif
|
2007-03-30 21:54:48 +00:00
|
|
|
|
2022-12-20 02:12:07 +00:00
|
|
|
#ifndef PLUGIN
|
|
|
|
|
#include "core_alloc.h" /*core_load_bmp()*/
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-11-16 10:25:43 +00:00
|
|
|
#ifdef HAVE_HARDWARE_CLICK
|
|
|
|
|
#include "piezo.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-10-17 13:40:42 +00:00
|
|
|
/* units used with output_dyn_value */
|
|
|
|
|
const unsigned char * const byte_units[] =
|
|
|
|
|
{
|
|
|
|
|
ID2P(LANG_BYTE),
|
2018-12-09 18:09:40 +00:00
|
|
|
ID2P(LANG_KIBIBYTE),
|
|
|
|
|
ID2P(LANG_MEBIBYTE),
|
|
|
|
|
ID2P(LANG_GIBIBYTE)
|
2009-10-17 13:40:42 +00:00
|
|
|
};
|
|
|
|
|
|
2018-12-09 18:09:40 +00:00
|
|
|
const unsigned char * const * const kibyte_units = &byte_units[1];
|
2009-10-17 13:40:42 +00:00
|
|
|
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
/* units used with format_time_auto, option_select.c->option_get_valuestring() */
|
|
|
|
|
const unsigned char * const unit_strings_core[] =
|
|
|
|
|
{
|
|
|
|
|
[UNIT_INT] = "", [UNIT_MS] = "ms",
|
|
|
|
|
[UNIT_SEC] = "s", [UNIT_MIN] = "min",
|
|
|
|
|
[UNIT_HOUR]= "hr", [UNIT_KHZ] = "kHz",
|
|
|
|
|
[UNIT_DB] = "dB", [UNIT_PERCENT] = "%",
|
|
|
|
|
[UNIT_MAH] = "mAh", [UNIT_PIXEL] = "px",
|
|
|
|
|
[UNIT_PER_SEC] = "per sec",
|
|
|
|
|
[UNIT_HERTZ] = "Hz",
|
|
|
|
|
[UNIT_MB] = "MB", [UNIT_KBIT] = "kb/s",
|
|
|
|
|
[UNIT_PM_TICK] = "units/10ms",
|
|
|
|
|
};
|
|
|
|
|
|
2005-01-31 00:39:20 +00:00
|
|
|
/* Format a large-range value for output, using the appropriate unit so that
|
|
|
|
|
* the displayed value is in the range 1 <= display < 1000 (1024 for "binary"
|
|
|
|
|
* units) if possible, and 3 significant digits are shown. If a buffer is
|
|
|
|
|
* given, the result is snprintf()'d into that buffer, otherwise the result is
|
|
|
|
|
* voiced.*/
|
2018-12-09 18:09:40 +00:00
|
|
|
char *output_dyn_value(char *buf,
|
|
|
|
|
int buf_size,
|
|
|
|
|
int value,
|
|
|
|
|
const unsigned char * const *units,
|
|
|
|
|
unsigned int unit_count,
|
|
|
|
|
bool binary_scale)
|
2002-11-22 13:00:10 +00:00
|
|
|
{
|
2018-12-09 18:09:40 +00:00
|
|
|
unsigned int scale = binary_scale ? 1024 : 1000;
|
|
|
|
|
unsigned int fraction = 0;
|
|
|
|
|
unsigned int unit_no = 0;
|
|
|
|
|
unsigned int value_abs = (value < 0) ? -value : value;
|
2005-01-31 00:39:20 +00:00
|
|
|
char tbuf[5];
|
|
|
|
|
|
2018-12-09 18:09:40 +00:00
|
|
|
while (value_abs >= scale && unit_no < (unit_count - 1))
|
2005-01-31 00:39:20 +00:00
|
|
|
{
|
2018-12-09 18:09:40 +00:00
|
|
|
fraction = value_abs % scale;
|
|
|
|
|
value_abs /= scale;
|
2005-01-31 00:39:20 +00:00
|
|
|
unit_no++;
|
2002-11-22 13:00:10 +00:00
|
|
|
}
|
2019-01-04 01:46:54 +00:00
|
|
|
|
2018-12-09 18:09:40 +00:00
|
|
|
value = (value < 0) ? -value_abs : value_abs; /* preserve sign */
|
|
|
|
|
fraction = (fraction * 1000 / scale) / 10;
|
2005-01-31 00:39:20 +00:00
|
|
|
|
2019-01-04 01:46:54 +00:00
|
|
|
if (value_abs >= 100 || fraction >= 100 || !unit_no)
|
2005-01-31 02:25:36 +00:00
|
|
|
tbuf[0] = '\0';
|
2018-12-09 18:09:40 +00:00
|
|
|
else if (value_abs >= 10)
|
|
|
|
|
snprintf(tbuf, sizeof(tbuf), "%01u", fraction / 10);
|
2005-01-31 02:25:36 +00:00
|
|
|
else
|
2018-12-09 18:09:40 +00:00
|
|
|
snprintf(tbuf, sizeof(tbuf), "%02u", fraction);
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2005-01-31 00:39:20 +00:00
|
|
|
if (buf)
|
|
|
|
|
{
|
2010-08-28 23:11:59 +00:00
|
|
|
if (*tbuf)
|
2005-01-31 02:25:36 +00:00
|
|
|
snprintf(buf, buf_size, "%d%s%s%s", value, str(LANG_POINT),
|
|
|
|
|
tbuf, P2STR(units[unit_no]));
|
2005-01-31 00:39:20 +00:00
|
|
|
else
|
2005-01-31 02:25:36 +00:00
|
|
|
snprintf(buf, buf_size, "%d%s", value, P2STR(units[unit_no]));
|
2002-11-22 13:00:10 +00:00
|
|
|
}
|
2005-01-31 00:39:20 +00:00
|
|
|
else
|
|
|
|
|
{
|
2008-04-20 11:02:42 +00:00
|
|
|
talk_fractional(tbuf, value, P2ID(units[unit_no]));
|
2002-11-22 13:00:10 +00:00
|
|
|
}
|
2005-01-31 00:39:20 +00:00
|
|
|
return buf;
|
2002-11-22 13:00:10 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-01 10:13:12 +00:00
|
|
|
/* Ask the user if they really want to erase the current dynamic playlist
|
|
|
|
|
* returns true if the playlist should be replaced */
|
|
|
|
|
bool warn_on_pl_erase(void)
|
|
|
|
|
{
|
|
|
|
|
if (global_settings.warnon_erase_dynplaylist &&
|
|
|
|
|
!global_settings.party_mode &&
|
|
|
|
|
playlist_modified(NULL))
|
|
|
|
|
{
|
|
|
|
|
static const char *lines[] =
|
|
|
|
|
{ID2P(LANG_WARN_ERASEDYNPLAYLIST_PROMPT)};
|
|
|
|
|
static const struct text_message message={lines, 1};
|
|
|
|
|
|
|
|
|
|
return (gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2003-05-04 02:04:31 +00:00
|
|
|
|
2010-05-03 15:19:05 +00:00
|
|
|
/* Performance optimized version of the read_line() (see below) function. */
|
2006-10-21 20:37:33 +00:00
|
|
|
int fast_readline(int fd, char *buf, int buf_size, void *parameters,
|
2011-06-23 20:22:00 +00:00
|
|
|
int (*callback)(int n, char *buf, void *parameters))
|
2006-10-21 20:37:33 +00:00
|
|
|
{
|
|
|
|
|
char *p, *next;
|
|
|
|
|
int rc, pos = 0;
|
|
|
|
|
int count = 0;
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2006-10-21 20:37:33 +00:00
|
|
|
while ( 1 )
|
|
|
|
|
{
|
|
|
|
|
next = NULL;
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2006-10-21 20:37:33 +00:00
|
|
|
rc = read(fd, &buf[pos], buf_size - pos - 1);
|
|
|
|
|
if (rc >= 0)
|
|
|
|
|
buf[pos+rc] = '\0';
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2011-06-20 15:53:33 +00:00
|
|
|
if ( (p = strchr(buf, '\n')) != NULL)
|
2006-10-21 20:37:33 +00:00
|
|
|
{
|
|
|
|
|
*p = '\0';
|
|
|
|
|
next = ++p;
|
|
|
|
|
}
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2012-07-05 13:00:31 +00:00
|
|
|
if ( (p = strchr(buf, '\r')) != NULL)
|
|
|
|
|
{
|
|
|
|
|
*p = '\0';
|
|
|
|
|
if (!next)
|
|
|
|
|
next = ++p;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-21 20:37:33 +00:00
|
|
|
rc = callback(count, buf, parameters);
|
|
|
|
|
if (rc < 0)
|
|
|
|
|
return rc;
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2006-10-21 20:37:33 +00:00
|
|
|
count++;
|
|
|
|
|
if (next)
|
|
|
|
|
{
|
2017-01-15 23:10:38 +00:00
|
|
|
pos = buf_size - ((intptr_t)next - (intptr_t)buf) - 1;
|
2006-10-21 20:37:33 +00:00
|
|
|
memmove(buf, next, pos);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break ;
|
|
|
|
|
}
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2006-10-21 20:37:33 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2004-09-03 22:24:29 +00:00
|
|
|
/* parse a line from a configuration file. the line format is:
|
2004-07-05 11:15:50 +00:00
|
|
|
|
|
|
|
|
name: value
|
|
|
|
|
|
|
|
|
|
Any whitespace before setting name or value (after ':') is ignored.
|
|
|
|
|
A # as first non-whitespace character discards the whole line.
|
|
|
|
|
Function sets pointers to null-terminated setting name and value.
|
|
|
|
|
Returns false if no valid config entry was found.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
bool settings_parseline(char* line, char** name, char** value)
|
|
|
|
|
{
|
|
|
|
|
char* ptr;
|
|
|
|
|
|
2009-02-08 11:09:55 +00:00
|
|
|
line = skip_whitespace(line);
|
2004-07-05 11:15:50 +00:00
|
|
|
|
|
|
|
|
if ( *line == '#' )
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
ptr = strchr(line, ':');
|
|
|
|
|
if ( !ptr )
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
*name = line;
|
2022-12-08 02:33:02 +00:00
|
|
|
*ptr = '\0'; /* terminate previous */
|
2004-07-05 11:15:50 +00:00
|
|
|
ptr++;
|
2009-02-08 11:09:55 +00:00
|
|
|
ptr = skip_whitespace(ptr);
|
2004-07-05 11:15:50 +00:00
|
|
|
*value = ptr;
|
2022-12-05 19:25:40 +00:00
|
|
|
|
|
|
|
|
/* strip whitespace from the right side of value */
|
|
|
|
|
ptr += strlen(ptr);
|
2022-12-08 02:33:02 +00:00
|
|
|
ptr--;
|
|
|
|
|
while ((ptr > (*value) - 1) && isspace(*ptr))
|
2022-12-05 19:25:40 +00:00
|
|
|
{
|
2022-12-08 02:33:02 +00:00
|
|
|
*ptr = '\0';
|
|
|
|
|
ptr--;
|
2022-12-05 19:25:40 +00:00
|
|
|
}
|
|
|
|
|
|
2004-07-05 11:15:50 +00:00
|
|
|
return true;
|
|
|
|
|
}
|
2004-07-24 21:26:41 +00:00
|
|
|
|
2005-09-14 09:07:05 +00:00
|
|
|
static void system_flush(void)
|
|
|
|
|
{
|
2008-11-17 07:34:00 +00:00
|
|
|
playlist_shutdown();
|
2005-09-14 09:07:05 +00:00
|
|
|
tree_flush();
|
2021-03-11 00:07:06 +00:00
|
|
|
open_plugin_cache_flush();
|
2008-11-01 16:14:28 +00:00
|
|
|
call_storage_idle_notifys(true); /*doesnt work on usb and shutdown from ata thread */
|
2005-09-14 09:07:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void system_restore(void)
|
|
|
|
|
{
|
|
|
|
|
tree_restore();
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-16 13:25:49 +00:00
|
|
|
static bool clean_shutdown(enum shutdown_type sd_type,
|
|
|
|
|
void (*callback)(void *), void *parameter)
|
2004-07-24 21:26:41 +00:00
|
|
|
{
|
2007-08-06 13:08:36 +00:00
|
|
|
long msg_id = -1;
|
2006-04-24 06:34:45 +00:00
|
|
|
|
2019-08-06 02:05:32 +00:00
|
|
|
status_save();
|
|
|
|
|
|
2007-02-18 05:32:06 +00:00
|
|
|
#if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
|
2004-07-24 21:26:41 +00:00
|
|
|
if(!charger_inserted())
|
2005-02-10 21:53:41 +00:00
|
|
|
#endif
|
2004-07-24 21:26:41 +00:00
|
|
|
{
|
2007-06-29 19:01:24 +00:00
|
|
|
bool batt_safe = battery_level_safe();
|
2020-07-17 04:01:32 +00:00
|
|
|
#if defined(HAVE_RECORDING)
|
2006-12-07 19:34:26 +00:00
|
|
|
int audio_stat = audio_status();
|
2011-06-29 07:06:10 +00:00
|
|
|
#endif
|
2006-12-07 19:34:26 +00:00
|
|
|
|
2006-04-24 06:34:45 +00:00
|
|
|
FOR_NB_SCREENS(i)
|
2009-05-30 22:01:21 +00:00
|
|
|
{
|
2006-04-24 06:34:45 +00:00
|
|
|
screens[i].clear_display();
|
2009-05-30 22:01:21 +00:00
|
|
|
screens[i].update();
|
|
|
|
|
}
|
2007-08-12 11:18:52 +00:00
|
|
|
|
2007-06-29 19:01:24 +00:00
|
|
|
if (batt_safe)
|
|
|
|
|
{
|
2012-01-03 23:44:38 +00:00
|
|
|
int level;
|
2006-10-25 10:17:57 +00:00
|
|
|
#ifdef HAVE_TAGCACHE
|
2006-11-11 01:18:57 +00:00
|
|
|
if (!tagcache_prepare_shutdown())
|
|
|
|
|
{
|
|
|
|
|
cancel_shutdown();
|
2008-08-15 08:27:39 +00:00
|
|
|
splash(HZ, ID2P(LANG_TAGCACHE_BUSY));
|
2006-11-11 01:18:57 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
2006-10-25 10:17:57 +00:00
|
|
|
#endif
|
2012-01-03 23:44:38 +00:00
|
|
|
level = battery_level();
|
|
|
|
|
if (level > 10 || level < 0)
|
2021-10-21 21:36:09 +00:00
|
|
|
{
|
|
|
|
|
if (global_settings.show_shutdown_message)
|
|
|
|
|
splash(0, str(LANG_SHUTTINGDOWN));
|
|
|
|
|
}
|
2007-06-29 19:01:24 +00:00
|
|
|
else
|
2007-08-06 13:08:36 +00:00
|
|
|
{
|
|
|
|
|
msg_id = LANG_WARNING_BATTERY_LOW;
|
2008-08-15 08:27:39 +00:00
|
|
|
splashf(0, "%s %s", str(LANG_WARNING_BATTERY_LOW),
|
|
|
|
|
str(LANG_SHUTTINGDOWN));
|
2007-08-06 13:08:36 +00:00
|
|
|
}
|
2007-06-29 19:01:24 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2007-08-06 13:08:36 +00:00
|
|
|
msg_id = LANG_WARNING_BATTERY_EMPTY;
|
2008-08-15 08:27:39 +00:00
|
|
|
splashf(0, "%s %s", str(LANG_WARNING_BATTERY_EMPTY),
|
|
|
|
|
str(LANG_SHUTTINGDOWN));
|
2006-11-11 01:18:57 +00:00
|
|
|
}
|
2006-12-07 19:34:26 +00:00
|
|
|
|
2016-03-30 23:49:03 +00:00
|
|
|
#ifdef HAVE_DISK_STORAGE
|
2007-06-29 19:01:24 +00:00
|
|
|
if (batt_safe) /* do not save on critical battery */
|
2016-03-30 23:49:03 +00:00
|
|
|
#endif
|
2006-12-07 19:34:26 +00:00
|
|
|
{
|
2020-07-17 04:01:32 +00:00
|
|
|
#if defined(HAVE_RECORDING)
|
2007-06-29 19:01:24 +00:00
|
|
|
if (audio_stat & AUDIO_STATUS_RECORD)
|
2007-07-25 02:15:04 +00:00
|
|
|
{
|
2007-08-25 15:53:54 +00:00
|
|
|
rec_command(RECORDING_CMD_STOP);
|
2007-07-25 02:15:04 +00:00
|
|
|
/* wait for stop to complete */
|
|
|
|
|
while (audio_status() & AUDIO_STATUS_RECORD)
|
|
|
|
|
sleep(1);
|
|
|
|
|
}
|
2006-12-07 19:34:26 +00:00
|
|
|
#endif
|
2010-03-28 23:27:49 +00:00
|
|
|
bookmark_autobookmark(false);
|
2007-08-22 16:33:34 +00:00
|
|
|
|
2007-06-29 19:01:24 +00:00
|
|
|
/* audio_stop_recording == audio_stop for HWCODEC */
|
|
|
|
|
audio_stop();
|
2006-12-07 19:34:26 +00:00
|
|
|
|
2007-06-29 19:01:24 +00:00
|
|
|
if (callback != NULL)
|
|
|
|
|
callback(parameter);
|
2005-09-14 09:07:05 +00:00
|
|
|
|
2020-07-17 04:01:32 +00:00
|
|
|
#if defined(HAVE_RECORDING)
|
2009-12-18 14:17:28 +00:00
|
|
|
audio_close_recording();
|
2007-06-29 19:01:24 +00:00
|
|
|
#endif
|
2007-08-06 13:08:36 +00:00
|
|
|
|
2006-11-11 01:18:57 +00:00
|
|
|
system_flush();
|
2006-08-15 22:54:06 +00:00
|
|
|
#ifdef HAVE_EEPROM_SETTINGS
|
2007-06-29 19:01:24 +00:00
|
|
|
if (firmware_settings.initialized)
|
|
|
|
|
{
|
|
|
|
|
firmware_settings.disk_clean = true;
|
|
|
|
|
firmware_settings.bl_version = 0;
|
|
|
|
|
eeprom_settings_store();
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2006-08-05 20:19:10 +00:00
|
|
|
}
|
2016-03-30 23:49:03 +00:00
|
|
|
#if defined(HAVE_DIRCACHE) && defined(HAVE_DISK_STORAGE)
|
2007-06-29 19:01:24 +00:00
|
|
|
else
|
|
|
|
|
dircache_disable();
|
2006-08-05 20:19:10 +00:00
|
|
|
#endif
|
2007-06-29 19:01:24 +00:00
|
|
|
|
2018-12-09 01:06:55 +00:00
|
|
|
if(global_settings.talk_menu)
|
|
|
|
|
{
|
|
|
|
|
bool enqueue = false;
|
|
|
|
|
if(msg_id != -1)
|
|
|
|
|
{
|
|
|
|
|
talk_id(msg_id, enqueue);
|
|
|
|
|
enqueue = true;
|
|
|
|
|
}
|
|
|
|
|
talk_id(LANG_SHUTTINGDOWN, enqueue);
|
|
|
|
|
voice_wait();
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-16 13:25:49 +00:00
|
|
|
shutdown_hw(sd_type);
|
2004-07-24 21:26:41 +00:00
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2004-07-26 16:06:59 +00:00
|
|
|
|
2007-04-09 13:39:37 +00:00
|
|
|
bool list_stop_handler(void)
|
|
|
|
|
{
|
|
|
|
|
bool ret = false;
|
|
|
|
|
|
2010-10-17 08:47:56 +00:00
|
|
|
#if CONFIG_TUNER
|
|
|
|
|
radio_stop();
|
|
|
|
|
#endif
|
|
|
|
|
|
2007-04-09 13:39:37 +00:00
|
|
|
/* Stop the music if it is playing */
|
2010-10-17 08:47:56 +00:00
|
|
|
if(audio_status())
|
2007-04-09 13:39:37 +00:00
|
|
|
{
|
2010-10-17 08:47:56 +00:00
|
|
|
if (!global_settings.party_mode)
|
2007-04-09 13:39:37 +00:00
|
|
|
{
|
2010-03-28 23:27:49 +00:00
|
|
|
bookmark_autobookmark(true);
|
2007-04-09 13:39:37 +00:00
|
|
|
audio_stop();
|
2007-08-05 15:21:47 +00:00
|
|
|
ret = true; /* bookmarking can make a refresh necessary */
|
2007-04-09 13:39:37 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#if CONFIG_CHARGING
|
|
|
|
|
#ifndef HAVE_POWEROFF_WHILE_CHARGING
|
|
|
|
|
{
|
|
|
|
|
static long last_off = 0;
|
|
|
|
|
|
|
|
|
|
if (TIME_BEFORE(current_tick, last_off + HZ/2))
|
|
|
|
|
{
|
2013-07-12 16:03:20 +00:00
|
|
|
if (charger_inserted())
|
2007-04-09 13:39:37 +00:00
|
|
|
{
|
|
|
|
|
charging_splash();
|
|
|
|
|
ret = true; /* screen is dirty, caller needs to refresh */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
last_off = current_tick;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
#endif /* CONFIG_CHARGING */
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-18 05:32:06 +00:00
|
|
|
#if CONFIG_CHARGING
|
2005-04-06 11:12:22 +00:00
|
|
|
static bool waiting_to_resume_play = false;
|
2019-01-02 02:05:13 +00:00
|
|
|
static bool paused_on_unplugged = false;
|
2005-04-06 11:12:22 +00:00
|
|
|
static long play_resume_tick;
|
|
|
|
|
|
|
|
|
|
static void car_adapter_mode_processing(bool inserted)
|
2009-12-18 14:17:28 +00:00
|
|
|
{
|
2005-04-06 11:12:22 +00:00
|
|
|
if (global_settings.car_adapter_mode)
|
|
|
|
|
{
|
|
|
|
|
if(inserted)
|
2009-12-18 14:17:28 +00:00
|
|
|
{
|
2005-04-06 11:12:22 +00:00
|
|
|
/*
|
|
|
|
|
* Just got plugged in, delay & resume if we were playing
|
|
|
|
|
*/
|
2019-01-02 02:05:13 +00:00
|
|
|
if ((audio_status() & AUDIO_STATUS_PAUSE) && paused_on_unplugged)
|
2005-04-06 11:12:22 +00:00
|
|
|
{
|
|
|
|
|
/* delay resume a bit while the engine is cranking */
|
2019-01-02 02:05:13 +00:00
|
|
|
play_resume_tick = current_tick + HZ*global_settings.car_adapter_mode_delay;
|
2005-04-06 11:12:22 +00:00
|
|
|
waiting_to_resume_play = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Just got unplugged, pause if playing
|
|
|
|
|
*/
|
|
|
|
|
if ((audio_status() & AUDIO_STATUS_PLAY) &&
|
|
|
|
|
!(audio_status() & AUDIO_STATUS_PAUSE))
|
|
|
|
|
{
|
2022-10-02 18:47:51 +00:00
|
|
|
pause_action(true);
|
2019-01-02 02:05:13 +00:00
|
|
|
paused_on_unplugged = true;
|
2005-04-06 11:12:22 +00:00
|
|
|
}
|
2019-01-02 02:05:13 +00:00
|
|
|
else if (!waiting_to_resume_play)
|
|
|
|
|
paused_on_unplugged = false;
|
2007-10-08 09:09:40 +00:00
|
|
|
waiting_to_resume_play = false;
|
2005-04-06 11:12:22 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void car_adapter_tick(void)
|
|
|
|
|
{
|
|
|
|
|
if (waiting_to_resume_play)
|
|
|
|
|
{
|
2019-01-02 02:05:13 +00:00
|
|
|
if ((audio_status() & AUDIO_STATUS_PLAY) &&
|
|
|
|
|
!(audio_status() & AUDIO_STATUS_PAUSE))
|
|
|
|
|
waiting_to_resume_play = false;
|
2005-04-06 11:12:22 +00:00
|
|
|
if (TIME_AFTER(current_tick, play_resume_tick))
|
|
|
|
|
{
|
|
|
|
|
if (audio_status() & AUDIO_STATUS_PAUSE)
|
|
|
|
|
{
|
2007-10-08 09:09:40 +00:00
|
|
|
queue_broadcast(SYS_CAR_ADAPTER_RESUME, 0);
|
2005-04-06 11:12:22 +00:00
|
|
|
}
|
|
|
|
|
waiting_to_resume_play = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void car_adapter_mode_init(void)
|
|
|
|
|
{
|
|
|
|
|
tick_add_task(car_adapter_tick);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-09-26 10:03:56 +00:00
|
|
|
#ifdef HAVE_HEADPHONE_DETECTION
|
2019-01-04 01:46:54 +00:00
|
|
|
static void hp_unplug_change(bool inserted)
|
2006-09-26 10:03:56 +00:00
|
|
|
{
|
2020-09-17 18:53:29 +00:00
|
|
|
static bool headphone_caused_pause = true;
|
2008-03-18 07:01:23 +00:00
|
|
|
|
2006-09-26 10:03:56 +00:00
|
|
|
if (global_settings.unplug_mode)
|
|
|
|
|
{
|
2008-03-18 07:01:23 +00:00
|
|
|
int audio_stat = audio_status();
|
2006-09-26 10:03:56 +00:00
|
|
|
if (inserted)
|
|
|
|
|
{
|
2011-05-09 12:59:46 +00:00
|
|
|
backlight_on();
|
2008-03-18 07:01:23 +00:00
|
|
|
if ((audio_stat & AUDIO_STATUS_PLAY) &&
|
|
|
|
|
headphone_caused_pause &&
|
|
|
|
|
global_settings.unplug_mode > 1 )
|
2022-10-02 18:47:51 +00:00
|
|
|
unpause_action(true);
|
2008-03-18 07:01:23 +00:00
|
|
|
headphone_caused_pause = false;
|
2006-09-26 10:03:56 +00:00
|
|
|
} else {
|
2008-03-18 07:01:23 +00:00
|
|
|
if ((audio_stat & AUDIO_STATUS_PLAY) &&
|
|
|
|
|
!(audio_stat & AUDIO_STATUS_PAUSE))
|
2006-09-26 10:03:56 +00:00
|
|
|
{
|
2008-03-18 07:01:23 +00:00
|
|
|
headphone_caused_pause = true;
|
2022-10-02 18:47:51 +00:00
|
|
|
pause_action(false);
|
2006-09-26 10:03:56 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-01-14 00:40:12 +00:00
|
|
|
|
|
|
|
|
#ifdef HAVE_SPEAKER
|
|
|
|
|
/* update speaker status */
|
|
|
|
|
audio_enable_speaker(global_settings.speaker_mode);
|
|
|
|
|
#endif
|
2006-09-26 10:03:56 +00:00
|
|
|
}
|
2020-09-17 18:53:29 +00:00
|
|
|
#endif /*HAVE_HEADPHONE_DETECTION*/
|
2006-09-26 10:03:56 +00:00
|
|
|
|
2019-01-04 01:46:54 +00:00
|
|
|
#ifdef HAVE_LINEOUT_DETECTION
|
|
|
|
|
static void lo_unplug_change(bool inserted)
|
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_LINEOUT_POWEROFF
|
|
|
|
|
lineout_set(inserted);
|
|
|
|
|
#else
|
2020-10-01 20:08:20 +00:00
|
|
|
#ifdef AUDIOHW_HAVE_LINEOUT
|
2020-09-17 18:53:29 +00:00
|
|
|
audiohw_set_lineout_volume(0,0); /*hp vol re-set by this function as well*/
|
2020-10-01 20:08:20 +00:00
|
|
|
#endif
|
2020-09-17 18:53:29 +00:00
|
|
|
static bool lineout_caused_pause = true;
|
|
|
|
|
|
|
|
|
|
if (global_settings.unplug_mode)
|
|
|
|
|
{
|
|
|
|
|
int audio_stat = audio_status();
|
|
|
|
|
if (inserted)
|
|
|
|
|
{
|
|
|
|
|
backlight_on();
|
|
|
|
|
if ((audio_stat & AUDIO_STATUS_PLAY) &&
|
|
|
|
|
lineout_caused_pause &&
|
|
|
|
|
global_settings.unplug_mode > 1 )
|
2022-10-02 18:47:51 +00:00
|
|
|
unpause_action(true);
|
2020-09-17 18:53:29 +00:00
|
|
|
lineout_caused_pause = false;
|
|
|
|
|
} else {
|
|
|
|
|
if ((audio_stat & AUDIO_STATUS_PLAY) &&
|
|
|
|
|
!(audio_stat & AUDIO_STATUS_PAUSE))
|
|
|
|
|
{
|
|
|
|
|
lineout_caused_pause = true;
|
2022-10-02 18:47:51 +00:00
|
|
|
pause_action(false);
|
2020-09-17 18:53:29 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif /*HAVE_LINEOUT_POWEROFF*/
|
2019-01-04 01:46:54 +00:00
|
|
|
}
|
2020-09-17 18:53:29 +00:00
|
|
|
#endif /*HAVE_LINEOUT_DETECTION*/
|
2019-01-04 01:46:54 +00:00
|
|
|
|
2005-02-07 22:56:37 +00:00
|
|
|
long default_event_handler_ex(long event, void (*callback)(void *), void *parameter)
|
2004-07-26 16:06:59 +00:00
|
|
|
{
|
2011-02-08 20:05:25 +00:00
|
|
|
#if CONFIG_PLATFORM & (PLATFORM_ANDROID|PLATFORM_MAEMO)
|
2010-08-07 21:30:22 +00:00
|
|
|
static bool resume = false;
|
|
|
|
|
#endif
|
2010-10-31 15:32:57 +00:00
|
|
|
|
2004-07-26 23:31:40 +00:00
|
|
|
switch(event)
|
2004-07-26 16:06:59 +00:00
|
|
|
{
|
2007-11-03 05:00:49 +00:00
|
|
|
case SYS_BATTERY_UPDATE:
|
|
|
|
|
if(global_settings.talk_battery_level)
|
|
|
|
|
{
|
|
|
|
|
talk_ids(true, VOICE_PAUSE, VOICE_PAUSE,
|
|
|
|
|
LANG_BATTERY_TIME,
|
|
|
|
|
TALK_ID(battery_level(), UNIT_PERCENT),
|
|
|
|
|
VOICE_PAUSE);
|
|
|
|
|
talk_force_enqueue_next();
|
|
|
|
|
}
|
|
|
|
|
break;
|
2004-07-26 16:06:59 +00:00
|
|
|
case SYS_USB_CONNECTED:
|
2004-10-12 22:45:01 +00:00
|
|
|
if (callback != NULL)
|
|
|
|
|
callback(parameter);
|
2005-09-14 09:07:05 +00:00
|
|
|
{
|
|
|
|
|
system_flush();
|
2007-03-30 21:54:48 +00:00
|
|
|
#ifdef BOOTFILE
|
2009-02-21 17:56:31 +00:00
|
|
|
#if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF)
|
2007-03-30 21:54:48 +00:00
|
|
|
check_bootfile(false); /* gets initial size */
|
2007-03-30 23:36:10 +00:00
|
|
|
#endif
|
2007-03-30 21:54:48 +00:00
|
|
|
#endif
|
2010-10-10 13:17:39 +00:00
|
|
|
gui_usb_screen_run(false);
|
2007-03-30 21:54:48 +00:00
|
|
|
#ifdef BOOTFILE
|
2009-02-21 17:56:31 +00:00
|
|
|
#if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF)
|
2007-03-30 21:54:48 +00:00
|
|
|
check_bootfile(true);
|
2007-03-30 23:36:10 +00:00
|
|
|
#endif
|
2007-03-30 21:54:48 +00:00
|
|
|
#endif
|
2005-09-14 09:07:05 +00:00
|
|
|
system_restore();
|
|
|
|
|
}
|
2004-07-26 16:06:59 +00:00
|
|
|
return SYS_USB_CONNECTED;
|
2010-02-27 22:47:49 +00:00
|
|
|
|
2004-10-12 11:00:19 +00:00
|
|
|
case SYS_POWEROFF:
|
2022-04-16 13:25:49 +00:00
|
|
|
case SYS_REBOOT:
|
|
|
|
|
{
|
|
|
|
|
enum shutdown_type sd_type;
|
|
|
|
|
if (event == SYS_POWEROFF)
|
|
|
|
|
sd_type = SHUTDOWN_POWER_OFF;
|
|
|
|
|
else
|
|
|
|
|
sd_type = SHUTDOWN_REBOOT;
|
|
|
|
|
|
|
|
|
|
if (!clean_shutdown(sd_type, callback, parameter))
|
|
|
|
|
return event;
|
|
|
|
|
}
|
2004-10-12 11:00:19 +00:00
|
|
|
break;
|
2007-02-18 05:32:06 +00:00
|
|
|
#if CONFIG_CHARGING
|
2005-04-06 11:12:22 +00:00
|
|
|
case SYS_CHARGER_CONNECTED:
|
|
|
|
|
car_adapter_mode_processing(true);
|
|
|
|
|
return SYS_CHARGER_CONNECTED;
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2005-04-06 11:12:22 +00:00
|
|
|
case SYS_CHARGER_DISCONNECTED:
|
|
|
|
|
car_adapter_mode_processing(false);
|
2016-03-30 22:25:24 +00:00
|
|
|
reset_runtime();
|
2005-04-06 11:12:22 +00:00
|
|
|
return SYS_CHARGER_DISCONNECTED;
|
2007-10-08 09:09:40 +00:00
|
|
|
|
|
|
|
|
case SYS_CAR_ADAPTER_RESUME:
|
2022-10-02 18:47:51 +00:00
|
|
|
unpause_action(true);
|
2007-10-08 09:09:40 +00:00
|
|
|
return SYS_CAR_ADAPTER_RESUME;
|
2006-09-26 10:03:56 +00:00
|
|
|
#endif
|
2009-11-25 22:54:36 +00:00
|
|
|
#ifdef HAVE_HOTSWAP_STORAGE_AS_MAIN
|
|
|
|
|
case SYS_FS_CHANGED:
|
2009-11-25 23:18:53 +00:00
|
|
|
{
|
|
|
|
|
/* simple sanity: assume rockbox is on the first hotswappable
|
|
|
|
|
* driver, abort out if that one isn't inserted */
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < NUM_DRIVES; i++)
|
|
|
|
|
{
|
|
|
|
|
if (storage_removable(i) && !storage_present(i))
|
|
|
|
|
return SYS_FS_CHANGED;
|
|
|
|
|
}
|
2009-11-25 22:54:36 +00:00
|
|
|
system_flush();
|
|
|
|
|
check_bootfile(true); /* state gotten in main.c:init() */
|
|
|
|
|
system_restore();
|
2009-11-25 23:18:53 +00:00
|
|
|
}
|
2009-11-25 22:54:36 +00:00
|
|
|
return SYS_FS_CHANGED;
|
|
|
|
|
#endif
|
2006-09-26 10:03:56 +00:00
|
|
|
#ifdef HAVE_HEADPHONE_DETECTION
|
|
|
|
|
case SYS_PHONE_PLUGGED:
|
2019-01-04 01:46:54 +00:00
|
|
|
hp_unplug_change(true);
|
2006-09-26 10:03:56 +00:00
|
|
|
return SYS_PHONE_PLUGGED;
|
|
|
|
|
|
|
|
|
|
case SYS_PHONE_UNPLUGGED:
|
2019-01-04 01:46:54 +00:00
|
|
|
hp_unplug_change(false);
|
2006-09-26 10:03:56 +00:00
|
|
|
return SYS_PHONE_UNPLUGGED;
|
2008-12-25 01:46:16 +00:00
|
|
|
#endif
|
2019-01-04 01:46:54 +00:00
|
|
|
#ifdef HAVE_LINEOUT_DETECTION
|
|
|
|
|
case SYS_LINEOUT_PLUGGED:
|
|
|
|
|
lo_unplug_change(true);
|
|
|
|
|
return SYS_LINEOUT_PLUGGED;
|
|
|
|
|
|
|
|
|
|
case SYS_LINEOUT_UNPLUGGED:
|
|
|
|
|
lo_unplug_change(false);
|
|
|
|
|
return SYS_LINEOUT_UNPLUGGED;
|
|
|
|
|
#endif
|
2011-02-08 20:05:25 +00:00
|
|
|
#if CONFIG_PLATFORM & (PLATFORM_ANDROID|PLATFORM_MAEMO)
|
2010-08-07 21:30:22 +00:00
|
|
|
/* stop playback if we receive a call */
|
|
|
|
|
case SYS_CALL_INCOMING:
|
2010-10-17 17:52:35 +00:00
|
|
|
resume = audio_status() == AUDIO_STATUS_PLAY;
|
2010-08-07 21:30:22 +00:00
|
|
|
list_stop_handler();
|
|
|
|
|
return SYS_CALL_INCOMING;
|
|
|
|
|
/* resume playback if needed */
|
|
|
|
|
case SYS_CALL_HUNG_UP:
|
|
|
|
|
if (resume && playlist_resume() != -1)
|
|
|
|
|
{
|
|
|
|
|
playlist_start(global_status.resume_index,
|
2013-07-14 11:59:39 +00:00
|
|
|
global_status.resume_elapsed,
|
2010-10-31 15:32:57 +00:00
|
|
|
global_status.resume_offset);
|
2010-08-07 21:30:22 +00:00
|
|
|
}
|
|
|
|
|
resume = false;
|
|
|
|
|
return SYS_CALL_HUNG_UP;
|
2010-10-31 15:32:57 +00:00
|
|
|
#endif
|
2011-03-14 12:25:48 +00:00
|
|
|
#if (CONFIG_PLATFORM & PLATFORM_HOSTED) && defined(PLATFORM_HAS_VOLUME_CHANGE)
|
|
|
|
|
case SYS_VOLUME_CHANGED:
|
|
|
|
|
{
|
2011-03-31 07:04:44 +00:00
|
|
|
static bool firstvolume = true;
|
2011-08-14 13:38:10 +00:00
|
|
|
/* kludge: since this events go to the button_queue,
|
|
|
|
|
* event data is available in the last button data */
|
|
|
|
|
int volume = button_get_data();
|
2011-03-31 07:04:44 +00:00
|
|
|
DEBUGF("SYS_VOLUME_CHANGED: %d\n", volume);
|
|
|
|
|
if (global_settings.volume != volume) {
|
2011-03-14 12:25:48 +00:00
|
|
|
global_settings.volume = volume;
|
2011-03-31 07:04:44 +00:00
|
|
|
if (firstvolume) {
|
|
|
|
|
setvol();
|
|
|
|
|
firstvolume = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-03-14 12:25:48 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2010-10-31 15:32:57 +00:00
|
|
|
#ifdef HAVE_MULTIMEDIA_KEYS
|
|
|
|
|
/* multimedia keys on keyboards, headsets */
|
|
|
|
|
case BUTTON_MULTIMEDIA_PLAYPAUSE:
|
|
|
|
|
{
|
|
|
|
|
int status = audio_status();
|
|
|
|
|
if (status & AUDIO_STATUS_PLAY)
|
|
|
|
|
{
|
|
|
|
|
if (status & AUDIO_STATUS_PAUSE)
|
2022-10-02 18:47:51 +00:00
|
|
|
unpause_action(true);
|
2010-10-31 15:32:57 +00:00
|
|
|
else
|
2022-10-02 18:47:51 +00:00
|
|
|
pause_action(true);
|
2010-10-31 15:32:57 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
if (playlist_resume() != -1)
|
|
|
|
|
{
|
|
|
|
|
playlist_start(global_status.resume_index,
|
2013-07-14 11:59:39 +00:00
|
|
|
global_status.resume_elapsed,
|
2010-10-31 15:32:57 +00:00
|
|
|
global_status.resume_offset);
|
|
|
|
|
}
|
|
|
|
|
return event;
|
|
|
|
|
}
|
|
|
|
|
case BUTTON_MULTIMEDIA_NEXT:
|
|
|
|
|
audio_next();
|
|
|
|
|
return event;
|
|
|
|
|
case BUTTON_MULTIMEDIA_PREV:
|
|
|
|
|
audio_prev();
|
|
|
|
|
return event;
|
|
|
|
|
case BUTTON_MULTIMEDIA_STOP:
|
|
|
|
|
list_stop_handler();
|
|
|
|
|
return event;
|
|
|
|
|
case BUTTON_MULTIMEDIA_REW:
|
|
|
|
|
case BUTTON_MULTIMEDIA_FFWD:
|
|
|
|
|
/* not supported yet, needs to be done in the WPS */
|
|
|
|
|
return 0;
|
2005-04-06 11:12:22 +00:00
|
|
|
#endif
|
2004-07-26 16:06:59 +00:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2004-10-12 22:45:01 +00:00
|
|
|
|
2005-02-07 22:56:37 +00:00
|
|
|
long default_event_handler(long event)
|
2004-10-12 22:45:01 +00:00
|
|
|
{
|
|
|
|
|
return default_event_handler_ex(event, NULL, NULL);
|
|
|
|
|
}
|
2005-09-02 05:39:09 +00:00
|
|
|
|
2007-03-30 21:54:48 +00:00
|
|
|
#ifdef BOOTFILE
|
2009-11-25 22:54:36 +00:00
|
|
|
#if !defined(USB_NONE) && !defined(USB_HANDLED_BY_OF) || defined(HAVE_HOTSWAP_STORAGE_AS_MAIN)
|
2007-03-30 21:54:48 +00:00
|
|
|
/*
|
|
|
|
|
memorize/compare details about the BOOTFILE
|
|
|
|
|
we don't use dircache because it may not be up to date after
|
|
|
|
|
USB disconnect (scanning in the background)
|
|
|
|
|
*/
|
|
|
|
|
void check_bootfile(bool do_rolo)
|
|
|
|
|
{
|
Rewrite filesystem code (WIP)
This patch redoes the filesystem code from the FAT driver up to the
clipboard code in onplay.c.
Not every aspect of this is finished therefore it is still "WIP". I
don't wish to do too much at once (haha!). What is left to do is get
dircache back in the sim and find an implementation for the dircache
indicies in the tagcache and playlist code or do something else that
has the same benefit. Leaving these out for now does not make anything
unusable. All the basics are done.
Phone app code should probably get vetted (and app path handling
just plain rewritten as environment expansions); the SDL app and
Android run well.
Main things addressed:
1) Thread safety: There is none right now in the trunk code. Most of
what currently works is luck when multiple threads are involved or
multiple descriptors to the same file are open.
2) POSIX compliance: Many of the functions behave nothing like their
counterparts on a host system. This leads to inconsistent code or very
different behavior from native to hosted. One huge offender was
rename(). Going point by point would fill a book.
3) Actual running RAM usage: Many targets will use less RAM and less
stack space (some more RAM because I upped the number of cache buffers
for large memory). There's very little memory lying fallow in rarely-used
areas (see 'Key core changes' below). Also, all targets may open the same
number of directory streams whereas before those with less than 8MB RAM
were limited to 8, not 12 implying those targets will save slightly
less.
4) Performance: The test_disk plugin shows markedly improved performance,
particularly in the area of (uncached) directory scanning, due partly to
more optimal directory reading and to a better sector cache algorithm.
Uncached times tend to be better while there is a bit of a slowdown in
dircache due to it being a bit heavier of an implementation. It's not
noticeable by a human as far as I can say.
Key core changes:
1) Files and directories share core code and data structures.
2) The filesystem code knows which descriptors refer to same file.
This ensures that changes from one stream are appropriately reflected
in every open descriptor for that file (fileobj_mgr.c).
3) File and directory cache buffers are borrowed from the main sector
cache. This means that when they are not in use by a file, they are not
wasted, but used for the cache. Most of the time, only a few of them
are needed. It also means that adding more file and directory handles
is less expensive. All one must do in ensure a large enough cache to
borrow from.
4) Relative path components are supported and the namespace is unified.
It does not support full relative paths to an implied current directory;
what is does support is use of "." and "..". Adding the former would
not be very difficult. The namespace is unified in the sense that
volumes may be specified several times along with relative parts, e.g.:
"/<0>/foo/../../<1>/bar" :<=> "/<1>/bar".
5) Stack usage is down due to sharing of data, static allocation and
less duplication of strings on the stack. This requires more
serialization than I would like but since the number of threads is
limited to a low number, the tradoff in favor of the stack seems
reasonable.
6) Separates and heirarchicalizes (sic) the SIM and APP filesystem
code. SIM path and volume handling is just like the target. Some
aspects of the APP file code get more straightforward (e.g. no path
hashing is needed).
Dircache:
Deserves its own section. Dircache is new but pays homage to the old.
The old one was not compatible and so it, since it got redone, does
all the stuff it always should have done such as:
1) It may be update and used at any time during the build process.
No longer has one to wait for it to finish building to do basic file
management (create, remove, rename, etc.).
2) It does not need to be either fully scanned or completely disabled;
it can be incomplete (i.e. overfilled, missing paths), still be
of benefit and be correct.
3) Handles mounting and dismounting of individual volumes which means
a full rebuild is not needed just because you pop a new SD card in the
slot. Now, because it reuses its freed entry data, may rebuild only
that volume.
4) Much more fundamental to the file code. When it is built, it is
the keeper of the master file list whether enabled or not ("disabled"
is just a state of the cache). Its must always to ready to be started
and bind all streams opened prior to being enabled.
5) Maintains any short filenames in OEM format which means that it does
not need to be rebuilt when changing the default codepage.
Miscellaneous Compatibility:
1) Update any other code that would otherwise not work such as the
hotswap mounting code in various card drivers.
2) File management: Clipboard needed updating because of the behavioral
changes. Still needs a little more work on some finer points.
3) Remove now-obsolete functionality such as the mutex's "no preempt"
flag (which was only for the prior FAT driver).
4) struct dirinfo uses time_t rather than raw FAT directory entry
time fields. I plan to follow up on genericizing everything there
(i.e. no FAT attributes).
5) unicode.c needed some redoing so that the file code does not try
try to load codepages during a scan, which is actually a problem with
the current code. The default codepage, if any is required, is now
kept in RAM separarately (bufalloced) from codepages specified to
iso_decode() (which must not be bufalloced because the conversion
may be done by playback threads).
Brings with it some additional reusable core code:
1) Revised file functions: Reusable code that does things such as
safe path concatenation and parsing without buffer limitations or
data duplication. Variants that copy or alter the input path may be
based off these.
To do:
1) Put dircache functionality back in the sim. Treating it internally
as a different kind of file system seems the best approach at this
time.
2) Restore use of dircache indexes in the playlist and database or
something effectively the same. Since the cache doesn't have to be
complete in order to be used, not getting a hit on the cache doesn't
unambiguously say if the path exists or not.
Change-Id: Ia30f3082a136253e3a0eae0784e3091d138915c8
Reviewed-on: http://gerrit.rockbox.org/566
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested: Michael Sevakis <jethead71@rockbox.org>
2013-08-06 02:02:45 +00:00
|
|
|
static time_t mtime = 0;
|
2007-03-30 21:54:48 +00:00
|
|
|
DIR* dir = NULL;
|
|
|
|
|
struct dirent* entry = NULL;
|
|
|
|
|
|
2007-04-05 20:24:07 +00:00
|
|
|
/* 1. open BOOTDIR and find the BOOTFILE dir entry */
|
|
|
|
|
dir = opendir(BOOTDIR);
|
2007-03-30 21:54:48 +00:00
|
|
|
|
|
|
|
|
if(!dir) return; /* do we want an error splash? */
|
|
|
|
|
|
2007-04-05 20:24:07 +00:00
|
|
|
/* loop all files in BOOTDIR */
|
2007-03-30 21:54:48 +00:00
|
|
|
while(0 != (entry = readdir(dir)))
|
|
|
|
|
{
|
|
|
|
|
if(!strcasecmp(entry->d_name, BOOTFILE))
|
|
|
|
|
{
|
2010-09-01 21:29:34 +00:00
|
|
|
struct dirinfo info = dir_get_info(dir, entry);
|
2007-03-30 21:54:48 +00:00
|
|
|
/* found the bootfile */
|
Rewrite filesystem code (WIP)
This patch redoes the filesystem code from the FAT driver up to the
clipboard code in onplay.c.
Not every aspect of this is finished therefore it is still "WIP". I
don't wish to do too much at once (haha!). What is left to do is get
dircache back in the sim and find an implementation for the dircache
indicies in the tagcache and playlist code or do something else that
has the same benefit. Leaving these out for now does not make anything
unusable. All the basics are done.
Phone app code should probably get vetted (and app path handling
just plain rewritten as environment expansions); the SDL app and
Android run well.
Main things addressed:
1) Thread safety: There is none right now in the trunk code. Most of
what currently works is luck when multiple threads are involved or
multiple descriptors to the same file are open.
2) POSIX compliance: Many of the functions behave nothing like their
counterparts on a host system. This leads to inconsistent code or very
different behavior from native to hosted. One huge offender was
rename(). Going point by point would fill a book.
3) Actual running RAM usage: Many targets will use less RAM and less
stack space (some more RAM because I upped the number of cache buffers
for large memory). There's very little memory lying fallow in rarely-used
areas (see 'Key core changes' below). Also, all targets may open the same
number of directory streams whereas before those with less than 8MB RAM
were limited to 8, not 12 implying those targets will save slightly
less.
4) Performance: The test_disk plugin shows markedly improved performance,
particularly in the area of (uncached) directory scanning, due partly to
more optimal directory reading and to a better sector cache algorithm.
Uncached times tend to be better while there is a bit of a slowdown in
dircache due to it being a bit heavier of an implementation. It's not
noticeable by a human as far as I can say.
Key core changes:
1) Files and directories share core code and data structures.
2) The filesystem code knows which descriptors refer to same file.
This ensures that changes from one stream are appropriately reflected
in every open descriptor for that file (fileobj_mgr.c).
3) File and directory cache buffers are borrowed from the main sector
cache. This means that when they are not in use by a file, they are not
wasted, but used for the cache. Most of the time, only a few of them
are needed. It also means that adding more file and directory handles
is less expensive. All one must do in ensure a large enough cache to
borrow from.
4) Relative path components are supported and the namespace is unified.
It does not support full relative paths to an implied current directory;
what is does support is use of "." and "..". Adding the former would
not be very difficult. The namespace is unified in the sense that
volumes may be specified several times along with relative parts, e.g.:
"/<0>/foo/../../<1>/bar" :<=> "/<1>/bar".
5) Stack usage is down due to sharing of data, static allocation and
less duplication of strings on the stack. This requires more
serialization than I would like but since the number of threads is
limited to a low number, the tradoff in favor of the stack seems
reasonable.
6) Separates and heirarchicalizes (sic) the SIM and APP filesystem
code. SIM path and volume handling is just like the target. Some
aspects of the APP file code get more straightforward (e.g. no path
hashing is needed).
Dircache:
Deserves its own section. Dircache is new but pays homage to the old.
The old one was not compatible and so it, since it got redone, does
all the stuff it always should have done such as:
1) It may be update and used at any time during the build process.
No longer has one to wait for it to finish building to do basic file
management (create, remove, rename, etc.).
2) It does not need to be either fully scanned or completely disabled;
it can be incomplete (i.e. overfilled, missing paths), still be
of benefit and be correct.
3) Handles mounting and dismounting of individual volumes which means
a full rebuild is not needed just because you pop a new SD card in the
slot. Now, because it reuses its freed entry data, may rebuild only
that volume.
4) Much more fundamental to the file code. When it is built, it is
the keeper of the master file list whether enabled or not ("disabled"
is just a state of the cache). Its must always to ready to be started
and bind all streams opened prior to being enabled.
5) Maintains any short filenames in OEM format which means that it does
not need to be rebuilt when changing the default codepage.
Miscellaneous Compatibility:
1) Update any other code that would otherwise not work such as the
hotswap mounting code in various card drivers.
2) File management: Clipboard needed updating because of the behavioral
changes. Still needs a little more work on some finer points.
3) Remove now-obsolete functionality such as the mutex's "no preempt"
flag (which was only for the prior FAT driver).
4) struct dirinfo uses time_t rather than raw FAT directory entry
time fields. I plan to follow up on genericizing everything there
(i.e. no FAT attributes).
5) unicode.c needed some redoing so that the file code does not try
try to load codepages during a scan, which is actually a problem with
the current code. The default codepage, if any is required, is now
kept in RAM separarately (bufalloced) from codepages specified to
iso_decode() (which must not be bufalloced because the conversion
may be done by playback threads).
Brings with it some additional reusable core code:
1) Revised file functions: Reusable code that does things such as
safe path concatenation and parsing without buffer limitations or
data duplication. Variants that copy or alter the input path may be
based off these.
To do:
1) Put dircache functionality back in the sim. Treating it internally
as a different kind of file system seems the best approach at this
time.
2) Restore use of dircache indexes in the playlist and database or
something effectively the same. Since the cache doesn't have to be
complete in order to be used, not getting a hit on the cache doesn't
unambiguously say if the path exists or not.
Change-Id: Ia30f3082a136253e3a0eae0784e3091d138915c8
Reviewed-on: http://gerrit.rockbox.org/566
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested: Michael Sevakis <jethead71@rockbox.org>
2013-08-06 02:02:45 +00:00
|
|
|
if(mtime && do_rolo)
|
2007-03-30 21:54:48 +00:00
|
|
|
{
|
Rewrite filesystem code (WIP)
This patch redoes the filesystem code from the FAT driver up to the
clipboard code in onplay.c.
Not every aspect of this is finished therefore it is still "WIP". I
don't wish to do too much at once (haha!). What is left to do is get
dircache back in the sim and find an implementation for the dircache
indicies in the tagcache and playlist code or do something else that
has the same benefit. Leaving these out for now does not make anything
unusable. All the basics are done.
Phone app code should probably get vetted (and app path handling
just plain rewritten as environment expansions); the SDL app and
Android run well.
Main things addressed:
1) Thread safety: There is none right now in the trunk code. Most of
what currently works is luck when multiple threads are involved or
multiple descriptors to the same file are open.
2) POSIX compliance: Many of the functions behave nothing like their
counterparts on a host system. This leads to inconsistent code or very
different behavior from native to hosted. One huge offender was
rename(). Going point by point would fill a book.
3) Actual running RAM usage: Many targets will use less RAM and less
stack space (some more RAM because I upped the number of cache buffers
for large memory). There's very little memory lying fallow in rarely-used
areas (see 'Key core changes' below). Also, all targets may open the same
number of directory streams whereas before those with less than 8MB RAM
were limited to 8, not 12 implying those targets will save slightly
less.
4) Performance: The test_disk plugin shows markedly improved performance,
particularly in the area of (uncached) directory scanning, due partly to
more optimal directory reading and to a better sector cache algorithm.
Uncached times tend to be better while there is a bit of a slowdown in
dircache due to it being a bit heavier of an implementation. It's not
noticeable by a human as far as I can say.
Key core changes:
1) Files and directories share core code and data structures.
2) The filesystem code knows which descriptors refer to same file.
This ensures that changes from one stream are appropriately reflected
in every open descriptor for that file (fileobj_mgr.c).
3) File and directory cache buffers are borrowed from the main sector
cache. This means that when they are not in use by a file, they are not
wasted, but used for the cache. Most of the time, only a few of them
are needed. It also means that adding more file and directory handles
is less expensive. All one must do in ensure a large enough cache to
borrow from.
4) Relative path components are supported and the namespace is unified.
It does not support full relative paths to an implied current directory;
what is does support is use of "." and "..". Adding the former would
not be very difficult. The namespace is unified in the sense that
volumes may be specified several times along with relative parts, e.g.:
"/<0>/foo/../../<1>/bar" :<=> "/<1>/bar".
5) Stack usage is down due to sharing of data, static allocation and
less duplication of strings on the stack. This requires more
serialization than I would like but since the number of threads is
limited to a low number, the tradoff in favor of the stack seems
reasonable.
6) Separates and heirarchicalizes (sic) the SIM and APP filesystem
code. SIM path and volume handling is just like the target. Some
aspects of the APP file code get more straightforward (e.g. no path
hashing is needed).
Dircache:
Deserves its own section. Dircache is new but pays homage to the old.
The old one was not compatible and so it, since it got redone, does
all the stuff it always should have done such as:
1) It may be update and used at any time during the build process.
No longer has one to wait for it to finish building to do basic file
management (create, remove, rename, etc.).
2) It does not need to be either fully scanned or completely disabled;
it can be incomplete (i.e. overfilled, missing paths), still be
of benefit and be correct.
3) Handles mounting and dismounting of individual volumes which means
a full rebuild is not needed just because you pop a new SD card in the
slot. Now, because it reuses its freed entry data, may rebuild only
that volume.
4) Much more fundamental to the file code. When it is built, it is
the keeper of the master file list whether enabled or not ("disabled"
is just a state of the cache). Its must always to ready to be started
and bind all streams opened prior to being enabled.
5) Maintains any short filenames in OEM format which means that it does
not need to be rebuilt when changing the default codepage.
Miscellaneous Compatibility:
1) Update any other code that would otherwise not work such as the
hotswap mounting code in various card drivers.
2) File management: Clipboard needed updating because of the behavioral
changes. Still needs a little more work on some finer points.
3) Remove now-obsolete functionality such as the mutex's "no preempt"
flag (which was only for the prior FAT driver).
4) struct dirinfo uses time_t rather than raw FAT directory entry
time fields. I plan to follow up on genericizing everything there
(i.e. no FAT attributes).
5) unicode.c needed some redoing so that the file code does not try
try to load codepages during a scan, which is actually a problem with
the current code. The default codepage, if any is required, is now
kept in RAM separarately (bufalloced) from codepages specified to
iso_decode() (which must not be bufalloced because the conversion
may be done by playback threads).
Brings with it some additional reusable core code:
1) Revised file functions: Reusable code that does things such as
safe path concatenation and parsing without buffer limitations or
data duplication. Variants that copy or alter the input path may be
based off these.
To do:
1) Put dircache functionality back in the sim. Treating it internally
as a different kind of file system seems the best approach at this
time.
2) Restore use of dircache indexes in the playlist and database or
something effectively the same. Since the cache doesn't have to be
complete in order to be used, not getting a hit on the cache doesn't
unambiguously say if the path exists or not.
Change-Id: Ia30f3082a136253e3a0eae0784e3091d138915c8
Reviewed-on: http://gerrit.rockbox.org/566
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested: Michael Sevakis <jethead71@rockbox.org>
2013-08-06 02:02:45 +00:00
|
|
|
if(info.mtime != mtime)
|
2007-03-30 21:54:48 +00:00
|
|
|
{
|
2008-04-26 09:30:24 +00:00
|
|
|
static const char *lines[] = { ID2P(LANG_BOOT_CHANGED),
|
|
|
|
|
ID2P(LANG_REBOOT_NOW) };
|
|
|
|
|
static const struct text_message message={ lines, 2 };
|
2007-03-30 21:54:48 +00:00
|
|
|
button_clear_queue(); /* Empty the keyboard buffer */
|
|
|
|
|
if(gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES)
|
2011-08-14 15:13:00 +00:00
|
|
|
{
|
|
|
|
|
audio_hard_stop();
|
2011-01-18 00:37:17 +00:00
|
|
|
rolo_load(BOOTDIR "/" BOOTFILE);
|
2011-08-14 15:13:00 +00:00
|
|
|
}
|
2007-03-30 21:54:48 +00:00
|
|
|
}
|
|
|
|
|
}
|
Rewrite filesystem code (WIP)
This patch redoes the filesystem code from the FAT driver up to the
clipboard code in onplay.c.
Not every aspect of this is finished therefore it is still "WIP". I
don't wish to do too much at once (haha!). What is left to do is get
dircache back in the sim and find an implementation for the dircache
indicies in the tagcache and playlist code or do something else that
has the same benefit. Leaving these out for now does not make anything
unusable. All the basics are done.
Phone app code should probably get vetted (and app path handling
just plain rewritten as environment expansions); the SDL app and
Android run well.
Main things addressed:
1) Thread safety: There is none right now in the trunk code. Most of
what currently works is luck when multiple threads are involved or
multiple descriptors to the same file are open.
2) POSIX compliance: Many of the functions behave nothing like their
counterparts on a host system. This leads to inconsistent code or very
different behavior from native to hosted. One huge offender was
rename(). Going point by point would fill a book.
3) Actual running RAM usage: Many targets will use less RAM and less
stack space (some more RAM because I upped the number of cache buffers
for large memory). There's very little memory lying fallow in rarely-used
areas (see 'Key core changes' below). Also, all targets may open the same
number of directory streams whereas before those with less than 8MB RAM
were limited to 8, not 12 implying those targets will save slightly
less.
4) Performance: The test_disk plugin shows markedly improved performance,
particularly in the area of (uncached) directory scanning, due partly to
more optimal directory reading and to a better sector cache algorithm.
Uncached times tend to be better while there is a bit of a slowdown in
dircache due to it being a bit heavier of an implementation. It's not
noticeable by a human as far as I can say.
Key core changes:
1) Files and directories share core code and data structures.
2) The filesystem code knows which descriptors refer to same file.
This ensures that changes from one stream are appropriately reflected
in every open descriptor for that file (fileobj_mgr.c).
3) File and directory cache buffers are borrowed from the main sector
cache. This means that when they are not in use by a file, they are not
wasted, but used for the cache. Most of the time, only a few of them
are needed. It also means that adding more file and directory handles
is less expensive. All one must do in ensure a large enough cache to
borrow from.
4) Relative path components are supported and the namespace is unified.
It does not support full relative paths to an implied current directory;
what is does support is use of "." and "..". Adding the former would
not be very difficult. The namespace is unified in the sense that
volumes may be specified several times along with relative parts, e.g.:
"/<0>/foo/../../<1>/bar" :<=> "/<1>/bar".
5) Stack usage is down due to sharing of data, static allocation and
less duplication of strings on the stack. This requires more
serialization than I would like but since the number of threads is
limited to a low number, the tradoff in favor of the stack seems
reasonable.
6) Separates and heirarchicalizes (sic) the SIM and APP filesystem
code. SIM path and volume handling is just like the target. Some
aspects of the APP file code get more straightforward (e.g. no path
hashing is needed).
Dircache:
Deserves its own section. Dircache is new but pays homage to the old.
The old one was not compatible and so it, since it got redone, does
all the stuff it always should have done such as:
1) It may be update and used at any time during the build process.
No longer has one to wait for it to finish building to do basic file
management (create, remove, rename, etc.).
2) It does not need to be either fully scanned or completely disabled;
it can be incomplete (i.e. overfilled, missing paths), still be
of benefit and be correct.
3) Handles mounting and dismounting of individual volumes which means
a full rebuild is not needed just because you pop a new SD card in the
slot. Now, because it reuses its freed entry data, may rebuild only
that volume.
4) Much more fundamental to the file code. When it is built, it is
the keeper of the master file list whether enabled or not ("disabled"
is just a state of the cache). Its must always to ready to be started
and bind all streams opened prior to being enabled.
5) Maintains any short filenames in OEM format which means that it does
not need to be rebuilt when changing the default codepage.
Miscellaneous Compatibility:
1) Update any other code that would otherwise not work such as the
hotswap mounting code in various card drivers.
2) File management: Clipboard needed updating because of the behavioral
changes. Still needs a little more work on some finer points.
3) Remove now-obsolete functionality such as the mutex's "no preempt"
flag (which was only for the prior FAT driver).
4) struct dirinfo uses time_t rather than raw FAT directory entry
time fields. I plan to follow up on genericizing everything there
(i.e. no FAT attributes).
5) unicode.c needed some redoing so that the file code does not try
try to load codepages during a scan, which is actually a problem with
the current code. The default codepage, if any is required, is now
kept in RAM separarately (bufalloced) from codepages specified to
iso_decode() (which must not be bufalloced because the conversion
may be done by playback threads).
Brings with it some additional reusable core code:
1) Revised file functions: Reusable code that does things such as
safe path concatenation and parsing without buffer limitations or
data duplication. Variants that copy or alter the input path may be
based off these.
To do:
1) Put dircache functionality back in the sim. Treating it internally
as a different kind of file system seems the best approach at this
time.
2) Restore use of dircache indexes in the playlist and database or
something effectively the same. Since the cache doesn't have to be
complete in order to be used, not getting a hit on the cache doesn't
unambiguously say if the path exists or not.
Change-Id: Ia30f3082a136253e3a0eae0784e3091d138915c8
Reviewed-on: http://gerrit.rockbox.org/566
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested: Michael Sevakis <jethead71@rockbox.org>
2013-08-06 02:02:45 +00:00
|
|
|
mtime = info.mtime;
|
2007-03-30 21:54:48 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
closedir(dir);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2007-03-30 23:36:10 +00:00
|
|
|
#endif
|
2007-05-30 17:57:32 +00:00
|
|
|
|
|
|
|
|
/* check range, set volume and save settings */
|
|
|
|
|
void setvol(void)
|
|
|
|
|
{
|
|
|
|
|
const int min_vol = sound_min(SOUND_VOLUME);
|
|
|
|
|
const int max_vol = sound_max(SOUND_VOLUME);
|
|
|
|
|
if (global_settings.volume < min_vol)
|
|
|
|
|
global_settings.volume = min_vol;
|
|
|
|
|
if (global_settings.volume > max_vol)
|
|
|
|
|
global_settings.volume = max_vol;
|
2013-12-21 13:33:54 +00:00
|
|
|
if (global_settings.volume > global_settings.volume_limit)
|
|
|
|
|
global_settings.volume = global_settings.volume_limit;
|
|
|
|
|
|
2007-05-30 17:57:32 +00:00
|
|
|
sound_set_volume(global_settings.volume);
|
2009-11-01 02:36:51 +00:00
|
|
|
global_status.last_volume_change = current_tick;
|
2007-05-30 17:57:32 +00:00
|
|
|
settings_save();
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-18 14:12:01 +00:00
|
|
|
char* strrsplt(char* str, int c)
|
|
|
|
|
{
|
|
|
|
|
char* s = strrchr(str, c);
|
|
|
|
|
|
|
|
|
|
if (s != NULL)
|
|
|
|
|
{
|
|
|
|
|
*s++ = '\0';
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
s = str;
|
|
|
|
|
}
|
2009-12-18 14:17:28 +00:00
|
|
|
|
2007-11-18 14:12:01 +00:00
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
2008-01-18 10:02:03 +00:00
|
|
|
/*
|
|
|
|
|
* removes the extension of filename (if it doesn't start with a .)
|
|
|
|
|
* puts the result in buffer
|
|
|
|
|
*/
|
2008-02-06 19:51:19 +00:00
|
|
|
char *strip_extension(char* buffer, int buffer_size, const char *filename)
|
2008-01-18 10:02:03 +00:00
|
|
|
{
|
2021-08-17 12:28:23 +00:00
|
|
|
if (!buffer || !filename || buffer_size <= 0)
|
2008-02-06 19:51:19 +00:00
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-17 12:28:23 +00:00
|
|
|
off_t dotpos = (strrchr(filename, '.') - filename) + 1;
|
2008-02-06 19:51:19 +00:00
|
|
|
|
2021-08-17 12:28:23 +00:00
|
|
|
/* no match on filename beginning with '.' or beyond buffer_size */
|
|
|
|
|
if(dotpos > 1 && dotpos < buffer_size)
|
|
|
|
|
buffer_size = dotpos;
|
2022-11-14 16:32:34 +00:00
|
|
|
strmemccpy(buffer, filename, buffer_size);
|
2008-02-06 19:51:19 +00:00
|
|
|
|
2008-01-18 10:02:03 +00:00
|
|
|
return buffer;
|
|
|
|
|
}
|
2011-07-08 22:51:12 +00:00
|
|
|
|
|
|
|
|
/* Play a standard sound */
|
|
|
|
|
void system_sound_play(enum system_sound sound)
|
|
|
|
|
{
|
|
|
|
|
static const struct beep_params
|
|
|
|
|
{
|
|
|
|
|
int *setting;
|
|
|
|
|
unsigned short frequency;
|
|
|
|
|
unsigned short duration;
|
|
|
|
|
unsigned short amplitude;
|
|
|
|
|
} beep_params[] =
|
|
|
|
|
{
|
|
|
|
|
[SOUND_KEYCLICK] =
|
|
|
|
|
{ &global_settings.keyclick,
|
|
|
|
|
4000, KEYCLICK_DURATION, 2500 },
|
|
|
|
|
[SOUND_TRACK_SKIP] =
|
|
|
|
|
{ &global_settings.beep,
|
|
|
|
|
2000, 100, 2500 },
|
|
|
|
|
[SOUND_TRACK_NO_MORE] =
|
|
|
|
|
{ &global_settings.beep,
|
|
|
|
|
1000, 100, 1500 },
|
2018-12-16 00:15:28 +00:00
|
|
|
[SOUND_LIST_EDGE_BEEP_NOWRAP] =
|
|
|
|
|
{ &global_settings.keyclick,
|
|
|
|
|
1000, 40, 1500 },
|
|
|
|
|
[SOUND_LIST_EDGE_BEEP_WRAP] =
|
|
|
|
|
{ &global_settings.keyclick,
|
|
|
|
|
2000, 20, 1500 },
|
|
|
|
|
|
2011-07-08 22:51:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const struct beep_params *params = &beep_params[sound];
|
|
|
|
|
|
|
|
|
|
if (*params->setting)
|
|
|
|
|
{
|
|
|
|
|
beep_play(params->frequency, params->duration,
|
|
|
|
|
params->amplitude * *params->setting);
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-01-12 11:28:36 +00:00
|
|
|
|
|
|
|
|
static keyclick_callback keyclick_current_callback = NULL;
|
|
|
|
|
static void* keyclick_data = NULL;
|
|
|
|
|
void keyclick_set_callback(keyclick_callback cb, void* data)
|
|
|
|
|
{
|
|
|
|
|
keyclick_current_callback = cb;
|
|
|
|
|
keyclick_data = data;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-08 22:51:12 +00:00
|
|
|
/* Produce keyclick based upon button and global settings */
|
2012-03-03 12:52:13 +00:00
|
|
|
void keyclick_click(bool rawbutton, int action)
|
2011-07-08 22:51:12 +00:00
|
|
|
{
|
2012-03-03 12:10:56 +00:00
|
|
|
int button = action;
|
2011-11-16 11:05:46 +00:00
|
|
|
static long last_button = BUTTON_NONE;
|
|
|
|
|
bool do_beep = false;
|
2012-01-12 11:28:36 +00:00
|
|
|
|
2012-03-03 12:52:13 +00:00
|
|
|
if (!rawbutton)
|
2012-03-03 12:10:56 +00:00
|
|
|
get_action_statuscode(&button);
|
|
|
|
|
|
2011-07-08 22:51:12 +00:00
|
|
|
/* Settings filters */
|
2011-11-16 10:25:43 +00:00
|
|
|
if (
|
|
|
|
|
#ifdef HAVE_HARDWARE_CLICK
|
|
|
|
|
(global_settings.keyclick || global_settings.keyclick_hardware)
|
|
|
|
|
#else
|
|
|
|
|
global_settings.keyclick
|
|
|
|
|
#endif
|
2011-11-16 11:05:46 +00:00
|
|
|
)
|
2011-07-08 22:51:12 +00:00
|
|
|
{
|
2011-11-16 11:05:46 +00:00
|
|
|
if (global_settings.keyclick_repeats || !(button & BUTTON_REPEAT))
|
2011-07-08 22:51:12 +00:00
|
|
|
{
|
2011-11-16 11:05:46 +00:00
|
|
|
/* Button filters */
|
|
|
|
|
if (button != BUTTON_NONE && !(button & BUTTON_REL)
|
|
|
|
|
&& !(button & (SYS_EVENT|BUTTON_MULTIMEDIA)) )
|
2011-11-16 10:25:43 +00:00
|
|
|
{
|
2011-11-16 11:05:46 +00:00
|
|
|
do_beep = true;
|
2011-11-16 10:25:43 +00:00
|
|
|
}
|
2011-11-16 11:05:46 +00:00
|
|
|
}
|
|
|
|
|
else if ((button & BUTTON_REPEAT) && (last_button == BUTTON_NONE))
|
|
|
|
|
{
|
|
|
|
|
do_beep = true;
|
|
|
|
|
}
|
|
|
|
|
#ifdef HAVE_SCROLLWHEEL
|
|
|
|
|
else if (button & (BUTTON_SCROLL_BACK | BUTTON_SCROLL_FWD))
|
|
|
|
|
{
|
|
|
|
|
do_beep = true;
|
|
|
|
|
}
|
2011-11-16 10:25:43 +00:00
|
|
|
#endif
|
2011-11-16 11:05:46 +00:00
|
|
|
}
|
|
|
|
|
if (button&BUTTON_REPEAT)
|
|
|
|
|
last_button = button;
|
|
|
|
|
else
|
|
|
|
|
last_button = BUTTON_NONE;
|
2012-01-12 11:28:36 +00:00
|
|
|
|
|
|
|
|
if (do_beep && keyclick_current_callback)
|
|
|
|
|
do_beep = keyclick_current_callback(action, keyclick_data);
|
|
|
|
|
keyclick_current_callback = NULL;
|
|
|
|
|
|
2011-11-16 11:05:46 +00:00
|
|
|
if (do_beep)
|
|
|
|
|
{
|
|
|
|
|
#ifdef HAVE_HARDWARE_CLICK
|
|
|
|
|
if (global_settings.keyclick)
|
|
|
|
|
{
|
2011-07-08 22:51:12 +00:00
|
|
|
system_sound_play(SOUND_KEYCLICK);
|
2011-11-16 11:05:46 +00:00
|
|
|
}
|
|
|
|
|
if (global_settings.keyclick_hardware)
|
|
|
|
|
{
|
|
|
|
|
#if !defined(SIMULATOR)
|
|
|
|
|
piezo_button_beep(false, false);
|
2011-11-16 10:25:43 +00:00
|
|
|
#endif
|
2011-07-08 22:51:12 +00:00
|
|
|
}
|
2011-11-16 11:05:46 +00:00
|
|
|
#else
|
|
|
|
|
system_sound_play(SOUND_KEYCLICK);
|
|
|
|
|
#endif
|
2011-07-08 22:51:12 +00:00
|
|
|
}
|
|
|
|
|
}
|
2012-04-30 20:27:01 +00:00
|
|
|
|
|
|
|
|
/* Return the ReplayGain mode adjusted by other relevant settings */
|
|
|
|
|
static int replaygain_setting_mode(int type)
|
|
|
|
|
{
|
|
|
|
|
switch (type)
|
|
|
|
|
{
|
|
|
|
|
case REPLAYGAIN_SHUFFLE:
|
|
|
|
|
type = global_settings.playlist_shuffle ?
|
|
|
|
|
REPLAYGAIN_TRACK : REPLAYGAIN_ALBUM;
|
|
|
|
|
case REPLAYGAIN_ALBUM:
|
|
|
|
|
case REPLAYGAIN_TRACK:
|
|
|
|
|
case REPLAYGAIN_OFF:
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the ReplayGain mode adjusted for display purposes */
|
|
|
|
|
int id3_get_replaygain_mode(const struct mp3entry *id3)
|
|
|
|
|
{
|
|
|
|
|
if (!id3)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
int type = global_settings.replaygain_settings.type;
|
|
|
|
|
type = replaygain_setting_mode(type);
|
|
|
|
|
|
|
|
|
|
return (type != REPLAYGAIN_TRACK && id3->album_gain != 0) ?
|
|
|
|
|
REPLAYGAIN_ALBUM : (id3->track_gain != 0 ? REPLAYGAIN_TRACK : -1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Update DSP's replaygain from global settings */
|
|
|
|
|
void replaygain_update(void)
|
|
|
|
|
{
|
|
|
|
|
struct replaygain_settings settings = global_settings.replaygain_settings;
|
|
|
|
|
settings.type = replaygain_setting_mode(settings.type);
|
|
|
|
|
dsp_replaygain_set_settings(&settings);
|
|
|
|
|
}
|
2011-07-08 22:51:12 +00:00
|
|
|
|
2017-11-21 11:07:13 +00:00
|
|
|
/* format a sound value like: -1.05 dB */
|
|
|
|
|
int format_sound_value(char *buf, size_t size, int snd, int val)
|
|
|
|
|
{
|
|
|
|
|
int numdec = sound_numdecimals(snd);
|
|
|
|
|
const char *unit = sound_unit(snd);
|
|
|
|
|
int physval = sound_val2phys(snd, val);
|
|
|
|
|
|
|
|
|
|
unsigned int factor = ipow(10, numdec);
|
2021-08-04 02:41:04 +00:00
|
|
|
if (factor == 0)
|
|
|
|
|
{
|
|
|
|
|
DEBUGF("DIVISION BY ZERO: format_sound_value s:%d v:%d", snd, val);
|
|
|
|
|
factor = 1;
|
|
|
|
|
}
|
2017-11-21 11:07:13 +00:00
|
|
|
unsigned int av = abs(physval);
|
|
|
|
|
unsigned int i = av / factor;
|
|
|
|
|
unsigned int d = av - i*factor;
|
|
|
|
|
return snprintf(buf, size, "%c%u%.*s%.*u %s", " -"[physval < 0],
|
|
|
|
|
i, numdec, ".", numdec, d, unit);
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-25 21:09:58 +00:00
|
|
|
#endif /* !defined(__PCTOOL__) */
|
|
|
|
|
|
2010-05-03 15:12:19 +00:00
|
|
|
/* Read (up to) a line of text from fd into buffer and return number of bytes
|
|
|
|
|
* read (which may be larger than the number of bytes stored in buffer). If
|
|
|
|
|
* an error occurs, -1 is returned (and buffer contains whatever could be
|
|
|
|
|
* read). A line is terminated by a LF char. Neither LF nor CR chars are
|
|
|
|
|
* stored in buffer.
|
|
|
|
|
*/
|
|
|
|
|
int read_line(int fd, char* buffer, int buffer_size)
|
|
|
|
|
{
|
2017-12-12 20:57:51 +00:00
|
|
|
if (!buffer || buffer_size-- <= 0)
|
|
|
|
|
{
|
|
|
|
|
errno = EINVAL;
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned char rdbuf[32];
|
|
|
|
|
off_t rdbufend = 0;
|
|
|
|
|
int rdbufidx = 0;
|
2010-05-03 15:12:19 +00:00
|
|
|
int count = 0;
|
|
|
|
|
int num_read = 0;
|
|
|
|
|
|
|
|
|
|
while (count < buffer_size)
|
|
|
|
|
{
|
2017-12-12 20:57:51 +00:00
|
|
|
if (rdbufidx >= rdbufend)
|
|
|
|
|
{
|
|
|
|
|
rdbufidx = 0;
|
|
|
|
|
rdbufend = read(fd, rdbuf, sizeof (rdbuf));
|
2010-05-03 15:12:19 +00:00
|
|
|
|
2017-12-12 20:57:51 +00:00
|
|
|
if (rdbufend <= 0)
|
|
|
|
|
break;
|
2010-05-03 15:12:19 +00:00
|
|
|
|
2017-12-12 20:57:51 +00:00
|
|
|
num_read += rdbufend;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int c = rdbuf[rdbufidx++];
|
2010-05-03 15:12:19 +00:00
|
|
|
|
2017-12-12 20:57:51 +00:00
|
|
|
if (c == '\n')
|
2010-05-03 15:12:19 +00:00
|
|
|
break;
|
|
|
|
|
|
2017-12-12 20:57:51 +00:00
|
|
|
if (c == '\r')
|
2010-05-03 15:12:19 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
buffer[count++] = c;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-12 20:57:51 +00:00
|
|
|
rdbufidx -= rdbufend;
|
|
|
|
|
|
|
|
|
|
if (rdbufidx < 0)
|
|
|
|
|
{
|
|
|
|
|
/* "put back" what wasn't read from the buffer */
|
|
|
|
|
num_read += rdbufidx;
|
|
|
|
|
rdbufend = lseek(fd, rdbufidx, SEEK_CUR);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
buffer[count] = '\0';
|
2010-05-03 15:12:19 +00:00
|
|
|
|
2017-12-12 20:57:51 +00:00
|
|
|
return rdbufend >= 0 ? num_read : -1;
|
2010-05-03 15:12:19 +00:00
|
|
|
}
|
|
|
|
|
|
2009-02-26 10:20:28 +00:00
|
|
|
char* skip_whitespace(char* const str)
|
|
|
|
|
{
|
|
|
|
|
char *s = str;
|
|
|
|
|
|
2009-10-17 13:40:42 +00:00
|
|
|
while (isspace(*s))
|
2009-02-26 10:20:28 +00:00
|
|
|
s++;
|
2009-10-17 13:40:42 +00:00
|
|
|
|
2009-02-26 10:20:28 +00:00
|
|
|
return s;
|
|
|
|
|
}
|
2018-12-22 20:31:40 +00:00
|
|
|
|
|
|
|
|
#if !defined(CHECKWPS) && !defined(DBTOOL)
|
2022-11-25 04:44:35 +00:00
|
|
|
|
|
|
|
|
int confirm_delete_yesno(const char *name)
|
|
|
|
|
{
|
|
|
|
|
const char *lines[] = { ID2P(LANG_REALLY_DELETE), name };
|
|
|
|
|
const char *yes_lines[] = { ID2P(LANG_DELETING), name };
|
|
|
|
|
const struct text_message message = { lines, 2 };
|
|
|
|
|
const struct text_message yes_message = { yes_lines, 2 };
|
|
|
|
|
return gui_syncyesno_run(&message, &yes_message, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
/* time_split_units()
|
|
|
|
|
split time values depending on base unit
|
|
|
|
|
unit_idx: UNIT_HOUR, UNIT_MIN, UNIT_SEC, UNIT_MS
|
|
|
|
|
abs_value: absolute time value
|
|
|
|
|
units_in: array of unsigned ints with UNIT_IDX_TIME_COUNT fields
|
|
|
|
|
*/
|
|
|
|
|
unsigned int time_split_units(int unit_idx, unsigned long abs_val,
|
|
|
|
|
unsigned long (*units_in)[UNIT_IDX_TIME_COUNT])
|
|
|
|
|
{
|
|
|
|
|
unsigned int base_idx = UNIT_IDX_HR;
|
|
|
|
|
unsigned long hours;
|
|
|
|
|
unsigned long minutes = 0;
|
|
|
|
|
unsigned long seconds = 0;
|
|
|
|
|
unsigned long millisec = 0;
|
|
|
|
|
|
|
|
|
|
switch (unit_idx & UNIT_IDX_MASK) /*Mask off upper bits*/
|
|
|
|
|
{
|
|
|
|
|
case UNIT_MS:
|
|
|
|
|
base_idx = UNIT_IDX_MS;
|
|
|
|
|
millisec = abs_val;
|
|
|
|
|
abs_val = abs_val / 1000U;
|
|
|
|
|
millisec = millisec - (1000U * abs_val);
|
|
|
|
|
/* fallthrough and calculate the rest of the units */
|
|
|
|
|
case UNIT_SEC:
|
|
|
|
|
if (base_idx == UNIT_IDX_HR)
|
|
|
|
|
base_idx = UNIT_IDX_SEC;
|
|
|
|
|
seconds = abs_val;
|
|
|
|
|
abs_val = abs_val / 60U;
|
|
|
|
|
seconds = seconds - (60U * abs_val);
|
|
|
|
|
/* fallthrough and calculate the rest of the units */
|
|
|
|
|
case UNIT_MIN:
|
|
|
|
|
if (base_idx == UNIT_IDX_HR)
|
|
|
|
|
base_idx = UNIT_IDX_MIN;
|
|
|
|
|
minutes = abs_val;
|
|
|
|
|
abs_val = abs_val / 60U;
|
|
|
|
|
minutes = minutes -(60U * abs_val);
|
|
|
|
|
/* fallthrough and calculate the rest of the units */
|
|
|
|
|
case UNIT_HOUR:
|
|
|
|
|
default:
|
|
|
|
|
hours = abs_val;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
(*units_in)[UNIT_IDX_HR] = hours;
|
|
|
|
|
(*units_in)[UNIT_IDX_MIN] = minutes;
|
|
|
|
|
(*units_in)[UNIT_IDX_SEC] = seconds;
|
|
|
|
|
(*units_in)[UNIT_IDX_MS] = millisec;
|
|
|
|
|
|
|
|
|
|
return base_idx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* format_time_auto - return an auto ranged time string;
|
|
|
|
|
buffer: needs to be at least 25 characters for full range
|
|
|
|
|
|
|
|
|
|
unit_idx: specifies lowest or base index of the value
|
|
|
|
|
add | UNIT_LOCK_ to keep place holder of units that would normally be
|
|
|
|
|
discarded.. For instance, UNIT_LOCK_HR would keep the hours place, ex: string
|
|
|
|
|
00:10:10 (0 HRS 10 MINS 10 SECONDS) normally it would return as 10:10
|
|
|
|
|
add | UNIT_TRIM_ZERO to supress leading zero on the largest unit
|
|
|
|
|
|
|
|
|
|
value: should be passed in the same form as unit_idx
|
|
|
|
|
|
|
|
|
|
supress_unit: may be set to true and in this case the
|
|
|
|
|
hr, min, sec, ms identifiers will be left off the resulting string but
|
|
|
|
|
since right to left languages are handled it is advisable to leave units
|
|
|
|
|
as an indication of the text direction
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
const char *format_time_auto(char *buffer, int buf_len, long value,
|
|
|
|
|
int unit_idx, bool supress_unit)
|
|
|
|
|
{
|
|
|
|
|
const char * const sign = &"-"[value < 0 ? 0 : 1];
|
|
|
|
|
bool is_rtl = lang_is_rtl();
|
|
|
|
|
char timebuf[25]; /* -2147483648:00:00.00\0 */
|
|
|
|
|
int len, left_offset;
|
|
|
|
|
unsigned char base_idx, max_idx;
|
|
|
|
|
|
|
|
|
|
unsigned long units_in[UNIT_IDX_TIME_COUNT];
|
|
|
|
|
unsigned char fwidth[UNIT_IDX_TIME_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[UNIT_IDX_HR] = 0, /* hr is variable length */
|
|
|
|
|
[UNIT_IDX_MIN] = 2,
|
|
|
|
|
[UNIT_IDX_SEC] = 2,
|
|
|
|
|
[UNIT_IDX_MS] = 3,
|
|
|
|
|
}; /* {0,2,2,3}; Field Widths */
|
|
|
|
|
unsigned char offsets[UNIT_IDX_TIME_COUNT] =
|
|
|
|
|
{
|
|
|
|
|
[UNIT_IDX_HR] = 10,/* ?:59:59.999 Std offsets */
|
|
|
|
|
[UNIT_IDX_MIN] = 7, /*0?:+1:+4.+7 need calculated */
|
|
|
|
|
[UNIT_IDX_SEC] = 4,/* 999.59:59:0 RTL offsets */
|
|
|
|
|
[UNIT_IDX_MS] = 0,/* 0 .4 :7 :10 won't change */
|
|
|
|
|
}; /* {10,7,4,0}; Offsets */
|
2022-12-07 06:40:49 +00:00
|
|
|
static const uint16_t unitlock[UNIT_IDX_TIME_COUNT] =
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
{
|
|
|
|
|
[UNIT_IDX_HR] = UNIT_LOCK_HR,
|
|
|
|
|
[UNIT_IDX_MIN] = UNIT_LOCK_MIN,
|
|
|
|
|
[UNIT_IDX_SEC] = UNIT_LOCK_SEC,
|
|
|
|
|
[UNIT_IDX_MS] = 0,
|
|
|
|
|
}; /* unitlock */
|
2022-12-07 06:40:49 +00:00
|
|
|
static const uint16_t units[UNIT_IDX_TIME_COUNT] =
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
{
|
|
|
|
|
[UNIT_IDX_HR] = UNIT_HOUR,
|
|
|
|
|
[UNIT_IDX_MIN] = UNIT_MIN,
|
|
|
|
|
[UNIT_IDX_SEC] = UNIT_SEC,
|
|
|
|
|
[UNIT_IDX_MS] = UNIT_MS,
|
|
|
|
|
}; /* units */
|
|
|
|
|
|
|
|
|
|
#if 0 /* unused */
|
|
|
|
|
if (idx_pos != NULL)
|
|
|
|
|
{
|
|
|
|
|
(*idx_pos)[0] = MIN((*idx_pos)[0], UNIT_IDX_TIME_COUNT - 1);
|
|
|
|
|
unit_idx |= unitlock[(*idx_pos)[0]];
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
base_idx = time_split_units(unit_idx, labs(value), &units_in);
|
|
|
|
|
|
|
|
|
|
if (units_in[UNIT_IDX_HR] || (unit_idx & unitlock[UNIT_IDX_HR]))
|
|
|
|
|
max_idx = UNIT_IDX_HR;
|
|
|
|
|
else if (units_in[UNIT_IDX_MIN] || (unit_idx & unitlock[UNIT_IDX_MIN]))
|
|
|
|
|
max_idx = UNIT_IDX_MIN;
|
|
|
|
|
else if (units_in[UNIT_IDX_SEC] || (unit_idx & unitlock[UNIT_IDX_SEC]))
|
|
|
|
|
max_idx = UNIT_IDX_SEC;
|
|
|
|
|
else if (units_in[UNIT_IDX_MS])
|
|
|
|
|
max_idx = UNIT_IDX_MS;
|
|
|
|
|
else /* value is 0 */
|
|
|
|
|
max_idx = base_idx;
|
|
|
|
|
|
|
|
|
|
if (!is_rtl)
|
|
|
|
|
{
|
|
|
|
|
len = snprintf(timebuf, sizeof(timebuf),
|
|
|
|
|
"%02lu:%02lu:%02lu.%03lu",
|
|
|
|
|
units_in[UNIT_IDX_HR],
|
|
|
|
|
units_in[UNIT_IDX_MIN],
|
|
|
|
|
units_in[UNIT_IDX_SEC],
|
|
|
|
|
units_in[UNIT_IDX_MS]);
|
|
|
|
|
|
|
|
|
|
fwidth[UNIT_IDX_HR] = len - offsets[UNIT_IDX_HR];
|
|
|
|
|
|
|
|
|
|
/* calculate offsets of the other fields based on length of previous */
|
|
|
|
|
offsets[UNIT_IDX_MS] = fwidth[UNIT_IDX_HR] + offsets[UNIT_IDX_MIN];
|
|
|
|
|
offsets[UNIT_IDX_SEC] = fwidth[UNIT_IDX_HR] + offsets[UNIT_IDX_SEC];
|
|
|
|
|
offsets[UNIT_IDX_MIN] = fwidth[UNIT_IDX_HR] + 1;
|
|
|
|
|
offsets[UNIT_IDX_HR] = 0;
|
|
|
|
|
|
|
|
|
|
timebuf[offsets[base_idx] + fwidth[base_idx]] = '\0';
|
|
|
|
|
|
|
|
|
|
left_offset = -(offsets[max_idx]);
|
|
|
|
|
left_offset += strlcpy(buffer, sign, buf_len);
|
|
|
|
|
|
|
|
|
|
/* trim leading zero on the max_idx */
|
|
|
|
|
if ((unit_idx & UNIT_TRIM_ZERO) == UNIT_TRIM_ZERO &&
|
|
|
|
|
timebuf[offsets[max_idx]] == '0' && fwidth[max_idx] > 1)
|
|
|
|
|
{
|
|
|
|
|
offsets[max_idx]++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
strlcat(buffer, &timebuf[offsets[max_idx]], buf_len);
|
|
|
|
|
|
|
|
|
|
if (!supress_unit)
|
|
|
|
|
{
|
|
|
|
|
strlcat(buffer, " ", buf_len);
|
|
|
|
|
strlcat(buffer, unit_strings_core[units[max_idx]], buf_len);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else /*RTL Languages*/
|
|
|
|
|
{
|
|
|
|
|
len = snprintf(timebuf, sizeof(timebuf),
|
|
|
|
|
"%03lu.%02lu:%02lu:%02lu",
|
|
|
|
|
units_in[UNIT_IDX_MS],
|
|
|
|
|
units_in[UNIT_IDX_SEC],
|
|
|
|
|
units_in[UNIT_IDX_MIN],
|
|
|
|
|
units_in[UNIT_IDX_HR]);
|
|
|
|
|
|
|
|
|
|
fwidth[UNIT_IDX_HR] = len - offsets[UNIT_IDX_HR];
|
|
|
|
|
|
|
|
|
|
left_offset = -(offsets[base_idx]);
|
|
|
|
|
|
|
|
|
|
/* trim leading zero on the max_idx */
|
|
|
|
|
if ((unit_idx & UNIT_TRIM_ZERO) == UNIT_TRIM_ZERO &&
|
|
|
|
|
timebuf[offsets[max_idx]] == '0' && fwidth[max_idx] > 1)
|
|
|
|
|
{
|
|
|
|
|
timebuf[offsets[max_idx]] = timebuf[offsets[max_idx]+1];
|
|
|
|
|
fwidth[max_idx]--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
timebuf[offsets[max_idx] + fwidth[max_idx]] = '\0';
|
|
|
|
|
|
|
|
|
|
if (!supress_unit)
|
|
|
|
|
{
|
2022-11-14 16:32:34 +00:00
|
|
|
strmemccpy(buffer, unit_strings_core[units[max_idx]], buf_len);
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
left_offset += strlcat(buffer, " ", buf_len);
|
|
|
|
|
strlcat(buffer, &timebuf[offsets[base_idx]], buf_len);
|
|
|
|
|
}
|
|
|
|
|
else
|
2022-11-14 16:32:34 +00:00
|
|
|
strmemccpy(buffer, &timebuf[offsets[base_idx]], buf_len);
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
|
|
|
|
|
strlcat(buffer, sign, buf_len);
|
|
|
|
|
}
|
|
|
|
|
#if 0 /* unused */
|
|
|
|
|
if (idx_pos != NULL)
|
|
|
|
|
{
|
|
|
|
|
(*idx_pos)[1]= fwidth[*(idx_pos)[0]];
|
|
|
|
|
(*idx_pos)[0]= left_offset + offsets[(*idx_pos)[0]];
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-29 21:08:38 +00:00
|
|
|
/* Format time into buf.
|
|
|
|
|
*
|
|
|
|
|
* buf - buffer to format to.
|
|
|
|
|
* buf_size - size of buffer.
|
|
|
|
|
* t - time to format, in milliseconds.
|
|
|
|
|
*/
|
|
|
|
|
void format_time(char* buf, int buf_size, long t)
|
|
|
|
|
{
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
unsigned long units_in[UNIT_IDX_TIME_COUNT] = {0};
|
|
|
|
|
time_split_units(UNIT_MS, labs(t), &units_in);
|
|
|
|
|
int hashours = units_in[UNIT_IDX_HR] > 0;
|
2017-09-18 10:00:05 +00:00
|
|
|
snprintf(buf, buf_size, "%.*s%.0lu%.*s%.*lu:%.2lu",
|
Auto-Ranging Time Formatting For Menus (hh:mm:ss:mss)
Unifies time formatting in settings_list.c allows time format to
display as HH:MM:SS.MSS or any consecutive combination thereof
(hh:mm:ss, mm:ss, mm:ss.mss, ss.mss, hh, mm, ss ,mss)
works in INT and TABLE settings with the addition of flag 'F_TIME_SETTING'
Time is auto-ranged dependent on value
Adds talk_time_intervals to allow time values to be spoken similar to
display format: x Hours, x Minutes, x Seconds, x Milliseconds
Table lookups merged or removed from recording, clip meter and lcd timeout
-String_Choice replaced with TABLE_SETTING or INT_SETTING for these
functions as well, cleaned-up cfg_vals that get saved to cfgfile
RTL Languages ARE supported
Negative values ARE supported
Backlight on/off are now Always and Never to share formatter with LCD
Timeout
Added flag to allow ranged units to be locked to a minimum index
Added flag to allow leading zero to be supressed from the largest unit
merged talk_time_unit() and talk_time_intervals()
optimized time_split()
optimized format_time_auto()
Backlight time-out list same as original
Change-Id: I59027c62d3f2956bd16fdcc1a48b2ac32c084abd
2018-12-18 04:27:55 +00:00
|
|
|
t < 0, "-", units_in[UNIT_IDX_HR], hashours, ":",
|
|
|
|
|
hashours+1, units_in[UNIT_IDX_MIN], units_in[UNIT_IDX_SEC]);
|
2008-08-29 21:08:38 +00:00
|
|
|
}
|
2018-12-22 20:31:40 +00:00
|
|
|
#endif /* !defined(CHECKWPS) && !defined(DBTOOL)*/
|
|
|
|
|
|
2012-07-18 21:26:21 +00:00
|
|
|
/**
|
|
|
|
|
* Splits str at each occurence of split_char and puts the substrings into vector,
|
|
|
|
|
* but at most vector_lenght items. Empty substrings are ignored.
|
|
|
|
|
*
|
|
|
|
|
* Modifies str by replacing each split_char following a substring with nul
|
|
|
|
|
*
|
|
|
|
|
* Returns the number of substrings found, i.e. the number of valid strings
|
|
|
|
|
* in vector
|
|
|
|
|
*/
|
|
|
|
|
int split_string(char *str, const char split_char, char *vector[], const int vector_length)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
2022-11-16 04:29:01 +00:00
|
|
|
char sep[2] = {split_char, '\0'};
|
|
|
|
|
char *e, *p = strtok_r(str, sep, &e);
|
2012-07-18 21:26:21 +00:00
|
|
|
|
2022-11-15 16:24:34 +00:00
|
|
|
/* strtok takes care of leading & trailing splitters */
|
2022-11-16 04:29:01 +00:00
|
|
|
for(i = 0; i < vector_length; i++)
|
2012-07-18 21:26:21 +00:00
|
|
|
{
|
|
|
|
|
vector[i] = p;
|
2022-11-16 04:29:01 +00:00
|
|
|
if (!p)
|
|
|
|
|
break;
|
|
|
|
|
p = strtok_r(NULL, sep, &e);
|
2012-07-18 21:26:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-13 07:35:18 +00:00
|
|
|
/* returns match index from option list
|
|
|
|
|
* returns -1 if option was not found
|
|
|
|
|
* option list is array of char pointers with the final item set to null
|
2022-05-04 02:54:33 +00:00
|
|
|
* ex - const char * const option[] = { "op_a", "op_b", "op_c", NULL}
|
2022-03-13 07:35:18 +00:00
|
|
|
*/
|
|
|
|
|
int string_option(const char *option, const char *const oplist[], bool ignore_case)
|
|
|
|
|
{
|
|
|
|
|
const char *op;
|
2022-03-13 18:31:02 +00:00
|
|
|
int (*cmp_fn)(const char*, const char*) = &strcasecmp;
|
|
|
|
|
if (!ignore_case)
|
|
|
|
|
cmp_fn = strcmp;
|
|
|
|
|
for (int i=0; (op=oplist[i]) != NULL; i++)
|
2022-03-13 07:35:18 +00:00
|
|
|
{
|
2022-03-13 18:31:02 +00:00
|
|
|
if (cmp_fn(op, option) == 0)
|
|
|
|
|
return i;
|
2022-03-13 07:35:18 +00:00
|
|
|
}
|
2022-03-13 18:31:02 +00:00
|
|
|
return -1;
|
2022-03-13 07:35:18 +00:00
|
|
|
}
|
2008-08-29 21:08:38 +00:00
|
|
|
|
2022-11-20 03:39:14 +00:00
|
|
|
/* open but with a builtin printf for assembling the path */
|
2022-11-24 02:46:13 +00:00
|
|
|
int open_pathfmt(char *buf, size_t size, int oflag, const char *pathfmt, ...)
|
2022-11-20 03:39:14 +00:00
|
|
|
{
|
|
|
|
|
va_list ap;
|
2022-11-20 05:00:40 +00:00
|
|
|
va_start(ap, pathfmt);
|
2022-11-24 02:46:13 +00:00
|
|
|
vsnprintf(buf, size, pathfmt, ap);
|
2022-11-20 03:39:14 +00:00
|
|
|
va_end(ap);
|
2022-11-25 02:30:47 +00:00
|
|
|
if ((oflag & O_PATH) == O_PATH)
|
|
|
|
|
return -1;
|
2022-11-20 03:39:14 +00:00
|
|
|
return open(buf, oflag, 0666);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-02 20:39:03 +00:00
|
|
|
/** Open a UTF-8 file and set file descriptor to first byte after BOM.
|
|
|
|
|
* If no BOM is present this behaves like open().
|
|
|
|
|
* If the file is opened for writing and O_TRUNC is set, write a BOM to
|
|
|
|
|
* the opened file and leave the file pointer set after the BOM.
|
|
|
|
|
*/
|
2008-08-28 12:49:38 +00:00
|
|
|
|
2008-08-02 20:39:03 +00:00
|
|
|
int open_utf8(const char* pathname, int flags)
|
|
|
|
|
{
|
2014-06-29 10:23:48 +00:00
|
|
|
ssize_t ret;
|
2008-08-02 20:39:03 +00:00
|
|
|
int fd;
|
2011-12-20 08:15:36 +00:00
|
|
|
unsigned char bom[BOM_UTF_8_SIZE];
|
2008-08-02 20:39:03 +00:00
|
|
|
|
2010-11-07 11:45:20 +00:00
|
|
|
fd = open(pathname, flags, 0666);
|
2008-08-02 20:39:03 +00:00
|
|
|
if(fd < 0)
|
|
|
|
|
return fd;
|
|
|
|
|
|
|
|
|
|
if(flags & (O_TRUNC | O_WRONLY))
|
|
|
|
|
{
|
2014-06-29 10:23:48 +00:00
|
|
|
ret = write(fd, BOM_UTF_8, BOM_UTF_8_SIZE);
|
2008-08-02 20:39:03 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2014-06-29 10:23:48 +00:00
|
|
|
ret = read(fd, bom, BOM_UTF_8_SIZE);
|
2008-08-02 20:39:03 +00:00
|
|
|
/* check for BOM */
|
2014-06-29 10:23:48 +00:00
|
|
|
if (ret == BOM_UTF_8_SIZE)
|
|
|
|
|
{
|
|
|
|
|
if(memcmp(bom, BOM_UTF_8, BOM_UTF_8_SIZE))
|
|
|
|
|
lseek(fd, 0, SEEK_SET);
|
|
|
|
|
}
|
2008-08-02 20:39:03 +00:00
|
|
|
}
|
2014-06-29 10:23:48 +00:00
|
|
|
/* read or write failure, do not continue */
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
|
|
return ret >= 0 ? fd : -1;
|
2008-08-02 20:39:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-03-25 21:09:58 +00:00
|
|
|
#ifdef HAVE_LCD_COLOR
|
|
|
|
|
/*
|
|
|
|
|
* Helper function to convert a string of 6 hex digits to a native colour
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int hex2dec(int c)
|
|
|
|
|
{
|
2009-12-18 14:17:28 +00:00
|
|
|
return (((c) >= '0' && ((c) <= '9')) ? (c) - '0' :
|
|
|
|
|
(toupper(c)) - 'A' + 10);
|
2008-03-25 21:09:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hex_to_rgb(const char* hex, int* color)
|
|
|
|
|
{
|
|
|
|
|
int red, green, blue;
|
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
|
|
while ((i < 6) && (isxdigit(hex[i])))
|
|
|
|
|
i++;
|
|
|
|
|
|
|
|
|
|
if (i < 6)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
red = (hex2dec(hex[0]) << 4) | hex2dec(hex[1]);
|
|
|
|
|
green = (hex2dec(hex[2]) << 4) | hex2dec(hex[3]);
|
|
|
|
|
blue = (hex2dec(hex[4]) << 4) | hex2dec(hex[5]);
|
|
|
|
|
|
|
|
|
|
*color = LCD_RGBPACK(red,green,blue);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif /* HAVE_LCD_COLOR */
|
2008-03-21 13:41:35 +00:00
|
|
|
|
|
|
|
|
/* '0'-'3' are ASCII 0x30 to 0x33 */
|
|
|
|
|
#define is0123(x) (((x) & 0xfc) == 0x30)
|
2010-08-10 14:26:53 +00:00
|
|
|
#if !defined(__PCTOOL__) || defined(CHECKWPS)
|
2010-08-10 14:15:03 +00:00
|
|
|
bool parse_color(enum screen_type screen, char *text, int *value)
|
2008-03-21 13:41:35 +00:00
|
|
|
{
|
2010-07-29 12:37:48 +00:00
|
|
|
(void)text; (void)value; /* silence warnings on mono bitmap */
|
2010-08-10 14:32:08 +00:00
|
|
|
(void)screen;
|
2013-07-12 16:03:20 +00:00
|
|
|
|
2008-03-21 13:41:35 +00:00
|
|
|
#ifdef HAVE_LCD_COLOR
|
2010-08-10 14:26:53 +00:00
|
|
|
if (screens[screen].depth > 2)
|
2010-08-10 14:15:03 +00:00
|
|
|
{
|
|
|
|
|
if (hex_to_rgb(text, value) < 0)
|
|
|
|
|
return false;
|
|
|
|
|
else
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2008-03-21 13:41:35 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if LCD_DEPTH == 2 || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH == 2)
|
2010-08-10 14:26:53 +00:00
|
|
|
if (screens[screen].depth == 2)
|
2010-08-10 14:15:03 +00:00
|
|
|
{
|
|
|
|
|
if (text[1] != '\0' || !is0123(*text))
|
|
|
|
|
return false;
|
|
|
|
|
*value = *text - '0';
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2008-03-21 13:41:35 +00:00
|
|
|
#endif
|
2010-08-10 14:15:03 +00:00
|
|
|
return false;
|
2008-03-21 13:41:35 +00:00
|
|
|
}
|
2010-08-10 14:26:53 +00:00
|
|
|
#endif /* !defined(__PCTOOL__) || defined(CHECKWPS) */
|
2009-10-23 13:29:19 +00:00
|
|
|
|
|
|
|
|
/* only used in USB HID and set_time screen */
|
|
|
|
|
#if defined(USB_ENABLE_HID) || (CONFIG_RTC != 0)
|
|
|
|
|
int clamp_value_wrap(int value, int max, int min)
|
|
|
|
|
{
|
|
|
|
|
if (value > max)
|
|
|
|
|
return min;
|
|
|
|
|
if (value < min)
|
|
|
|
|
return max;
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2014-01-15 21:39:51 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef __PCTOOL__
|
|
|
|
|
|
2011-06-01 14:41:49 +00:00
|
|
|
#define MAX_ACTIVITY_DEPTH 12
|
2013-07-12 16:03:20 +00:00
|
|
|
static enum current_activity
|
2011-06-01 14:41:49 +00:00
|
|
|
current_activity[MAX_ACTIVITY_DEPTH] = {ACTIVITY_UNKNOWN};
|
|
|
|
|
static int current_activity_top = 0;
|
2022-12-14 08:06:04 +00:00
|
|
|
|
|
|
|
|
static void push_current_activity_refresh(enum current_activity screen, bool refresh)
|
2011-06-01 14:41:49 +00:00
|
|
|
{
|
|
|
|
|
current_activity[current_activity_top++] = screen;
|
Lists can now be completly draw using the skin engine!
due to lack of user feedback the actual tags may change, hopefully not though.
The way it works is the skin specifies a rectangle and a viewport label. For each item in the list that is being displayed all viewports with the specified label are drawn. However, instead of the viewport x/y position being offset from the top left corner like normal they are offset from the rectangle position in the list (so think of them as child-viewports of the rectangle which moves).
Normally the rectangle will move down the screen to show a normal list, this can be changed to move across the screen in a grid pattern.
The UI viewport is used to bound the items (i.e %Vi() )
Scrolling is completly disabled in all items except the currently selected item.
This works well in combination with the %cs tag to show differently styled lists based on the current screen :)
New tags:
%LT - Get the current items text
%LI - Get the current items icon number
%Lc - Use as a conditional to determine if the current item is the selected item
%LB - BAR TAG to show the scroll bar, params/options like other bar types. It still needs a bit of work though. Use as a conditional to find out if the bar is actually needed
%Lb(viewport, width, height [,tile]) - specify the viewport label to draw for each item and the size of each item. if the last param is 'tile' it will form a grid instead of a list
example.sbs:
%?cs<%Lb(a,100,20)|>
%V(0,0,10,-,1)%Vf(aabbcc)
%?LB<%LB(0,0,10,185, invert)>
%Vi(-,10,0,-,-35,1)
%Vl(a,5,5,160,12,1)
%s%?Lc<%Vg(00ffaa, ff0000, 000000)%Vs(gradient)%>%>%>%ac>zzzzzzz %LT zzzzz%s%?Lc<%ar%<%<%<>
%V(0,185,-,-,1)
%s%LT
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30461 a1c6a512-1295-4272-9138-f99709370657
2011-09-06 13:49:41 +00:00
|
|
|
FOR_NB_SCREENS(i)
|
2014-01-15 17:57:46 +00:00
|
|
|
{
|
Lists can now be completly draw using the skin engine!
due to lack of user feedback the actual tags may change, hopefully not though.
The way it works is the skin specifies a rectangle and a viewport label. For each item in the list that is being displayed all viewports with the specified label are drawn. However, instead of the viewport x/y position being offset from the top left corner like normal they are offset from the rectangle position in the list (so think of them as child-viewports of the rectangle which moves).
Normally the rectangle will move down the screen to show a normal list, this can be changed to move across the screen in a grid pattern.
The UI viewport is used to bound the items (i.e %Vi() )
Scrolling is completly disabled in all items except the currently selected item.
This works well in combination with the %cs tag to show differently styled lists based on the current screen :)
New tags:
%LT - Get the current items text
%LI - Get the current items icon number
%Lc - Use as a conditional to determine if the current item is the selected item
%LB - BAR TAG to show the scroll bar, params/options like other bar types. It still needs a bit of work though. Use as a conditional to find out if the bar is actually needed
%Lb(viewport, width, height [,tile]) - specify the viewport label to draw for each item and the size of each item. if the last param is 'tile' it will form a grid instead of a list
example.sbs:
%?cs<%Lb(a,100,20)|>
%V(0,0,10,-,1)%Vf(aabbcc)
%?LB<%LB(0,0,10,185, invert)>
%Vi(-,10,0,-,-35,1)
%Vl(a,5,5,160,12,1)
%s%?Lc<%Vg(00ffaa, ff0000, 000000)%Vs(gradient)%>%>%>%ac>zzzzzzz %LT zzzzz%s%?Lc<%ar%<%<%<>
%V(0,185,-,-,1)
%s%LT
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30461 a1c6a512-1295-4272-9138-f99709370657
2011-09-06 13:49:41 +00:00
|
|
|
skinlist_set_cfg(i, NULL);
|
2022-12-14 08:06:04 +00:00
|
|
|
if (refresh)
|
|
|
|
|
skin_update(CUSTOM_STATUSBAR, i, SKIN_REFRESH_ALL);
|
2014-01-15 17:57:46 +00:00
|
|
|
}
|
2011-06-01 14:41:49 +00:00
|
|
|
}
|
2014-01-15 17:57:46 +00:00
|
|
|
|
2022-12-14 08:06:04 +00:00
|
|
|
static void pop_current_activity_refresh(bool refresh)
|
2022-12-12 02:49:06 +00:00
|
|
|
{
|
2022-12-14 08:06:04 +00:00
|
|
|
current_activity_top--;
|
2022-12-12 02:49:06 +00:00
|
|
|
FOR_NB_SCREENS(i)
|
2022-12-14 08:06:04 +00:00
|
|
|
{
|
2022-12-12 02:49:06 +00:00
|
|
|
skinlist_set_cfg(i, NULL);
|
2022-12-14 08:06:04 +00:00
|
|
|
if (refresh)
|
|
|
|
|
skin_update(CUSTOM_STATUSBAR, i, SKIN_REFRESH_ALL);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void push_current_activity(enum current_activity screen)
|
|
|
|
|
{
|
|
|
|
|
push_current_activity_refresh(screen, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void push_activity_without_refresh(enum current_activity screen)
|
|
|
|
|
{
|
|
|
|
|
push_current_activity_refresh(screen, false);
|
2022-12-12 02:49:06 +00:00
|
|
|
}
|
|
|
|
|
|
2022-12-14 08:06:04 +00:00
|
|
|
void pop_current_activity(void)
|
2011-06-01 14:41:49 +00:00
|
|
|
{
|
2022-12-14 08:06:04 +00:00
|
|
|
pop_current_activity_refresh(true);
|
|
|
|
|
#if 0
|
2011-06-01 14:41:49 +00:00
|
|
|
current_activity_top--;
|
Lists can now be completly draw using the skin engine!
due to lack of user feedback the actual tags may change, hopefully not though.
The way it works is the skin specifies a rectangle and a viewport label. For each item in the list that is being displayed all viewports with the specified label are drawn. However, instead of the viewport x/y position being offset from the top left corner like normal they are offset from the rectangle position in the list (so think of them as child-viewports of the rectangle which moves).
Normally the rectangle will move down the screen to show a normal list, this can be changed to move across the screen in a grid pattern.
The UI viewport is used to bound the items (i.e %Vi() )
Scrolling is completly disabled in all items except the currently selected item.
This works well in combination with the %cs tag to show differently styled lists based on the current screen :)
New tags:
%LT - Get the current items text
%LI - Get the current items icon number
%Lc - Use as a conditional to determine if the current item is the selected item
%LB - BAR TAG to show the scroll bar, params/options like other bar types. It still needs a bit of work though. Use as a conditional to find out if the bar is actually needed
%Lb(viewport, width, height [,tile]) - specify the viewport label to draw for each item and the size of each item. if the last param is 'tile' it will form a grid instead of a list
example.sbs:
%?cs<%Lb(a,100,20)|>
%V(0,0,10,-,1)%Vf(aabbcc)
%?LB<%LB(0,0,10,185, invert)>
%Vi(-,10,0,-,-35,1)
%Vl(a,5,5,160,12,1)
%s%?Lc<%Vg(00ffaa, ff0000, 000000)%Vs(gradient)%>%>%>%ac>zzzzzzz %LT zzzzz%s%?Lc<%ar%<%<%<>
%V(0,185,-,-,1)
%s%LT
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30461 a1c6a512-1295-4272-9138-f99709370657
2011-09-06 13:49:41 +00:00
|
|
|
FOR_NB_SCREENS(i)
|
2014-01-15 17:57:46 +00:00
|
|
|
{
|
Lists can now be completly draw using the skin engine!
due to lack of user feedback the actual tags may change, hopefully not though.
The way it works is the skin specifies a rectangle and a viewport label. For each item in the list that is being displayed all viewports with the specified label are drawn. However, instead of the viewport x/y position being offset from the top left corner like normal they are offset from the rectangle position in the list (so think of them as child-viewports of the rectangle which moves).
Normally the rectangle will move down the screen to show a normal list, this can be changed to move across the screen in a grid pattern.
The UI viewport is used to bound the items (i.e %Vi() )
Scrolling is completly disabled in all items except the currently selected item.
This works well in combination with the %cs tag to show differently styled lists based on the current screen :)
New tags:
%LT - Get the current items text
%LI - Get the current items icon number
%Lc - Use as a conditional to determine if the current item is the selected item
%LB - BAR TAG to show the scroll bar, params/options like other bar types. It still needs a bit of work though. Use as a conditional to find out if the bar is actually needed
%Lb(viewport, width, height [,tile]) - specify the viewport label to draw for each item and the size of each item. if the last param is 'tile' it will form a grid instead of a list
example.sbs:
%?cs<%Lb(a,100,20)|>
%V(0,0,10,-,1)%Vf(aabbcc)
%?LB<%LB(0,0,10,185, invert)>
%Vi(-,10,0,-,-35,1)
%Vl(a,5,5,160,12,1)
%s%?Lc<%Vg(00ffaa, ff0000, 000000)%Vs(gradient)%>%>%>%ac>zzzzzzz %LT zzzzz%s%?Lc<%ar%<%<%<>
%V(0,185,-,-,1)
%s%LT
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30461 a1c6a512-1295-4272-9138-f99709370657
2011-09-06 13:49:41 +00:00
|
|
|
skinlist_set_cfg(i, NULL);
|
2022-11-27 00:15:14 +00:00
|
|
|
if (ACTIVITY_REFRESH_NOW == refresh)
|
|
|
|
|
skin_update(CUSTOM_STATUSBAR, i, SKIN_REFRESH_ALL);
|
2014-01-15 17:57:46 +00:00
|
|
|
}
|
2022-12-14 08:06:04 +00:00
|
|
|
#endif
|
2011-06-01 14:41:49 +00:00
|
|
|
}
|
2022-12-14 08:06:04 +00:00
|
|
|
|
|
|
|
|
void pop_current_activity_without_refresh(void)
|
|
|
|
|
{
|
|
|
|
|
pop_current_activity_refresh(false);
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-01 14:41:49 +00:00
|
|
|
enum current_activity get_current_activity(void)
|
|
|
|
|
{
|
|
|
|
|
return current_activity[current_activity_top?current_activity_top-1:0];
|
|
|
|
|
}
|
2014-01-15 21:39:51 +00:00
|
|
|
|
2022-12-20 02:12:07 +00:00
|
|
|
/* core_load_bmp opens bitmp filename and allocates space for it
|
|
|
|
|
* you must set bm->data with the result from core_get_data(handle)
|
|
|
|
|
* you must also call core_free(handle) when finished with the bitmap
|
|
|
|
|
* returns handle, ALOC_ERR(0) on failure
|
|
|
|
|
* ** Extended error info truth table **
|
|
|
|
|
* [ Handle ][buf_reqd]
|
|
|
|
|
* [ > 0 ][ > 0 ] buf_reqd indicates how many bytes were used
|
|
|
|
|
* [ALOC_ERR][ > 0 ] buf_reqd indicates how many bytes are needed
|
|
|
|
|
* [ALOC_ERR][READ_ERR] there was an error reading the file or it is empty
|
|
|
|
|
*/
|
|
|
|
|
int core_load_bmp(const char * filename, struct bitmap *bm, const int bmformat,
|
|
|
|
|
ssize_t *buf_reqd, struct buflib_callbacks *ops)
|
|
|
|
|
{
|
|
|
|
|
ssize_t buf_size;
|
|
|
|
|
ssize_t size_read = 0;
|
|
|
|
|
int handle = CLB_ALOC_ERR;
|
|
|
|
|
|
|
|
|
|
int fd = open(filename, O_RDONLY);
|
|
|
|
|
*buf_reqd = CLB_READ_ERR;
|
|
|
|
|
|
|
|
|
|
if (fd < 0) /* Exit if file opening failed */
|
|
|
|
|
{
|
|
|
|
|
DEBUGF("read_bmp_file: can't open '%s', rc: %d\n", filename, fd);
|
|
|
|
|
return CLB_ALOC_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
buf_size = read_bmp_fd(fd, bm, 0, bmformat|FORMAT_RETURN_SIZE, NULL);
|
|
|
|
|
|
|
|
|
|
if (buf_size > 0)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
handle = core_alloc_ex(filename, (size_t) buf_size, ops);
|
|
|
|
|
|
|
|
|
|
if (handle > 0)
|
|
|
|
|
{
|
|
|
|
|
core_pin(handle);
|
|
|
|
|
bm->data = core_get_data(handle);
|
|
|
|
|
lseek(fd, 0, SEEK_SET); /* reset to beginning of file */
|
|
|
|
|
size_read = read_bmp_fd(fd, bm, buf_size, bmformat, NULL);
|
|
|
|
|
|
|
|
|
|
if (size_read > 0) /* free unused alpha channel, if any */
|
|
|
|
|
{
|
|
|
|
|
core_shrink(handle, bm->data, size_read);
|
|
|
|
|
*buf_reqd = size_read;
|
|
|
|
|
}
|
|
|
|
|
bm->data = NULL; /* do this to force a crash later if the
|
|
|
|
|
caller doesnt call core_get_data() */
|
|
|
|
|
core_unpin(handle);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*buf_reqd = buf_size; /* couldn't allocate pass bytes needed */
|
|
|
|
|
|
|
|
|
|
if (size_read <= 0)
|
|
|
|
|
{
|
|
|
|
|
/* error reading file */
|
|
|
|
|
core_free(handle); /* core_free() ignores free handles (<= 0) */
|
|
|
|
|
handle = CLB_ALOC_ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
|
return handle;
|
|
|
|
|
}
|
|
|
|
|
#endif /* ndef __PCTOOL__ */
|