Aksal/nuttx-apps
1
0
Fork 1
mirror of https://github.com/apache/nuttx-apps.git synced 2026-08-09 22:45:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add NxWdigets::CGlyphSliderHorizontal and associated grip widgets. From Ken Pettit.

Browse source
This commit is contained in:
Gregory Nutt 2013-05-15 16:45:57 -06:00
parent e067c9337a
commit 4e5c8e97e8
13 changed files with 1748 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

2
ChangeLog.txt
View file

@ -360,3 +360,5 @@
2013-5-12).
* Kconfig: Default priorities for NxWidget and NxWM threads
should be 100, not 50, to be consistent with other default priorities.
* NxWidgets::CGlyphSliderHorizontal and NxWidgets::CGlyphSliderHorizontalGrip:
New widgets added by Ken Pettit (2013-5-15).

8
UnitTests/nxwm/nxwm_main.cxx
View file

@ -574,8 +574,8 @@ static bool createMediaPlayer(void)
// Add the hex calculator application to the start window
printf("createHexCalculator: Creating the hex calculator application\n");
NxWM::CMediaPlayerFactory *calculator = new NxWM::CMediaPlayerFactory(g_nxwmtest.taskbar);
if (!calculator)
NxWM::CMediaPlayerFactory *mediaplayer = new NxWM::CMediaPlayerFactory(g_nxwmtest.taskbar);
if (!mediaplayer)
{
printf("createMediaPlayer: ERROR: Failed to instantiate CMediaPlayerFactory\n");
return false;
@ -583,10 +583,10 @@ static bool createMediaPlayer(void)
showTestCaseMemory("createMediaPlayer: After creating the media player application");
printf("createMediaPlayer: Adding the hex calculator application to the start window\n");
if (!g_nxwmtest.startwindow->addApplication(calculator))
if (!g_nxwmtest.startwindow->addApplication(mediaplayer))
{
printf("createMediaPlayer: ERROR: Failed to add CNxConsoleFactory to the start window\n");
delete calculator;
delete mediaplayer;
return false;
}

3
libnxwidgets/Makefile
View file

@ -56,7 +56,8 @@ CXXSRCS += cstringiterator.cxx ctext.cxx cwidgetcontrol.cxx cwidgeteventhandler
CXXSRCS += cwindoweventhandlerlist.cxx singletons.cxx
# Widget APIs
CXXSRCS += cbutton.cxx cbuttonarray.cxx ccheckbox.cxx ccyclebutton.cxx
CXXSRCS += cglyphbutton.cxx cimage.cxx ckeypad.cxx clabel.cxx clatchbutton.cxx
CXXSRCS += cglyphbutton.cxx cglyphsliderhorizontal.cxx cglyphsliderhorizontalgrip.cxx
CXXSRCS += cimage.cxx ckeypad.cxx clabel.cxx clatchbutton.cxx
CXXSRCS += clatchbuttonarray.cxx clistbox.cxx clistboxdataitem.cxx cmultilinetextbox.cxx
CXXSRCS += cnumericedit.cxx
CXXSRCS += cprogressbar.cxx cradiobutton.cxx cradiobuttongroup.cxx cscrollbarhorizontal.cxx

336
libnxwidgets/include/cglyphsliderhorizontal.hxx Normal file
View file

@ -0,0 +1,336 @@
/****************************************************************************
* NxWidgets/libnxwidgets/include/cglyphsliderhorizontal.hxx
*
* Copyright (C) 2013 Ken Pettit. All rights reserved.
* Author: Ken Pettit <pettitkd@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
* me be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************
*
* Portions of this package derive from Woopsi (http://woopsi.org/) and
* portions are original efforts. It is difficult to determine at this
* point what parts are original efforts and which parts derive from Woopsi.
* However, in any event, the work of Antony Dzeryn will be acknowledged
* in most NxWidget files. Thanks Antony!
*
* Copyright (c) 2007-2011, Antony Dzeryn
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the names "Woopsi", "Simian Zombie" nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Antony Dzeryn ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Antony Dzeryn BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_CGLYPHSLIDERHORIZONTAL_HXX
#define __INCLUDE_CGLYPHSLIDERHORIZONTAL_HXX
/****************************************************************************
* Included Files
****************************************************************************/
#include "csliderhorizontal.hxx"
#include "cglyphsliderhorizontalgrip.hxx"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Implementation Classes
****************************************************************************/
#if defined(__cplusplus)
namespace NXWidgets
{
/**
* Widget providing a sliding "grip" that can be moved left and
* right in the "gutter". Essentially a scrollbar, but more
* generic.
*/
class CGlyphSliderHorizontal : public ISlider, public CNxWidget, public CWidgetEventHandler
{
protected:
CGlyphSliderHorizontalGrip *m_grip; /**< Pointer to the grip. */
nxgl_coord_t m_minimumValue; /**< Minimum value that the grip can represent. */
nxgl_coord_t m_maximumValue; /**< Maximum value that the grip can represent. */
int32_t m_value; /**< Current value of the slider. */
nxgl_coord_t m_minimumGripWidth; /**< Smallest width that the grip can become */
nxgl_coord_t m_pageSize; /**< Value of a page of data, used when clicking
the gutter. */
int32_t m_gutterWidth; /**< Width of the gutter, taking into account
any adjustments made to the width of the grip. */
uint32_t m_contentSize; /**< Number of values in the min/max range. */
nxwidget_pixel_t m_fillColor; /**< Fill color for left side of "fuel gague" */
bool m_fill; /**< Set true if fill is active */
uint32_t m_barThickness; /**< Thickness (in pixels) of the bar */
/**
* Get the maximum possible value that the slider can represent. Useful when
* using the slider as a scrollbar, as the height of the grip prevents the full
* range of values being accessed (intentionally).
* The returned value is bitshfted left 16 places for more accuracy in fixed-point
* calculations.
*
* @return The maximum possible value that the slider can represent.
*/
int32_t getPhysicalMaximumValueWithBitshift(void) const;
/**
* Get the value represented by the top of the grip.
* return The value represented by the top of the grip.
*/
const int32_t getGripValue(void) const;
/**
* Draw the area of this widget that falls within the clipping region.
* Called by the redraw() function to draw all visible regions.
*
* @param port The CGraphicsPort to draw to.
* @see redraw()
*/
virtual void drawContents(CGraphicsPort *port);
/**
* Draw the area of this widget that falls within the clipping region.
* Called by the redraw() function to draw all visible regions.
*
* @param port The CGraphicsPort to draw to.
* @see redraw()
*/
virtual void drawBorder(CGraphicsPort *port);
/**
* Resize the slider to the new dimensions.
*
* @param width The new width.
* @param height The new height.
*/
virtual void onResize(nxgl_coord_t width, nxgl_coord_t height);
/**
* Moves the grip towards the mouse.
*
* @param x The x coordinate of the click.
* @param y The y coordinate of the click.
*/
virtual void onClick(nxgl_coord_t x, nxgl_coord_t y);
public:
/**
* Constructor.
*
* @param pWidgetControl The widget control instance for the window.
* @param x The x coordinate of the slider, relative to its parent.
* @param y The y coordinate of the slider, relative to its parent.
* @param width The width of the slider.
* @param height The height of the slider.
*/
CGlyphSliderHorizontal(CWidgetControl *pWidgetControl,
nxgl_coord_t x, nxgl_coord_t y, nxgl_coord_t width,
nxgl_coord_t height, IBitmap *pGripBitmap,
nxwidget_pixel_t fillColor, bool fill = true);
/**
* Destructor.
*/
virtual inline ~CGlyphSliderHorizontal(void) { }
/**
* Get the smallest value that the slider can represent.
*
* @return The smallest value.
*/
inline const nxgl_coord_t getMinimumValue(void) const
{
return m_minimumValue;
}
/**
* Get the largest value that the slider can represent.
*
* @return The largest value.
*/
inline const nxgl_coord_t getMaximumValue(void) const
{
return m_maximumValue;
}
/**
* Get the current value of the slider.
*
* return The current slider value.
*/
inline const nxgl_coord_t getValue(void) const
{
return m_value >> 16;
}
/**
* Get the value represented by the height of the grip.
* For sliders, this would typically be 1 (so each new
* grip position is worth 1). For scrollbars, this
* would be the height of the scrolling widget.
*
* @return The page size.
*/
inline const nxgl_coord_t getPageSize(void) const
{
return m_pageSize;
}
/**
* Set the smallest value that the slider can represent.
*
* @param value The smallest value.
*/
inline void setMinimumValue(const nxgl_coord_t value)
{
m_minimumValue = value;
m_contentSize = m_maximumValue - m_minimumValue + 1;
//resizeGrip();
};
/**
* Set the largest value that the slider can represent.
*
* @param value The largest value.
*/
inline void setMaximumValue(const nxgl_coord_t value)
{
m_maximumValue = value;
m_contentSize = m_maximumValue - m_minimumValue + 1;
//resizeGrip();
};
/**
* Set the value that of the slider. This will reposition
* and redraw the grip.
*
* @param value The new value.
*/
void setValue(const nxgl_coord_t value);
/**
* Set the value that of the slider. This will reposition and redraw
* the grip. The supplied value should be bitshifted left 16 places.
* This ensures greater accuracy than the standard setValue() method if
* the slider is being used as a scrollbar.
*
* @param value The new value.
*/
void setValueWithBitshift(const int32_t value);
/**
* Set the page size represented by the grip.
*
* @param pageSize The page size.
* @see getPageSize().
*/
inline void setPageSize(const nxgl_coord_t pageSize)
{
m_pageSize = pageSize;
//resizeGrip();
};
/**
* Set the thickness of the slider bar
*
* @param thickness The slider bar thickness in pixels
*/
inline void setBarThickness(const nxgl_coord_t thickness)
{
m_barThickness = thickness;
redraw();
};
/**
* Process events fired by the grip.
*
* @param e The event details.
*/
virtual void handleDragEvent(const CWidgetEventArgs &e);
/**
* Get the smallest value that the slider can move through when
* dragged.
*
* @return The smallest value that the slider can move through when
* dragged.
*/
nxgl_coord_t getMinimumStep(void) const;
};
}
#endif // __cplusplus
#endif // __INCLUDE_CGLYPHSLIDERHORIZONTAL_HXX

206
libnxwidgets/include/cglyphsliderhorizontalgrip.hxx Normal file
View file

@ -0,0 +1,206 @@
/****************************************************************************
* NxWidgets/libnxwidgets/include/cglyphsliderhorizontalgrip.hxx
*
* Copyright (C) 2012 Ken Pettit. All rights reserved.
* Author: Ken Pettit <pettitkd@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
* me be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************
*
* Portions of this package derive from Woopsi (http://woopsi.org/) and
* portions are original efforts. It is difficult to determine at this
* point what parts are original efforts and which parts derive from Woopsi.
* However, in any event, the work of Antony Dzeryn will be acknowledged
* in most NxWidget files. Thanks Antony!
*
* Copyright (c) 2007-2011, Antony Dzeryn
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the names "Woopsi", "Simian Zombie" nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Antony Dzeryn ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Antony Dzeryn BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_CGLYPHSLIDERHORIZONTALGRIP_HXX
#define __INCLUDE_CGLYPHSLIDERHORIZONTALGRIP_HXX
/****************************************************************************
* Included Files
****************************************************************************/
#include "csliderhorizontalgrip.hxx"
#include "cimage.hxx"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Implementation Classes
****************************************************************************/
#if defined(__cplusplus)
namespace NXWidgets
{
class IBitmap;
/**
* Class representing the grip, or draggable button, with a horizontal
* slider.
*/
class CGlyphSliderHorizontalGrip : public CImage
{
protected:
/**
* The CImage to represent the grip.
*/
//CImage* m_pImage;
/**
* Draw the area of this widget that falls within the clipping region.
* Called by the redraw() function to draw all visible regions.
*
* @param port The CGraphicsPort to draw to.
* @see redraw()
*/
//virtual void drawContents(CGraphicsPort *port);
/**
* Draw the area of this widget that falls within the clipping region.
* Called by the redraw() function to draw all visible regions.
*
* @param port The CGraphicsPort to draw to.
* @see redraw()
*/
//virtual void drawBorder(CGraphicsPort *port);
/**
* Resize the slider to the new dimensions.
*
* @param width The new width.
* @param height The new height.
*/
virtual void onResize(nxgl_coord_t width, nxgl_coord_t height);
/**
* Starts dragging the grip and redraws it.
*
* @param x The x coordinate of the click.
* @param y The y coordinate of the click.
*/
virtual void onClick(nxgl_coord_t x, nxgl_coord_t y);
/**
* Redraws the grip.
*
* @param x The x coordinate of the mouse.
* @param y The y coordinate of the mouse.
*/
virtual void onRelease(nxgl_coord_t x, nxgl_coord_t y);
/**
* Redraws the grip.
*
* @param x The x coordinate of the mouse.
* @param y The y coordinate of the mouse.
*/
virtual void onReleaseOutside(nxgl_coord_t x, nxgl_coord_t y);
/**
* Moves the grip to follow the mouse.
*
* @param x The x coordinate of the mouse.
* @param y The y coordinate of the mouse.
* @param vX The horizontal distance of the drag.
* @param vY The vertical distance of the drag.
*/
virtual void onDrag(nxgl_coord_t x, nxgl_coord_t y,
nxgl_coord_t vX, nxgl_coord_t vY);
public:
/**
* Constructor.
*
* @param pWidgetControl The controlling widget for the display
* @param x The x coordinate of the grip, relative to its parent.
* @param y The y coordinate of the grip, relative to its parent.
* @param width The width of the grip.
* @param height The height of the grip.
*/
CGlyphSliderHorizontalGrip(CWidgetControl *pWidgetControl,
nxgl_coord_t x, nxgl_coord_t y,
nxgl_coord_t width, nxgl_coord_t height,
IBitmap *pGripBitmap);
/**
* Destructor.
*/
virtual inline ~CGlyphSliderHorizontalGrip(void) { }
};
}
#endif // __cplusplus
#endif // __INCLUDE_CGLYPHSLIDERHORIZONTALGRIP_HXX

503
libnxwidgets/src/cglyphsliderhorizontal.cxx Normal file
View file

@ -0,0 +1,503 @@
/****************************************************************************
* NxWidgets/libnxwidgets/src/cglyphsliderhorizontal.cxx
*
* Copyright (C) 2013 Ken Pettit. All rights reserved.
* Author: Ken Pettit <pettitkd@gmail.com>
*
* Based on and copied from csliderhorizontal.cxx written by Gregory Nutt
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
* me be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************
*
* Portions of this package derive from Woopsi (http://woopsi.org/) and
* portions are original efforts. It is difficult to determine at this
* point what parts are original efforts and which parts derive from Woopsi.
* However, in any event, the work of Antony Dzeryn will be acknowledged
* in most NxWidget files. Thanks Antony!
*
* Copyright (c) 2007-2011, Antony Dzeryn
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the names "Woopsi", "Simian Zombie" nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Antony Dzeryn ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Antony Dzeryn BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <stdbool.h>
#include "cwidgetcontrol.hxx"
#include "cglyphsliderhorizontal.hxx"
#include "cglyphsliderhorizontalgrip.hxx"
#include "cimage.hxx"
#include "cgraphicsport.hxx"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Method Implementations
****************************************************************************/
using namespace NXWidgets;
/**
* Constructor.
*
* @param pWidgetControl The controlling widget for the display
* @param x The x coordinate of the slider, relative to its parent.
* @param y The y coordinate of the slider, relative to its parent.
* @param width The width of the slider.
* @param height The height of the slider.
*/
CGlyphSliderHorizontal::CGlyphSliderHorizontal(CWidgetControl * pWidgetControl,
nxgl_coord_t x, nxgl_coord_t y,
nxgl_coord_t width, nxgl_coord_t height,
IBitmap * pGripBitmap,
nxwidget_pixel_t fillColor, bool fill)
:CNxWidget(pWidgetControl, x, y, width, height, WIDGET_DRAGGABLE)
{
m_minimumValue = 0;
m_maximumValue = 0;
m_contentSize = 0;
m_value = 0;
m_minimumGripWidth = 10;
m_pageSize = 1;
m_fillColor = fillColor;
m_fill = fill;
m_barThickness = 8;
m_flags.permeable = false;
m_flags.borderless = false;
m_flags.doubleClickable = false;
// Create grip
CRect rect;
getClientRect(rect);
m_gutterWidth = rect.getWidth();
// Create grip
m_grip = new CGlyphSliderHorizontalGrip(pWidgetControl, x, y,
width, height, pGripBitmap);
m_grip->setBorderless(true);
m_grip->addWidgetEventHandler(this);
addWidget(m_grip);
}
/**
* Set the value that of the slider. This will reposition
* and redraw the grip.
*
* @param value The new value.
*/
void CGlyphSliderHorizontal::setValue(const nxgl_coord_t value)
{
setValueWithBitshift((int32_t) value << 16);
}
/**
* Set the value that of the slider. This will reposition and redraw
* the grip. The supplied value should be bitshifted left 16 places.
* This ensures greater accuracy than the standard setValue() method if
* the slider is being used as a scrollbar.
*
* @param value The new value.
*/
void CGlyphSliderHorizontal::setValueWithBitshift(const int32_t value)
{
CRect rect;
getClientRect(rect);
// Can the grip move?
if ((rect.getWidth() > m_grip->getWidth()) &&
(m_maximumValue != m_minimumValue))
{
int32_t newValue = value;
int32_t maxValue = getPhysicalMaximumValueWithBitshift();
// Limit to max/min values
if (newValue > maxValue)
{
newValue = maxValue;
}
if (newValue >> 16 < m_minimumValue)
{
newValue = m_minimumValue << 16;
}
uint32_t scrollRatio = newValue / m_contentSize;
int32_t newGripX = m_gutterWidth * scrollRatio;
newGripX += newGripX & 0x8000;
newGripX >>= 16;
newGripX += rect.getX();
m_grip->moveTo(newGripX, (rect.getHeight() - m_grip->getHeight()) >> 1);
// Update stored value if necessary
if (m_value != newValue)
{
m_value = newValue;
m_widgetEventHandlers->raiseValueChangeEvent();
}
}
}
/**
* Process events fired by the grip.
*
* @param e The event details.
*/
void CGlyphSliderHorizontal::handleDragEvent(const CWidgetEventArgs & e)
{
// Handle grip events
if ((e.getSource() == m_grip) && (e.getSource() != NULL))
{
int32_t newValue = getGripValue() >> 16;
// Grip has moved - compare values and raise event if the
// value has changed. Compare using integer values rather
// than fixed-point.
if (m_value >> 16 != newValue)
{
m_value = newValue << 16;
m_widgetEventHandlers->raiseValueChangeEvent();
}
}
}
/**
* Get the smallest value that the slider can move through when
* dragged.
*
* @return The smallest value that the slider can move through when
* dragged.
*/
nxgl_coord_t CGlyphSliderHorizontal::getMinimumStep(void) const
{
// If the ratio of content to gutter is greater than or equal to one,
// the minimum step that the slider can represent will be that ratio.
uint32_t gutterRatio = m_contentSize << 16 / m_gutterWidth;
gutterRatio += gutterRatio & 0x8000;
gutterRatio >>= 16;
if (gutterRatio > 0)
{
return gutterRatio;
}
return 1;
}
/**
* Get the maximum possible value that the slider can represent. Useful when
* using the slider as a scrollbar, as the height of the grip prevents the full
* range of values being accessed (intentionally).
* The returned value is bitshfted left 16 places for more accuracy in fixed-point
* calculations.
*
* @return The maximum possible value that the slider can represent.
*/
int32_t CGlyphSliderHorizontal::getPhysicalMaximumValueWithBitshift(void) const
{
uint32_t maxX = m_gutterWidth - m_grip->getWidth();
uint32_t scrollRatio = (maxX << 16) / m_gutterWidth;
int32_t value = (scrollRatio * m_contentSize);
return value;
}
/**
* Get the value represented by the top of the grip.
* return The value represented by the top of the grip.
*/
const int32_t CGlyphSliderHorizontal::getGripValue(void) const
{
// Calculate the current value represented by the top of the grip
CRect rect;
getClientRect(rect);
uint32_t gripPos = ((m_grip->getX() - getX()) - rect.getX());
uint32_t scrollRatio = (gripPos << 16) / m_gutterWidth;
int32_t value = (scrollRatio * m_contentSize);
return value;
}
/**
* Draw the area of this widget that falls within the clipping region.
* Called by the redraw() function to draw all visible regions.
*
* @param port The CGraphicsPort to draw to.
* @see redraw()
*/
void CGlyphSliderHorizontal::drawContents(CGraphicsPort * port)
{
int halfGripWidth = m_grip->getWidth() >> 1;
int halfBar = m_barThickness >> 1;
int halfHeight = getHeight() >> 1;
int width;
nxwidget_pixel_t color;
// Fill in (erase) the region to the left and right of the fuel guage
width =
m_grip->getX() > halfGripWidth ? halfGripWidth : m_grip->getX() - getX();
port->drawFilledRect(getX(), getY(), width, getHeight(),
getBackgroundColor());
// Fill in (erase) the region above the "fuel gauge"
port->drawFilledRect(getX(), getY(), getWidth(), halfHeight - halfBar,
getBackgroundColor());
// Fill in the bar area to the left of the grip
if (m_fill)
color = m_fillColor;
else
color = getBackgroundColor();
if (m_grip->getX() > halfGripWidth)
port->drawFilledRect(getX() + 1 + halfGripWidth,
getY() + halfHeight - halfBar + 1,
m_grip->getX() - halfGripWidth, m_barThickness - 2,
color);
// Fill in bar the area to the right of the grip
width = getWidth() - (m_grip->getX() - getX() + m_grip->getWidth()) - 1 -
halfGripWidth;
if (width > 0)
port->drawFilledRect(m_grip->getX() + m_grip->getWidth(),
getY() + halfHeight - halfBar + 1, width,
m_barThickness - 2, getBackgroundColor());
// Fill in (erase) the area to right of the bar
width = m_grip->getX() - getX() + m_grip->getWidth() <
getWidth() - halfGripWidth ? halfGripWidth : getWidth() - (m_grip->getX() -
getX() +
halfGripWidth);
if (width > 0)
port->drawFilledRect(getX() + getWidth() - halfGripWidth, getY(), width,
getHeight(), getBackgroundColor());
// Fill in (erase) the region below the "fuel gauge"
port->drawFilledRect(getX(), getY() + halfHeight + (m_barThickness - halfBar),
getWidth(), halfHeight - (m_barThickness - halfBar),
getBackgroundColor());
// Now redraw the grip
m_grip->enableDrawing();
m_grip->redraw();
}
/**
* Draw the area of this widget that falls within the clipping region.
* Called by the redraw() function to draw all visible regions.
*
* @param port The CGraphicsPort to draw to.
* @see redraw()
*/
void CGlyphSliderHorizontal::drawBorder(CGraphicsPort * port)
{
// Stop drawing if the widget indicates it should not have an outline
if (!isBorderless())
{
int y1, y2;
int x = getX();
int gripWidth = m_grip->getWidth();
int halfGripWidth = gripWidth >> 1;
int gripX = m_grip->getX();
int width;
nxwidget_pixel_t shine;
nxwidget_pixel_t shadow;
y1 = getY() + (getHeight() >> 1) - (m_barThickness >> 1);
y2 = getY() + (getHeight() >> 1) + m_barThickness -
(m_barThickness >> 1) - 1;
// To the Left of the grip. Only draw if the icon isn't covering the
// edge of the bar
width = gripX - x - halfGripWidth;
if (width > 0)
{
// If we aren't filling, then don't draw a "raised" bar
if (m_fill)
{
shine = getShineEdgeColor();
shadow = getShadowEdgeColor();
}
else
{
shadow = getShineEdgeColor();
shine = getShadowEdgeColor();
}
port->drawHorizLine(x + halfGripWidth, y1, width, shine);
port->drawHorizLine(x + halfGripWidth, y2, width, shadow);
}
// To the Right of the grip
// Only draw if the icon isn't covering the edge of the bar
width = getWidth() - (gripX - x + gripWidth) - 1 - halfGripWidth;
if (width > 0)
{
port->drawHorizLine(gripX + gripWidth, y1,
getWidth() - (gripX - x + gripWidth) - 1 -
halfGripWidth, getShadowEdgeColor());
port->drawHorizLine(gripX + gripWidth, y2,
getWidth() - (gripX - x + gripWidth) - 1 -
halfGripWidth, getShineEdgeColor());
}
// Left edge
if (gripX > x + halfGripWidth)
{
port->drawVertLine(x + halfGripWidth, y1, m_barThickness,
getShineEdgeColor());
}
// Right edge
if (gripX + gripWidth < x + getWidth() - 1 - halfGripWidth)
{
port->drawVertLine(x + getWidth() - 1 - halfGripWidth,
y1, m_barThickness, getShadowEdgeColor());
}
}
}
/**
* Resize the slider to the new dimensions.
*
* @param width The new width.
* @param height The new height.
*/
void CGlyphSliderHorizontal::onResize(nxgl_coord_t width, nxgl_coord_t height)
{
// Remember current values
int32_t oldValue = m_value;
bool events = raisesEvents();
// Disable event raising
setRaisesEvents(false);
// resizeGrip();
// Set back to current value
setValue(oldValue);
// Reset event raising
setRaisesEvents(events);
}
/**
* Moves the grip towards the mouse.
*
* @param x The x coordinate of the click.
* @param y The y coordinate of the click.
*/
void CGlyphSliderHorizontal::onClick(nxgl_coord_t x, nxgl_coord_t y)
{
// Which way should the grip move?
if (x > m_grip->getX())
{
// Move grip right
setValueWithBitshift(m_value + (m_pageSize << 16));
}
else
{
// Move grip left
setValueWithBitshift(m_value - (m_pageSize << 16));
}
redraw();
}

204
libnxwidgets/src/cglyphsliderhorizontalgrip.cxx Normal file
View file

@ -0,0 +1,204 @@
/****************************************************************************
* NxWidgets/libnxwidgets/src/cglyphsliderhorizontalgrip.cxx
*
* Copyright (C) 2013 Ken Pettit. All rights reserved.
* Author: Ken Pettit <pettitkd@gmail.com>
*
* Mostly copied from CSliderHorizontalGrip written by Gregory Nutt
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
* me be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************
*
* Portions of this package derive from Woopsi (http://woopsi.org/) and
* portions are original efforts. It is difficult to determine at this
* point what parts are original efforts and which parts derive from Woopsi.
* However, in any event, the work of Antony Dzeryn will be acknowledged
* in most NxWidget files. Thanks Antony!
*
* Copyright (c) 2007-2011, Antony Dzeryn
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the names "Woopsi", "Simian Zombie" nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Antony Dzeryn ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Antony Dzeryn BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include "cglyphsliderhorizontalgrip.hxx"
#include "ibitmap.hxx"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Method Implementations
****************************************************************************/
using namespace NXWidgets;
/**
* Constructor.
*
* @param pWidgetControl The controlling widget for the display
* @param x The x coordinate of the grip, relative to its parent.
* @param y The y coordinate of the grip, relative to its parent.
* @param width The width of the grip.
* @param height The height of the grip.
*/
CGlyphSliderHorizontalGrip::CGlyphSliderHorizontalGrip(CWidgetControl *pWidgetControl,
nxgl_coord_t x, nxgl_coord_t y,
nxgl_coord_t width, nxgl_coord_t height,
IBitmap *pGripBitmap)
: CImage(pWidgetControl, 0, (height>>1) - (pGripBitmap->getHeight() >> 1),
pGripBitmap->getWidth(), pGripBitmap->getHeight(),
pGripBitmap, 0)
{
// Make the widget draggable
setDraggable(true);
}
/**
* Resize the slider to the new dimensions.
*
* @param width The new width.
* @param height The new height.
*/
void CGlyphSliderHorizontalGrip::onResize(nxgl_coord_t width, nxgl_coord_t height)
{
}
/**
* Starts dragging the grip and redraws it.
*
* @param x The x coordinate of the click.
* @param y The y coordinate of the click.
*/
void CGlyphSliderHorizontalGrip::onClick(nxgl_coord_t x, nxgl_coord_t y)
{
startDragging(x, y);
redraw();
}
/**
* Redraws the grip.
*
* @param x The x coordinate of the mouse.
* @param y The y coordinate of the mouse.
*/
void CGlyphSliderHorizontalGrip::onRelease(nxgl_coord_t x, nxgl_coord_t y)
{
redraw();
}
/**
* Redraws the grip.
*
* @param x The x coordinate of the mouse.
* @param y The y coordinate of the mouse.
*/
void CGlyphSliderHorizontalGrip::onReleaseOutside(nxgl_coord_t x, nxgl_coord_t y)
{
redraw();
}
/**
* Moves the grip to follow the mouse.
*
* @param x The x coordinate of the mouse.
* @param y The y coordinate of the mouse.
* @param vX The horizontal distance of the drag.
* @param vY The vertical distance of the drag.
*/
void CGlyphSliderHorizontalGrip::onDrag(nxgl_coord_t x, nxgl_coord_t y,
nxgl_coord_t vX, nxgl_coord_t vY)
{
// Work out where we're moving to
nxgl_coord_t destX = x - m_grabPointX - m_parent->getX();
// Do we need to move?
if (destX != m_rect.getX())
{
// Get parent rect
CRect rect;
m_parent->getClientRect(rect);
// Prevent grip from moving outside parent
if (destX < rect.getX())
{
destX = rect.getX();
}
else
{
if (destX + getWidth() > rect.getWidth() + rect.getX())
{
destX = (rect.getWidth() + rect.getX()) - getWidth() ;
}
}
// Move to new location
moveTo(destX, (rect.getHeight() - getHeight()) >> 1);
m_parent->redraw();
}
}

2
nxwm/Makefile
View file

@ -76,7 +76,7 @@ CXXSRCS += glyph_minimize.cxx glyph_nsh.cxx glyph_play.cxx glyph_start.cxx
CXXSRCS += glyph_stop.cxx
ifeq ($(CONFIG_NXWM_MEDIAPLAYER),y)
CXXSRCS += glyph_mediaplayer.cxx cmediaplayer.cxx
CXXSRCS += glyph_mediaplayer.cxx cmediaplayer.cxx glyph_mplayer_controls.cxx
endif
SRCS = $(ASRCS) $(CSRCS) $(CXXSRCS)

7
nxwm/include/cmediaplayer.hxx
View file

@ -46,9 +46,10 @@
#include <nuttx/nx/nxtk.h>
#include <nuttx/nx/nxconsole.h>
#include "cbuttonarray.hxx"
#include "cimage.hxx"
#include "clabel.hxx"
#include "cnxfont.hxx"
#include "cglyphsliderhorizontal.hxx"
#include "iapplication.hxx"
#include "capplicationwindow.hxx"
@ -105,6 +106,10 @@ namespace NxWM
NXWidgets::CLabel *m_text; /**< Some text in the app for now */
NXWidgets::CNxFont *m_font; /**< The font used in the media player */
NXWidgets::CImage *m_rew; /**< Rewind control */
NXWidgets::CImage *m_playPause; /**< Play/Pause control */
NXWidgets::CImage *m_fwd; /**< Forward control */
NXWidgets::CGlyphSliderHorizontal *m_volume; /**< Volume control */
/**
* Calculator geometry. This stuff does not really have to be retained

20
nxwm/include/nxwmconfig.hxx
View file

@ -552,6 +552,26 @@
# define CONFIG_NXWM_MEDIAPLAYER_ICON NxWM::g_mediaplayerBitmap
#endif
#ifndef CONFIG_NXWM_MPLAYER_FWD_ICON
# define CONFIG_NXWM_MPLAYER_FWD_ICON NxWM::g_mplayerFwdBitmap
#endif
#ifndef CONFIG_NXWM_MPLAYER_PLAY_ICON
# define CONFIG_NXWM_MPLAYER_PLAY_ICON NxWM::g_mplayerPlayBitmap
#endif
#ifndef CONFIG_NXWM_MPLAYER_PAUSE_ICON
# define CONFIG_NXWM_MPLAYER_PAUSE_ICON NxWM::g_mplayerPauseBitmap
#endif
#ifndef CONFIG_NXWM_MPLAYER_REW_ICON
# define CONFIG_NXWM_MPLAYER_REW_ICON NxWM::g_mplayerRewBitmap
#endif
#ifndef CONFIG_NXWM_MPLAYER_VOL_ICON
# define CONFIG_NXWM_MPLAYER_VOL_ICON NxWM::g_mplayerVolBitmap
#endif
#ifndef CONFIG_NXWM_MEDIAPLAYER_FONTID
# define CONFIG_NXWM_MEDIAPLAYER_FONTID CONFIG_NXWM_DEFAULT_FONTID
#endif

7
nxwm/include/nxwmglyphs.hxx
View file

@ -60,7 +60,14 @@ namespace NxWM
extern const struct NXWidgets::SRlePaletteBitmap g_calculatorBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_calibrationBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_cmdBitmap;
#ifdef CONFIG_NXWM_MEDIAPLAYER
extern const struct NXWidgets::SRlePaletteBitmap g_mediaplayerBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_mplayerFwdBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_mplayerPlayBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_mplayerPauseBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_mplayerRewBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_mplayerVolBitmap;
#endif
extern const struct NXWidgets::SRlePaletteBitmap g_minimizeBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_nshBitmap;
extern const struct NXWidgets::SRlePaletteBitmap g_playBitmap;

59
nxwm/src/cmediaplayer.cxx
View file

@ -267,6 +267,15 @@ void CMediaPlayer::redraw(void)
m_text->enableDrawing();
m_text->redraw();
m_rew->enableDrawing();
m_rew->redraw();
m_playPause->enableDrawing();
m_playPause->redraw();
m_fwd->enableDrawing();
m_fwd->redraw();
m_volume->enableDrawing();
m_volume->redraw();
}
/**
@ -314,6 +323,8 @@ void CMediaPlayer::setGeometry(void)
bool CMediaPlayer::createPlayer(void)
{
int playControlX, playControlY;
// Select a font for the calculator
m_font = new NXWidgets::CNxFont((nx_fontid_e)CONFIG_NXWM_MEDIAPLAYER_FONTID,
@ -354,6 +365,54 @@ bool CMediaPlayer::createPlayer(void)
// Select the font
m_text->setFont(m_font);
// Create button for rewind
playControlX = (m_windowSize.w >> 1) - 64;
playControlY = m_windowSize.h - 64;
// Create the Rewind Image
NXWidgets::CRlePaletteBitmap *pRewBitmap = new NXWidgets::
CRlePaletteBitmap(&CONFIG_NXWM_MPLAYER_REW_ICON);
m_rew = new NXWidgets::CImage(control,
playControlX, playControlY,
32, 32,
pRewBitmap, 0);
m_rew->setBorderless(true);
// Create the Play Image
pRewBitmap = new NXWidgets::
CRlePaletteBitmap(&CONFIG_NXWM_MPLAYER_PLAY_ICON);
m_playPause = new NXWidgets::CImage(control,
playControlX + 32 + 16, playControlY,
32, 32,
pRewBitmap, 0);
m_playPause->setBorderless(true);
// Create the Forward Image
pRewBitmap = new NXWidgets::
CRlePaletteBitmap(&CONFIG_NXWM_MPLAYER_FWD_ICON);
m_fwd = new NXWidgets::CImage(control,
playControlX + 32*3, playControlY,
32, 32,
pRewBitmap, 0);
m_fwd->setBorderless(true);
// Create the Volume control
pRewBitmap = new NXWidgets::
CRlePaletteBitmap(&CONFIG_NXWM_MPLAYER_VOL_ICON);
m_volume = new NXWidgets::CGlyphSliderHorizontal(control,
10, m_windowSize.h - 30,
m_windowSize.w - 20, 26,
pRewBitmap, MKRGB( 63, 90,192));
m_volume->setMinimumValue(0);
m_volume->setMaximumValue(100);
m_volume->setValue(15);
return true;
}

398
nxwm/src/glyph_mplayer_controls.cxx Normal file
View file

@ -0,0 +1,398 @@
/********************************************************************************************
* NxWidgets/nxwm/src/glyph_mediaplayer.cxx
*
* Copyright (C) 2013 Ken Pettit. All rights reserved.
* Author: Ken Pettit <pettitkd@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
* me be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
********************************************************************************************/
/********************************************************************************************
* Included Files
********************************************************************************************/
/* Automatically NuttX bitmap file. */
/* Generated from play_music.png by bitmap_converter.py. */
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <nuttx/nx/nxglib.h>
#include <nuttx/fb.h>
#include <nuttx/rgbcolors.h>
#include "crlepalettebitmap.hxx"
#include "nxwmconfig.hxx"
#include "nxwmglyphs.hxx"
/********************************************************************************************
* Pre-Processor Definitions
********************************************************************************************/
#define BITMAP_WIDTH 32
#define BITMAP_HEIGHT 32
#define BITMAP_PALETTESIZE 8
using namespace NxWM;
/* RGB24 (8-8-8) Colors */
static const NXWidgets::nxwidget_pixel_t palette[BITMAP_PALETTESIZE] =
{
CONFIG_NXWM_DEFAULT_BACKGROUNDCOLOR, MKRGB( 11, 24,108), MKRGB( 63, 90,192), MKRGB(121,136,250),
MKRGB(224,234,244), MKRGB( 69, 80,149), MKRGB(127,169,239), MKRGB(152,174,207),
};
static const NXWidgets::nxwidget_pixel_t hilight_palette[BITMAP_PALETTESIZE] =
{
CONFIG_NXWM_DEFAULT_BACKGROUNDCOLOR, MKRGB( 61, 74,158), MKRGB(113,140,242), MKRGB(171,186,255),
MKRGB(255,255,255), MKRGB(119,130,199), MKRGB(177,219,255), MKRGB(202,224,255),
};
/* Bitmap definition for the "Play" button */
static const NXWidgets::SRlePaletteBitmapEntry play_bitmap[] =
{
{ 32, 0}, /* Row 0 */
{ 14, 0}, { 4, 7}, { 14, 0}, /* Row 1 */
{ 10, 0}, { 12, 7}, { 10, 0}, /* Row 2 */
{ 8, 0}, { 3, 6}, { 9, 7}, { 3, 6}, { 1, 7}, { 8, 0}, /* Row 3 */
{ 7, 0}, { 7, 6}, { 4, 7}, { 7, 6}, { 7, 0}, /* Row 4 */
{ 6, 0}, { 3, 3}, { 13, 6}, { 4, 3}, { 6, 0}, /* Row 5 */
{ 5, 0}, { 6, 3}, { 9, 6}, { 7, 3}, { 5, 0}, /* Row 6 */
{ 4, 0}, { 1, 2}, { 22, 3}, { 1, 2}, { 4, 0}, /* Row 7 */
{ 3, 0}, { 1, 5}, { 23, 3}, { 1, 2}, { 1, 5}, { 3, 0}, /* Row 8 */
{ 3, 0}, { 3, 2}, { 5, 3}, { 1, 6}, { 13, 3}, { 4, 2},
{ 3, 0}, /* Row 9 */
{ 2, 0}, { 1, 5}, { 6, 2}, { 2, 3}, { 2, 4}, { 1, 6},
{ 9, 3}, { 6, 2}, { 1, 5}, { 2, 0}, /* Row 10 */
{ 2, 0}, { 1, 5}, { 8, 2}, { 1, 7}, { 3, 4}, { 1, 6},
{ 2, 2}, { 1, 3}, { 10, 2}, { 1, 5}, { 2, 0}, /* Row 11 */
{ 1, 0}, { 4, 5}, { 6, 2}, { 1, 7}, { 4, 4}, { 1, 7},
{ 1, 3}, { 8, 2}, { 4, 5}, { 2, 0}, /* Row 12 */
{ 1, 0}, { 7, 5}, { 3, 2}, { 1, 7}, { 6, 4}, { 1, 7},
{ 3, 2}, { 8, 5}, { 2, 0}, /* Row 13 */
{ 1, 0}, { 9, 5}, { 1, 2}, { 1, 7}, { 8, 4}, { 1, 7},
{ 8, 5}, { 1, 1}, { 1, 5}, { 1, 0}, /* Row 14 */
{ 1, 0}, { 4, 1}, { 6, 5}, { 1, 7}, { 10, 4}, { 1, 7},
{ 3, 5}, { 4, 1}, { 1, 5}, { 1, 0}, /* Row 15 */
{ 1, 0}, { 8, 1}, { 2, 5}, { 1, 7}, { 10, 4}, { 1, 7},
{ 7, 1}, { 1, 5}, { 1, 0}, /* Row 16 */
{ 1, 0}, { 10, 1}, { 1, 7}, { 9, 4}, { 1, 5}, { 8, 1},
{ 1, 5}, { 1, 0}, /* Row 17 */
{ 1, 0}, { 10, 1}, { 1, 7}, { 7, 4}, { 1, 5}, { 10, 1},
{ 2, 0}, /* Row 18 */
{ 1, 0}, { 1, 5}, { 9, 1}, { 1, 7}, { 5, 4}, { 1, 7},
{ 12, 1}, { 2, 0}, /* Row 19 */
{ 2, 0}, { 9, 1}, { 1, 7}, { 4, 4}, { 1, 5}, { 13, 1},
{ 2, 0}, /* Row 20 */
{ 2, 0}, { 9, 1}, { 1, 7}, { 2, 4}, { 1, 7}, { 1, 2},
{ 13, 1}, { 1, 5}, { 2, 0}, /* Row 21 */
{ 2, 0}, { 1, 5}, { 8, 1}, { 1, 7}, { 1, 4}, { 1, 5},
{ 6, 2}, { 9, 1}, { 3, 0}, /* Row 22 */
{ 3, 0}, { 7, 1}, { 1, 2}, { 1, 5}, { 10, 2}, { 6, 1},
{ 1, 5}, { 3, 0}, /* Row 23 */
{ 4, 0}, { 4, 1}, { 16, 2}, { 4, 1}, { 4, 0}, /* Row 24 */
{ 4, 0}, { 1, 5}, { 2, 1}, { 18, 2}, { 2, 1}, { 5, 0}, /* Row 25 */
{ 5, 0}, { 1, 5}, { 1, 1}, { 19, 2}, { 1, 5}, { 5, 0}, /* Row 26 */
{ 6, 0}, { 1, 5}, { 18, 2}, { 7, 0}, /* Row 27 */
{ 8, 0}, { 15, 2}, { 1, 5}, { 8, 0}, /* Row 28 */
{ 9, 0}, { 1, 5}, { 12, 2}, { 10, 0}, /* Row 29 */
{ 12, 0}, { 8, 2}, { 12, 0}, /* Row 30 */
{ 32, 0}, /* Row 31 */
};
const struct NXWidgets::SRlePaletteBitmap NxWM::g_mplayerPlayBitmap =
{
CONFIG_NXWIDGETS_BPP,
CONFIG_NXWIDGETS_FMT,
BITMAP_PALETTESIZE,
BITMAP_WIDTH,
BITMAP_HEIGHT,
{palette, hilight_palette},
play_bitmap
};
/* Bitmap definition for the "Pause" button */
static const NXWidgets::SRlePaletteBitmapEntry pause_bitmap[] =
{
{ 32, 0}, /* Row 0 */
{ 14, 0}, { 4, 7}, { 14, 0}, /* Row 1 */
{ 10, 0}, { 12, 7}, { 10, 0}, /* Row 2 */
{ 8, 0}, { 4, 6}, { 8, 7}, { 4, 6}, { 8, 0}, /* Row 3 */
{ 7, 0}, { 7, 6}, { 3, 7}, { 8, 6}, { 7, 0}, /* Row 4 */
{ 6, 0}, { 3, 3}, { 13, 6}, { 4, 3}, { 6, 0}, /* Row 5 */
{ 5, 0}, { 6, 3}, { 9, 6}, { 7, 3}, { 5, 0}, /* Row 6 */
{ 4, 0}, { 1, 2}, { 22, 3}, { 1, 2}, { 4, 0}, /* Row 7 */
{ 3, 0}, { 1, 5}, { 23, 3}, { 1, 2}, { 1, 5}, { 3, 0}, /* Row 8 */
{ 3, 0}, { 3, 2}, { 19, 3}, { 4, 2}, { 3, 0}, /* Row 9 */
{ 2, 0}, { 1, 5}, { 5, 2}, { 2, 3}, { 1, 6}, { 3, 4},
{ 3, 3}, { 1, 7}, { 2, 4}, { 1, 7}, { 2, 3}, { 6, 2},
{ 1, 5}, { 2, 0}, /* Row 10 */
{ 2, 0}, { 1, 5}, { 7, 2}, { 1, 7}, { 3, 4}, { 1, 7},
{ 1, 2}, { 1, 3}, { 4, 4}, { 1, 3}, { 7, 2}, { 1, 5},
{ 2, 0}, /* Row 11 */
{ 1, 0}, { 4, 5}, { 5, 2}, { 1, 7}, { 3, 4}, { 1, 7},
{ 1, 2}, { 1, 3}, { 4, 4}, { 1, 6}, { 4, 2}, { 4, 5},
{ 2, 0}, /* Row 12 */
{ 1, 0}, { 8, 5}, { 1, 2}, { 1, 7}, { 3, 4}, { 1, 7},
{ 1, 2}, { 1, 5}, { 4, 4}, { 1, 5}, { 1, 2}, { 7, 5},
{ 2, 0}, /* Row 13 */
{ 1, 0}, { 9, 5}, { 1, 7}, { 3, 4}, { 1, 7}, { 1, 2},
{ 1, 5}, { 4, 4}, { 8, 5}, { 1, 1}, { 1, 5}, { 1, 0}, /* Row 14 */
{ 1, 0}, { 4, 1}, { 5, 5}, { 1, 7}, { 3, 4}, { 1, 7},
{ 2, 5}, { 4, 4}, { 5, 5}, { 4, 1}, { 1, 5}, { 1, 0}, /* Row 15 */
{ 1, 0}, { 9, 1}, { 1, 7}, { 3, 4}, { 1, 7}, { 2, 5},
{ 4, 4}, { 1, 5}, { 8, 1}, { 1, 5}, { 1, 0}, /* Row 16 */
{ 1, 0}, { 9, 1}, { 1, 7}, { 3, 4}, { 1, 7}, { 1, 1},
{ 1, 5}, { 4, 4}, { 1, 5}, { 8, 1}, { 1, 5}, { 1, 0}, /* Row 17 */
{ 1, 0}, { 9, 1}, { 1, 7}, { 3, 4}, { 1, 7}, { 1, 1},
{ 1, 5}, { 4, 4}, { 1, 5}, { 8, 1}, { 2, 0}, /* Row 18 */
{ 1, 0}, { 1, 5}, { 8, 1}, { 1, 7}, { 3, 4}, { 1, 7},
{ 1, 1}, { 1, 5}, { 4, 4}, { 1, 5}, { 8, 1}, { 2, 0}, /* Row 19 */
{ 2, 0}, { 8, 1}, { 1, 7}, { 3, 4}, { 1, 7}, { 1, 1},
{ 1, 5}, { 4, 4}, { 1, 5}, { 8, 1}, { 2, 0}, /* Row 20 */
{ 2, 0}, { 8, 1}, { 1, 7}, { 3, 4}, { 1, 7}, { 1, 1},
{ 1, 2}, { 4, 4}, { 1, 5}, { 7, 1}, { 1, 5}, { 2, 0}, /* Row 21 */
{ 2, 0}, { 1, 5}, { 7, 1}, { 1, 7}, { 3, 4}, { 1, 6},
{ 1, 1}, { 1, 2}, { 4, 4}, { 1, 2}, { 7, 1}, { 3, 0}, /* Row 22 */
{ 3, 0}, { 7, 1}, { 1, 2}, { 3, 6}, { 4, 2}, { 2, 6},
{ 2, 2}, { 6, 1}, { 1, 5}, { 3, 0}, /* Row 23 */
{ 4, 0}, { 4, 1}, { 16, 2}, { 4, 1}, { 4, 0}, /* Row 24 */
{ 4, 0}, { 1, 5}, { 2, 1}, { 18, 2}, { 2, 1}, { 5, 0}, /* Row 25 */
{ 5, 0}, { 1, 5}, { 1, 1}, { 6, 2}, { 6, 2}, { 7, 2},
{ 1, 5}, { 5, 0}, /* Row 26 */
{ 6, 0}, { 1, 5}, { 4, 2}, { 1, 5}, { 8, 2}, { 1, 5},
{ 4, 2}, { 7, 0}, /* Row 27 */
{ 8, 0}, { 3, 2}, { 4, 2}, { 2, 2}, { 4, 2}, { 2, 2},
{ 1, 5}, { 8, 0}, /* Row 28 */
{ 9, 0}, { 1, 5}, { 3, 2}, { 6, 2}, { 3, 2}, { 10, 0}, /* Row 29 */
{ 12, 0}, { 8, 2}, { 12, 0}, /* Row 30 */
{ 32, 0}, /* Row 31 */
};
const struct NXWidgets::SRlePaletteBitmap NxWM::g_mplayerPauseBitmap =
{
CONFIG_NXWIDGETS_BPP,
CONFIG_NXWIDGETS_FMT,
BITMAP_PALETTESIZE,
BITMAP_WIDTH,
BITMAP_HEIGHT,
{palette, hilight_palette},
pause_bitmap
};
/* Bitmap definition for "Rewind" control */
static const NXWidgets::SRlePaletteBitmapEntry rew_bitmap[] =
{
{ 32, 0}, /* Row 0 */
// { 14, 0}, { 3, 4}, { 1, 7}, { 14, 0}, /* Row 1 */
{ 14, 0}, { 4, 7}, { 14, 0}, /* Row 1 */
{ 10, 0}, { 12, 7}, { 10, 0}, /* Row 2 */
{ 8, 0}, { 1, 7}, { 3, 6}, { 8, 7},
{ 3, 6}, { 1, 7}, { 8, 0}, /* Row 3 */
{ 7, 0}, { 7, 6}, { 3, 7}, { 8, 6}, { 7, 0}, /* Row 4 */
{ 6, 0}, { 3, 3}, { 13, 6}, { 4, 3}, { 6, 0}, /* Row 5 */
{ 5, 0}, { 6, 3}, { 9, 6}, { 7, 3}, { 5, 0}, /* Row 6 */
{ 4, 0}, { 23, 3}, { 1, 2}, { 4, 0}, /* Row 7 */
{ 3, 0}, { 1, 5}, { 23, 3}, { 1, 2}, { 1, 5}, { 3, 0}, /* Row 8 */
{ 3, 0}, { 3, 2}, { 18, 3}, { 5, 2}, { 3, 0}, /* Row 9 */
{ 2, 0}, { 1, 5}, { 5, 2}, { 6, 3}, { 1, 6}, { 7, 3},
{ 2, 2}, { 2, 6}, { 3, 2}, { 1, 5}, { 2, 0}, /* Row 10 */
{ 2, 0}, { 1, 5}, { 9, 2}, { 1, 6}, { 2, 4}, { 1, 3},
{ 1, 2}, { 2, 3}, { 3, 2}, { 1, 6}, { 2, 4}, { 1, 6},
{ 3, 2}, { 1, 5}, { 2, 0}, /* Row 11 */
{ 1, 0}, { 2, 5}, { 7, 2}, { 1, 6}, { 4, 4}, { 1, 3},
{ 4, 2}, { 1, 3}, { 1, 7}, { 3, 4}, { 1, 7}, { 3, 2},
{ 1, 5}, { 2, 0}, /* Row 12 */
{ 1, 0}, { 5, 5}, { 2, 2}, { 1, 5}, { 1, 7}, { 5, 4},
{ 1, 5}, { 3, 2}, { 1, 7}, { 5, 4}, { 1, 7}, { 1, 2},
{ 3, 5}, { 2, 0}, /* Row 13 */
{ 1, 0}, { 6, 5}, { 1, 7}, { 7, 4}, { 1, 5}, { 1, 2},
{ 1, 7}, { 7, 4}, { 1, 7}, { 3, 5}, { 1, 1}, { 1, 5},
{ 1, 0}, /* Row 14 */
{ 1, 0}, { 4, 1}, { 1, 7}, { 9, 4}, { 1, 7}, { 9, 4},
{ 1, 7}, { 4, 1}, { 1, 5}, { 1, 0}, /* Row 15 */
{ 1, 0}, { 4, 1}, { 1, 5}, { 9, 4}, { 1, 7}, { 9, 4},
{ 1, 5}, { 4, 1}, { 1, 5}, { 1, 0}, /* Row 16 */
{ 1, 0}, { 6, 1}, { 1, 5}, { 7, 4}, { 1, 5}, { 1, 1},
{ 1, 5}, { 7, 4}, { 1, 5}, { 4, 1}, { 1, 5}, { 1, 0}, /* Row 17 */
{ 1, 0}, { 8, 1}, { 1, 7}, { 5, 4}, { 1, 5}, { 3, 1},
{ 1, 7}, { 5, 4}, { 1, 5}, { 4, 1}, { 2, 0}, /* Row 18 */
{ 1, 0}, { 1, 5}, { 8, 1}, { 1, 5}, { 4, 4}, { 1, 5},
{ 4, 1}, { 1, 5}, { 4, 4}, { 1, 5}, { 4, 1}, { 2, 0}, /* Row 19 */
{ 2, 0}, { 10, 1}, { 1, 7}, { 2, 4}, { 1, 2}, { 6, 1},
{ 1, 7}, { 2, 4}, { 1, 5}, { 4, 1}, { 2, 0}, /* Row 20 */
{ 2, 0}, { 11, 1}, { 1, 5}, { 1, 4}, { 1, 2}, { 7, 1},
{ 1, 5}, { 1, 7}, { 1, 5}, { 3, 1}, { 1, 5}, { 2, 0}, /* Row 21 */
{ 2, 0}, { 1, 5}, { 9, 1}, { 1, 2}, { 1, 1}, { 6, 2},
{ 9, 1}, { 3, 0}, /* Row 22 */
{ 3, 0}, { 7, 1}, { 12, 2}, { 6, 1}, { 1, 5}, { 3, 0}, /* Row 23 */
{ 4, 0}, { 5, 1}, { 14, 2}, { 5, 1}, { 4, 0}, /* Row 24 */
{ 4, 0}, { 1, 5}, { 2, 1}, { 18, 2}, { 2, 1}, { 5, 0}, /* Row 25 */
{ 5, 0}, { 1, 5}, { 1, 1}, { 6, 2}, { 6, 2}, { 7, 2},
{ 1, 5}, { 5, 0}, /* Row 26 */
{ 6, 0}, { 1, 5}, { 4, 2}, { 1, 5}, { 8, 2}, { 1, 5},
{ 4, 2}, { 7, 0}, /* Row 27 */
{ 8, 0}, { 3, 2}, { 3, 2}, { 4, 2}, { 3, 2}, { 2, 2},
{ 1, 5}, { 8, 0}, /* Row 28 */
{ 9, 0}, { 1, 5}, { 3, 2}, { 6, 2}, { 2, 2}, { 1, 5},
{ 10, 0}, /* Row 29 */
{ 12, 0}, { 3, 2}, { 2, 2}, { 3, 2}, { 12, 0}, /* Row 30 */
{ 32, 0}, /* Row 31 */
};
const struct NXWidgets::SRlePaletteBitmap NxWM::g_mplayerRewBitmap =
{
CONFIG_NXWIDGETS_BPP,
CONFIG_NXWIDGETS_FMT,
BITMAP_PALETTESIZE,
BITMAP_WIDTH,
BITMAP_HEIGHT,
{palette, hilight_palette},
rew_bitmap
};
/* Bitmap definition for "Forward" control */
static const NXWidgets::SRlePaletteBitmapEntry fwd_bitmap[] =
{
{ 32, 0}, /* Row 0 */
{ 14, 0}, { 4, 7}, { 14, 0}, /* Row 1 */
{ 10, 0}, { 12, 7}, { 10, 0}, /* Row 2 */
{ 8, 0}, { 1, 7}, { 3, 6}, { 8, 7},
{ 3, 6}, { 1, 7}, { 8, 0}, /* Row 3 */
{ 7, 0}, { 7, 6}, { 3, 7}, { 8, 6}, { 7, 0}, /* Row 4 */
{ 6, 0}, { 3, 3}, { 13, 6}, { 4, 3}, { 6, 0}, /* Row 5 */
{ 5, 0}, { 6, 3}, { 10, 6}, { 6, 3}, { 5, 0}, /* Row 6 */
{ 4, 0}, { 1, 2}, { 22, 3}, { 1, 2}, { 4, 0}, /* Row 7 */
{ 3, 0}, { 1, 5}, { 23, 3}, { 1, 2}, { 1, 5}, { 3, 0}, /* Row 8 */
{ 3, 0}, { 3, 2}, { 19, 3}, { 4, 2}, { 3, 0}, /* Row 9 */
{ 2, 0}, { 1, 5}, { 3, 2}, { 2, 6}, { 2, 2}, { 7, 3},
{ 1, 6}, { 5, 3}, { 6, 2}, { 1, 5}, { 2, 0}, /* Row 10 */
{ 2, 0}, { 1, 5}, { 3, 2}, { 1, 7}, { 2, 4}, { 1, 3},
{ 2, 2}, { 3, 3}, { 1, 2}, { 1, 6}, { 2, 4}, { 1, 6},
{ 9, 2}, { 1, 5}, { 2, 0}, /* Row 11 */
{ 1, 0}, { 2, 5}, { 3, 2}, { 1, 7}, { 3, 4}, { 1, 7},
{ 5, 2}, { 1, 6}, { 4, 4}, { 1, 5}, { 7, 2}, { 1, 5},
{ 2, 0}, /* Row 12 */
{ 1, 0}, { 4, 5}, { 1, 2}, { 1, 7}, { 5, 4}, { 1, 7},
{ 3, 2}, { 1, 6}, { 5, 4}, { 1, 7}, { 1, 5}, { 2, 2},
{ 4, 5}, { 2, 0}, /* Row 13 */
{ 1, 0}, { 1, 5}, { 1, 1}, { 2, 5}, { 1, 1}, { 1, 7},
{ 7, 4}, { 1, 7}, { 1, 2}, { 1, 5}, { 7, 4}, { 1, 7},
{ 4, 5}, { 1, 1}, { 1, 5}, { 1, 0}, /* Row 14 */
{ 1, 0}, { 5, 1}, { 1, 7}, { 9, 4}, { 1, 7}, { 9, 4},
{ 1, 5}, { 3, 1}, { 1, 5}, { 1, 0}, /* Row 15 */
{ 1, 0}, { 5, 1}, { 1, 7}, { 8, 4}, { 2, 7}, { 8, 4},
{ 1, 7}, { 4, 1}, { 1, 5}, { 1, 0}, /* Row 16 */
{ 1, 0}, { 5, 1}, { 1, 5}, { 7, 4}, { 1, 5}, { 1, 1},
{ 1, 5}, { 7, 4}, { 1, 5}, { 5, 1}, { 1, 5}, { 1, 0}, /* Row 17 */
{ 1, 0}, { 5, 1}, { 1, 5}, { 5, 4}, { 1, 7}, { 3, 1},
{ 1, 5}, { 5, 4}, { 1, 7}, { 7, 1}, { 2, 0}, /* Row 18 */
{ 1, 0}, { 1, 5}, { 4, 1}, { 1, 5}, { 3, 4}, { 1, 7},
{ 1, 2}, { 4, 1}, { 1, 5}, { 4, 4}, { 1, 5}, { 8, 1},
{ 2, 0}, /* Row 19 */
{ 2, 0}, { 4, 1}, { 1, 5}, { 2, 4}, { 1, 5}, { 6, 1},
{ 1, 5}, { 2, 4}, { 1, 7}, { 10, 1}, { 2, 0}, /* Row 20 */
{ 2, 0}, { 4, 1}, { 2, 7}, { 8, 1}, { 1, 5}, { 1, 4},
{ 1, 2}, { 10, 1}, { 1, 5}, { 2, 0}, /* Row 21 */
{ 2, 0}, { 1, 5}, { 9, 1}, { 6, 2}, { 1, 1}, { 1, 2},
{ 9, 1}, { 3, 0}, /* Row 22 */
{ 3, 0}, { 7, 1}, { 12, 2}, { 6, 1}, { 1, 5}, { 3, 0}, /* Row 23 */
{ 4, 0}, { 5, 1}, { 14, 2}, { 5, 1}, { 4, 0}, /* Row 24 */
{ 4, 0}, { 1, 5}, { 2, 1}, { 18, 2}, { 2, 1}, { 5, 0}, /* Row 25 */
{ 5, 0}, { 1, 5}, { 1, 1}, { 6, 2}, { 6, 2}, { 7, 2},
{ 1, 5}, { 5, 0}, /* Row 26 */
{ 6, 0}, { 1, 5}, { 4, 2}, { 1, 5}, { 8, 2}, { 1, 5},
{ 4, 2}, { 7, 0}, /* Row 27 */
{ 8, 0}, { 3, 2}, { 3, 2}, { 4, 2}, { 3, 2}, { 2, 2},
{ 1, 5}, { 8, 0}, /* Row 28 */
{ 9, 0}, { 1, 5}, { 3, 2}, { 6, 2}, { 2, 2}, { 1, 5},
{ 10, 0}, /* Row 29 */
{ 12, 0}, { 3, 2}, { 2, 2}, { 3, 2}, { 12, 0}, /* Row 30 */
{ 32, 0}, /* Row 31 */
};
const struct NXWidgets::SRlePaletteBitmap NxWM::g_mplayerFwdBitmap =
{
CONFIG_NXWIDGETS_BPP,
CONFIG_NXWIDGETS_FMT,
BITMAP_PALETTESIZE,
BITMAP_WIDTH,
BITMAP_HEIGHT,
{palette, hilight_palette},
fwd_bitmap
};
static const NXWidgets::SRlePaletteBitmapEntry vol_bitmap[] =
{
{ 22, 0}, /* Row 0 */
{ 9, 0}, { 5, 7}, { 8, 0}, /* Row 1 */
{ 6, 0}, { 2, 6}, { 6, 7}, { 2, 6}, { 1, 7}, { 5, 0}, /* Row 2 */
{ 4, 0}, { 2, 3}, { 9, 6}, { 3, 3}, { 4, 0}, /* Row 3 */
{ 3, 0}, { 5, 3}, { 6, 6}, { 5, 3}, { 3, 0}, /* Row 4 */
{ 3, 0}, { 16, 3}, { 3, 0}, /* Row 5 */
{ 2, 0}, { 2, 2}, { 13, 3}, { 3, 2}, { 2, 0}, /* Row 6 */
{ 1, 0}, { 1, 5}, { 4, 2}, { 10, 3}, { 4, 2}, { 1, 5},
{ 1, 0}, /* Row 7 */
{ 1, 0}, { 2, 5}, { 15, 2}, { 3, 5}, { 1, 0}, /* Row 8 */
{ 1, 0}, { 5, 5}, { 10, 2}, { 5, 5}, { 1, 0}, /* Row 9 */
{ 1, 0}, { 2, 1}, { 15, 5}, { 3, 1}, { 1, 0}, /* Row 10 */
{ 1, 0}, { 5, 1}, { 10, 5}, { 5, 1}, { 1, 0}, /* Row 11 */
{ 1, 0}, { 20, 1}, { 1, 0}, /* Row 12 */
{ 1, 0}, { 20, 1}, { 1, 0}, /* Row 13 */
{ 1, 0}, { 19, 1}, { 1, 5}, { 1, 0}, /* Row 14 */
{ 1, 0}, { 1, 5}, { 7, 1}, { 1, 5}, { 4, 2}, { 6, 1},
{ 2, 0}, /* Row 15 */
{ 2, 0}, { 5, 1}, { 8, 2}, { 4, 1}, { 1, 5}, { 2, 0}, /* Row 16 */
{ 3, 0}, { 2, 1}, { 12, 2}, { 2, 1}, { 3, 0}, /* Row 17 */
{ 3, 0}, { 1, 5}, { 1, 1}, { 13, 2}, { 1, 5}, { 3, 0}, /* Row 18 */
{ 6, 0}, { 10, 2}, { 1, 5}, { 5, 0}, /* Row 19 */
{ 6, 0}, { 1, 5}, { 8, 2}, { 7, 0}, /* Row 20 */
{ 22, 0}, /* Row 21 */
};
const struct NXWidgets::SRlePaletteBitmap NxWM::g_mplayerVolBitmap =
{
CONFIG_NXWIDGETS_BPP,
CONFIG_NXWIDGETS_FMT,
BITMAP_PALETTESIZE,
22,
22,
{hilight_palette, hilight_palette},
vol_bitmap
};