rockbox - My Rockbox tree

diff options

author	Michael Sevakis <jethead71@rockbox.org>	2017-12-15 21:46:30 -0500
committer	Michael Sevakis <jethead71@rockbox.org>	2017-12-15 22:39:46 -0500
commit	02d20ebc25e90914528c6af712f27c5424b863a4 (patch)
tree	498d3e1972688d6cc0cba0190bd1dd1f45dc2d68 /utils/themeeditor/gui/editorwindow.cpp
parent	c8564f1ca8287eba9220df191d13c949bb49c8ce (diff)
download	rockbox-02d20ebc25e90914528c6af712f27c5424b863a4.zip rockbox-02d20ebc25e90914528c6af712f27c5424b863a4.tar.gz rockbox-02d20ebc25e90914528c6af712f27c5424b863a4.tar.bz2 rockbox-02d20ebc25e90914528c6af712f27c5424b863a4.tar.xz

Fix big WTF when closing the current track.

It must be set to something else valid (unless it's the only one left) when closing it, IN ALL CASES, not just if it's first or last. Don't know what was in my head. Hopefully takes care of a reported issue. Even if it's not causing any issues, it was still incorrect. Change-Id: I594af8b35d774ec222dadce80dfa8b95138f037e

Diffstat (limited to 'utils/themeeditor/gui/editorwindow.cpp')

0 files changed, 0 insertions, 0 deletions

/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Greyscale framework * Drawing functions * * This is a generic framework to display up to 33 shades of grey * on low-depth bitmap LCDs (Archos b&w, Iriver 4-grey) within plugins. * * Copyright (C) 2004-2006 Jens Arnold * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ #include "plugin.h" #ifdef HAVE_LCD_BITMAP #include "gray.h" /*** low-level drawing functions ***/ static void setpixel(unsigned char *address) { *address = _gray_info.fg_brightness; } static void clearpixel(unsigned char *address) { *address = _gray_info.bg_brightness; } static void flippixel(unsigned char *address) { *address = _gray_info.depth - *address; } static void nopixel(unsigned char *address) { (void)address; } void (* const _gray_pixelfuncs[8])(unsigned char *address) = { flippixel, nopixel, setpixel, setpixel, nopixel, clearpixel, nopixel, clearpixel }; /*** Drawing functions ***/ /* Clear the whole display */ void gray_clear_display(void) { int brightness = (_gray_info.drawmode & DRMODE_INVERSEVID) ? _gray_info.fg_brightness : _gray_info.bg_brightness; _gray_rb->memset(_gray_info.cur_buffer, brightness, MULU16(_gray_info.width, _gray_info.height)); } /* Set a single pixel */ void gray_drawpixel(int x, int y) { if (((unsigned)x < (unsigned)_gray_info.width) && ((unsigned)y < (unsigned)_gray_info.height)) _gray_pixelfuncs[_gray_info.drawmode](&_gray_info.cur_buffer[MULU16(x, _gray_info.height) + y]); } /* Draw a line */ void gray_drawline(int x1, int y1, int x2, int y2) { int numpixels; int i; int deltax, deltay; int d, dinc1, dinc2; int x, xinc1, xinc2; int y, yinc1, yinc2; void (*pfunc)(unsigned char *address) = _gray_pixelfuncs[_gray_info.drawmode]; deltax = abs(x2 - x1); deltay = abs(y2 - y1); xinc2 = 1; yinc2 = 1; if (deltax >= deltay) { numpixels = deltax; d = 2 * deltay - deltax; dinc1 = deltay * 2; dinc2 = (deltay - deltax) * 2; xinc1 = 1; yinc1 = 0; } else { numpixels = deltay; d = 2 * deltax - deltay; dinc1 = deltax * 2; dinc2 = (deltax - deltay) * 2; xinc1 = 0; yinc1 = 1; } numpixels++; /* include endpoints */ if (x1 > x2) { xinc1 = -xinc1; xinc2 = -xinc2; } if (y1 > y2) { yinc1 = -yinc1; yinc2 = -yinc2; } x = x1; y = y1; for (i = 0; i < numpixels; i++) { if (((unsigned)x < (unsigned)_gray_info.width) && ((unsigned)y < (unsigned)_gray_info.height)) pfunc(&_gray_info.cur_buffer[MULU16(x, _gray_info.height) + y]); if (d < 0) { d += dinc1; x += xinc1; y += yinc1; } else { d += dinc2; x += xinc2; y += yinc2; } } } /* Draw a horizontal line (optimised) */ void gray_hline(int x1, int x2, int y) { int x; unsigned char *dst, *dst_end; void (*pfunc)(unsigned char *address); /* direction flip */ if (x2 < x1) { x = x1; x1 = x2; x2 = x; } /* nothing to draw? */ if (((unsigned)y >= (unsigned)_gray_info.height) || (x1 >= _gray_info.width) || (x2 < 0)) return; /* clipping */ if (x1 < 0) x1 = 0; if (x2 >= _gray_info.width) x2 = _gray_info.width - 1; pfunc = _gray_pixelfuncs[_gray_info.drawmode]; dst = &_gray_info.cur_buffer[MULU16(x1, _gray_info.height) + y]; dst_end = dst + MULU16(x2 - x1, _gray_info.height); do { pfunc(dst); dst += _gray_info.height; } while (dst <= dst_end); } /* Draw a vertical line (optimised) */ void gray_vline(int x, int y1, int y2) { int y; int bits = 0; unsigned char *dst; bool fillopt = false; void (*pfunc)(unsigned char *address); /* direction flip */ if (y2 < y1) { y = y1; y1 = y2; y2 = y; } /* nothing to draw? */ if (((unsigned)x >= (unsigned)_gray_info.width) || (y1 >= _gray_info.height) || (y2 < 0)) return; /* clipping */ if (y1 < 0) y1 = 0; if (y2 >= _gray_info.height) y2 = _gray_info.height - 1; if (_gray_info.drawmode & DRMODE_INVERSEVID) { if (_gray_info.drawmode & DRMODE_BG) { fillopt = true; bits = _gray_info.bg_brightness; } } else { if (_gray_info.drawmode & DRMODE_FG) { fillopt = true; bits = _gray_info.fg_brightness; } } pfunc = _gray_pixelfuncs[_gray_info.drawmode]; dst = &_gray_info.cur_buffer[MULU16(x, _gray_info.height) + y1]; if (fillopt) _gray_rb->memset(dst, bits, y2 - y1 + 1); else { unsigned char *dst_end = dst + y2 - y1; do pfunc(dst++); while (dst <= dst_end); } } /* Draw a rectangular box */ void gray_drawrect(int x, int y, int width, int height) { if ((width <= 0) || (height <= 0)) return; int x2 = x + width - 1; int y2 = y + height - 1; gray_vline(x, y, y2); gray_vline(x2, y, y2); gray_hline(x, x2, y); gray_hline(x, x2, y2); } /* Fill a rectangular area */ void gray_fillrect(int x, int y, int width, int height) { int bits = 0; unsigned char *dst, *dst_end; bool fillopt = false; void (*pfunc)(unsigned char *address); /* nothing to draw? */ if ((width <= 0) || (height <= 0) || (x >= _gray_info.width) || (y >= _gray_info.height) || (x + width <= 0) || (y + height <= 0)) return; /* clipping */ if (x < 0) { width += x; x = 0; } if (y < 0) { height += y; y = 0; } if (x + width > _gray_info.width) width = _gray_info.width - x; if (y + height > _gray_info.height) height = _gray_info.height - y; if (_gray_info.drawmode & DRMODE_INVERSEVID) { if (_gray_info.drawmode & DRMODE_BG) { fillopt = true; bits = _gray_info.bg_brightness; } } else { if (_gray_info.drawmode & DRMODE_FG) { fillopt = true; bits = _gray_info.fg_brightness; } } pfunc = _gray_pixelfuncs[_gray_info.drawmode]; dst = &_gray_info.cur_buffer[MULU16(x, _gray_info.height) + y]; dst_end = dst + MULU16(width, _gray_info.height); do { if (fillopt) _gray_rb->memset(dst, bits, height); else { unsigned char *dst_col = dst; unsigned char *col_end = dst_col + height; do pfunc(dst_col++); while (dst_col < col_end); } dst += _gray_info.height; } while (dst < dst_end); } /* Draw a filled triangle */ void gray_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3) { int x, y; long fp_y1, fp_y2, fp_dy1, fp_dy2; /* sort vertices by increasing x value */ if (x1 > x3) { if (x2 < x3) /* x2 < x3 < x1 */ { x = x1; x1 = x2; x2 = x3; x3 = x; y = y1; y1 = y2; y2 = y3; y3 = y; } else if (x2 > x1) /* x3 < x1 < x2 */ { x = x1; x1 = x3; x3 = x2; x2 = x; y = y1; y1 = y3; y3 = y2; y2 = y; } else /* x3 <= x2 <= x1 */ { x = x1; x1 = x3; x3 = x; y = y1; y1 = y3; y3 = y; } } else { if (x2 < x1) /* x2 < x1 <= x3 */ { x = x1; x1 = x2; x2 = x; y = y1; y1 = y2; y2 = y; } else if (x2 > x3) /* x1 <= x3 < x2 */ { x = x2; x2 = x3; x3 = x; y = y2; y2 = y3; y3 = y; } /* else already sorted */ } if (x1 < x3) /* draw */ { fp_dy1 = ((y3 - y1) << 16) / (x3 - x1); fp_y1 = (y1 << 16) + (1<<15) + (fp_dy1 >> 1); if (x1 < x2) /* first part */ { fp_dy2 = ((y2 - y1) << 16) / (x2 - x1); fp_y2 = (y1 << 16) + (1<<15) + (fp_dy2 >> 1); for (x = x1; x < x2; x++) { gray_vline(x, fp_y1 >> 16, fp_y2 >> 16); fp_y1 += fp_dy1; fp_y2 += fp_dy2; } } if (x2 < x3) /* second part */ { fp_dy2 = ((y3 - y2) << 16) / (x3 - x2); fp_y2 = (y2 << 16) + (1<<15) + (fp_dy2 >> 1); for (x = x2; x < x3; x++) { gray_vline(x, fp_y1 >> 16, fp_y2 >> 16); fp_y1 += fp_dy1; fp_y2 += fp_dy2; } } } } /* About Rockbox' internal monochrome bitmap format: * * A bitmap contains one bit for every pixel that defines if that pixel is * foreground (1) or background (0). Bits within a byte are arranged * vertically, LSB at top. * The bytes are stored in row-major order, with byte 0 being top left, * byte 1 2nd from left etc. The first row of bytes defines pixel rows * 0..7, the second row defines pixel row 8..15 etc. * * This is similar to the internal lcd hw format. */ /* Draw a partial monochrome bitmap */ void gray_mono_bitmap_part(const unsigned char *src, int src_x, int src_y, int stride, int x, int y, int width, int height) { const unsigned char *src_end; unsigned char *dst, *dst_end; void (*fgfunc)(unsigned char *address); void (*bgfunc)(unsigned char *address); /* nothing to draw? */ if ((width <= 0) || (height <= 0) || (x >= _gray_info.width) || (y >= _gray_info.height) || (x + width <= 0) || (y + height <= 0)) return; /* clipping */ if (x < 0) { width += x; src_x -= x; x = 0; } if (y < 0) { height += y; src_y -= y; y = 0; } if (x + width > _gray_info.width) width = _gray_info.width - x; if (y + height > _gray_info.height) height = _gray_info.height - y; src += MULU16(stride, src_y >> 3) + src_x; /* move starting point */ src_y &= 7; src_end = src + width; dst = &_gray_info.cur_buffer[MULU16(x, _gray_info.height) + y]; fgfunc = _gray_pixelfuncs[_gray_info.drawmode]; bgfunc = _gray_pixelfuncs[_gray_info.drawmode ^ DRMODE_INVERSEVID]; do { const unsigned char *src_col = src++; unsigned char *dst_col = dst; unsigned data = *src_col >> src_y; int numbits = 8 - src_y; dst_end = dst_col + height; do { if (data & 0x01) fgfunc(dst_col++); else bgfunc(dst_col++); data >>= 1; if (--numbits == 0) { src_col += stride; data = *src_col; numbits = 8; } } while (dst_col < dst_end); dst += _gray_info.height; } while (src < src_end); } /* Draw a full monochrome bitmap */ void gray_mono_bitmap(const unsigned char *src, int x, int y, int width, int height) { gray_mono_bitmap_part(src, 0, 0, width, x, y, width, height); } /* Draw a partial greyscale bitmap, canonical format */ void gray_gray_bitmap_part(const unsigned char *src, int src_x, int src_y, int stride, int x, int y, int width, int height) { const unsigned char *src_end; unsigned char *dst, *dst_end; /* nothing to draw? */ if ((width <= 0) || (height <= 0) || (x >= _gray_info.width) || (y >= _gray_info.height) || (x + width <= 0) || (y + height <= 0)) return; /* clipping */ if (x < 0) { width += x; src_x -= x; x = 0; } if (y < 0) { height += y; src_y -= y; y = 0; } if (x + width > _gray_info.width) width = _gray_info.width - x; if (y + height > _gray_info.height) height = _gray_info.height - y; src += MULU16(stride, src_y) + src_x; /* move starting point */ src_end = src + width; dst = &_gray_info.cur_buffer[MULU16(x, _gray_info.height) + y]; do { const unsigned char *src_col = src++; unsigned char *dst_col = dst; dst_end = dst_col + height; do { unsigned data = MULU16(_gray_info.depth, *src_col) + 127; *dst_col++ = (data + (data >> 8)) >> 8; /* approx. data / 255 */ src_col += stride; } while (dst_col < dst_end); dst += _gray_info.height; } while (src < src_end); } /* Draw a full greyscale bitmap, canonical format */ void gray_gray_bitmap(const unsigned char *src, int x, int y, int width, int height) { gray_gray_bitmap_part(src, 0, 0, width, x, y, width, height); } /* Put a string at a given pixel position, skipping first ofs pixel columns */ void gray_putsxyofs(int x, int y, int ofs, const unsigned char *str) { int ch; struct font* pf = _gray_rb->font_get(_gray_info.curfont); while ((ch = *str++) != '\0' && x < _gray_info.width) { int width; const unsigned char *bits; /* check input range */ if (ch < pf->firstchar || ch >= pf->firstchar+pf->size) ch = pf->defaultchar; ch -= pf->firstchar; /* get proportional width and glyph bits */ width = pf->width ? pf->width[ch] : pf->maxwidth; if (ofs > width) { ofs -= width; continue; } bits = pf->bits + (pf->offset ? pf->offset[ch] : ((pf->height + 7) / 8 * pf->maxwidth * ch)); gray_mono_bitmap_part(bits, ofs, 0, width, x, y, width - ofs, pf->height); x += width - ofs; ofs = 0; } } /* Put a string at a given pixel position */ void gray_putsxy(int x, int y, const unsigned char *str) { gray_putsxyofs(x, y, 0, str); } /*** Unbuffered drawing functions ***/ #ifdef SIMULATOR /* Clear the greyscale display (sets all pixels to white) */ void gray_ub_clear_display(void) { _gray_rb->memset(_gray_info.cur_buffer, _gray_info.depth, MULU16(_gray_info.width, _gray_info.height)); gray_update(); } /* Draw a partial greyscale bitmap, canonical format */ void gray_ub_gray_bitmap_part(const unsigned char *src, int src_x, int src_y, int stride, int x, int y, int width, int height) { gray_gray_bitmap_part(src, src_x, src_y, stride, x, y, width, height); gray_update_rect(x, y, width, height); } #else /* !SIMULATOR */ /* Clear the greyscale display (sets all pixels to white) */ void gray_ub_clear_display(void) { _gray_rb->memset(_gray_info.plane_data, 0, MULU16(_gray_info.depth, _gray_info.plane_size)); } /* Write a pixel block, defined by their brightnesses in a greymap. Address is the byte in the first bitplane, src is the greymap start address, stride is the increment for the greymap to get to the next pixel, mask determines which pixels of the destination block are changed. */ static void _writearray(unsigned char *address, const unsigned char *src, int stride, unsigned mask) { #if (CONFIG_CPU == SH7034) && (LCD_DEPTH == 1)


context:
space:
mode: