libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'master' of https://github.com/RT-Thread/rt-thread

This commit is contained in:
Bernard Xiong 2013-03-04 06:59:05 -08:00
parent c5d5a54c5d c6ba8eac62
commit 784e8e2459
80 changed files with 3681 additions and 5545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -1,4 +1,6 @@
RT-Thread RT-Thread
========= =========
[![Build Status](https://travis-ci.org/RT-Thread/rt-thread.png)](https://travis-ci.org/RT-Thread/rt-thread)
RT-Thread is an open source real-time operating system for embedded devices. RT-Thread is an open source real-time operating system for embedded devices.

67
bsp/simulator/SConstruct
View File

@ -12,14 +12,14 @@ if os.getenv('RTT_RTGUI'):
else: else:
# set the rtgui root directory by hand # set the rtgui root directory by hand
# empty string means use the RTGUI in svn # empty string means use the RTGUI in svn
# RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui') RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui')
RTT_RTGUI ='' # RTT_RTGUI =''
sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')] sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
from building import * from building import *
env = Environment() env = Environment(TARGET_ARCH='x86')
Export('RTT_ROOT') Export('RTT_ROOT')
Export('rtconfig') Export('rtconfig')
@ -51,13 +51,34 @@ if rtconfig.PLATFORM == 'cl':
env.Append(LINKFLAGS=rtconfig.LFLAGS) env.Append(LINKFLAGS=rtconfig.LFLAGS)
env['LIBS']=libs env['LIBS']=libs
env['CPPDEFINES']=definitions env['CPPDEFINES']=definitions
elif rtconfig.PLATFORM == 'mingw':
libs = Split('''
winmm
gdi32
winspool
comdlg32
advapi32
shell32
ole32
oleaut32
uuid
odbc32
odbccp32
''')
TARGET = 'rtthread-win32.' + rtconfig.TARGET_EXT
env = Environment(tools = ['mingw'],
AS = rtconfig.AS, ASFLAGS = rtconfig.AFLAGS,
CC = rtconfig.CC, CCFLAGS = rtconfig.CFLAGS,
AR = rtconfig.AR, ARFLAGS = '-rc',
LINK = rtconfig.LINK, LINKFLAGS = rtconfig.LFLAGS)
env['LIBS']=libs
env.PrependENVPath('PATH', rtconfig.EXEC_PATH)
else: else:
TARGET = 'rtthread' TARGET = 'rtthread'
env.Append(CCFLAGS=rtconfig.CFLAGS) env.Append(CCFLAGS=rtconfig.CFLAGS)
env.Append(LINKFLAGS=rtconfig.LFLAGS) env.Append(LINKFLAGS=rtconfig.LFLAGS)
env.Append(LIBS=['m']) env.Append(LIBS=['m'])
# prepare building environment # prepare building environment
objs = PrepareBuilding(env, RTT_ROOT, has_libcpu=False, remove_components=['rtgui']) objs = PrepareBuilding(env, RTT_ROOT, has_libcpu=False, remove_components=['rtgui'])
@ -85,8 +106,42 @@ if GetDepend('RT_USING_RTGUI'):
if GetDepend('RT_USING_TC'): if GetDepend('RT_USING_TC'):
objs = objs + SConscript(RTT_ROOT + '/examples/kernel/SConscript', variant_dir = 'build/tc/kernel', duplicate=0) objs = objs + SConscript(RTT_ROOT + '/examples/kernel/SConscript', variant_dir = 'build/tc/kernel', duplicate=0)
# build program def ObjRemove(objs, remove):
program = env.Program(TARGET, objs) for item in objs:
# print type(item), os.path.basename(str(item))
if os.path.basename(str(item)) in remove:
objs.remove(item)
return
# build program -shared
if GetDepend('RT_USING_MODULE'):
# Remove module.c in $RTT_ROOT/src
ObjRemove(objs, ['module.obj', 'module.o'])
AddOption('--def',
dest='def',
action='store_true',
default=False,
help='create rthread.def of rtthread.dll on windows')
if GetOption('def'):
if rtconfig.PLATFORM != 'mingw':
print "scons error: `--def' can only work with mingw"
exit(1)
env['LINKFLAGS'] = rtconfig.DEFFILE_LFLAGS
env.SharedLibrary("rtthread.dll", objs)
program = ''
else:
if rtconfig.PLATFORM == 'cl':
objs += ['rtthread.def']
elif rtconfig.PLATFORM == 'mingw':
rtconfig.POST_ACTION = 'del /Q rtthread.lib \n rename librtthread.a rtthread.lib\n'
# rtconfig.POST_ACTION = 'lib /machine:i386 /def:rtthread.def /out:rtthread.lib'
env.SharedLibrary("rtthread.dll", objs)
program = env.Program(TARGET, 'dummy.c', LIBS='rtthread', LIBPATH='.')
else:
program = env.Program(TARGET, objs)
# end building # end building
EndBuilding(TARGET, program) EndBuilding(TARGET, program)

2
bsp/simulator/applications/SConscript
View File

@ -6,6 +6,8 @@ src = Glob('*.c')
# remove no need file. # remove no need file.
if GetDepend('RT_USING_DFS_WINSHAREDIR') == False: if GetDepend('RT_USING_DFS_WINSHAREDIR') == False:
SrcRemove(src, 'dfs_win32.c') SrcRemove(src, 'dfs_win32.c')
if GetDepend('RT_USING_MODULE') == False:
SrcRemove(src, ['module_win32.c'])
CPPPATH = [cwd, str(Dir('#'))] CPPPATH = [cwd, str(Dir('#'))]
group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH) group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH)

4
bsp/simulator/applications/application.c
View File

@ -25,11 +25,11 @@ void rt_init_thread_entry(void *parameter)
pcap_netif_hw_init(); pcap_netif_hw_init();
#endif #endif
rt_platform_init();
/* initialization RT-Thread Components */ /* initialization RT-Thread Components */
rt_components_init(); rt_components_init();
rt_platform_init();
/* File system Initialization */ /* File system Initialization */
#ifdef RT_USING_DFS #ifdef RT_USING_DFS
{ {

26
bsp/simulator/applications/dfs_win32.c
View File

@ -27,6 +27,22 @@
#include <WinError.h> #include <WinError.h>
#include <windows.h> #include <windows.h>
#if defined(__MINGW32__) && defined(_NO_OLDNAMES)
#define O_RDONLY _O_RDONLY
#define O_WRONLY _O_WRONLY
#define O_RDWR _O_RDWR
#define O_ACCMODE _O_ACCMODE
#define O_APPEND _O_APPEND
#define O_CREAT _O_CREAT
#define O_TRUNC _O_TRUNC
#define O_EXCL _O_EXCL
#define O_TEXT _O_TEXT
#define O_BINARY _O_BINARY
#define O_TEMPORARY _O_TEMPORARY
#define O_NOINHERIT _O_NOINHERIT
#define O_SEQUENTIAL _O_SEQUENTIAL
#define O_RANDOM _O_RANDOM
#endif
/* /*
* RT-Thread DFS Interface for win-directory as an disk device * RT-Thread DFS Interface for win-directory as an disk device
*/ */
@ -95,7 +111,7 @@ static int dfs_win32_unmount(struct dfs_filesystem *fs)
return 0; return 0;
} }
static int dfs_win32_mkfs(const char *device_name) static int dfs_win32_mkfs(rt_device_t devid)
{ {
return -DFS_STATUS_ENOSYS; return -DFS_STATUS_ENOSYS;
} }
@ -132,6 +148,14 @@ static char *winpath_dirdup(char *des, const char *src)
return path; return path;
} }
/* This function can convert the path in rt-thread/dfs to the path in windows */
char * dfs_win32_dirdup(char * path)
{
char * file_path;
file_path = winpath_dirdup(WIN32_DIRDISK_ROOT, path);
return file_path;
}
static int dfs_win32_open(struct dfs_fd *file) static int dfs_win32_open(struct dfs_fd *file)
{ {
int fd; int fd;

367
bsp/simulator/applications/module_win32.c Normal file
View File

@ -0,0 +1,367 @@
/*
* File : module.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2013-02-26 prife first version for win32
*/
#include <rthw.h>
#include <rtthread.h>
#include <rtm.h>
#ifdef RT_USING_MODULE
static void rt_module_init_object_container(struct rt_module *module)
{
RT_ASSERT(module != RT_NULL);
/* initialize object container - thread */
rt_list_init(&(module->module_object[RT_Object_Class_Thread].object_list));
module->module_object[RT_Object_Class_Thread].object_size = sizeof(struct rt_thread);
module->module_object[RT_Object_Class_Thread].type = RT_Object_Class_Thread;
#ifdef RT_USING_SEMAPHORE
/* initialize object container - semaphore */
rt_list_init(&(module->module_object[RT_Object_Class_Semaphore].object_list));
module->module_object[RT_Object_Class_Semaphore].object_size = sizeof(struct rt_semaphore);
module->module_object[RT_Object_Class_Semaphore].type = RT_Object_Class_Semaphore;
#endif
#ifdef RT_USING_MUTEX
/* initialize object container - mutex */
rt_list_init(&(module->module_object[RT_Object_Class_Mutex].object_list));
module->module_object[RT_Object_Class_Mutex].object_size = sizeof(struct rt_mutex);
module->module_object[RT_Object_Class_Mutex].type = RT_Object_Class_Mutex;
#endif
#ifdef RT_USING_EVENT
/* initialize object container - event */
rt_list_init(&(module->module_object[RT_Object_Class_Event].object_list));
module->module_object[RT_Object_Class_Event].object_size = sizeof(struct rt_event);
module->module_object[RT_Object_Class_Event].type = RT_Object_Class_Event;
#endif
#ifdef RT_USING_MAILBOX
/* initialize object container - mailbox */
rt_list_init(&(module->module_object[RT_Object_Class_MailBox].object_list));
module->module_object[RT_Object_Class_MailBox].object_size = sizeof(struct rt_mailbox);
module->module_object[RT_Object_Class_MailBox].type = RT_Object_Class_MailBox;
#endif
#ifdef RT_USING_MESSAGEQUEUE
/* initialize object container - message queue */
rt_list_init(&(module->module_object[RT_Object_Class_MessageQueue].object_list));
module->module_object[RT_Object_Class_MessageQueue].object_size = sizeof(struct rt_messagequeue);
module->module_object[RT_Object_Class_MessageQueue].type = RT_Object_Class_MessageQueue;
#endif
#ifdef RT_USING_MEMHEAP
/* initialize object container - memory heap */
rt_list_init(&(module->module_object[RT_Object_Class_MemHeap].object_list));
module->module_object[RT_Object_Class_MemHeap].object_size = sizeof(struct rt_memheap);
module->module_object[RT_Object_Class_MemHeap].type = RT_Object_Class_MemHeap;
#endif
#ifdef RT_USING_MEMPOOL
/* initialize object container - memory pool */
rt_list_init(&(module->module_object[RT_Object_Class_MemPool].object_list));
module->module_object[RT_Object_Class_MemPool].object_size = sizeof(struct rt_mempool);
module->module_object[RT_Object_Class_MemPool].type = RT_Object_Class_MemPool;
#endif
#ifdef RT_USING_DEVICE
/* initialize object container - device */
rt_list_init(&(module->module_object[RT_Object_Class_Device].object_list));
module->module_object[RT_Object_Class_Device].object_size = sizeof(struct rt_device);
module->module_object[RT_Object_Class_Device].type = RT_Object_Class_Device;
#endif
/* initialize object container - timer */
rt_list_init(&(module->module_object[RT_Object_Class_Timer].object_list));
module->module_object[RT_Object_Class_Timer].object_size = sizeof(struct rt_timer);
module->module_object[RT_Object_Class_Timer].type = RT_Object_Class_Timer;
}
#ifdef RT_USING_HOOK
static void (*rt_module_load_hook)(rt_module_t module);
static void (*rt_module_unload_hook)(rt_module_t module);
/**
* @addtogroup Hook
*/
/*@{*/
/**
* This function will set a hook function, which will be invoked when module
* be loaded to system.
*
* @param hook the hook function
*/
void rt_module_load_sethook(void (*hook)(rt_module_t module))
{
rt_module_load_hook = hook;
}
/**
* This function will set a hook function, which will be invoked when module
* be unloaded from system.
*
* @param hook the hook function
*/
void rt_module_unload_sethook(void (*hook)(rt_module_t module))
{
rt_module_unload_hook = hook;
}
/*@}*/
#endif
/**
* @ingroup SystemInit
*
* This function will initialize system module
*/
void rt_system_module_init(void)
{
}
/**
* This function will return self module object
*
* @return the self module object
*/
rt_module_t rt_module_self(void)
{
rt_thread_t tid;
tid = rt_thread_self();
if (tid == RT_NULL)
return RT_NULL;
/* return current module */
return (rt_module_t)tid->module_id;
}
/**
* This function will find the specified module.
*
* @param name the name of module finding
*
* @return the module
*/
rt_module_t rt_module_find(const char *name)
{
struct rt_object_information *information;
struct rt_object *object;
struct rt_list_node *node;
extern struct rt_object_information rt_object_container[];
RT_DEBUG_NOT_IN_INTERRUPT;
/* enter critical */
rt_enter_critical();
/* try to find device object */
information = &rt_object_container[RT_Object_Class_Module];
for (node = information->object_list.next;
node != &(information->object_list);
node = node->next)
{
object = rt_list_entry(node, struct rt_object, list);
if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)
{
/* leave critical */
rt_exit_critical();
return (rt_module_t)object;
}
}
/* leave critical */
rt_exit_critical();
/* not found */
return RT_NULL;
}
#ifdef RT_USING_DFS
#include <windows.h>
#include <dfs_posix.h>
extern char * dfs_win32_dirdup(char * path);
static char* _module_name(const char *path)
{
const char *first, *end, *ptr;
char *name;
int size;
ptr = (char *)path;
first = ptr;
end = path + rt_strlen(path);
while (*ptr != '\0')
{
if (*ptr == '/')
first = ptr + 1;
if (*ptr == '.')
end = ptr - 1;
ptr ++;
}
size = end - first + 1;
name = rt_malloc(size);
rt_strncpy(name, first, size);
name[size] = '\0';
return name;
}
typedef int (*appentry_t)(void);
/**
* This function will load a module from a file
*
* @param path the full path of application module
*
* @return the module object
*/
rt_module_t rt_module_open(const char *path)
{
struct dfs_filesystem *fs;
appentry_t fptr;
HINSTANCE hinstlib;
int len;
char * winpath;
rt_module_t module;
char * name;
RT_DEBUG_NOT_IN_INTERRUPT;
/* check parameters */
RT_ASSERT(path != RT_NULL);
/* app module should only in DFS_WIN32 */
fs = dfs_filesystem_lookup(path);
if ((fs == RT_NULL) || (strcmp(fs->ops->name,"wdir") != 0))
{
rt_kprintf("invalid path: %s\n", path);
return RT_NULL;
}
/* change path */
len = strlen(path+1);
if ((winpath = dfs_win32_dirdup((char *)path)) == RT_NULL)
{
rt_kprintf("out of memory, exit", path);
return RT_NULL;
}
hinstlib = LoadLibrary(winpath);
if (hinstlib == NULL)
{
rt_kprintf("error: unable to open %s\n", winpath);
return RT_NULL;
}
fptr = (appentry_t)GetProcAddress(hinstlib, "main");
if (fptr == NULL)
{
rt_kprintf("error: unable to find function in %s\n", winpath);
FreeLibrary(hinstlib);
return RT_NULL;
}
/* get the name of the module */
name = _module_name(path);
/* allocate module */
module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module,
name);
if (!module)
return RT_NULL;
module->nref = 0;
module->module_entry = fptr;
/* init module object container */
rt_module_init_object_container(module);
/* increase module reference count */
module->nref ++;
if (module->module_entry != 0)
{
rt_uint32_t *stack_size;
rt_uint8_t *priority;
#ifdef RT_USING_SLAB
/* init module memory allocator */
module->mem_list = RT_NULL;
/* create page array */
module->page_array =
(void *)rt_malloc(PAGE_COUNT_MAX * sizeof(struct rt_page_info));
module->page_cnt = 0;
#endif
/* get the main thread stack size */
module->stack_size = 2048;
module->thread_priority = RT_THREAD_PRIORITY_MAX - 2;
/* create module thread */
module->module_thread =
rt_thread_create(name,
(void(*)(void *))module->module_entry,
RT_NULL,
module->stack_size,
module->thread_priority,
10);
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("thread entry 0x%x\n",
module->module_entry));
/* set module id */
module->module_thread->module_id = (void *)module;
module->parent.flag = RT_MODULE_FLAG_WITHENTRY;
/* startup module thread */
rt_thread_startup(module->module_thread);
}
else
{
/* without entry point */
module->parent.flag |= RT_MODULE_FLAG_WITHOUTENTRY;
}
#ifdef RT_USING_HOOK
if (rt_module_load_hook != RT_NULL)
{
rt_module_load_hook(module);
}
#endif
rt_free(name);
return module;
/* FreeLibrary(hinstlib); */
}
#if defined(RT_USING_FINSH)
#include <finsh.h>
FINSH_FUNCTION_EXPORT_ALIAS(rt_module_open, exec, exec module from a file);
#endif
#endif
rt_err_t rt_module_destroy(rt_module_t module)
{
return 0;
}
#endif

2
bsp/simulator/drivers/board.c
View File

@ -53,7 +53,7 @@ void rt_hw_win32_low_cpu(void)
#endif #endif
} }
#ifdef _WIN32 #ifdef _MSC_VER
#ifndef _CRT_TERMINATE_DEFINED #ifndef _CRT_TERMINATE_DEFINED
#define _CRT_TERMINATE_DEFINED #define _CRT_TERMINATE_DEFINED
_CRTIMP __declspec(noreturn) void __cdecl exit(__in int _Code); _CRTIMP __declspec(noreturn) void __cdecl exit(__in int _Code);

18
bsp/simulator/drivers/sdl_fb.c
View File

@ -151,6 +151,7 @@ static void sdlfb_hw_init(void)
#include <rtgui/rtgui_system.h> #include <rtgui/rtgui_system.h>
#ifdef _WIN32 #ifdef _WIN32
static HANDLE sdl_ok_event = NULL;
static DWORD WINAPI sdl_loop(LPVOID lpParam) static DWORD WINAPI sdl_loop(LPVOID lpParam)
#else #else
static void *sdl_loop(void *lpParam) static void *sdl_loop(void *lpParam)
@ -172,7 +173,9 @@ static void *sdl_loop(void *lpParam)
device = rt_device_find("sdl"); device = rt_device_find("sdl");
rtgui_graphic_set_device(device); rtgui_graphic_set_device(device);
#ifdef _WIN32
SetEvent(sdl_ok_event);
#endif
/* handle SDL event */ /* handle SDL event */
while (!quit) while (!quit)
{ {
@ -307,7 +310,15 @@ void rt_hw_sdl_start(void)
#ifdef _WIN32 #ifdef _WIN32
HANDLE thread; HANDLE thread;
DWORD thread_id; DWORD thread_id;
sdl_ok_event = CreateEvent(NULL,
FALSE,
FALSE,
NULL);
if (sdl_ok_event == NULL)
{
printf("error, create SDL event failed\n");
exit(-1);
}
/* create thread that loop sdl event */ /* create thread that loop sdl event */
thread = CreateThread(NULL, thread = CreateThread(NULL,
0, 0,
@ -322,6 +333,9 @@ void rt_hw_sdl_start(void)
return; return;
} }
ResumeThread(thread); ResumeThread(thread);
/* wait until SDL LCD device is registered and seted */
WaitForSingleObject(sdl_ok_event, INFINITE);
#else #else
/* Linux */ /* Linux */
pthread_t pid; pthread_t pid;

4
bsp/simulator/dummy.c Normal file
View File

@ -0,0 +1,4 @@
int dummy_main()
{
return 0;
}

222
bsp/simulator/mingw.ld Normal file
View File

@ -0,0 +1,222 @@
/* Default linker script, for normal executables */
OUTPUT_FORMAT(pei-i386)
SEARCH_DIR("/usr/local/mingw32/lib"); SEARCH_DIR("/usr/local/lib"); SEARCH_DIR("/lib"); SEARCH_DIR("/usr/lib");
SECTIONS
{
/* Make the virtual address and file offset synced if the alignment is
lower than the target page size. */
. = SIZEOF_HEADERS;
. = ALIGN(__section_alignment__);
.text __image_base__ + ( __section_alignment__ < 0x1000 ? . : __section_alignment__ ) :
{
*(.init)
*(.text)
*(SORT(.text$*))
*(.glue_7t)
*(.glue_7)
___CTOR_LIST__ = .; __CTOR_LIST__ = . ;
LONG (-1);*(.ctors); *(.ctor); *(SORT(.ctors.*)); LONG (0);
___DTOR_LIST__ = .; __DTOR_LIST__ = . ;
LONG (-1); *(.dtors); *(.dtor); *(SORT(.dtors.*)); LONG (0);
*(.fini)
/* ??? Why is .gcc_exc here? */
*(.gcc_exc)
PROVIDE (etext = .);
*(.gcc_except_table)
}
/* setction information for finsh shell begin */
. = ALIGN(__section_alignment__);
FSymTab () :
{
___fsymtab_start = .; __fsymtab_start = .;
KEEP(*(FSymTab))
___fsymtab_end = .; __fsymtab_end = .;
}
. = ALIGN(__section_alignment__);
VSymTab () :
{
___vsymtab_start = .; __vsymtab_start = .;
KEEP(*(VSymTab))
___vsymtab_end = .; __vsymtab_end = .;
}
/* setction information for finsh shell end */
/* The Cygwin32 library uses a section to avoid copying certain data
on fork. This used to be named ".data". The linker used
to include this between __data_start__ and __data_end__, but that
breaks building the cygwin32 dll. Instead, we name the section
".data_cygwin_nocopy" and explictly include it after __data_end__. */
.data BLOCK(__section_alignment__) :
{
__data_start__ = . ;
*(.data)
*(.data2)
*(SORT(.data$*))
*(.jcr)
__data_end__ = . ;
*(.data_cygwin_nocopy)
}
.rdata BLOCK(__section_alignment__) :
{
*(.rdata)
*(SORT(.rdata$*))
*(.eh_frame)
___RUNTIME_PSEUDO_RELOC_LIST__ = .;
__RUNTIME_PSEUDO_RELOC_LIST__ = .;
*(.rdata_runtime_pseudo_reloc)
___RUNTIME_PSEUDO_RELOC_LIST_END__ = .;
__RUNTIME_PSEUDO_RELOC_LIST_END__ = .;
}
.pdata BLOCK(__section_alignment__) :
{
*(.pdata)
}
.bss BLOCK(__section_alignment__) :
{
__bss_start__ = . ;
*(.bss)
*(COMMON)
__bss_end__ = . ;
}
.edata BLOCK(__section_alignment__) :
{
*(.edata)
}
/DISCARD/ :
{
*(.debug$S)
*(.debug$T)
*(.debug$F)
*(.drectve)
}
.idata BLOCK(__section_alignment__) :
{
/* This cannot currently be handled with grouped sections.
See pe.em:sort_sections. */
SORT(*)(.idata$2)
SORT(*)(.idata$3)
/* These zeroes mark the end of the import list. */
LONG (0); LONG (0); LONG (0); LONG (0); LONG (0);
SORT(*)(.idata$4)
SORT(*)(.idata$5)
SORT(*)(.idata$6)
SORT(*)(.idata$7)
}
.CRT BLOCK(__section_alignment__) :
{
___crt_xc_start__ = . ;
*(SORT(.CRT$XC*)) /* C initialization */
___crt_xc_end__ = . ;
___crt_xi_start__ = . ;
*(SORT(.CRT$XI*)) /* C++ initialization */
___crt_xi_end__ = . ;
___crt_xl_start__ = . ;
*(SORT(.CRT$XL*)) /* TLS callbacks */
/* ___crt_xl_end__ is defined in the TLS Directory support code */
___crt_xp_start__ = . ;
*(SORT(.CRT$XP*)) /* Pre-termination */
___crt_xp_end__ = . ;
___crt_xt_start__ = . ;
*(SORT(.CRT$XT*)) /* Termination */
___crt_xt_end__ = . ;
}
.tls BLOCK(__section_alignment__) :
{
___tls_start__ = . ;
*(.tls)
*(.tls$)
*(SORT(.tls$*))
___tls_end__ = . ;
}
.endjunk BLOCK(__section_alignment__) :
{
/* end is deprecated, don't use it */
PROVIDE (end = .);
PROVIDE ( _end = .);
__end__ = .;
}
.rsrc BLOCK(__section_alignment__) :
{
*(.rsrc)
*(SORT(.rsrc$*))
}
.reloc BLOCK(__section_alignment__) :
{
*(.reloc)
}
.stab BLOCK(__section_alignment__) (NOLOAD) :
{
*(.stab)
}
.stabstr BLOCK(__section_alignment__) (NOLOAD) :
{
*(.stabstr)
}
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section. Unlike other targets that fake this by putting the
section VMA at 0, the PE format will not allow it. */
/* DWARF 1.1 and DWARF 2. */
.debug_aranges BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_aranges)
}
.debug_pubnames BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_pubnames)
}
/* DWARF 2. */
.debug_info BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_info) *(.gnu.linkonce.wi.*)
}
.debug_abbrev BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_abbrev)
}
.debug_line BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_line)
}
.debug_frame BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_frame)
}
.debug_str BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_str)
}
.debug_loc BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_loc)
}
.debug_macinfo BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_macinfo)
}
/* SGI/MIPS DWARF 2 extensions. */
.debug_weaknames BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_weaknames)
}
.debug_funcnames BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_funcnames)
}
.debug_typenames BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_typenames)
}
.debug_varnames BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_varnames)
}
/* DWARF 3. */
.debug_ranges BLOCK(__section_alignment__) (NOLOAD) :
{
*(.debug_ranges)
}
}

227
bsp/simulator/readme.txt
View File

@ -1,23 +1,35 @@
说明: 本BSP可以如下演示 说明: 本BSP可以如下演示
默认演示realtouch GUI效果，并提供了一个贪吃的demo用于演示
目前支持的功能有 一 平台及组件支持
1). LWIP（可以打开LWIP选项，不过尚存在bug，不建议使用） 目前rtconfig.py中支持的编译器有
2). 文件系统支持，支持ELM FatFS，UFFS，JFFS2 1). msvc 用于windows平台
3). RTGUI支持 此平台支持的组件
目前SVN中的RTGUI源码可以直接用于simulator。 kernel
如果读者想快速在simulator上体验RTGUI，那么不需要修改任何文件，首先在命令行中使用 finsh
scons --target=vs -s LWIP
生成工程后，打开project.vsproj编译，即可看到realtouch的ui出现，然后执行 DFS, ELM FatFS, UFFS, JFFS2, DFS_WIN32
在finsh中执行snake_main()，即可运行贪吃蛇demo RTGUI
APP MODULE
2). mingw 用于windows平台
kernel
finsh
DFS, ELM FatFS, UFFS, DFS_WIN32
RTGUI
APP MODULE
3). gcc 用于linux平台
kernel
finsh
DFS, ELM FatFS, UFFS
RTGUI
再补充说明一点，RTGUI的最新源码目前是托管在git上。 二 组件配置
github网页：https://github.com/RT-Thread/RTGUI 1) RTGUI
如果要使用rtgui中的最新源码，共有两种方法。 当前代码中已经不含RTGUI源码，因此读者需要配置一下才能在simulator中使用RTGUI
RTGUI的最新源码目前是托管在github上：https://github.com/RT-Thread/RTGUI
共有两种方法。
方法1 添加环境变量 方法1 添加环境变量
向系统环境变量中加入RTT_RTGUI，其值为刚才github上下载的rtgui源码包的路径。 向系统加入RTT_RTGUI环境变量，其值为刚才github上下载的rtgui源码包的路径。
例如笔者的rtgui源码包解压至 F:\Project\git\rt-gui\下 例如笔者的rtgui源码包解压至 F:\Project\git\rt-gui\下， 则将此环境变量配置为 F:\Project\git\rt-gui\components\rtgui
则将此环境变量配置为 F:\Project\git\rt-gui\components\rtgui
方法2 不添加环境变量 方法2 不添加环境变量
打开SConstruct文件， 打开SConstruct文件，
.... ....
@ -37,106 +49,105 @@
1)#号表示注释，类似于c语言中的//， 1)#号表示注释，类似于c语言中的//，
2)其中15行的路径为你的RTGUI路径源码，注意不是压缩包路径，而是压缩包路径下的 components\rtgui目录的绝对路径。 2)其中15行的路径为你的RTGUI路径源码，注意不是压缩包路径，而是压缩包路径下的 components\rtgui目录的绝对路径。
1 编译： 三 编译
1.1 使用Visual Studio(2005以上版本） 1) 使用Visual Studio(2005以上版本)
在命令行中执行 scons --target=vs -s 可以生成vs2005的工程，名为project.vsproj 在当前目录中打开cmd，输入命令
`scons --target=vs -s`
可以生成project.vsproj，双击运行
编译后运行 2) 命令行编译
修改rtconfig.py, 配置合适的编译器(msvc/mingw/gcc)，及其路径
1.2 使用scons编译，在当前目录中打开cmd，输入 在当前目录中打开cmd，输入命令
scons -j4 `scons -j4`
编译完成后会在当前目录下生成 rtthrad-win32.exe，双击即可运行。 编译完成后会在当前目录下生成 rtthrad-win32.exe，双击即可运行。
2. 测试文件系统
运行：
编译后运行，会弹出CMD命令行窗口，可以看到控制台的输出信息，如下所示
\ | /
- RT - Thread Operating System
/ | \ 1.1.0 build Oct 21 2012
2006 - 2012 Copyright by rt-thread team
init jffs2 lock mutex okay
hello, world
finsh>>fatfs initialzation failed!
uffs initialzation failed!
jffs2 initialzation failed!
thread 29e4 exit
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
thread 2898 exit
注意上面的信息显示，fatfs/uffs/jffs2均挂载失败，这是因为我们还没有为sd.bin创建fat分区，并且sd上也没有目录用于挂载jffs2和uffs。
并且此时当前bsp目录下，新增了三个文件用于模拟sd卡，nand flash与nor flash，它们是
sd.bin--模拟SD卡，挂载fat，大小为16M
nand.bin-模拟nand flash，挂载uffs，参数page=2048+64bytes，block=64pages，16M
nor.bin--模拟nor flash，挂载jffs2，型号为sst25vf，2M
按下回车，出现finsh，然后输入如下命令格式化sd.bin
四 程序测试
1) 测试文件系统
此时当前目录下，新增了三个文件
sd.bin--模拟SD卡，挂载fat，大小为16M
nand.bin-模拟nand flash，挂载uffs，参数page=2048+64bytes，block=64pages，16M
nor.bin--模拟nor flash，挂载jffs2，型号为sst25vf，2M
第一次启动时，会看到fatfs挂在失败。
按下回车，出现finsh，然后输入`mkfs("elm", "sd0")`格式化SD卡，如下所示
finsh>>mkfs("elm", "sd0") finsh>>mkfs("elm", "sd0")
0, 0x00000000 0, 0x00000000
finsh>> 然后重启程序，就可以看到fatfs挂载成功了
关闭程序重新运行，此时可以看到fatfs挂载成功，不过jffs2和uffs依然失败，如下所示。 2) 测试RTGUI
\ | / 启动后就会看到GUI窗口，分辨率800x480，此时在finsh中输入snake_main()并回车，即可运行贪吃蛇程序
- RT - Thread Operating System
/ | \ 1.1.0 build Oct 21 2012
2006 - 2012 Copyright by rt-thread team
init jffs2 lock mutex okay
hello, world
finsh>>fatfs initialized!
uffs initialzation failed!
jffs2 initialzation failed!
这是因为sd上还没有目录来用于挂载jffs2和uffs，在finsh中输入如下命令在sd上创建nand与nor文件夹，分别用于挂载uffs与jffs2文件系统。 3) 测试APP module
rtconfig.h中需要打开RT_USING_MODULE
finsh>>mkdir("/nand") a. 生成rtthread.def文件
0, 0x00000000 使用msv编译主程序时需要此文件，使用MingW编译主程序时不需要
finsh>>mkdir("/nor") msvc需要此文件才能生成正确导出符号的rtthread.dll和rtthread-win32.exe。
0, 0x00000000 此目录下默认自带了一个rtthread.def文件，当修改了rtconfig.h，禁用了某些组件时，则需要重新生成rtthread.def文件.
finsh>> 生成方法：
然后再次关闭程序后重新运行，此时可以看到jffs2与uffs挂载成功。 需要借助MingW工具，修改rtconfig.py中CROSS_TOOL为'mingw'，然后打开CMD执行`scons --def`就会自动更新rtthread.def。
最终输出如下所示： b. 生成主程序
主程序可以使用msvc和mingw生成
如果rtconfig.h中的使能了RTGUI，则需要参考第二节第1小节配置RTGUI
a.1 使用msvc
修改rtconfig.py中CROSS_TOOL为'msvc'
首先要保证当前目录下有合适的rtthread.def文件，如果没有对默认的rtconfig.h作修改，则使用默认的rtthread.def即可
CMD命令行执行`scons -j4`，即可生成rtthread.dll和 rtthread-win32.exe
a.2 使用mingw
修改rtconfig.py中CROSS_TOOL为'mingw'
CMD命令行执行`scons -j4`，这就会生成 rtthread.dll和 rtthread-win32.exe
\ | / c. 生成app module
- RT - Thread Operating System 进入testdll目录，再次修改 testdll/SConstruct， 同样需要配置RTT_RTGUI路径，同 1中3)
/ | \ 1.1.0 build Oct 21 2012 在此目录下执行
2006 - 2012 Copyright by rt-thread team `scons --app=basicapp`
init jffs2 lock mutex okay 就会在 basicapp/building目录下生成 basicapp.dll。
hello, world
finsh>>fatfs initialized!
os : system memory alloc 320 bytes
flsh: ECC size 24
flsh: UFFS consume spare data size 34
os : system memory alloc 83520 bytes
os : system memory alloc 52400 bytes
os : system memory alloc 2048 bytes
tree: DIR 0, FILE 0, DATA 0
uffs initialized!
jffs2 initialized!
thread 2fb4 exit
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
hello, world
thread 312c exit
Ok，到现在，一个完整的文件系统测试环境就搭建完毕了，enjoy～～ 然后运行simulator目录下的 rtthread-win32.exe, 在finsh中运行
`exec("/testdll/basicapp/building/basicapp.dll")`
如果觉得这个路径太长，就把 basicapp.dll复制到 simualtor目录下，执行
`exec("/basicapp.dll")`
3 测试RTGUI 如果想编译RTGUI应用，如testdll目录下的snake，则需要对RTGUI打一点补丁，共有两个方法
启动后就会看到GUI窗口，分辨率800×480串口，并出现图形界面。 1. 注释掉 //#define RTGUI_USING_CAST_CHECK`
此时在finsh中输入 snake_main()并回车，即可运行贪吃蛇程序。 找到rtgui_config.h源码，注释掉如下语句
//#define RTGUI_USING_CAST_CHECK`
然后在testdll目录下打开CMD窗口，执行`scons --app=snake`，才可以正确编译，如果不注释掉上面的宏，则会出现链接错误。
2. 不注释掉#define RTGUI_USING_CAST_CHECK`
那么需要如下两个补丁
1) 修改testdll/SConstruct文件
diff --git a/bsp/simulator/testdll/SConstruct b/bsp/simulator/testdll/SConstruct
index 3324f88..005289c 100644
--- a/bsp/simulator/testdll/SConstruct
+++ b/bsp/simulator/testdll/SConstruct
@@ -70,6 +70,7 @@ env.Append(CCFLAGS=rtconfig.CFLAGS)
env.Append(LINKFLAGS=rtconfig.LFLAGS)
env.Append(CPPPATH=CPPPATH)
env.Append(LIBS='rtthread', LIBPATH='../')
+env.Append(CPPDEFINES=['RTT_IN_MODULE'])
env.PrependENVPath('PATH', rtconfig.EXEC_PATH)
PrepareModuleBuilding(env, RTT_ROOT)
2) 修改RTGUI源码
diff --git a/components/rtgui/include/rtgui/rtgui_object.h b/components/rtgui/include/rtgui/rtgui_object.h
index 57fd47f..b32ee17 100644
--- a/components/rtgui/include/rtgui/rtgui_object.h
+++ b/components/rtgui/include/rtgui/rtgui_object.h
@@ -56,7 +56,12 @@ extern "C" {
typedef struct rtgui_type rtgui_type_t;
#define RTGUI_TYPE(type) (struct rtgui_type*)&(_rtgui_##type)
+#ifdef RTT_IN_MODULE
+#define DECLARE_CLASS_TYPE(type) _declspec(dllimport) const struct rtgui_type _rtgui_##type
+#else
#define DECLARE_CLASS_TYPE(type) extern const struct rtgui_type _rtgui_##type
+#endif
+
#define DEFINE_CLASS_TYPE(type, name, parent, constructor, destructor, size) \
const struct rtgui_type _rtgui_##type = { \
name, \
然后再编译snake，可以正确生成。测试方法同basicapp

10
bsp/simulator/rtconfig.h
View File

@ -21,6 +21,10 @@
#elif defined(__GNUC__) #elif defined(__GNUC__)
#define RT_USING_NOLIBC #define RT_USING_NOLIBC
#if defined(__MINGW32__)
#define _NO_OLDNAMES /* to ignore: mode_t in sys/type.h */
#endif
#endif #endif
/* SECTION: basic kernel options */ /* SECTION: basic kernel options */
@ -83,6 +87,7 @@
/* SECTION: Device System */ /* SECTION: Device System */
/* Using Device System */ /* Using Device System */
#define RT_USING_DEVICE #define RT_USING_DEVICE
#define RT_USING_DEVICE_IPC
/* #define RT_USING_UART1 */ /* #define RT_USING_UART1 */
/* SECTION: Console options */ /* SECTION: Console options */
@ -94,11 +99,14 @@
/* SECTION: component options */ /* SECTION: component options */
#define RT_USING_COMPONENTS_INIT #define RT_USING_COMPONENTS_INIT
/* SECTION: APP MODULE */
#define RT_USING_MODULE
/* SECTION: MTD interface options */ /* SECTION: MTD interface options */
/* using mtd nand flash */ /* using mtd nand flash */
#define RT_USING_MTD_NAND #define RT_USING_MTD_NAND
/* using mtd nor flash */ /* using mtd nor flash */
#define RT_USING_MTD_NOR /* #define RT_USING_MTD_NOR */
/* SECTION: finsh, a C-Express shell */ /* SECTION: finsh, a C-Express shell */
#define RT_USING_FINSH #define RT_USING_FINSH

42
bsp/simulator/rtconfig.py
View File

@ -1,7 +1,7 @@
# toolchains options # toolchains options
ARCH='sim' ARCH='sim'
#CROSS_TOOL='msvc' or 'gcc' or 'mingw' (mingw is not supported yet!) #CROSS_TOOL='msvc' or 'gcc' or 'mingw' (mingw is not supported yet!)
CROSS_TOOL='msvc' CROSS_TOOL='mingw'
# cross_tool provides the cross compiler # cross_tool provides the cross compiler
# EXEC_PATH is the compiler execute path # EXEC_PATH is the compiler execute path
@ -10,11 +10,20 @@ if CROSS_TOOL == 'gcc':
PLATFORM = 'gcc' PLATFORM = 'gcc'
EXEC_PATH = '/usr/bin/gcc' EXEC_PATH = '/usr/bin/gcc'
if CROSS_TOOL == 'msvc': elif CROSS_TOOL == 'mingw':
CPU = 'win32'
PLATFORM = 'mingw'
EXEC_PATH = r'D:\Program Files\CodeBlocks\MinGW\bin'
elif CROSS_TOOL == 'msvc':
CPU = 'win32' CPU = 'win32'
PLATFORM = 'cl' PLATFORM = 'cl'
EXEC_PATH = '' EXEC_PATH = ''
else :
print "bad CROSS TOOL!"
exit(1)
BUILD = 'debug' BUILD = 'debug'
#BUILD = '' #BUILD = ''
@ -48,6 +57,35 @@ if PLATFORM == 'gcc':
POST_ACTION = '' POST_ACTION = ''
elif PLATFORM == 'mingw':
# toolchains
PREFIX = ''
CC = PREFIX + 'gcc'
AS = PREFIX + 'gcc'
AR = PREFIX + 'ar'
LINK = PREFIX + 'gcc'
TARGET_EXT = 'exe'
SIZE = PREFIX + 'size'
OBJDUMP = PREFIX + 'objdump'
OBJCPY = PREFIX + 'objcopy'
DEVICE = ' -ffunction-sections -fdata-sections'
DEVICE = ' '
CFLAGS = DEVICE
AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp'
DEFFILE_LFLAGS = DEVICE + ' -Wl,-Map=rtthread-win32.map,--output-def,rtthread.def -T mingw.ld '
LFLAGS = DEVICE + ' -Wl,-Map=rtthread-win32.map -T mingw.ld '
CPATH = ''
LPATH = ''
if BUILD == 'debug':
CFLAGS += ' -g -O0 -gdwarf-2'
AFLAGS += ' -gdwarf-2'
else:
CFLAGS += ' -O2'
POST_ACTION = ''
elif PLATFORM == 'cl': elif PLATFORM == 'cl':
# toolchains # toolchains
PREFIX = '' PREFIX = ''

1430
bsp/simulator/rtthread.def Normal file
View File

File diff suppressed because it is too large Load Diff

84
bsp/simulator/testdll/SConstruct Normal file
View File

@ -0,0 +1,84 @@
import os
import sys
import SCons.cpp
import rtconfig
if os.getenv('RTT_ROOT'):
RTT_ROOT = os.getenv('RTT_ROOT')
else:
RTT_ROOT = os.path.normpath(os.getcwd() + '/../..')
if os.getenv('RTT_RTGUI'):
RTT_RTGUI = os.getenv('RTT_RTGUI')
else:
# set the rtgui root directory by hand
# empty string means use the RTGUI in svn
RTT_RTGUI = os.path.normpath(r'F:\Project\git\rt-gui\components\rtgui')
# RTT_RTGUI =''
sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
from building import *
Export('RTT_ROOT')
# add target option
AddOption('--app',
dest='app',
nargs=1, type='string',
action='store',
metavar='DIR',
help='installation prefix')
# add target option
AddOption('--type',
dest='type',
nargs=1, type='string',
action='store',
metavar='DIR',
help='installation prefix')
app = GetOption('app')
env = Environment()
CPPPATH = [
RTT_ROOT + '/include',
RTT_ROOT + '/bsp/' + rtconfig.BSP,
RTT_ROOT + '/components/finsh',
RTT_ROOT + '/components/libdl',
RTT_ROOT + '/components/external/ftk/ftk/src/os/rt-thread',
RTT_ROOT + '/components/external/ftk/ftk/src/demos',
RTT_ROOT + '/components/external/ftk/ftk/apps/common',
RTT_ROOT + '/components/external/ftk/ftk/src',
RTT_ROOT + '/components/dfs',
RTT_ROOT + '/components/dfs/include',
RTT_ROOT + '/components/libc/newlib',
RTT_ROOT + '/components/external/cairo/cairo-1.10.2/src',
RTT_ROOT + '/components/external/cairo/'
]
if RTT_RTGUI:
RTGUI_ROOT = RTT_RTGUI
else:
RTGUI_ROOT = RTT_ROOT + '/components/rtgui'
RTGUI_PATH = [
RTGUI_ROOT + '/include',
RTGUI_ROOT + '/common',
RTGUI_ROOT + '/server',
RTGUI_ROOT + '/widgets',
]
CPPPATH += RTGUI_PATH
env.Append(CCFLAGS=rtconfig.CFLAGS)
env.Append(LINKFLAGS=rtconfig.LFLAGS)
env.Append(CPPPATH=CPPPATH)
env.Append(LIBS='rtthread', LIBPATH='../')
env.PrependENVPath('PATH', rtconfig.EXEC_PATH)
PrepareModuleBuilding(env, RTT_ROOT)
#dir = app + '/build/' + rtconfig.BSP
dir = app + '/build/'
objs = SConscript(app + '/Sconscript', variant_dir=dir, duplicate=0)
TARGET = dir + '/' + app + '.' + rtconfig.TARGET_EXT
# build program
#env.Program(TARGET, objs)
env.SharedLibrary(TARGET, objs)

7
bsp/simulator/testdll/basicapp/Sconscript Normal file
View File

@ -0,0 +1,7 @@
import rtconfig
Import('RTT_ROOT')
from building import *
src = Glob('*.c')
group = DefineGroup('', src, depend = [''])
Return('group')

30
bsp/simulator/testdll/basicapp/basicapp.c Normal file
View File

@ -0,0 +1,30 @@
#include <rtthread.h>
static int a = 0;
static int b = 1000000;
int c = 100;
static void function(int count1, int count2, int count3)
{
rt_kprintf("Hello RT-Thread %d %d\n", count1, count2, count3);
}
int main(void)
{
int i;
rt_kprintf("application entry\n");
rt_kprintf("[addr]a-0x%x,b-0x%x,c-0x%x\n", &a, &b, &c);
rt_kprintf("[value]a-%d,b-%d,c-%d\n", a, b, c);
for(i=0; i<100; i++)
{
a++;
b--;
c++;
function(a, c, b );
}
return 0;
}

7
bsp/simulator/testdll/label/Sconscript Normal file
View File

@ -0,0 +1,7 @@
import rtconfig
Import('RTT_ROOT')
from building import *
src = Glob('*.c')
group = DefineGroup('', src, depend = [''])
Return('group')

74
bsp/simulator/testdll/label/label_demo1.c Normal file
View File

@ -0,0 +1,74 @@
#include <rtthread.h>
#include <rtgui/rtgui.h>
#include <rtgui/rtgui_app.h>
#include <rtgui/widgets/window.h>
#include <rtgui/widgets/label.h>
#include <rtgui/driver.h>
/* 在LCD上创建一个主窗口，这是第一个窗口 */
static void win_thread_entry(void *parameter)
{
struct rtgui_app *app;
struct rtgui_win *win;
struct rtgui_label *label;
struct rtgui_rect rect;
app = rtgui_app_create(rt_thread_self(), "MyApp");
RT_ASSERT(app != RT_NULL);
/* create a full screen window */
rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &rect);
win = rtgui_win_create(RT_NULL, "MainWin", &rect,
RTGUI_WIN_STYLE_NO_BORDER | RTGUI_WIN_STYLE_NO_TITLE);
if (win == RT_NULL)
{
rtgui_app_destroy(app);
return;
}
/* 建立一个label，内容为helloworld */
label = rtgui_label_create("Hello World!");
/* 设置label的位置，这里是绝对坐标 */
rect.x1 = 0;
rect.y1 = 100;
rect.x2 = 240;
rect.y2 = 140;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rt_kprintf("bc: %x\n", RTGUI_WIDGET_BACKGROUND(label));
rt_kprintf("fc: %x\n", RTGUI_WIDGET_FOREGROUND(label));
#if 0
RTGUI_WIDGET_BACKGROUND(label) = 0;
RTGUI_WIDGET_FOREGROUND(label) = RTGUI_RGB(0xFF, 0xFF, 0);
#endif
/*添加label到主窗口*/
rtgui_container_add_child(RTGUI_CONTAINER(win), RTGUI_WIDGET(label));
/* 显示主窗口 */
rtgui_win_show(win, RT_FALSE);
/* 循环 */
rtgui_app_run(app);
rtgui_win_destroy(win);
rtgui_app_destroy(app);
rt_kprintf("MyApp Quit.\n");
}
int main()
{
rt_thread_t tid;
tid = rt_thread_create("win", win_thread_entry, RT_NULL,
2048, 20, 20);
if (tid != RT_NULL)
{
rt_thread_startup(tid);
}
return 0;
}

51
bsp/simulator/testdll/rtconfig.py Normal file
View File

@ -0,0 +1,51 @@
# bsp name
BSP = 'simulator'
# toolchains
EXEC_PATH = ''
PREFIX = ''
TARGET_EXT = 'dll'
AS = PREFIX + 'cl'
CC = PREFIX + 'cl'
AR = PREFIX + 'cl'
LINK = PREFIX + 'cl'
AFLAGS = ''
CFLAGS = ''
LFLAGS = ''
BUILD = 'debug'
if BUILD == 'debug':
CFLAGS += ' /MTd'
LFLAGS += ' /DEBUG'
else:
CFLAGS += ' /MT'
LFLAGS += ''
CFLAGS += ' /ZI /Od /W 3 /WL'
LFLAGS += ' /DEF:rttapp.def /SUBSYSTEM:CONSOLE /MACHINE:X86'
#LFLAGS += ' /DEF:rttapp.def /SUBSYSTEM:WINDOWS /MACHINE:X86' #/ENTRY:mainCRTStartup
CPATH = ''
LPATH = ''
'''
EXEC_PATH = 'C:/Program Files/CodeSourcery/Sourcery G++ Lite/bin'
PREFIX = 'arm-none-eabi-'
CC = PREFIX + 'gcc'
CXX = PREFIX + 'g++'
AS = PREFIX + 'gcc'
AR = PREFIX + 'ar'
LINK = PREFIX + 'gcc'
TARGET_EXT = 'so'
SIZE = PREFIX + 'size'
OBJDUMP = PREFIX + 'objdump'
OBJCPY = PREFIX + 'objcopy'
DEVICE = ' -mcpu=arm920t'
CFLAGS = DEVICE + ' -O0 -fPIC -DFTK_AS_PLUGIN -DRT_THREAD '
AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp'
LFLAGS = DEVICE + ' -Wl,-z,max-page-size=0x4 -shared -fPIC -nostdlib -s'
CPATH = ''
LPATH = ''
'''

3
bsp/simulator/testdll/rttapp.def Normal file
View File

@ -0,0 +1,3 @@
LIBRARY app
EXPORTS
main

7
bsp/simulator/testdll/snake/SConscript Normal file
View File

@ -0,0 +1,7 @@
import rtconfig
Import('RTT_ROOT')
from building import *
src = Glob('*.c')
group = DefineGroup('', src, depend = [''])
Return('group')

271
bsp/simulator/testdll/snake/snake.c Normal file
View File

@ -0,0 +1,271 @@
#include <string.h>
#include <stdlib.h>
#include <rtthread.h>
#include "snake.h"
#define ASSERT_RET(x, ret) \
do{ \
if (x) \
return ret; \
}while(0)
rt_list_t snake_head;
SNAKE_DIR prevdir, newdir;
static SNAKE_DIR dir_adjust(SNAKE_DIR dir)
{
if ((SNAKE_DIR_UP == prevdir && SNAKE_DIR_DOWN != dir)
|| (SNAKE_DIR_DOWN == prevdir && SNAKE_DIR_UP != dir)
|| (SNAKE_DIR_LEFT == prevdir && SNAKE_DIR_RIGHT != dir)
|| (SNAKE_DIR_RIGHT == prevdir && SNAKE_DIR_LEFT != dir)
)
{
newdir = dir;
}
else
{
rt_kprintf("dirction change error\n\r");
}
return newdir;
}
static void across_XY(point_t *node, const map_t *map)
{
RT_ASSERT(node != RT_NULL && map != RT_NULL);
// 如果长度超出当前边框则可以穿越墙到对面
node->x = (node->x + map->width) % map->width;
node->y = (node->y + map->height) % map->height;
}
static SYS_STE node_update(snake_t *tail, const point_t *node, map_t *map)
{
SYS_STE ret;
point_t *pos;
RT_ASSERT(tail != RT_NULL && node != RT_NULL && map != RT_NULL);
pos = map->snake_flush;
pos[0].x = pos[0].y = -1;
pos[1].x = pos[1].y = -1;
ret = (SYS_STE)map->range[node->y * map->width + node->x];
if (FOOD == map->range[node->y * map->width + node->x])
{
// 吃一个食物增加一个节点
snake_t *new = (snake_t *)rt_malloc(sizeof(snake_t));
if (!new)
return NORMAL;
pos[0] = *node;
new->body = *node;
rt_list_insert_after(&snake_head, &new->list);
}
else if (NORMAL == map->range[node->y * map->width + node->x])
{
// 将尾巴修改后拿到头部，其他不变
rt_list_remove(&tail->list);
map->range[tail->body.y * map->width + tail->body.x] = NORMAL;
pos[0] = *node;
pos[1] = tail->body;
tail->body = *node;
rt_list_insert_after(&snake_head, &tail->list);
}
map->range[node->y * map->width + node->x] = OVER;
if (ret != OVER)
prevdir = newdir;
return ret;
}
map_t *map_init(rt_uint32_t width, rt_uint32_t heigth)
{
map_t *map = rt_malloc(sizeof(map_t));
if (map != RT_NULL)
{
map->range = rt_malloc(heigth * width);
if (!map->range)
{
rt_free(map);
map = RT_NULL;
}
else
{
map->width = width;
map->height = heigth;
memset(map->range, NORMAL, heigth * width);
}
}
return map;
}
// 构造一条指定长度的蛇在指定点
rt_bool_t snake_init(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map)
{
rt_int32_t i;
rt_int32_t inc_x, inc_y;
point_t old = *start;
ASSERT_RET(!map || !start, RT_FALSE);
rt_list_init(&snake_head);
if (dir == SNAKE_DIR_UP || dir == SNAKE_DIR_DOWN)
{
if (map->height <= length)
return RT_FALSE;
inc_x = 0;
inc_y = dir == SNAKE_DIR_DOWN ? 1 : -1; // 反向延长身子，头部在指定位置
old.y -= inc_y;
}
else
{
if (map->width <= length)
return RT_FALSE;
inc_y = 0;
inc_x = dir == SNAKE_DIR_RIGHT ? -1 : 1;
old.x -= inc_x;
}
for (i = 0; i < length; i++)
{
snake_t *new = (snake_t *)rt_malloc(sizeof(snake_t));
if (!new)
return RT_FALSE;
new->body.y = inc_y + old.y;
new->body.x = inc_x + old.x;
// 如果长度超出当前边框则可以穿越墙到对面
across_XY(&new->body, map);
map->range[new->body.y * map->width + new->body.x] = OVER;
old = new->body;
rt_list_insert_before(&snake_head, &new->list);
}
prevdir = dir;
return RT_TRUE;
}
// 构造出食物
rt_bool_t food_init(map_t *map, rt_uint32_t max_num)
{
point_t food;
#ifndef FOOD_TIMEOUT
#define FOOD_TIMEOUT 10
#endif
rt_uint32_t timeout, num;
ASSERT_RET(!map, RT_FALSE);
num = 0;
timeout = rt_tick_get();
srand(rand());
map->food_flush[0].x = map->food_flush[0].y = -1;
do
{
food.x = rand() % map->width;
food.y = rand() % map->height;
if (map->range[food.y * map->width + food.x] == NORMAL)
{
map->food_flush[0] = food;
map->range[food.y * map->width + food.x] = FOOD;
num++;
}
}
while (num < max_num && rt_tick_get() - timeout < FOOD_TIMEOUT);
return num;
}
void map_deinit(map_t *map)
{
if (map)
{
if (map->range)
{
rt_free(map->range);
map->range = RT_NULL;
}
rt_free(map);
}
}
void snake_deinit(void)
{
snake_t *node;
while (!rt_list_isempty(&snake_head))
{
node = rt_list_entry(snake_head.prev, snake_t, list);
rt_list_remove(&node->list);
rt_free(node);
}
}
void food_deinit(void)
{
}
SYS_STE snake_step(SNAKE_DIR dir, map_t *map)
{
snake_t *tail, *head;
point_t node;
ASSERT_RET(!map, RT_FALSE);
dir = dir_adjust(dir);
// 取出头尾两个节点，其他节点不需要改变
tail = rt_list_entry(snake_head.prev, snake_t, list);
head = rt_list_entry(snake_head.next, snake_t, list);
node = head->body;
// 构造一个新的蛇头坐标
switch (dir)
{
case SNAKE_DIR_UP:
case SNAKE_DIR_DOWN:
node.y = head->body.y + (dir == SNAKE_DIR_DOWN ? -1 : 1);
break;
case SNAKE_DIR_LEFT:
case SNAKE_DIR_RIGHT:
node.x = head->body.x + (dir == SNAKE_DIR_RIGHT ? 1 : -1);
break;
}
across_XY(&node, map);
return node_update(tail, &node, map);
}
rt_bool_t snake_restart(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map)
{
ASSERT_RET(!map || !start, RT_FALSE);
snake_deinit();
memset(map->range, NORMAL, map->width * map->height);
return snake_init(start, length, dir, map);
}

68
bsp/simulator/testdll/snake/snake.h Normal file
View File

@ -0,0 +1,68 @@
#ifndef _SNAKE_H_
#define _SNAKE_H_
#include <rtthread.h>
#define snake_length_max 20 //最大蛇长
#define snake_length_init 3 //初始化蛇长
#define snake_room_size_hight 8 //房子高 0-255 建议>8
#define snake_room_size_widht 8 //房子宽 0-255 建议>8
#define snake_init_pointx 1
#define snake_init_pointy 2
typedef struct
{
rt_int32_t x, y;
} point_t;
typedef struct
{
rt_int32_t width; // max x
rt_int32_t height; // max y
rt_uint8_t *range; // map, map->range[y * map->width + x]
point_t snake_flush[2];
point_t food_flush[1];
} map_t;
typedef enum
{
SNAKE_DIR_UP,
SNAKE_DIR_DOWN,
SNAKE_DIR_LEFT,
SNAKE_DIR_RIGHT
} SNAKE_DIR;
typedef enum
{
FOOD, // 吃到水果
OVER, // 咬到自身
NORMAL // 正常行动
} SYS_STE;
typedef struct
{
point_t body;
rt_list_t list;
} snake_t;
// 构造一个地图
map_t *map_init(rt_uint32_t width, rt_uint32_t heigth);
// 构造一条指定长度的蛇在指定点
rt_bool_t snake_init(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map);
// 构造出食物
rt_bool_t food_init(map_t *map, rt_uint32_t max_num);
void map_deinit(map_t *map);
void snake_deinit(void);
void food_deinit(void);
SYS_STE snake_step(SNAKE_DIR dir, map_t *map);
rt_bool_t snake_restart(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map);
#endif

397
bsp/simulator/testdll/snake/snake_gui.c Normal file
View File

@ -0,0 +1,397 @@
#include <string.h>
#include <rtthread.h>
#include <rtgui/rtgui.h>
#include <rtgui/rtgui_app.h>
#include <rtgui/widgets/container.h>
#include <rtgui/widgets/window.h>
#include <rtgui/widgets/button.h>
#include "snake.h"
#define LATTICE_SIZE (20)
#define FOOD_MAX (8)
#define WALL_COLOR RTGUI_RGB(255, 0, 0)
#define SNAKE_COLOR RTGUI_RGB(0, 100, 200)
#define SNAKE_HEAD_COLOR RTGUI_RGB(180, 70, 130)
#define BACKGROUND_COLOR RTGUI_RGB(153, 153, 0)
#define FOOD_COLOR RTGUI_RGB(128, 0, 0)
static rtgui_timer_t *timer;
static rt_size_t room_size_x, room_size_y;
static rt_size_t lattice_size_x, lattice_size_y;
static struct rtgui_rect room_rect, lattice_rect;
map_t *map;
SNAKE_DIR run_state;
rt_int32_t snake_len;
rt_int32_t food_num;
point_t second_node;
static void snake_fill_lattice(struct rtgui_dc *dc,
rt_uint32_t x,
rt_uint32_t y,
rtgui_color_t color)
{
struct rtgui_rect rect;
// coordinate conversion
y = (lattice_size_y - 1) - y;
RTGUI_DC_BC(dc) = color;
rect.x1 = lattice_rect.x1 + (LATTICE_SIZE * x);
rect.x2 = rect.x1 + LATTICE_SIZE;
rect.x1 += 2;
rect.y1 = lattice_rect.y1 + (LATTICE_SIZE * y);
rect.y2 = rect.y1 + LATTICE_SIZE;
rect.y1 += 2;
rtgui_dc_fill_rect(dc, &rect);
}
static void snake_draw(struct rtgui_widget *widget)
{
struct rtgui_dc *dc;
struct rtgui_rect rect;
rt_uint32_t i;
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL)
{
rt_kprintf("dc == RT_NULL\r\n");
return;
}
/* get room size, run once frist. */
if ((room_size_x == 0) || (room_size_y == 0))
{
rt_size_t tmp;
rtgui_widget_get_rect(widget, &rect);
rt_kprintf("rect => x1:%d x2:%d, y1:%d y2:%d\r\n", rect.x1, rect.x2, rect.y1, rect.y2);
room_size_x = rect.x2 - rect.x1;
room_size_y = rect.y2 - rect.y1;
memcpy(&room_rect, &rect, sizeof(struct rtgui_rect));
rt_kprintf("room_rect => x1:%d x2:%d, y1:%d y2:%d\r\n",
room_rect.x1, room_rect.x2,
room_rect.y1, room_rect.y2);
lattice_size_x = (room_rect.x2 - room_rect.x1) / LATTICE_SIZE;
lattice_size_y = (room_rect.y2 - room_rect.y1) / LATTICE_SIZE;
lattice_size_x -= 2;
lattice_size_y -= 2;
rt_kprintf("lattice_size_x:%d lattice_size_y:%d\r\n",
lattice_size_x,
lattice_size_y);
tmp = (room_rect.x2 - room_rect.x1) - (LATTICE_SIZE * lattice_size_x);
lattice_rect.x1 = room_rect.x1 + (tmp / 2);
lattice_rect.x2 = lattice_rect.x1 + (LATTICE_SIZE * lattice_size_x);
tmp = (room_rect.y2 - room_rect.y1) - (LATTICE_SIZE * lattice_size_y);
lattice_rect.y1 = room_rect.y1 + (tmp / 2);
lattice_rect.y2 = lattice_rect.y1 + (LATTICE_SIZE * lattice_size_y);
rt_kprintf("lattice_rect => x1:%d x2:%d, y1:%d y2:%d\r\n",
lattice_rect.x1, lattice_rect.x2,
lattice_rect.y1, lattice_rect.y2);
/* create snake. */
{
point_t start;
map = map_init(lattice_size_x, lattice_size_y);
if (map != RT_NULL)
{
start.x = snake_init_pointx;
start.y = snake_init_pointy;
run_state = SNAKE_DIR_DOWN;
if (snake_init(&start, snake_length_init, run_state, map))
{
food_num = 1;
food_init(map, food_num);
}
else
{
map_deinit(map);
map = RT_NULL;
}
}
}
}
RTGUI_DC_BC(dc) = BACKGROUND_COLOR;
rtgui_dc_fill_rect(dc, &room_rect);
memcpy(&rect, &lattice_rect, sizeof(struct rtgui_rect));
rect.x2 += 1;
rect.y2 += 1;
RTGUI_DC_FC(dc) = WALL_COLOR;
rtgui_dc_draw_rect(dc, &rect);
for (i = 1; i < lattice_size_y; i++)
{
memcpy(&rect, &lattice_rect, sizeof(struct rtgui_rect));
rect.x1 += 1;
rect.x2 -= 1;
rtgui_dc_draw_horizontal_line(dc, rect.x1, rect.x2,
rect.y1 + (LATTICE_SIZE * i));
}
for (i = 1; i < lattice_size_x; i++)
{
memcpy(&rect, &lattice_rect, sizeof(struct rtgui_rect));
rect.y1 += 1;
rect.y2 -= 1;
rtgui_dc_draw_vertical_line(dc, rect.x1 + (LATTICE_SIZE * i),
rect.y1, rect.y2);
}
/* draw snake. */
{
rt_int32_t x, y;
rt_bool_t first_node = RT_TRUE;
for (y = 0; y < map->height; y++)
{
for (x = 0; x < map->width; x++)
{
switch (map->range[y * map->width + x])
{
case NORMAL:
break;
case FOOD:
snake_fill_lattice(dc, x, y, FOOD_COLOR);
break;
case OVER:
if (first_node)
{
first_node = RT_FALSE;
second_node.x = x;
second_node.y = y;
snake_fill_lattice(dc, x, y, SNAKE_HEAD_COLOR);
}
else
{
snake_fill_lattice(dc, x, y, SNAKE_COLOR);
}
break;
}
}
}
}
rtgui_dc_end_drawing(dc);
return;
}
static void snake_update(struct rtgui_widget *widget)
{
struct rtgui_dc *dc;
rt_int32_t x, y;
rt_uint32_t i;
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL)
{
rt_kprintf("dc == RT_NULL\r\n");
return;
}
snake_fill_lattice(dc, second_node.x, second_node.y, SNAKE_COLOR);
second_node = map->snake_flush[0];
for (i = 0; i < 3; i++)
{
if (i < 2)
{
x = map->snake_flush[i].x;
y = map->snake_flush[i].y;
}
else
{
x = map->food_flush[0].x;
y = map->food_flush[0].y;
}
if ((x >= 0) && (y >= 0))
{
switch (map->range[(map->width * y) + x])
{
case NORMAL:
snake_fill_lattice(dc, x, y, BACKGROUND_COLOR);
break;
case FOOD:
snake_fill_lattice(dc, x, y, FOOD_COLOR);
break;
case OVER:
if (0 == i)
snake_fill_lattice(dc, x, y, SNAKE_HEAD_COLOR);
else
snake_fill_lattice(dc, x, y, SNAKE_COLOR);
break;
}
}
}
rtgui_dc_end_drawing(dc);
return;
}
static void snake_handler(struct rtgui_widget *widget, rtgui_event_t *event)
{
struct rtgui_event_kbd *ekbd;
ekbd = (struct rtgui_event_kbd *) event;
if (ekbd->type == RTGUI_KEYDOWN)
{
switch (ekbd->key)
{
case RTGUIK_UP:
rt_kprintf("RTGUIK_UP\r\n");
run_state = SNAKE_DIR_UP;
break;
case RTGUIK_DOWN:
rt_kprintf("RTGUIK_DOWN\r\n");
run_state = SNAKE_DIR_DOWN;
break;
case RTGUIK_LEFT:
rt_kprintf("RTGUIK_LEFT\r\n");
run_state = SNAKE_DIR_LEFT;
break;
case RTGUIK_RIGHT:
rt_kprintf("RTGUIK_RIGHT\r\n");
run_state = SNAKE_DIR_RIGHT;
break;
default:
break;
}
}
}
static rt_bool_t event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
rt_kprintf("event_handler\r\n");
if (event->type == RTGUI_EVENT_PAINT)
{
rt_kprintf("RTGUI_EVENT_PAINT\r\n");
rtgui_win_event_handler((struct rtgui_object *)object, event);
snake_draw(widget);
rtgui_timer_start(timer);
}
else if (event->type == RTGUI_EVENT_SHOW)
{
rt_kprintf("RTGUI_EVENT_SHOW\r\n");
rtgui_win_event_handler((struct rtgui_object *)object, event);
snake_draw(widget);
rtgui_timer_start(timer);
}
else if (event->type == RTGUI_EVENT_HIDE)
{
rt_kprintf("RTGUI_EVENT_HIDE\r\n");
rtgui_win_event_handler((struct rtgui_object *)object, event);
rtgui_timer_stop(timer);
}
else if (event->type == RTGUI_EVENT_WIN_DEACTIVATE)
{
rt_kprintf("RTGUI_EVENT_WIN_DEACTIVATE\r\n");
rtgui_win_event_handler((struct rtgui_object *)object, event);
rtgui_timer_stop(timer);
}
else if (event->type == RTGUI_EVENT_KBD)
{
rtgui_win_event_handler((struct rtgui_object *)object, event);
snake_handler(widget, event);
}
else
{
rt_kprintf("event->type:%d\r\n", event->type);
return rtgui_win_event_handler((struct rtgui_object *)object, event);
}
return RT_FALSE;
}
static void timeout(struct rtgui_timer *timer, void *parameter)
{
struct rtgui_widget *widget;
SYS_STE ret;
if (!map)
return;
ret = snake_step(run_state, map);
if (OVER == ret)
return;
if (FOOD == ret)
{
snake_len++;
if (snake_len >= (map->width * map->height) / 3)
{
point_t start;
start.x = snake_init_pointx;
start.y = snake_init_pointy;
run_state = SNAKE_DIR_DOWN;
snake_len = snake_length_init;
if (!snake_restart(&start, snake_len, run_state, map))
{
map_deinit(map);
snake_deinit();
map = RT_NULL;
}
}
food_init(map, 1);
}
widget = RTGUI_WIDGET(parameter);
snake_update(widget);
}
void main(void)
{
struct rtgui_app *application;
struct rtgui_win *win;
rtgui_rect_t rect;
application = rtgui_app_create("sanke_app");
if (application != RT_NULL)
{
rtgui_get_screen_rect(&rect);
rtgui_set_mainwin_rect(&rect);
win = rtgui_mainwin_create(RT_NULL,
"sanke_win",
RTGUI_WIN_STYLE_MAINWIN | RTGUI_WIN_STYLE_DESTROY_ON_CLOSE);
if (win == RT_NULL)
{
rt_kprintf("sanke_win create fail!\r\n");
return;
}
rtgui_object_set_event_handler(RTGUI_OBJECT(win), event_handler);
timer = rtgui_timer_create(RT_TICK_PER_SECOND / 2,
RT_TIMER_FLAG_PERIODIC,
timeout,
(void *)win);
rtgui_win_show(win, RT_TRUE);
//Í˳öºó²Å·µ»Ø
map_deinit(map);
snake_deinit();
food_deinit();
rtgui_app_destroy(application);
}
}

7
bsp/simulator/testdll/var/Sconscript Normal file
View File

@ -0,0 +1,7 @@
import rtconfig
Import('RTT_ROOT')
from building import *
src = Glob('*.c')
group = DefineGroup('', src, depend = [''])
Return('group')

20
bsp/simulator/testdll/var/var.c Normal file
View File

@ -0,0 +1,20 @@
#include <rtthread.h>
/* rtgui\common\rtgui_object.c */
_declspec(dllimport) void * _rtgui_object;
/* rtgui\common\color.c */
_declspec(dllimport) rt_uint32_t blue;
//extern rt_uint32_t * green;
int main(void)
{
int i;
//rt_kprintf("green = %x, *green", green, *(rt_uint32_t *)green);
rt_kprintf("blue = %x\n", blue);
rt_kprintf("_rtgui_object = %x\n", _rtgui_object);
return 0;
}

2
bsp/stm32f10x/SConscript
View File

@ -15,7 +15,7 @@ if GetDepend('RT_USING_LWIP'):
src_drv += ['enc28j60.c'] + ['dm9000a.c'] src_drv += ['enc28j60.c'] + ['dm9000a.c']
if GetDepend('RT_USING_RTGUI'): if GetDepend('RT_USING_RTGUI'):
src_drv += ['touch.c', 'calibration.c'] src_drv += ['touch.c']
if GetDepend('RT_USING_RTGUI'): if GetDepend('RT_USING_RTGUI'):
if rtconfig.RT_USING_LCD_TYPE == 'FMT0371': if rtconfig.RT_USING_LCD_TYPE == 'FMT0371':

22
bsp/stm32f10x/application.c
View File

@ -41,6 +41,7 @@
#include <rtgui/rtgui_server.h> #include <rtgui/rtgui_server.h>
#include <rtgui/rtgui_system.h> #include <rtgui/rtgui_system.h>
#include <rtgui/driver.h> #include <rtgui/driver.h>
#include <rtgui/calibration.h>
#endif #endif
#include "led.h" #include "led.h"
@ -73,6 +74,23 @@ static void led_thread_entry(void* parameter)
} }
} }
#ifdef RT_USING_RTGUI
rt_bool_t cali_setup(void)
{
rt_kprintf("cali setup entered\n");
return RT_FALSE;
}
void cali_store(struct calibration_data *data)
{
rt_kprintf("cali finished (%d, %d), (%d, %d)\n",
data->min_x,
data->max_x,
data->min_y,
data->max_y);
}
#endif
void rt_init_thread_entry(void* parameter) void rt_init_thread_entry(void* parameter)
{ {
/* Filesystem Initialization */ /* Filesystem Initialization */
@ -149,6 +167,10 @@ void rt_init_thread_entry(void* parameter)
/* init rtgui system server */ /* init rtgui system server */
rtgui_system_server_init(); rtgui_system_server_init();
calibration_set_restore(cali_setup);
calibration_set_after(cali_store);
calibration_init();
} }
#endif /* #ifdef RT_USING_RTGUI */ #endif /* #ifdef RT_USING_RTGUI */
} }

284
bsp/stm32f10x/calibration.c
View File

@ -1,284 +0,0 @@
#include <rtgui/rtgui.h>
#include <rtgui/dc.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/window.h>
#include "touch.h"
#define CALIBRATION_STEP_LEFTTOP 0
#define CALIBRATION_STEP_RIGHTTOP 1
#define CALIBRATION_STEP_RIGHTBOTTOM 2
#define CALIBRATION_STEP_LEFTBOTTOM 3
#define CALIBRATION_STEP_CENTER 4
#define TOUCH_WIN_UPDATE 1
#define TOUCH_WIN_CLOSE 2
#define CALIBRATION_WIDTH 15
#define CALIBRATION_HEIGHT 15
struct calibration_session
{
rt_uint8_t step;
struct calibration_data data;
rt_uint16_t width; rt_uint16_t height;
rt_device_t device;
rt_thread_t tid;
};
static struct calibration_session* calibration_ptr = RT_NULL;
static void calibration_data_post(rt_uint16_t x, rt_uint16_t y)
{
if (calibration_ptr != RT_NULL)
{
switch (calibration_ptr->step)
{
case CALIBRATION_STEP_LEFTTOP:
calibration_ptr->data.min_x = x;
calibration_ptr->data.min_y = y;
break;
case CALIBRATION_STEP_RIGHTTOP:
calibration_ptr->data.max_x = x;
calibration_ptr->data.min_y = (calibration_ptr->data.min_y + y)/2;
break;
case CALIBRATION_STEP_LEFTBOTTOM:
calibration_ptr->data.min_x = (calibration_ptr->data.min_x + x)/2;
calibration_ptr->data.max_y = y;
break;
case CALIBRATION_STEP_RIGHTBOTTOM:
calibration_ptr->data.max_x = (calibration_ptr->data.max_x + x)/2;
calibration_ptr->data.max_y = (calibration_ptr->data.max_y + y)/2;
break;
case CALIBRATION_STEP_CENTER:
/* calibration done */
{
rt_uint16_t w, h;
struct rtgui_event_command ecmd;
RTGUI_EVENT_COMMAND_INIT(&ecmd);
ecmd.command_id = TOUCH_WIN_CLOSE;
/* calculate calibrated data */
if (calibration_ptr->data.max_x > calibration_ptr->data.min_x)
w = calibration_ptr->data.max_x - calibration_ptr->data.min_x;
else
w = calibration_ptr->data.min_x - calibration_ptr->data.max_x;
w = (w/(calibration_ptr->width - 2 * CALIBRATION_WIDTH)) * CALIBRATION_WIDTH;
if (calibration_ptr->data.max_y > calibration_ptr->data.min_y)
h = calibration_ptr->data.max_y - calibration_ptr->data.min_y;
else
h = calibration_ptr->data.min_y - calibration_ptr->data.max_y;
h = (h/(calibration_ptr->height - 2 * CALIBRATION_HEIGHT)) * CALIBRATION_HEIGHT;
rt_kprintf("w: %d, h: %d\n", w, h);
if (calibration_ptr->data.max_x > calibration_ptr->data.min_x)
{
calibration_ptr->data.min_x -= w;
calibration_ptr->data.max_x += w;
}
else
{
calibration_ptr->data.min_x += w;
calibration_ptr->data.max_x -= w;
}
if (calibration_ptr->data.max_y > calibration_ptr->data.min_y)
{
calibration_ptr->data.min_y -= h;
calibration_ptr->data.max_y += h;
}
else
{
calibration_ptr->data.min_y += h;
calibration_ptr->data.max_y -= h;
}
rt_kprintf("calibration data: (%d, %d), (%d, %d)\n",
calibration_ptr->data.min_x,
calibration_ptr->data.max_x,
calibration_ptr->data.min_y,
calibration_ptr->data.max_y);
rtgui_thread_send(calibration_ptr->tid, &ecmd.parent, sizeof(struct rtgui_event_command));
}
return;
}
calibration_ptr->step ++;
/* post command event */
{
struct rtgui_event_command ecmd;
RTGUI_EVENT_COMMAND_INIT(&ecmd);
ecmd.command_id = TOUCH_WIN_UPDATE;
rtgui_thread_send(calibration_ptr->tid, &ecmd.parent, sizeof(struct rtgui_event_command));
}
}
}
rt_bool_t calibration_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
switch (event->type)
{
case RTGUI_EVENT_PAINT:
{
struct rtgui_dc* dc;
struct rtgui_rect rect;
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) break;
/* get rect information */
rtgui_widget_get_rect(widget, &rect);
/* clear whole window */
RTGUI_WIDGET_BACKGROUND(widget) = white;
rtgui_dc_fill_rect(dc, &rect);
/* reset color */
RTGUI_WIDGET_BACKGROUND(widget) = green;
RTGUI_WIDGET_FOREGROUND(widget) = black;
switch (calibration_ptr->step)
{
case CALIBRATION_STEP_LEFTTOP:
rtgui_dc_draw_hline(dc, 0, 2 * CALIBRATION_WIDTH, CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, CALIBRATION_WIDTH, 0, 2 * CALIBRATION_HEIGHT);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, CALIBRATION_WIDTH, CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_RIGHTTOP:
rtgui_dc_draw_hline(dc, calibration_ptr->width - 2 * CALIBRATION_WIDTH,
calibration_ptr->width, CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, calibration_ptr->width - CALIBRATION_WIDTH, 0, 2 * CALIBRATION_HEIGHT);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, calibration_ptr->width - CALIBRATION_WIDTH, CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_LEFTBOTTOM:
rtgui_dc_draw_hline(dc, 0, 2 * CALIBRATION_WIDTH, calibration_ptr->height - CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, CALIBRATION_WIDTH, calibration_ptr->height - 2 * CALIBRATION_HEIGHT, calibration_ptr->height);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, CALIBRATION_WIDTH, calibration_ptr->height - CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_RIGHTBOTTOM:
rtgui_dc_draw_hline(dc, calibration_ptr->width - 2 * CALIBRATION_WIDTH,
calibration_ptr->width, calibration_ptr->height - CALIBRATION_HEIGHT);
rtgui_dc_draw_vline(dc, calibration_ptr->width - CALIBRATION_WIDTH, calibration_ptr->height - 2 * CALIBRATION_HEIGHT, calibration_ptr->height);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, calibration_ptr->width - CALIBRATION_WIDTH, calibration_ptr->height - CALIBRATION_HEIGHT, 4);
break;
case CALIBRATION_STEP_CENTER:
rtgui_dc_draw_hline(dc, calibration_ptr->width/2 - CALIBRATION_WIDTH, calibration_ptr->width/2 + CALIBRATION_WIDTH, calibration_ptr->height/2);
rtgui_dc_draw_vline(dc, calibration_ptr->width/2, calibration_ptr->height/2 - CALIBRATION_HEIGHT, calibration_ptr->height/2 + CALIBRATION_HEIGHT);
RTGUI_WIDGET_FOREGROUND(widget) = red;
rtgui_dc_fill_circle(dc, calibration_ptr->width/2, calibration_ptr->height/2, 4);
break;
}
rtgui_dc_end_drawing(dc);
}
break;
case RTGUI_EVENT_COMMAND:
{
struct rtgui_event_command* ecmd = (struct rtgui_event_command*)event;
switch (ecmd->command_id)
{
case TOUCH_WIN_UPDATE:
rtgui_widget_update(widget);
break;
case TOUCH_WIN_CLOSE:
rtgui_win_close(RTGUI_WIN(widget));
break;
}
}
return RT_TRUE;
default:
rtgui_win_event_handler(widget, event);
}
return RT_FALSE;
}
void calibration_entry(void* parameter)
{
rt_mq_t mq;
rtgui_win_t* win;
struct rtgui_rect rect;
mq = rt_mq_create("cali", 40, 8, RT_IPC_FLAG_FIFO);
if (mq == RT_NULL) return;
rtgui_thread_register(rt_thread_self(), mq);
rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &rect);
/* set screen rect */
calibration_ptr->width = rect.x2;
calibration_ptr->height = rect.y2;
/* create calibration window */
win = rtgui_win_create(RT_NULL,
"calibration", &rect, RTGUI_WIN_STYLE_NO_TITLE | RTGUI_WIN_STYLE_NO_BORDER);
rtgui_widget_set_event_handler(RTGUI_WIDGET(win), calibration_event_handler);
if (win != RT_NULL)
{
rtgui_win_show(win, RT_FALSE);
// rtgui_widget_update(RTGUI_WIDGET(win));
rtgui_win_event_loop(win);
}
rtgui_thread_deregister(rt_thread_self());
rt_mq_delete(mq);
/* set calibration data */
rt_device_control(calibration_ptr->device, RT_TOUCH_CALIBRATION_DATA, &calibration_ptr->data);
/* recover to normal */
rt_device_control(calibration_ptr->device, RT_TOUCH_NORMAL, RT_NULL);
/* release memory */
rt_free(calibration_ptr);
calibration_ptr = RT_NULL;
}
void calibration_init()
{
rt_device_t device;
device = rt_device_find("touch");
if (device == RT_NULL) return; /* no this device */
calibration_ptr = (struct calibration_session*)rt_malloc(sizeof(struct calibration_session));
rt_memset(calibration_ptr, 0, sizeof(struct calibration_data));
calibration_ptr->device = device;
rt_device_control(calibration_ptr->device, RT_TOUCH_CALIBRATION, (void*)calibration_data_post);
calibration_ptr->tid = rt_thread_create("cali", calibration_entry, RT_NULL,
2048, 20, 5);
if (calibration_ptr->tid != RT_NULL) rt_thread_startup(calibration_ptr->tid);
}
#ifdef RT_USING_FINSH
#include <finsh.h>
void calibration()
{
calibration_init();
}
FINSH_FUNCTION_EXPORT(calibration, perform touch calibration);
#endif

38
components/dfs/filesystems/elmfat/dfs_elm.c
View File

@ -14,8 +14,12 @@
* 2011-11-23 Bernard fixed the rename issue. * 2011-11-23 Bernard fixed the rename issue.
* 2012-07-26 aozima implement ff_memalloc and ff_memfree. * 2012-07-26 aozima implement ff_memalloc and ff_memfree.
* 2012-12-19 Bernard fixed the O_APPEND and lseek issue. * 2012-12-19 Bernard fixed the O_APPEND and lseek issue.
* 2013-03-01 aozima fixed the stat(st_mtime) issue.
*/ */
#include <string.h>
#include <time.h>
#include <rtthread.h> #include <rtthread.h>
#include "ffconf.h" #include "ffconf.h"
#include "ff.h" #include "ff.h"
@ -178,7 +182,7 @@ int dfs_elm_mkfs(rt_device_t dev_id)
{ {
#define FSM_STATUS_INIT 0 #define FSM_STATUS_INIT 0
#define FSM_STATUS_USE_TEMP_DRIVER 1 #define FSM_STATUS_USE_TEMP_DRIVER 1
FATFS *fat; FATFS *fat = RT_NULL;
int flag; int flag;
FRESULT result; FRESULT result;
int index; int index;
@ -710,8 +714,38 @@ int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
st->st_mode &= ~(DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH); st->st_mode &= ~(DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH);
st->st_size = file_info.fsize; st->st_size = file_info.fsize;
st->st_mtime = file_info.ftime;
st->st_blksize = 512; st->st_blksize = 512;
/* get st_mtime. */
{
struct tm tm_file;
int year, mon, day, hour, min, sec;
WORD tmp;
tmp = file_info.fdate;
day = tmp & 0x1F; /* bit[4:0] Day(1..31) */
tmp >>= 5;
mon = tmp & 0x0F; /* bit[8:5] Month(1..12) */
tmp >>= 4;
year = (tmp & 0x7F) + 1980; /* bit[15:9] Year origin from 1980(0..127) */
tmp = file_info.ftime;
sec = (tmp & 0x1F) * 2; /* bit[4:0] Second/2(0..29) */
tmp >>= 5;
min = tmp & 0x3F; /* bit[10:5] Minute(0..59) */
tmp >>= 6;
hour = tmp & 0x1F; /* bit[15:11] Hour(0..23) */
memset(&tm_file, 0, sizeof(tm_file));
tm_file.tm_year = year - 1900; /* Years since 1900 */
tm_file.tm_mon = mon - 1; /* Months *since* january: 0-11 */
tm_file.tm_mday = day; /* Day of the month: 1-31 */
tm_file.tm_hour = hour; /* Hours since midnight: 0-23 */
tm_file.tm_min = min; /* Minutes: 0-59 */
tm_file.tm_sec = sec; /* Seconds: 0-59 */
st->st_mtime = mktime(&tm_file);
} /* get st_mtime. */
} }
#if _USE_LFN #if _USE_LFN

498
components/net/lwip/src/netif/ethernetif.c
View File

@ -14,6 +14,7 @@
* 2012-04-10 Bernard add more compatible with RT-Thread. * 2012-04-10 Bernard add more compatible with RT-Thread.
* 2012-11-12 Bernard The network interface can be initialized * 2012-11-12 Bernard The network interface can be initialized
* after lwIP initialization. * after lwIP initialization.
* 2013-02-28 aozima fixed list_tcps bug: ipaddr_ntoa isn't reentrant.
*/ */
/* /*
@ -71,8 +72,8 @@
*/ */
struct eth_tx_msg struct eth_tx_msg
{ {
struct netif *netif; struct netif *netif;
struct pbuf *buf; struct pbuf *buf;
}; };
static struct rt_mailbox eth_tx_thread_mb; static struct rt_mailbox eth_tx_thread_mb;
@ -99,288 +100,288 @@ static char eth_rx_thread_stack[RT_LWIP_ETHTHREAD_STACKSIZE];
static err_t ethernetif_linkoutput(struct netif *netif, struct pbuf *p) static err_t ethernetif_linkoutput(struct netif *netif, struct pbuf *p)
{ {
struct eth_tx_msg msg; struct eth_tx_msg msg;
struct eth_device* enetif; struct eth_device* enetif;
enetif = (struct eth_device*)netif->state; enetif = (struct eth_device*)netif->state;
/* send a message to eth tx thread */ /* send a message to eth tx thread */
msg.netif = netif; msg.netif = netif;
msg.buf = p; msg.buf = p;
if (rt_mb_send(&eth_tx_thread_mb, (rt_uint32_t) &msg) == RT_EOK) if (rt_mb_send(&eth_tx_thread_mb, (rt_uint32_t) &msg) == RT_EOK)
{ {
/* waiting for ack */ /* waiting for ack */
rt_sem_take(&(enetif->tx_ack), RT_WAITING_FOREVER); rt_sem_take(&(enetif->tx_ack), RT_WAITING_FOREVER);
} }
return ERR_OK; return ERR_OK;
} }
static err_t eth_netif_device_init(struct netif *netif) static err_t eth_netif_device_init(struct netif *netif)
{ {
struct eth_device *ethif; struct eth_device *ethif;
ethif = (struct eth_device*)netif->state; ethif = (struct eth_device*)netif->state;
if (ethif != RT_NULL) if (ethif != RT_NULL)
{ {
rt_device_t device; rt_device_t device;
/* get device object */ /* get device object */
device = (rt_device_t) ethif; device = (rt_device_t) ethif;
if (rt_device_init(device) != RT_EOK) if (rt_device_init(device) != RT_EOK)
{ {
return ERR_IF; return ERR_IF;
} }
/* copy device flags to netif flags */ /* copy device flags to netif flags */
netif->flags = ethif->flags; netif->flags = ethif->flags;
/* set default netif */ /* set default netif */
if (netif_default == RT_NULL) if (netif_default == RT_NULL)
netif_set_default(ethif->netif); netif_set_default(ethif->netif);
#if LWIP_DHCP #if LWIP_DHCP
if (ethif->flags & NETIF_FLAG_DHCP) if (ethif->flags & NETIF_FLAG_DHCP)
{ {
/* if this interface uses DHCP, start the DHCP client */ /* if this interface uses DHCP, start the DHCP client */
dhcp_start(ethif->netif); dhcp_start(ethif->netif);
} }
else else
#endif #endif
{ {
/* set interface up */ /* set interface up */
netif_set_up(ethif->netif); netif_set_up(ethif->netif);
} }
#ifdef LWIP_NETIF_LINK_CALLBACK #ifdef LWIP_NETIF_LINK_CALLBACK
netif_set_link_up(ethif->netif); netif_set_link_up(ethif->netif);
#endif #endif
return ERR_OK; return ERR_OK;
} }
return ERR_IF; return ERR_IF;
} }
/* Keep old drivers compatible in RT-Thread */ /* Keep old drivers compatible in RT-Thread */
rt_err_t eth_device_init_with_flag(struct eth_device *dev, char *name, rt_uint8_t flags) rt_err_t eth_device_init_with_flag(struct eth_device *dev, char *name, rt_uint8_t flags)
{ {
struct netif* netif; struct netif* netif;
netif = (struct netif*) rt_malloc (sizeof(struct netif)); netif = (struct netif*) rt_malloc (sizeof(struct netif));
if (netif == RT_NULL) if (netif == RT_NULL)
{ {
rt_kprintf("malloc netif failed\n"); rt_kprintf("malloc netif failed\n");
return -RT_ERROR; return -RT_ERROR;
} }
rt_memset(netif, 0, sizeof(struct netif)); rt_memset(netif, 0, sizeof(struct netif));
/* set netif */ /* set netif */
dev->netif = netif; dev->netif = netif;
/* device flags, which will be set to netif flags when initializing */ /* device flags, which will be set to netif flags when initializing */
dev->flags = flags; dev->flags = flags;
/* link changed status of device */ /* link changed status of device */
dev->link_changed = 0x00; dev->link_changed = 0x00;
dev->parent.type = RT_Device_Class_NetIf; dev->parent.type = RT_Device_Class_NetIf;
/* register to RT-Thread device manager */ /* register to RT-Thread device manager */
rt_device_register(&(dev->parent), name, RT_DEVICE_FLAG_RDWR); rt_device_register(&(dev->parent), name, RT_DEVICE_FLAG_RDWR);
rt_sem_init(&(dev->tx_ack), name, 0, RT_IPC_FLAG_FIFO); rt_sem_init(&(dev->tx_ack), name, 0, RT_IPC_FLAG_FIFO);
/* set name */ /* set name */
netif->name[0] = name[0]; netif->name[0] = name[0];
netif->name[1] = name[1]; netif->name[1] = name[1];
/* set hw address to 6 */ /* set hw address to 6 */
netif->hwaddr_len = 6; netif->hwaddr_len = 6;
/* maximum transfer unit */ /* maximum transfer unit */
netif->mtu = ETHERNET_MTU; netif->mtu = ETHERNET_MTU;
/* get hardware MAC address */ /* get hardware MAC address */
rt_device_control(&(dev->parent), NIOCTL_GADDR, netif->hwaddr); rt_device_control(&(dev->parent), NIOCTL_GADDR, netif->hwaddr);
/* set output */ /* set output */
netif->output = etharp_output; netif->output = etharp_output;
netif->linkoutput = ethernetif_linkoutput; netif->linkoutput = ethernetif_linkoutput;
/* if tcp thread has been started up, we add this netif to the system */ /* if tcp thread has been started up, we add this netif to the system */
if (rt_thread_find("tcpip") != RT_NULL) if (rt_thread_find("tcpip") != RT_NULL)
{ {
struct ip_addr ipaddr, netmask, gw; struct ip_addr ipaddr, netmask, gw;
#if !LWIP_DHCP #if !LWIP_DHCP
IP4_ADDR(&ipaddr, RT_LWIP_IPADDR0, RT_LWIP_IPADDR1, RT_LWIP_IPADDR2, RT_LWIP_IPADDR3); IP4_ADDR(&ipaddr, RT_LWIP_IPADDR0, RT_LWIP_IPADDR1, RT_LWIP_IPADDR2, RT_LWIP_IPADDR3);
IP4_ADDR(&gw, RT_LWIP_GWADDR0, RT_LWIP_GWADDR1, RT_LWIP_GWADDR2, RT_LWIP_GWADDR3); IP4_ADDR(&gw, RT_LWIP_GWADDR0, RT_LWIP_GWADDR1, RT_LWIP_GWADDR2, RT_LWIP_GWADDR3);
IP4_ADDR(&netmask, RT_LWIP_MSKADDR0, RT_LWIP_MSKADDR1, RT_LWIP_MSKADDR2, RT_LWIP_MSKADDR3); IP4_ADDR(&netmask, RT_LWIP_MSKADDR0, RT_LWIP_MSKADDR1, RT_LWIP_MSKADDR2, RT_LWIP_MSKADDR3);
#else #else
IP4_ADDR(&ipaddr, 0, 0, 0, 0); IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&gw, 0, 0, 0, 0); IP4_ADDR(&gw, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0); IP4_ADDR(&netmask, 0, 0, 0, 0);
#endif #endif
netifapi_netif_add(netif, &ipaddr, &netmask, &gw, dev, eth_netif_device_init, tcpip_input); netifapi_netif_add(netif, &ipaddr, &netmask, &gw, dev, eth_netif_device_init, tcpip_input);
} }
return RT_EOK; return RT_EOK;
} }
rt_err_t eth_device_init(struct eth_device * dev, char *name) rt_err_t eth_device_init(struct eth_device * dev, char *name)
{ {
rt_uint8_t flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP; rt_uint8_t flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
#if LWIP_DHCP #if LWIP_DHCP
/* DHCP support */ /* DHCP support */
flags |= NETIF_FLAG_DHCP; flags |= NETIF_FLAG_DHCP;
#endif #endif
#if LWIP_IGMP #if LWIP_IGMP
/* IGMP support */ /* IGMP support */
flags |= NETIF_FLAG_IGMP; flags |= NETIF_FLAG_IGMP;
#endif #endif
return eth_device_init_with_flag(dev, name, flags); return eth_device_init_with_flag(dev, name, flags);
} }
rt_err_t eth_device_ready(struct eth_device* dev) rt_err_t eth_device_ready(struct eth_device* dev)
{ {
if (dev->netif) if (dev->netif)
/* post message to Ethernet thread */ /* post message to Ethernet thread */
return rt_mb_send(&eth_rx_thread_mb, (rt_uint32_t)dev); return rt_mb_send(&eth_rx_thread_mb, (rt_uint32_t)dev);
else else
return ERR_OK; /* netif is not initialized yet, just return. */ return ERR_OK; /* netif is not initialized yet, just return. */
} }
rt_err_t eth_device_linkchange(struct eth_device* dev, rt_bool_t up) rt_err_t eth_device_linkchange(struct eth_device* dev, rt_bool_t up)
{ {
rt_uint32_t level; rt_uint32_t level;
RT_ASSERT(dev != RT_NULL); RT_ASSERT(dev != RT_NULL);
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
dev->link_changed = 0x01; dev->link_changed = 0x01;
if (up == RT_TRUE) if (up == RT_TRUE)
dev->link_status = 0x01; dev->link_status = 0x01;
else else
dev->link_status = 0x00; dev->link_status = 0x00;
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
/* post message to ethernet thread */ /* post message to ethernet thread */
return rt_mb_send(&eth_rx_thread_mb, (rt_uint32_t)dev); return rt_mb_send(&eth_rx_thread_mb, (rt_uint32_t)dev);
} }
/* Ethernet Tx Thread */ /* Ethernet Tx Thread */
static void eth_tx_thread_entry(void* parameter) static void eth_tx_thread_entry(void* parameter)
{ {
struct eth_tx_msg* msg; struct eth_tx_msg* msg;
while (1) while (1)
{ {
if (rt_mb_recv(&eth_tx_thread_mb, (rt_uint32_t*)&msg, RT_WAITING_FOREVER) == RT_EOK) if (rt_mb_recv(&eth_tx_thread_mb, (rt_uint32_t*)&msg, RT_WAITING_FOREVER) == RT_EOK)
{ {
struct eth_device* enetif; struct eth_device* enetif;
RT_ASSERT(msg->netif != RT_NULL); RT_ASSERT(msg->netif != RT_NULL);
RT_ASSERT(msg->buf != RT_NULL); RT_ASSERT(msg->buf != RT_NULL);
enetif = (struct eth_device*)msg->netif->state; enetif = (struct eth_device*)msg->netif->state;
if (enetif != RT_NULL) if (enetif != RT_NULL)
{ {
/* call driver's interface */ /* call driver's interface */
if (enetif->eth_tx(&(enetif->parent), msg->buf) != RT_EOK) if (enetif->eth_tx(&(enetif->parent), msg->buf) != RT_EOK)
{ {
rt_kprintf("transmit eth packet failed\n"); rt_kprintf("transmit eth packet failed\n");
} }
} }
/* send ACK */ /* send ACK */
rt_sem_release(&(enetif->tx_ack)); rt_sem_release(&(enetif->tx_ack));
} }
} }
} }
/* Ethernet Rx Thread */ /* Ethernet Rx Thread */
static void eth_rx_thread_entry(void* parameter) static void eth_rx_thread_entry(void* parameter)
{ {
struct eth_device* device; struct eth_device* device;
while (1) while (1)
{ {
if (rt_mb_recv(&eth_rx_thread_mb, (rt_uint32_t*)&device, RT_WAITING_FOREVER) == RT_EOK) if (rt_mb_recv(&eth_rx_thread_mb, (rt_uint32_t*)&device, RT_WAITING_FOREVER) == RT_EOK)
{ {
struct pbuf *p; struct pbuf *p;
/* check link status */ /* check link status */
if (device->link_changed) if (device->link_changed)
{ {
int status; int status;
rt_uint32_t level; rt_uint32_t level;
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
status = device->link_status; status = device->link_status;
device->link_changed = 0x00; device->link_changed = 0x00;
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
if (status) if (status)
netifapi_netif_set_link_up(device->netif); netifapi_netif_set_link_up(device->netif);
else else
netifapi_netif_set_link_down(device->netif); netifapi_netif_set_link_down(device->netif);
} }
/* receive all of buffer */ /* receive all of buffer */
while (1) while (1)
{ {
p = device->eth_rx(&(device->parent)); p = device->eth_rx(&(device->parent));
if (p != RT_NULL) if (p != RT_NULL)
{ {
/* notify to upper layer */ /* notify to upper layer */
if( device->netif->input(p, device->netif) != ERR_OK ) if( device->netif->input(p, device->netif) != ERR_OK )
{ {
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: Input error\n")); LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: Input error\n"));
pbuf_free(p); pbuf_free(p);
p = NULL; p = NULL;
} }
} }
else break; else break;
} }
} }
else else
{ {
LWIP_ASSERT("Should not happen!\n",0); LWIP_ASSERT("Should not happen!\n",0);
} }
} }
} }
void eth_system_device_init() void eth_system_device_init()
{ {
rt_err_t result = RT_EOK; rt_err_t result = RT_EOK;
/* initialize Rx thread. /* initialize Rx thread.
* initialize mailbox and create Ethernet Rx thread */ * initialize mailbox and create Ethernet Rx thread */
result = rt_mb_init(&eth_rx_thread_mb, "erxmb", result = rt_mb_init(&eth_rx_thread_mb, "erxmb",
&eth_rx_thread_mb_pool[0], sizeof(eth_rx_thread_mb_pool)/4, &eth_rx_thread_mb_pool[0], sizeof(eth_rx_thread_mb_pool)/4,
RT_IPC_FLAG_FIFO); RT_IPC_FLAG_FIFO);
RT_ASSERT(result == RT_EOK); RT_ASSERT(result == RT_EOK);
result = rt_thread_init(&eth_rx_thread, "erx", eth_rx_thread_entry, RT_NULL, result = rt_thread_init(&eth_rx_thread, "erx", eth_rx_thread_entry, RT_NULL,
&eth_rx_thread_stack[0], sizeof(eth_rx_thread_stack), &eth_rx_thread_stack[0], sizeof(eth_rx_thread_stack),
RT_LWIP_ETHTHREAD_PRIORITY, 16); RT_LWIP_ETHTHREAD_PRIORITY, 16);
RT_ASSERT(result == RT_EOK); RT_ASSERT(result == RT_EOK);
result = rt_thread_startup(&eth_rx_thread); result = rt_thread_startup(&eth_rx_thread);
RT_ASSERT(result == RT_EOK); RT_ASSERT(result == RT_EOK);
/* initialize Tx thread */ /* initialize Tx thread */
/* initialize mailbox and create Ethernet Tx thread */ /* initialize mailbox and create Ethernet Tx thread */
result = rt_mb_init(&eth_tx_thread_mb, "etxmb", result = rt_mb_init(&eth_tx_thread_mb, "etxmb",
&eth_tx_thread_mb_pool[0], sizeof(eth_tx_thread_mb_pool)/4, &eth_tx_thread_mb_pool[0], sizeof(eth_tx_thread_mb_pool)/4,
RT_IPC_FLAG_FIFO); RT_IPC_FLAG_FIFO);
RT_ASSERT(result == RT_EOK); RT_ASSERT(result == RT_EOK);
result = rt_thread_init(&eth_tx_thread, "etx", eth_tx_thread_entry, RT_NULL, result = rt_thread_init(&eth_tx_thread, "etx", eth_tx_thread_entry, RT_NULL,
&eth_tx_thread_stack[0], sizeof(eth_tx_thread_stack), &eth_tx_thread_stack[0], sizeof(eth_tx_thread_stack),
RT_ETHERNETIF_THREAD_PREORITY, 16); RT_ETHERNETIF_THREAD_PREORITY, 16);
RT_ASSERT(result == RT_EOK); RT_ASSERT(result == RT_EOK);
result = rt_thread_startup(&eth_tx_thread); result = rt_thread_startup(&eth_tx_thread);
RT_ASSERT(result == RT_EOK); RT_ASSERT(result == RT_EOK);
} }
#ifdef RT_USING_FINSH #ifdef RT_USING_FINSH
@ -436,12 +437,12 @@ FINSH_FUNCTION_EXPORT(set_if, set network interface address);
#include <lwip/dns.h> #include <lwip/dns.h>
void set_dns(char* dns_server) void set_dns(char* dns_server)
{ {
struct ip_addr addr; struct ip_addr addr;
if ((dns_server != RT_NULL) && ipaddr_aton(dns_server, &addr)) if ((dns_server != RT_NULL) && ipaddr_aton(dns_server, &addr))
{ {
dns_setserver(0, &addr); dns_setserver(0, &addr);
} }
} }
FINSH_FUNCTION_EXPORT(set_dns, set DNS server address); FINSH_FUNCTION_EXPORT(set_dns, set DNS server address);
#endif #endif
@ -451,11 +452,16 @@ void list_if(void)
rt_ubase_t index; rt_ubase_t index;
struct netif * netif; struct netif * netif;
rt_enter_critical();
netif = netif_list; netif = netif_list;
while( netif != RT_NULL ) while( netif != RT_NULL )
{ {
rt_kprintf("network interface: %c%c%s\n", netif->name[0], netif->name[1], (netif == netif_default)?" (Default)":""); rt_kprintf("network interface: %c%c%s\n",
netif->name[0],
netif->name[1],
(netif == netif_default)?" (Default)":"");
rt_kprintf("MTU: %d\n", netif->mtu); rt_kprintf("MTU: %d\n", netif->mtu);
rt_kprintf("MAC: "); rt_kprintf("MAC: ");
for (index = 0; index < netif->hwaddr_len; index ++) for (index = 0; index < netif->hwaddr_len; index ++)
@ -489,6 +495,8 @@ void list_if(void)
} }
} }
#endif /**< #if LWIP_DNS */ #endif /**< #if LWIP_DNS */
rt_exit_critical();
} }
FINSH_FUNCTION_EXPORT(list_if, list network interface information); FINSH_FUNCTION_EXPORT(list_if, list network interface information);
@ -496,42 +504,62 @@ FINSH_FUNCTION_EXPORT(list_if, list network interface information);
#include <lwip/tcp.h> #include <lwip/tcp.h>
#include <lwip/tcp_impl.h> #include <lwip/tcp_impl.h>
void list_tcps() void list_tcps(void)
{ {
struct tcp_pcb *pcb; rt_uint32_t num = 0;
extern struct tcp_pcb *tcp_active_pcbs; struct tcp_pcb *pcb;
extern union tcp_listen_pcbs_t tcp_listen_pcbs; char local_ip_str[16];
extern struct tcp_pcb *tcp_tw_pcbs; char remote_ip_str[16];
extern const char *tcp_state_str[];
rt_enter_critical(); extern struct tcp_pcb *tcp_active_pcbs;
rt_kprintf("Active PCB states:\n"); extern union tcp_listen_pcbs_t tcp_listen_pcbs;
for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) extern struct tcp_pcb *tcp_tw_pcbs;
{ extern const char *tcp_state_str[];
rt_kprintf("%s:%d <==> %s:%d snd_nxt %d rcv_nxt %d ",
ipaddr_ntoa(&(pcb->local_ip)), pcb->local_port,
ipaddr_ntoa(&(pcb->remote_ip)), pcb->remote_port,
pcb->snd_nxt, pcb->rcv_nxt);
rt_kprintf("state: %s\n", tcp_state_str[pcb->state]);
}
rt_kprintf("Listen PCB states:\n"); rt_enter_critical();
for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) rt_kprintf("Active PCB states:\n");
{ for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next)
rt_kprintf("local port %d ", pcb->local_port); {
rt_kprintf("state: %s\n", tcp_state_str[pcb->state]); strcpy(local_ip_str, ipaddr_ntoa(&(pcb->local_ip)));
} strcpy(remote_ip_str, ipaddr_ntoa(&(pcb->remote_ip)));
rt_kprintf("TIME-WAIT PCB states:\n"); rt_kprintf("#%d %s:%d <==> %s:%d snd_nxt 0x%08X rcv_nxt 0x%08X ",
for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) num++,
{ local_ip_str,
rt_kprintf("%s:%d <==> %s:%d snd_nxt %d rcv_nxt %d ", pcb->local_port,
ipaddr_ntoa(&(pcb->local_ip)), pcb->local_port, remote_ip_str,
ipaddr_ntoa(&(pcb->remote_ip)), pcb->remote_port, pcb->remote_port,
pcb->snd_nxt, pcb->rcv_nxt); pcb->snd_nxt,
rt_kprintf("state: %s\n", tcp_state_str[pcb->state]); pcb->rcv_nxt);
} rt_kprintf("state: %s\n", tcp_state_str[pcb->state]);
rt_exit_critical(); }
rt_kprintf("Listen PCB states:\n");
num = 0;
for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next)
{
rt_kprintf("#%d local port %d ", num++, pcb->local_port);
rt_kprintf("state: %s\n", tcp_state_str[pcb->state]);
}
rt_kprintf("TIME-WAIT PCB states:\n");
num = 0;
for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next)
{
strcpy(local_ip_str, ipaddr_ntoa(&(pcb->local_ip)));
strcpy(remote_ip_str, ipaddr_ntoa(&(pcb->remote_ip)));
rt_kprintf("#%d %s:%d <==> %s:%d snd_nxt 0x%08X rcv_nxt 0x%08X ",
num++,
local_ip_str,
pcb->local_port,
remote_ip_str,
pcb->remote_port,
pcb->snd_nxt,
pcb->rcv_nxt);
rt_kprintf("state: %s\n", tcp_state_str[pcb->state]);
}
rt_exit_critical();
} }
FINSH_FUNCTION_EXPORT(list_tcps, list all of tcp connections); FINSH_FUNCTION_EXPORT(list_tcps, list all of tcp connections);
#endif #endif

60
examples/gui/SConscript
View File

@ -1,60 +0,0 @@
from building import *
import os
'''
demo_view_dc_buffer.c
demo_fnview.c
demo_listview.c
demo_listview_icon.c
demo_panel_single.c
demo_view_box.c
demo_view_image.c
demo_view_module.c
'''
src = Split("""
demo_application.c
demo_view.c
demo_xml.c
demo_view_benchmark.c
demo_view_dc.c
demo_view_ttf.c
demo_view_dc_buffer.c
demo_view_animation.c
demo_view_buffer_animation.c
demo_view_instrument_panel.c
demo_view_window.c
demo_view_label.c
demo_view_button.c
demo_view_checkbox.c
demo_view_progressbar.c
demo_view_scrollbar.c
demo_view_radiobox.c
demo_view_textbox.c
demo_view_listbox.c
demo_view_menu.c
demo_view_listctrl.c
demo_view_combobox.c
demo_view_slider.c
demo_view_notebook.c
demo_view_mywidget.c
demo_view_box.c
demo_view_edit.c
demo_view_bmp.c
demo_plot.c
mywidget.c
demo_view_digtube.c
""")
if GetDepend('RTGUI_USING_FONT_COMPACT'):
import stract_cjk as sf
fl1 = sf.get_font_lib('hz16')
fl2 = sf.get_font_lib('hz12')
cwd = GetCurrentDir()
for i in src:
fl1.push_file(open(os.path.join(cwd, i), 'r'))
fl2.push_file(open(os.path.join(cwd, i), 'r'))
group = DefineGroup('gui_examples', src, depend = ['RT_USING_RTGUI'])
Return('group')

156
examples/gui/demo_application.c
View File

@ -1,156 +0,0 @@
#include <rtgui/rtgui.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/rtgui_app.h>
#include <rtgui/widgets/window.h>
#include <rtgui/widgets/notebook.h>
struct rtgui_notebook *the_notebook;
static rt_bool_t demo_handle_key(struct rtgui_object *object, struct rtgui_event *event)
{
struct rtgui_event_kbd *ekbd = (struct rtgui_event_kbd *)event;
if (ekbd->type == RTGUI_KEYUP)
{
if (ekbd->key == RTGUIK_RIGHT)
{
demo_view_next(RT_NULL, RT_NULL);
return RT_TRUE;
}
else if (ekbd->key == RTGUIK_LEFT)
{
demo_view_prev(RT_NULL, RT_NULL);
return RT_TRUE;
}
}
return RT_TRUE;
}
struct rtgui_win *main_win;
static void application_entry(void *parameter)
{
struct rtgui_app *app;
struct rtgui_rect rect;
app = rtgui_app_create("gui_demo");
if (app == RT_NULL)
return;
/* create a full screen window */
rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &rect);
main_win = rtgui_win_create(RT_NULL, "demo_win", &rect,
RTGUI_WIN_STYLE_NO_BORDER | RTGUI_WIN_STYLE_NO_TITLE);
if (main_win == RT_NULL)
{
rtgui_app_destroy(app);
return;
}
rtgui_win_set_onkey(main_win, demo_handle_key);
/* create a no title notebook that we can switch demo on it easily. */
the_notebook = rtgui_notebook_create(&rect, RTGUI_NOTEBOOK_NOTAB);
if (the_notebook == RT_NULL)
{
rtgui_win_destroy(main_win);
rtgui_app_destroy(app);
return;
}
rtgui_container_add_child(RTGUI_CONTAINER(main_win), RTGUI_WIDGET(the_notebook));
//demo_view_box();
/* 初始化各个例子的视图 */
demo_view_benchmark();
demo_view_dc();
#ifdef RTGUI_USING_TTF
demo_view_ttf();
#endif
#ifndef RTGUI_USING_SMALL_SIZE
demo_view_dc_buffer();
#endif
demo_view_animation();
#ifndef RTGUI_USING_SMALL_SIZE
demo_view_buffer_animation();
demo_view_instrument_panel();
#endif
demo_view_window();
demo_view_label();
demo_view_button();
demo_view_checkbox();
demo_view_progressbar();
demo_view_scrollbar();
demo_view_radiobox();
demo_view_textbox();
demo_view_listbox();
demo_view_menu();
demo_view_listctrl();
demo_view_combobox();
demo_view_slider();
demo_view_notebook();
demo_view_mywidget();
demo_plot();
demo_view_digtube();
#if defined(RTGUI_USING_DFS_FILERW)
demo_view_edit();
demo_view_bmp();
#endif
#if 0
#if defined(RTGUI_USING_DFS_FILERW)
demo_view_image();
#endif
#ifdef RT_USING_MODULE
#if defined(RTGUI_USING_DFS_FILERW)
demo_view_module();
#endif
#endif
demo_listview_view();
demo_listview_icon_view();
#if defined(RTGUI_USING_DFS_FILERW)
demo_fn_view();
#endif
#endif
rtgui_win_show(main_win, RT_FALSE);
/* 执行工作台事件循环 */
rtgui_app_run(app);
rtgui_app_destroy(app);
}
void application_init()
{
static rt_bool_t inited = RT_FALSE;
if (inited == RT_FALSE) /* 避免重复初始化而做的保护 */
{
rt_thread_t tid;
tid = rt_thread_create("wb",
application_entry, RT_NULL,
2048 * 2, 25, 10);
if (tid != RT_NULL)
rt_thread_startup(tid);
inited = RT_TRUE;
}
}
#ifdef RT_USING_FINSH
#include <finsh.h>
void application()
{
application_init();
}
/* finsh的命令输出，可以直接执行application()函数以执行上面的函数 */
FINSH_FUNCTION_EXPORT(application, application demo)
#endif

90
examples/gui/demo_fnview.c
View File

@ -1,90 +0,0 @@
/*
* 程序清单：文件列表视图演示
*
* 这个例子会先创建出一个演示用的view，当点击上面的按钮时会按照模式显示的形式显示
* 新的文件列表视图。
*/
#include "demo_view.h"
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/filelist_view.h>
#if defined(RTGUI_USING_DFS_FILERW) || defined(RTGUI_USING_STDIO_FILERW)
/* 用于显示选择文件名的文本标签 */
static rtgui_label_t *label;
/* 触发文件列表视图的按钮回调函数 */
static void open_btn_onbutton(rtgui_widget_t *widget, struct rtgui_event *event)
{
rtgui_filelist_view_t *view;
rtgui_workbench_t *workbench;
rtgui_rect_t rect;
/* 获得顶层的workbench对象 */
workbench = RTGUI_APPLICATION(rtgui_widget_get_toplevel(widget));
rtgui_widget_get_rect(RTGUI_WIDGET(workbench), &rect);
/* 针对Win32平台和其他平台做的不同的其实目录位置 */
#ifdef _WIN32
view = rtgui_filelist_view_create(workbench, "d:\\", "*.*", &rect);
#else
view = rtgui_filelist_view_create(workbench, "/", "*.*", &rect);
#endif
/* 采用模式形式显示文件列表视图 */
if (rtgui_container_show(RTGUI_CONTAINER(view), RT_TRUE) == RTGUI_MODAL_OK)
{
char path[32];
/* 在文件列表视图中成功选择文件，这里获得相应的路径名 */
rtgui_filelist_view_get_fullpath(view, path, sizeof(path));
/* 设置文件路径到文本标签 */
rtgui_label_set_text(label, path);
}
/* 删除 文件列表 视图 */
rtgui_container_destroy(RTGUI_CONTAINER(view));
}
/* 创建用于演示文件列表视图的视图 */
rtgui_container_t *demo_fn_view(rtgui_workbench_t *workbench)
{
rtgui_rect_t rect;
rtgui_container_t *view;
rtgui_button_t *open_btn;
rtgui_font_t *font;
/* 默认采用12字体的显示 */
font = rtgui_font_refer("asc", 12);
/* 创建演示用的视图 */
view = demo_view(workbench, "FileList View");
/* 获得演示视图的位置信息 */
demo_view_get_rect(view, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建显示文件路径用的文本标签 */
label = rtgui_label_create("fn: ");
rtgui_container_add_child(RTGUI_CONTAINER(view), RTGUI_WIDGET(label));
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
RTGUI_WIDGET_FONT(RTGUI_WIDGET(label)) = font;
/* 获得演示视图的位置信息 */
demo_view_get_rect(view, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 80;
rect.y1 += 30;
rect.y2 = rect.y1 + 20;
/* 创建按钮以触发一个新的文件列表视图 */
open_btn = rtgui_button_create("Open File");
rtgui_container_add_child(RTGUI_CONTAINER(view), RTGUI_WIDGET(open_btn));
rtgui_widget_set_rect(RTGUI_WIDGET(open_btn), &rect);
RTGUI_WIDGET_FONT(RTGUI_WIDGET(open_btn)) = font;
rtgui_button_set_onbutton(open_btn, open_btn_onbutton);
return view;
}
#endif

107
examples/gui/demo_listview.c
View File

@ -1,107 +0,0 @@
/*
* 程序清单：列表视图演示
*
* 这个例子会先创建出一个演示用的container，当点击上面的按钮时会按照模式显示的形式显示
* 新的列表视图
*/
#include "demo_view.h"
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/window.h>
#include <rtgui/widgets/list_view.h>
static struct rtgui_application *application = RT_NULL;
static rtgui_list_view_t *_view = RT_NULL;
// static rtgui_image_t* return_image = RT_NULL;
/* 列表项的动作函数 */
static void listitem_action(rtgui_widget_t *widget, void *parameter)
{
char label_text[32];
rtgui_win_t *win;
rtgui_label_t *label;
rtgui_rect_t rect = {0, 0, 150, 80};
int no = (int)parameter;
rtgui_rect_moveto(&rect, 20, 50);
/* 显示消息窗口 */
win = rtgui_win_create(RTGUI_TOPLEVEL(application),
"窗口", &rect, RTGUI_WIN_STYLE_DEFAULT);
rect.x1 += 20;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 添加相应的标签 */
rt_sprintf(label_text, "动作 %d", no);
label = rtgui_label_create(label_text);
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(win, RTGUI_WIDGET(label));
/* 非模态显示窗口 */
rtgui_win_show(win, RT_FALSE);
}
/* 返回功能的动作函数 */
static void return_action(rtgui_widget_t *widget, void *parameter)
{
rtgui_container_end_modal(RTGUI_CONTAINER(_view), RTGUI_MODAL_OK);
}
/* 各个列表项定义 */
static struct rtgui_list_item items[] =
{
{"列表项1", RT_NULL, listitem_action, (void *)1},
{"列表项2", RT_NULL, listitem_action, (void *)2},
{"列表项3", RT_NULL, listitem_action, (void *)3},
{"列表项4", RT_NULL, listitem_action, (void *)4},
{"列表项5", RT_NULL, listitem_action, (void *)5},
{"返回", RT_NULL, return_action, RT_NULL},
};
/* 打开列表视图用的按钮触发函数 */
static void open_btn_onbutton(rtgui_widget_t *widget, struct rtgui_event *event)
{
rtgui_rect_t rect;
/* 获得顶层的application */
application = RTGUI_APPLICATION(rtgui_widget_get_toplevel(widget));
rtgui_widget_get_rect(RTGUI_WIDGET(application), &rect);
/* 创建一个列表视图， 项指定为items */
_view = rtgui_list_view_create(items, sizeof(items) / sizeof(struct rtgui_list_item),
&rect, RTGUI_LIST_VIEW_LIST);
rtgui_application_add_container(application, RTGUI_CONTAINER(_view));
/* 模式显示视图 */
rtgui_container_show(RTGUI_CONTAINER(_view), RT_TRUE);
rtgui_container_destroy(RTGUI_CONTAINER(_view));
_view = RT_NULL;
}
/* 创建用于演示列表视图的视图 */
rtgui_container_t *demo_listview_view(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_button_t *open_btn;
container = demo_view("列表视图演示");
/* 添加动作按钮 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 80;
rect.y1 += 30;
rect.y2 = rect.y1 + 20;
open_btn = rtgui_button_create("打开列表");
rtgui_container_add_child(container, RTGUI_WIDGET(open_btn));
rtgui_widget_set_rect(RTGUI_WIDGET(open_btn), &rect);
rtgui_button_set_onbutton(open_btn, open_btn_onbutton);
return container;
}

350
examples/gui/demo_listview_icon.c
View File

@ -1,350 +0,0 @@
/*
* 程序清单：列表视图演示
*
* 这个例子会先创建出一个演示用的view，当点击上面的按钮时会按照模式显示的形式显示
* 新的列表视图
*/
#include "demo_view.h"
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/window.h>
#include <rtgui/widgets/list_view.h>
static struct rtgui_application *application = RT_NULL;
static rtgui_list_view_t *_view = RT_NULL;
/* 列表项的动作函数 */
static void listitem_action(rtgui_widget_t *widget, void *parameter)
{
char label_text[32];
rtgui_win_t *win;
rtgui_label_t *label;
rtgui_rect_t rect = {0, 0, 150, 80};
int no = (int)parameter;
rtgui_rect_moveto(&rect, 20, 50);
/* 显示消息窗口 */
win = rtgui_win_create(RTGUI_TOPLEVEL(application),
"窗口", &rect, RTGUI_WIN_STYLE_DEFAULT);
rect.x1 += 20;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 添加相应的标签 */
rt_sprintf(label_text, "动作 %d", no);
label = rtgui_label_create(label_text);
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(win), RTGUI_WIDGET(label));
/* 非模态显示窗口 */
rtgui_win_show(win, RT_FALSE);
}
/* 返回功能的动作函数 */
static void return_action(rtgui_widget_t *widget, void *parameter)
{
/* 退出模态显示 */
rtgui_container_end_modal(RTGUI_CONTAINER(_view), RTGUI_MODAL_OK);
}
/* 列表项 */
#define ITEM_MAX 50
static struct rtgui_list_item *items = RT_NULL;
static rtgui_image_t *item_icon = RT_NULL;
static rtgui_image_t *exit_icon = RT_NULL;
static const char *image_xpm[] =
{
"16 16 106 2",
" c None",
". c #D0C83F",
"+ c #D0C840",
"@ c #D0C030",
"# c #D0B820",
"$ c #D0B020",
"% c #D0B01F",
"& c #5F571F",
"* c #F0F0C0",
"= c #FFF8D0",
"- c #FFF8C0",
"; c #FFF8B0",
"> c #FFF8A0",
", c #F0E870",
"' c #707030",
") c #4F87EF",
"! c #4F78C0",
"~ c #5088E0",
"{ c #5078C0",
"] c #C0D0F0",
"^ c #FFF8E0",
"/ c #FFF090",
"( c #F0E070",
"_ c #6F97D0",
": c #C0D8FE",
"< c #80A8F0",
"[ c #7088D0",
"} c #B0D0FF",
"| c #90B0F0",
"1 c #1040A0",
"2 c #F0F080",
"3 c #707040",
"4 c #7098F0",
"5 c #3068E0",
"6 c #A0B8F0",
"7 c #4070C0",
"8 c #002880",
"9 c #404040",
"0 c #505050",
"a c #F0F090",
"b c #F0E860",
"c c #F0D860",
"d c #807840",
"e c #2F5FC0",
"f c #1050D0",
"g c #1048B0",
"h c #002870",
"i c #C0C080",
"j c #C0C070",
"k c #F0F070",
"l c #F0E060",
"m c #E0D050",
"n c #00277F",
"o c #00287F",
"p c #1F3F6F",
"q c #1048C0",
"r c #0040B0",
"s c #204080",
"t c #FFF890",
"u c #F0D850",
"v c #E0C840",
"w c #807040",
"x c #A0B06F",
"y c #204880",
"z c #2048A0",
"A c #90A8C0",
"B c #FFF080",
"C c #F0D050",
"D c #C0A830",
"E c #6F682F",
"F c #F0F0A0",
"G c #E0D060",
"H c #B0A040",
"I c #D0B840",
"J c #E0C040",
"K c #D0B030",
"L c #706820",
"M c #5F581F",
"N c #CFBF3F",
"O c #FFF0A0",
"P c #A09830",
"Q c #A08820",
"R c #908030",
"S c #807830",
"T c #707020",
"U c #605820",
"V c #6F672F",
"W c #D0C040",
"X c #F0E880",
"Y c #907820",
"Z c #B09820",
"` c #B09010",
" . c #B08820",
".. c #806820",
"+. c #5F5F1F",
"@. c #F0E080",
"#. c #B09020",
"$. c #C0B040",
"%. c #A09030",
"&. c #908020",
"*. c #606020",
"=. c #6F5F1F",
"-. c #9F982F",
";. c #A0872F",
">. c #6F681F",
",. c #706020",
" ",
" . + + + @ @ # # $ % & ",
" + * = = = = - ; > , ' ",
" ) ! ~ { ] ^ = - - > / ( ' ",
"_ : < { [ } | 1 - ; > > / 2 ( 3 ",
"{ 4 5 1 6 7 5 8 9 0 a / , b c d ",
"e f g h 8 8 g h i j / k l c m d ",
" n o p q r s t 2 , l c u v w ",
" x y z A B , l u C v D E ",
" @ F > t k G H I J K L M ",
" N @ O / 2 l P Q R S T U V ",
" W m 2 X l I Y Z ` ...+. ",
" W @.l u I R #.Z Y U M ",
" $.G I $.%.R &.Y *.& =. ",
" -.;.>.,.L L ,.& M ",
" "
};
static const char *exit_xpm[] =
{
"16 16 71 1",
" c None",
". c #CF673F",
"+ c #D0673F",
"@ c #C05F3F",
"# c #BF5F3F",
"$ c #D0674F",
"% c #E07050",
"& c #F07850",
"* c #FF7040",
"= c #F06830",
"- c #E05830",
"; c #D05030",
"> c #B04F2F",
", c #D06F4F",
"' c #F08060",
") c #FF9070",
"! c #FF8860",
"~ c #FF8050",
"{ c #FF5820",
"] c #FF4810",
"^ c #D04810",
"/ c #B0482F",
"( c #FF9880",
"_ c #FF6030",
": c #F04000",
"< c #C04010",
"[ c #A03F2F",
"} c #E06840",
"| c #FF9870",
"1 c #FF7850",
"2 c #FF6840",
"3 c #F04010",
"4 c #E03800",
"5 c #A03820",
"6 c #8F372F",
"7 c #F06840",
"8 c #FF8060",
"9 c #FFFFFF",
"0 c #FFF8F0",
"a c #FFF0F0",
"b c #FFE8E0",
"c c #FFD0C0",
"d c #E04010",
"e c #B03010",
"f c #7F2F1F",
"g c #FFD8D0",
"h c #FFC8C0",
"i c #C03000",
"j c #6F281F",
"k c #F04810",
"l c #FF6830",
"m c #FFE0D0",
"n c #F0C0B0",
"o c #D04010",
"p c #5F1F1F",
"q c #E04820",
"r c #FF4000",
"s c #FF5020",
"t c #FF5010",
"u c #D03800",
"v c #D03000",
"w c #B02800",
"x c #5F170F",
"y c #C05020",
"z c #F03800",
"A c #802010",
"B c #4F0F0F",
"C c #A02800",
"D c #C03810",
"E c #5F0F00",
"F c #A03810",
" ",
" .+@@@# ",
" $%&*=-;> ",
" ,')!~*{]^/ ",
" +&)()~*_]:<[ ",
" .}~!||!12{3456 ",
" +7899990abcdef ",
" @{19990bgchdij ",
" @kl0abmchcnoip ",
" @qr]stt]3duvwx ",
" #yz:::z44uvvAB ",
" >o4444uvvvCB ",
" /DvvvvvvCE ",
" [FeiiwAB ",
" 6fjpxB ",
" "
};
/* 打开列表视图用的按钮触发函数 */
static void open_btn_onbutton(rtgui_widget_t *widget, struct rtgui_event *event)
{
rtgui_rect_t rect;
rt_uint32_t index;
/* 获得顶层的application */
application = RTGUI_APPLICATION(rtgui_widget_get_toplevel(widget));
rtgui_widget_get_rect(RTGUI_WIDGET(application), &rect);
/* 初始化图标列表 */
if (items == RT_NULL)
{
char item_name[32];
items = (struct rtgui_list_item *) rtgui_malloc((ITEM_MAX + 1) * sizeof(struct rtgui_list_item));
for (index = 0; index < ITEM_MAX; index ++)
{
rt_snprintf(item_name, sizeof(item_name), "图标%d", index);
items[index].action = listitem_action;
items[index].image = item_icon;
items[index].name = rt_strdup(item_name);
items[index].parameter = (void *) index;
}
items[ITEM_MAX].action = return_action;
items[ITEM_MAX].image = exit_icon;
items[ITEM_MAX].name = "退出";
items[ITEM_MAX].parameter = RT_NULL;
}
/* 创建一个列表视图， 项指定为items */
_view = rtgui_list_view_create(items, ITEM_MAX + 1, &rect, RTGUI_LIST_VIEW_ICON);
/* 在application中添加相应的视图 */
rtgui_application_add_container(application, RTGUI_CONTAINER(_view));
/* 模式显示视图 */
rtgui_container_show(RTGUI_CONTAINER(_view), RT_TRUE);
rtgui_container_destroy(RTGUI_CONTAINER(_view));
_view = RT_NULL;
}
/* 创建用于演示列表视图的视图 */
rtgui_container_t *demo_listview_icon_view(struct rtgui_application *app)
{
rtgui_rect_t rect;
rtgui_container_t *view;
rtgui_button_t *open_btn;
view = demo_view(app, "图标视图演示");
if (item_icon == RT_NULL)
item_icon = rtgui_image_create_from_mem("xpm",
(const rt_uint8_t *)image_xpm, sizeof(image_xpm), RT_TRUE);
if (exit_icon == RT_NULL)
exit_icon = rtgui_image_create_from_mem("xpm",
(const rt_uint8_t *)exit_xpm, sizeof(exit_xpm), RT_TRUE);
/* 添加动作按钮 */
demo_view_get_rect(view, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 80;
rect.y1 += 30;
rect.y2 = rect.y1 + 20;
open_btn = rtgui_button_create("打开图标列表");
rtgui_container_add_child(RTGUI_CONTAINER(view), RTGUI_WIDGET(open_btn));
rtgui_widget_set_rect(RTGUI_WIDGET(open_btn), &rect);
rtgui_button_set_onbutton(open_btn, open_btn_onbutton);
return view;
}

27
examples/gui/demo_panel.c
View File

@ -1,27 +0,0 @@
#include <rtgui/rtgui.h>
#include <rtgui/rtgui_server.h>
/*
* Panel demo for 240x320
* info panel: (0, 0) - (240, 25)
* main panel: (0, 25) - (240, 320)
*/
void panel_init(void)
{
rtgui_rect_t rect;
/* register dock panel */
rect.x1 = 0;
rect.y1 = 0;
rect.x2 = 240;
rect.y2 = 25;
rtgui_panel_register("info", &rect);
/* register main panel */
rect.x1 = 0;
rect.y1 = 25;
rect.x2 = 240;
rect.y2 = 320;
rtgui_panel_register("main", &rect);
rtgui_panel_set_default_focused("main");
}

19
examples/gui/demo_panel_single.c
View File

@ -1,19 +0,0 @@
#include <rtgui/rtgui.h>
#include <rtgui/driver.h>
#include <rtgui/rtgui_server.h>
/*
* a single panel
*/
void panel_init(void)
{
rtgui_rect_t rect;
/* register main panel */
rect.x1 = 0;
rect.y1 = 0;
rect.x2 = rtgui_graphic_driver_get_default()->width;
rect.y2 = rtgui_graphic_driver_get_default()->height;
rtgui_panel_register("main", &rect);
rtgui_panel_set_default_focused("main");
}

77
examples/gui/demo_plot.c
View File

@ -1,77 +0,0 @@
#include <rtgui/widgets/plot.h>
#include <rtgui/widgets/plot_curve.h>
#include "demo_view.h"
/* sin data */
rt_int16_t sin_ydata[] = {
0, 9, 19, 29, 38, 47, 56, 64, 71, 78, 84, 89, 93, 96, 98, 99, 99, 99, 97,
94, 90, 86, 80, 74, 67, 59, 51, 42, 33, 23, 14, 4, -5, -15, -25, -35, -44,
-52, -61, -68, -75, -81, -87, -91, -95, -97, -99, -99, -99, -98, -95, -92,
-88, -83, -77, -70, -63, -55, -46, -37, -27, -18, -8, 1, 11, 21, 31
};
rt_int16_t cos_ydata[] = {
50, 49, 46, 41, 34, 27, 18, 8, -1, -11, -20, -29, -36, -42, -47, -49, -49,
-48, -44, -39, -32, -24, -15, -5, 4, 14, 23, 31, 38, 44, 48, 49, 49, 47,
43, 37, 30, 21, 12, 2, -7, -16, -25, -33, -40, -45, -48, -49, -49, -46,
-41, -35, -28, -19, -9, 0, 10, 19, 28, 36, 42, 46, 49, 49, 48, 45, 40, 33,
25, 16, 6, -3, -12, -22, -30, -37, -43, -47, -49, -49, -47, -44, -38, -31,
-23, -13, -3, 6, 15, 24, 33, 39, 45, 48, 49, 49, 46, 42, 36, 29, 20, 10, 1,
-8, -18, -27, -35, -41, -46, -49, -49, -48, -45, -41, -34, -26, -17, -8, 1,
11, 21, 29, 37, 43, 47, 49, 49, 48, 44, 39, 32, 24, 14, 5, -4, -14, -23,
-32, -39, -44, -48, -49, -49, -47, -43, -37, -30, -21, -12, -2, 7, 17, 26,
34, 40, 45, 48, 49, 49, 46, 41, 35, 27, 18, 9, 0, -10, -20, -28, -36, -42,
-46, -49, -49, -48, -45, -40, -33, -25, -16, -6, 3, 13, 22, 31, 38, 43, 47,
49, 49, 47, 43, 38
};
struct rtgui_container* demo_plot(void)
{
struct rtgui_container *cnt;
struct rtgui_plot_curve *curve1, *curve2, *curve3;
struct rtgui_plot *plot;
struct rtgui_rect rect;
cnt = demo_view("ÇúĎßťćÍź");
plot = rtgui_plot_create();
curve1 = rtgui_plot_curve_create();
rtgui_plot_curve_set_y(curve1, sin_ydata);
RTGUI_MV_MODEL(curve1)->length = sizeof(sin_ydata)/sizeof(sin_ydata[0]);
curve1->min_x = 0;
curve1->max_x = sizeof(sin_ydata)/sizeof(sin_ydata[0]);
curve1->min_y = -100;
curve1->max_y = 100;
curve1->color = red;
rtgui_mv_model_add_view(RTGUI_MV_MODEL(curve1), RTGUI_MV_VIEW(plot));
curve2 = rtgui_plot_curve_create();
rtgui_plot_curve_set_y(curve2, cos_ydata);
RTGUI_MV_MODEL(curve2)->length = sizeof(cos_ydata)/sizeof(cos_ydata[0]);
curve2->min_x = 0;
curve2->max_x = sizeof(cos_ydata)/sizeof(cos_ydata[0]);
curve2->min_y = -50;
curve2->max_y = 50;
curve2->color = blue;
rtgui_mv_model_add_view(RTGUI_MV_MODEL(curve2), RTGUI_MV_VIEW(plot));
curve3 = rtgui_plot_curve_create();
rtgui_plot_curve_set_x(curve3, cos_ydata);
rtgui_plot_curve_set_y(curve3, sin_ydata);
curve3->min_x = -50;
curve3->max_x = 50;
curve3->min_y = -100;
curve3->max_y = 100;
RTGUI_MV_MODEL(curve3)->length = sizeof(sin_ydata)/sizeof(sin_ydata[0]);
curve3->color = black;
rtgui_mv_model_add_view(RTGUI_MV_MODEL(curve3), RTGUI_MV_VIEW(plot));
rtgui_widget_get_rect(RTGUI_WIDGET(cnt), &rect);
rtgui_widget_set_rect(RTGUI_WIDGET(plot), &rect);
rtgui_plot_set_base(plot, -100, -300);
rtgui_container_add_child(cnt, RTGUI_WIDGET(plot));
return cnt;
}

62
examples/gui/demo_simple_workbench.c
View File

@ -1,62 +0,0 @@
/*
* A simple workbench
*/
#include <rtthread.h>
#include <rtgui/rtgui_server.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/workbench.h>
static void workbench_entry(void *parameter)
{
rt_mq_t mq;
rtgui_container_t *view;
rtgui_label_t *label;
struct rtgui_workbench *workbench;
rtgui_rect_t rect;
mq = rt_mq_create("wmq", 256, 8, RT_IPC_FLAG_FIFO);
/* 注册当前线程为GUI线程 */
rtgui_thread_register(rt_thread_self(), mq);
/* 创建一个工作台 */
workbench = rtgui_workbench_create("main", "workbench #1");
if (workbench == RT_NULL) return;
view = rtgui_container_create("view");
if (view == RT_NULL) return;
/* 指定视图的背景色 */
RTGUI_WIDGET_BACKGROUND(RTGUI_WIDGET(view)) = white;
/* 添加一个label */
label = rtgui_label_create("你好！RT-Thread！");
rect.x1 = 10;
rect.y1 = 10;
rect.x2 = 210;
rect.y2 = 30;
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(view), RTGUI_WIDGET(label));
/* 添加到父workbench中 */
rtgui_workbench_add_view(workbench, view);
/* 非模式方式显示视图 */
rtgui_container_show(view, RT_FALSE);
/* 执行工作台事件循环 */
rtgui_workbench_event_loop(workbench);
/* 去注册GUI线程 */
rtgui_thread_deregister(rt_thread_self());
/* delete message queue */
rt_mq_delete(mq);
}
/* 初始化workbench */
void wb_init()
{
rt_thread_t tid;
tid = rt_thread_create("wb1", workbench_entry, RT_NULL, 2048, 20, 5);
if (tid != RT_NULL) rt_thread_startup(tid);
}

132
examples/gui/demo_view.c
View File

@ -1,132 +0,0 @@
#include <rtgui/rtgui.h>
#include <rtgui/rtgui_app.h>
#include <rtgui/widgets/container.h>
#include <rtgui/widgets/notebook.h>
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/staticline.h>
#include <rtgui/widgets/box.h>
extern struct rtgui_notebook *the_notebook;
void demo_view_next(struct rtgui_object *object, struct rtgui_event *event)
{
rtgui_notebook_set_current_by_index(the_notebook,
(rtgui_notebook_get_current_index(the_notebook) + 1) %
rtgui_notebook_get_count(the_notebook));
}
void demo_view_prev(struct rtgui_object *object, struct rtgui_event *event)
{
rt_int16_t cur_idx = rtgui_notebook_get_current_index(the_notebook);
if (cur_idx == 0)
rtgui_notebook_set_current_by_index(the_notebook,
rtgui_notebook_get_count(the_notebook) - 1);
else
rtgui_notebook_set_current_by_index(the_notebook,
--cur_idx);
}
rtgui_container_t *demo_view(const char *title)
{
struct rtgui_container *container;
struct rtgui_label *label;
struct rtgui_staticline *line;
struct rtgui_button *next_btn, *prev_btn;
struct rtgui_rect rect;
container = rtgui_container_create();
if (container == RT_NULL)
return RT_NULL;
rtgui_notebook_add(the_notebook, title, RTGUI_WIDGET(container));
/* 获得视图的位置信息(在加入到 notebook 中时，notebook 会自动调整 container
* 的大小) */
rtgui_widget_get_rect(RTGUI_WIDGET(container), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(container), &rect);
rect.x1 += 5;
rect.y1 += 5;
rect.x2 = rect.x1 + rt_strlen(title)*8;
rect.y2 = rect.y1 + 20;
/* 创建标题用的标签 */
label = rtgui_label_create(title);
/* 设置标签位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* 添加标签到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
rtgui_widget_get_rect(RTGUI_WIDGET(container), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(container), &rect);
rect.y1 += 20 + 5;
rect.y2 = rect.y1 + 2;
/* 创建一个水平的 staticline 线 */
line = rtgui_staticline_create(RTGUI_HORIZONTAL);
/* 设置静态线的位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(line), &rect);
/* 添加静态线到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(line));
/* 获得视图的位置信息 */
rtgui_widget_get_rect(RTGUI_WIDGET(container), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(container), &rect);
rect.x2 -= 5;
rect.y2 -= 5;
rect.x1 = rect.x2 - 100;
rect.y1 = rect.y2 - 25;
/* 创建"下一个"按钮 */
next_btn = rtgui_button_create("下一个");
/* 设置onbutton动作到demo_view_next函数 */
rtgui_button_set_onbutton(next_btn, demo_view_next);
/* 设置按钮的位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(next_btn), &rect);
/* 添加按钮到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(next_btn));
/* 获得视图的位置信息 */
rtgui_widget_get_rect(RTGUI_WIDGET(container), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(container), &rect);
rect.x1 += 5;
rect.y2 -= 5;
rect.x2 = rect.x1 + 100;
rect.y1 = rect.y2 - 25;
/* 创建"上一个"按钮 */
prev_btn = rtgui_button_create("上一个");
/* 设置onbutton动作到demo_view_prev函数 */
rtgui_button_set_onbutton(prev_btn, demo_view_prev);
/* 设置按钮的位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(prev_btn), &rect);
/* 添加按钮到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(prev_btn));
/* 返回创建的视图 */
return container;
}
/* 这个函数用于返回演示视图的对外可用区域 */
void demo_view_get_rect(rtgui_container_t *container, rtgui_rect_t *rect)
{
RT_ASSERT(container != RT_NULL);
RT_ASSERT(rect != RT_NULL);
rtgui_widget_get_rect(RTGUI_WIDGET(container), rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(container), rect);
/* 去除演示标题和下方按钮的区域 */
rect->y1 += 45;
rect->y2 -= 35;
}
void demo_view_get_logic_rect(rtgui_container_t *container, rtgui_rect_t *rect)
{
RT_ASSERT(container != RT_NULL);
RT_ASSERT(rect != RT_NULL);
rtgui_widget_get_rect(RTGUI_WIDGET(container), rect);
/* 去除演示标题和下方按钮的区域 */
rect->y1 += 45;
rect->y2 -= 35;
}

34
examples/gui/demo_view.h
View File

@ -1,34 +0,0 @@
/*
* 程序清单：view演示
*
* 这是一个视图的演示，也是为了配合整个GUI演示而制作的视图，或者说，其他大多数控件的演示
* 都是采用，先创建一个demo_view（演示视图），然后再在这个演示视图上添加相应的控件。
*
* 这个演示视图默认上方带一个演示标题，下方带两个按钮，点击它切换到前一个视图或后一个视图。
* 针对控件演示而言，这个演示视图最重要的是提供了一个可显示的区域，只需要在这块区域上添加
* 控件即可达到演示的目的。
*
* 获得这个显示区域的函数是：
* demo_view_get_rect函数。
*/
#ifndef __DEMO_VIEW_H__
#define __DEMO_VIEW_H__
#include <rtgui/rtgui.h>
#include <rtgui/rtgui_app.h>
#include <rtgui/widgets/container.h>
/* 如果是标准版本，可以启用box自动布局引擎 */
#ifndef RTGUI_USING_SMALL_SIZE
#include <rtgui/widgets/box.h>
#endif
/* 创建一个演示视图，需要给出这个视图的演示标题 */
rtgui_container_t *demo_view(const char *title);
/* 获得演示视图提供给演示控件用的区域信息 */
void demo_view_get_rect(rtgui_container_t *view, rtgui_rect_t *rect);
void demo_view_get_logic_rect(rtgui_container_t *view, rtgui_rect_t *rect);
void demo_view_show(void);
#endif

141
examples/gui/demo_view_animation.c
View File

@ -1,141 +0,0 @@
#include <rtgui/dc.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/container.h>
#include "demo_view.h"
/*
* 直接在DC上绘图以实现动画效果
*
* 动画是依赖于定时器驱动的，会上下翻滚显示文字
* "飞线乱飞"
*/
static rt_int8_t dx = 1, dy = 1;
static rtgui_rect_t text_rect;
static rtgui_timer_t *timer;
void timeout(struct rtgui_timer *timer, void *parameter)
{
struct rtgui_dc *dc;
struct rtgui_rect rect;
struct rtgui_widget *widget;
/* 控件(container)通过parameter参数传递给定时器 */
widget = RTGUI_WIDGET(parameter);
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) /* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
return ;
/* 获得demo container允许绘图的区域，主要用于判断边界 */
demo_view_get_rect(RTGUI_CONTAINER(widget), &rect);
rect.y2 -= 5;
/* 判断是否是第一次绘图 */
if ((text_rect.x1 == 0) && (text_rect.y1 == 0))
{
rtgui_rect_moveto(&text_rect, rect.x1, rect.y1);
}
else
{
/* 擦除老的文字 */
rtgui_dc_fill_rect(dc, &text_rect);
}
/* 设置dx和dy */
if (text_rect.x2 >= rect.x2) dx = -1;
if (text_rect.x1 < rect.x1) dx = 1;
if (text_rect.y2 >= rect.y2) dy = -1;
if (text_rect.y1 < rect.y1) dy = 1;
/* 移动文本框的位置 */
text_rect.x1 += dx;
text_rect.x2 += dx;
text_rect.y1 += dy;
text_rect.y2 += dy;
/* 绘图 */
rtgui_dc_draw_text(dc, "飞线乱飞", &text_rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
static rt_bool_t animation_on_show(struct rtgui_object *object, struct rtgui_event *event)
{
rt_kprintf("animation on show\n");
if (timer != RT_NULL)
rtgui_timer_start(timer);
return RT_TRUE;
}
static rt_bool_t animation_on_hide(struct rtgui_object *object, struct rtgui_event *event)
{
rt_kprintf("animation on hide\n");
if (timer != RT_NULL)
rtgui_timer_stop(timer);
return RT_TRUE;
}
rt_bool_t animation_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
/* 因为用的是demo container，上面本身有一部分控件，所以在绘图时先要让demo container先绘图 */
rtgui_container_event_handler(object, event);
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) /* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
return RT_FALSE;
/* 获得demo container允许绘图的区域 */
demo_view_get_rect(RTGUI_CONTAINER(widget), &rect);
/* 擦除所有 */
rtgui_dc_fill_rect(dc, &rect);
/* 绘图 */
rtgui_dc_draw_text(dc, "飞线乱飞", &text_rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
else if (event->type == RTGUI_EVENT_SHOW)
{
rtgui_container_event_handler(object, event);
animation_on_show(object, event);
}
else if (event->type == RTGUI_EVENT_HIDE)
{
rtgui_container_event_handler(object, event);
animation_on_hide(object, event);
}
else
{
/* 调用默认的事件处理函数 */
return rtgui_container_event_handler(object, event);
}
return RT_FALSE;
}
rtgui_container_t *demo_view_animation()
{
rtgui_container_t *container;
container = demo_view("DC 动画");
if (container != RT_NULL)
rtgui_object_set_event_handler(RTGUI_OBJECT(container), animation_event_handler);
rtgui_font_get_metrics(RTGUI_WIDGET_FONT(container), "飞线乱飞", &text_rect);
rtgui_rect_moveto(&text_rect, 0, 45);
timer = rtgui_timer_create(2, RT_TIMER_FLAG_PERIODIC, timeout, (void *)container);
return container;
}

146
examples/gui/demo_view_benchmark.c
View File

@ -1,146 +0,0 @@
#include <stdlib.h>
#include <rtgui/dc.h>
#include <rtgui/dc_hw.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/container.h>
#include "demo_view.h"
#define RAND(x1, x2) ((rand() % (x2 - x1)) + x1)
#define _int_swap(x, y) do {x ^= y; y ^= x; x ^= y; } while(0)
static struct rtgui_container *container = RT_NULL;
static int running = 0;
static rt_tick_t ticks;
static long long area;
static rt_bool_t _benchmark_onshow(struct rtgui_object *obj, struct rtgui_event *ev)
{
rtgui_widget_focus(RTGUI_WIDGET(obj));
return RT_TRUE;
}
void _onidle(struct rtgui_object *object, rtgui_event_t *event)
{
rtgui_color_t color;
rtgui_rect_t rect, draw_rect;
struct rtgui_dc *dc;
/* 获得控件所属的DC */
// dc = rtgui_dc_hw_create(RTGUI_WIDGET(container));
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(container));
if (dc == RT_NULL)
return;
demo_view_get_logic_rect(RTGUI_CONTAINER(container), &rect);
draw_rect.x1 = RAND(rect.x1, rect.x2);
draw_rect.y1 = RAND(rect.y1, rect.y2);
draw_rect.x2 = RAND(rect.x1, rect.x2);
draw_rect.y2 = RAND(rect.y1, rect.y2);
if(draw_rect.x1 > draw_rect.x2) _int_swap(draw_rect.x1, draw_rect.x2);
if(draw_rect.y1 > draw_rect.y2) _int_swap(draw_rect.y1, draw_rect.y2);
area += rtgui_rect_width(draw_rect) * rtgui_rect_height(draw_rect);
color = RTGUI_RGB(rand() % 255, rand() % 255, rand() % 255);
RTGUI_WIDGET_BACKGROUND(container) = color;
rtgui_dc_fill_rect(dc, &draw_rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
if(rt_tick_get()-ticks >= RT_TICK_PER_SECOND)
{
char buf[16];
sprintf(buf, "%.2f", (double)area/(800*480));
rt_kprintf("frames per second: %s fps\n", buf);
area = 0;
ticks = rt_tick_get();
}
}
void _draw_default(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
struct rtgui_dc *dc;
rtgui_rect_t rect;
/* 因为用的是demo container，上面本身有一部分控件，所以在绘图时先要让demo container先绘图 */
rtgui_container_event_handler(object, event);
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) /* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
return;
/* 获得demo container允许绘图的区域 */
demo_view_get_logic_rect(RTGUI_CONTAINER(widget), &rect);
/* 擦除所有 */
RTGUI_WIDGET_BACKGROUND(widget) = default_background;
rtgui_dc_fill_rect(dc, &rect);
/* 显示提示 */
rtgui_dc_draw_text(dc, "按任意键开始/停止测试...", &rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
rt_bool_t benchmark_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
if (event->type == RTGUI_EVENT_PAINT)
{
_draw_default(object, event);
}
else if (event->type == RTGUI_EVENT_SHOW)
{
rtgui_container_event_handler(object, event);
_benchmark_onshow(object, event);
}
else if (event->type == RTGUI_EVENT_KBD)
{
struct rtgui_event_kbd *kbd = (struct rtgui_event_kbd *)event;
if (kbd->key == RTGUIK_LEFT || kbd->key == RTGUIK_RIGHT)
return RT_FALSE;
if (RTGUI_KBD_IS_UP(kbd))
{
if (running)
{
/* stop */
rtgui_app_set_onidle(rtgui_app_self(), RT_NULL);
_draw_default(object, event);
}
else
{
/* run */
ticks = rt_tick_get();
area = 0;
rtgui_app_set_onidle(rtgui_app_self(), _onidle);
}
running = !running;
}
return RT_TRUE;
}
else
{
/* 调用默认的事件处理函数 */
return rtgui_container_event_handler(object, event);
}
return RT_FALSE;
}
rtgui_container_t *demo_view_benchmark(void)
{
srand(100);
container = demo_view("绘图测试");
RTGUI_WIDGET(container)->flag |= RTGUI_WIDGET_FLAG_FOCUSABLE;
rtgui_object_set_event_handler(RTGUI_OBJECT(container), benchmark_event_handler);
return container;
}

304
examples/gui/demo_view_bmp.c
View File

@ -1,304 +0,0 @@
/*
* 程序清单：bmp_zoom演示
*/
#include "demo_view.h"
#include <rtgui/dc.h>
#include <rtgui/image.h>
#include <rtgui/image_bmp.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/textbox.h>
#include <rtgui/widgets/container.h>
#if defined(RTGUI_USING_DFS_FILERW)
struct demo_bmp_dt
{
float scale, angle;
char *filename;
struct rtgui_image *image;
struct rtgui_image *showimg;
rtgui_container_t *showbox;
rtgui_textbox_t *box;
rtgui_rect_t lastrect;
}bmpdt;
rt_bool_t demo_bitmap_showbox(struct rtgui_object* object, struct rtgui_event* event)
{
rtgui_container_t *container;
rtgui_widget_t *widget;
RT_ASSERT(object != RT_NULL);
container = RTGUI_CONTAINER(object);
widget = RTGUI_WIDGET(object);
if(event->type == RTGUI_EVENT_PAINT)
{
int w, h;
rtgui_rect_t rect;
struct rtgui_dc *dc;
struct rtgui_image *image = bmpdt.showimg;
/* 如果从其他标签切换到当前标签, image应该是RT_NULL, 重置它 */
if(image == RT_NULL && bmpdt.image != RT_NULL)
{
image = bmpdt.image;
bmpdt.scale = 1.0f;
bmpdt.angle = 0.0f;
rtgui_widget_get_rect(RTGUI_WIDGET(bmpdt.showbox), &bmpdt.lastrect);
rtgui_rect_inflate(&bmpdt.lastrect, -RTGUI_WIDGET_BORDER(bmpdt.showbox));
}
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL)
return RT_FALSE;
rtgui_widget_get_rect(widget, &rect);
/* 在绘制边框后, 再将rect缩小填充背景, 可以降低闪烁现象 */
rtgui_dc_draw_border(dc, &rect, RTGUI_WIDGET_BORDER_STYLE(widget));
rtgui_rect_inflate(&rect, -RTGUI_WIDGET_BORDER(widget));
w = rtgui_rect_width(bmpdt.lastrect);
h = rtgui_rect_height(bmpdt.lastrect);
if(w > rtgui_rect_width(rect)) w = rtgui_rect_width(rect);
if(h > rtgui_rect_height(rect)) h = rtgui_rect_height(rect);
/* fill container with background */
/*
* 参数lastrect会记录上一次绘图所用区域
* 每次重绘时,只需与lastrect比较,即可得知那些背景区域需要刷新
* 例如当放大图片时,lastrect比当前绘图区小,所有无需更新背景区,
* 当缩小图片时, 也仅需要更新绘图区比lastrect大的区域.
*/
if(image != RT_NULL)
{ /* 减少不必要的绘图 */
rtgui_rect_t rc;
if(w > image->w)
{
rc.x1 = image->w;
rc.y1 = bmpdt.lastrect.y1;
rc.x2 = bmpdt.lastrect.x2;
rc.y2 = (h > image->h) ? image->h : bmpdt.lastrect.y2;
rtgui_dc_fill_rect(dc, &rc);
}
if(h > image->h)
{
rc.x1 = bmpdt.lastrect.x1;
rc.y1 = image->h;
rc.x2 = bmpdt.lastrect.x2;
rc.y2 = bmpdt.lastrect.y2;
rtgui_dc_fill_rect(dc, &rc);
}
}
else
rtgui_dc_fill_rect(dc, &bmpdt.lastrect);
/* 将图像数据blit到画布上 */
if (image != RT_NULL)
{
int value;
rtgui_image_blit(image, dc, &rect);
bmpdt.lastrect.x1 = bmpdt.lastrect.y1 = RTGUI_WIDGET_BORDER(bmpdt.showbox);
if(image->w > rtgui_rect_width(rect))
value = rtgui_rect_width(rect);
else
value = image->w;
bmpdt.lastrect.x2 = bmpdt.lastrect.x1 + value;
if(image->h > rtgui_rect_height(rect))
value = rtgui_rect_height(rect);
else
value = image->h;
bmpdt.lastrect.y2 = bmpdt.lastrect.y1 + value;
}
rtgui_dc_end_drawing(dc);
return RT_FALSE;
}
return rtgui_container_event_handler(object, event);
}
void demo_bitmap_open(struct rtgui_object* object, struct rtgui_event* event)
{
char *str;
rtgui_button_t *button = RTGUI_BUTTON(object);
/* 从textbox控件中取得文件名 */
str = (char*)rtgui_textbox_get_value(bmpdt.box);
if(str == RT_NULL) return;
if(*str == '/' && (rt_strstr(str, ".bmp")!=RT_NULL || rt_strstr(str, ".BMP")!=RT_NULL))
{ /* 如果是bmp文件, 且文件名有效, 则读入图像数据 */
if(bmpdt.filename != RT_NULL)
rt_free(bmpdt.filename);
bmpdt.filename = rt_strdup(str);
if(bmpdt.image != RT_NULL)
rtgui_image_destroy(bmpdt.image);
bmpdt.image = rtgui_image_create_from_file("bmp", bmpdt.filename, RT_TRUE);
if(bmpdt.image != RT_NULL)
{
bmpdt.showimg = bmpdt.image;
bmpdt.scale = 1.0;
bmpdt.angle = 0.0;
rtgui_widget_update(RTGUI_WIDGET(bmpdt.showbox));
}
}
else
rt_kprintf("Bad filename!");
}
void demo_image_zoom_in(struct rtgui_object* object, struct rtgui_event* event)
{
rtgui_button_t *button = RTGUI_BUTTON(object);
if (bmpdt.image == RT_NULL) return;
if (bmpdt.scale > 0.45)
{ /* 更新缩放倍率 */
if (bmpdt.scale > 1.0) bmpdt.scale -= (float)0.5;
else bmpdt.scale -= (float)0.1;
}
/* 根据缩放倍率, 缩放原始图形, 并得到新图形的指针 */
bmpdt.showimg = rtgui_image_zoom(bmpdt.image, bmpdt.scale, bmpdt.scale, RTGUI_IMG_ZOOM_BILINEAR);
if (bmpdt.showimg != RT_NULL)
rtgui_widget_update(RTGUI_WIDGET(bmpdt.showbox));
else
return;
if(bmpdt.showimg != bmpdt.image)
{ /* 释放掉新图形所用的资源 */
rtgui_image_destroy(bmpdt.showimg);
bmpdt.showimg = RT_NULL;
}
}
void demo_image_zoom_out(struct rtgui_object* object, struct rtgui_event* event)
{
rtgui_button_t *button = RTGUI_BUTTON(object);
if (bmpdt.image == RT_NULL) return;
if (bmpdt.scale < 4.95)
{ /* 更新缩放倍率 */
if (bmpdt.scale > 0.95) bmpdt.scale += (float)0.5;
else bmpdt.scale += (float)0.1;
}
bmpdt.showimg = rtgui_image_zoom(bmpdt.image, bmpdt.scale, bmpdt.scale, RTGUI_IMG_ZOOM_BILINEAR);
if (bmpdt.showimg != RT_NULL)
rtgui_widget_update(RTGUI_WIDGET(bmpdt.showbox));
else
return;
if(bmpdt.showimg != bmpdt.image)
{
rtgui_image_destroy(bmpdt.showimg);
bmpdt.showimg = RT_NULL;
}
}
void demo_image_rotate(struct rtgui_object* object, struct rtgui_event* event)
{
rtgui_button_t *button = RTGUI_BUTTON(object);
if (bmpdt.image == RT_NULL) return;
/* 更新图像旋转角度 */
if (bmpdt.angle < 360.0)
bmpdt.angle += (float)1.0;
else
bmpdt.angle = 0.0;
/* 调用旋转函数执行旋转, 并取得一个新的图像指针 */
bmpdt.showimg = rtgui_image_rotate(bmpdt.image, bmpdt.angle);
if (bmpdt.showimg != RT_NULL)
rtgui_widget_update(RTGUI_WIDGET(bmpdt.showbox));
else
return;
if(bmpdt.showimg != bmpdt.image)
{
rtgui_image_destroy(bmpdt.showimg);
bmpdt.showimg = RT_NULL;
}
}
rtgui_container_t *demo_view_bmp(void)
{
rtgui_rect_t rect;
rtgui_container_t *container, *showbox;
rtgui_button_t *button;
rtgui_textbox_t *box;
/* 用bmpdt结构体记录一些参数 */
rt_memset(&bmpdt, 0, sizeof(struct demo_bmp_dt));
bmpdt.scale = 1.0;
bmpdt.angle = 0.0;
/* 创建用于演示本代码的容器控件 */
container = demo_view("Bmp File:");
demo_view_get_rect(container, &rect);
rect.x1 += 85;
rect.x2 -= 5;
rect.y1 -= 42;
rect.y2 = rect.y1 + 20;
box = rtgui_textbox_create("", RTGUI_TEXTBOX_SINGLE);
rtgui_widget_set_rect(RTGUI_WIDGET(box), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(box));
bmpdt.box = box;
/* create a button "open" */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 60;
rect.y1 -= 10;
rect.y2 = rect.y1 + 24;
button = rtgui_button_create("open");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_bitmap_open);
/* create a button "zoom in" */
demo_view_get_rect(container, &rect);
rect.x1 += 85;
rect.x2 = rect.x1 + 70;
rect.y1 -= 10;
rect.y2 = rect.y1 + 24;
button = rtgui_button_create("zoom in");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_image_zoom_in);
/* create a button "zoom out" */
demo_view_get_rect(container, &rect);
rect.x1 += 165;
rect.x2 = rect.x1 + 70;
rect.y1 -= 10;
rect.y2 = rect.y1 + 24;
button = rtgui_button_create("zoom out");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_image_zoom_out);
/* create a button "rotate" */
demo_view_get_rect(container, &rect);
rect.x1 += 245;
rect.x2 = rect.x1 + 70;
rect.y1 -= 10;
rect.y2 = rect.y1 + 24;
button = rtgui_button_create("rotate");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_image_rotate);
/* create a container "showbox" */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 20;
rect.y2 -= 0;
showbox = rtgui_container_create();
rtgui_widget_set_rect(RTGUI_WIDGET(showbox), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(showbox));
rtgui_widget_set_border(RTGUI_WIDGET(showbox), RTGUI_BORDER_SIMPLE);
bmpdt.showbox = showbox;
rtgui_object_set_event_handler(RTGUI_OBJECT(showbox), demo_bitmap_showbox);
rtgui_widget_get_rect(RTGUI_WIDGET(showbox), &bmpdt.lastrect);
rtgui_rect_inflate(&bmpdt.lastrect, -RTGUI_WIDGET_BORDER(showbox));
return container;
}
#endif

44
examples/gui/demo_view_box.c
View File

@ -1,44 +0,0 @@
#include "demo_view.h"
#include <rtgui/widgets/box.h>
#include <rtgui/widgets/panel.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/button.h>
rtgui_container_t *demo_view_box(void)
{
rtgui_rect_t rect;
rtgui_container_t *view;
struct rtgui_panel *panel;
struct rtgui_box *box;
struct rtgui_label *label;
struct rtgui_button *button;
view = demo_view("Box View");
demo_view_get_rect(view, &rect);
panel = rtgui_panel_create(RTGUI_BORDER_NONE);
rtgui_widget_set_rect(RTGUI_WIDGET(panel), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(view), RTGUI_WIDGET(panel));
box = rtgui_box_create(RTGUI_VERTICAL, 5);
rtgui_container_set_box(RTGUI_CONTAINER(panel), box);
label = rtgui_label_create("label 1");
rtgui_container_add_child(RTGUI_CONTAINER(panel), RTGUI_WIDGET(label));
label = rtgui_label_create("label 2");
rtgui_container_add_child(RTGUI_CONTAINER(panel), RTGUI_WIDGET(label));
button = rtgui_button_create("button 1");
rtgui_container_add_child(RTGUI_CONTAINER(panel), RTGUI_WIDGET(button));
button = rtgui_button_create("button 2");
rtgui_container_add_child(RTGUI_CONTAINER(panel), RTGUI_WIDGET(button));
rtgui_widget_set_minheight(RTGUI_WIDGET(button), 25);
RTGUI_WIDGET_ALIGN(button) = RTGUI_ALIGN_EXPAND;
rtgui_container_layout(RTGUI_CONTAINER(panel));
return view;
}

157
examples/gui/demo_view_buffer_animation.c
View File

@ -1,157 +0,0 @@
#include <rtgui/dc.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/container.h>
#include "demo_view.h"
/*
* 直接在DC上绘图以实现动画效果
*
* 动画是依赖于定时器驱动的，会上下翻滚显示文字
* "飞线乱飞"
*/
static rt_int8_t dx = 1, dy = 1;
static rtgui_rect_t text_rect;
static rtgui_timer_t *timer;
static struct rtgui_dc *dc_buffer;
static void timeout(struct rtgui_timer *timer, void *parameter)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
rtgui_widget_t *widget;
/* 控件(view)通过parameter参数传递给定时器 */
widget = (rtgui_widget_t *)parameter;
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) /* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
return ;
/* 获得demo view允许绘图的区域，主要用于判断边界 */
demo_view_get_logic_rect(RTGUI_CONTAINER(widget), &rect);
rect.y2 -= 5;
/* 判断是否是第一次绘图 */
if ((text_rect.x1 == 0) && (text_rect.y1 == 0))
{
rtgui_rect_moveto(&text_rect, rect.x1, rect.y1);
}
/* 设置dx和dy */
if (text_rect.x2 >= rect.x2) dx = -1;
if (text_rect.x1 < rect.x1) dx = 1;
if (text_rect.y2 >= rect.y2) dy = -1;
if (text_rect.y1 < rect.y1) dy = 1;
/* 移动文本框的位置 */
text_rect.x1 += dx;
text_rect.x2 += dx;
text_rect.y1 += dy;
text_rect.y2 += dy;
/* 绘图 */
rect = text_rect;
rect.x2 += 2;
rect.y2 += 2;
rtgui_dc_blit(dc_buffer, NULL, dc, &rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
static rt_bool_t animation_on_show(struct rtgui_object *object, struct rtgui_event *event)
{
rt_kprintf("buffer animation on show\n");
rtgui_timer_start(timer);
return RT_TRUE;
}
static rt_bool_t animation_on_hide(struct rtgui_object *object, struct rtgui_event *event)
{
rt_kprintf("buffer animation on hide\n");
rtgui_timer_stop(timer);
return RT_TRUE;
}
static rt_bool_t animation_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
/* 因为用的是demo view，上面本身有一部分控件，所以在绘图时先要让demo view先绘图 */
rtgui_container_event_handler(object, event);
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) /* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
return RT_FALSE;
/* 获得demo view允许绘图的区域 */
demo_view_get_logic_rect(RTGUI_CONTAINER(widget), &rect);
/* 绘图 */
rect = text_rect;
rtgui_rect_inflate(&rect, +1);
rtgui_dc_blit(dc_buffer, NULL, dc, &rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
else if (event->type == RTGUI_EVENT_SHOW)
{
rtgui_container_event_handler(object, event);
animation_on_show(object, event);
}
else if (event->type == RTGUI_EVENT_HIDE)
{
rtgui_container_event_handler(object, event);
animation_on_hide(object, event);
}
else
{
/* 调用默认的事件处理函数 */
return rtgui_container_event_handler(object, event);
}
return RT_FALSE;
}
struct rtgui_container *demo_view_buffer_animation(void)
{
struct rtgui_container *container;
container = demo_view("DC 缓冲区动画");
if (container != RT_NULL)
rtgui_object_set_event_handler(RTGUI_OBJECT(container), animation_event_handler);
rtgui_font_get_metrics(RTGUI_WIDGET_FONT(container), "缓冲动画", &text_rect);
if (dc_buffer == RT_NULL)
{
rtgui_rect_t rect;
rect.x1 = 0;
rect.x2 = rtgui_rect_width(text_rect) + 2;
rect.y1 = 0;
rect.y2 = rtgui_rect_height(text_rect) + 2;
/* 创建 DC Buffer，长 50，宽 50 */
dc_buffer = rtgui_dc_buffer_create(rtgui_rect_width(rect), rtgui_rect_height(rect));
RTGUI_DC_FC(dc_buffer) = RTGUI_WIDGET_BACKGROUND(container);
rtgui_dc_fill_rect(dc_buffer, &rect);
RTGUI_DC_FC(dc_buffer) = black;
rect.x1 = 1;
rect.y1 = 1;
rtgui_dc_draw_text(dc_buffer, "缓冲动画", &rect);
}
/* 启动定时器以触发动画 */
timer = rtgui_timer_create(1, RT_TIMER_FLAG_PERIODIC, timeout, (void *)container);
return container;
}

80
examples/gui/demo_view_button.c
View File

@ -1,80 +0,0 @@
/*
* 程序清单：button控件演示
*
* 这个例子会在创建出的container上添加几个不同类型的button控件
*/
#include "demo_view.h"
#include <rtgui/widgets/button.h>
/* 创建用于演示button控件的视图 */
rtgui_container_t *demo_view_button(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_button_t *button;
rtgui_font_t *font;
/* 先创建一个演示用的视图 */
container = demo_view("Button View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个button控件 */
button = rtgui_button_create("Red");
/* 设置label控件的前景色为红色 */
RTGUI_WIDGET_FOREGROUND(button) = red;
/* 设置button的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个button控件 */
button = rtgui_button_create("Blue");
/* 设置label控件的前景色为蓝色 */
RTGUI_WIDGET_FOREGROUND(button) = blue;
/* 设置button的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个button控件 */
button = rtgui_button_create("12 font");
/* 设置字体为12点阵的asc字体 */
font = rtgui_font_refer("asc", 12);
RTGUI_WIDGET_FONT(button) = font;
/* 设置button的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个button控件 */
button = rtgui_button_create("16 font");
/* 设置字体为16点阵的asc字体 */
font = rtgui_font_refer("asc", 16);
RTGUI_WIDGET_FONT(button) = font;
/* 设置button的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
return container;
}

80
examples/gui/demo_view_checkbox.c
View File

@ -1,80 +0,0 @@
/*
* 程序清单：checkbox控件演示
*
* 这个例子会在创建出的container上添加几个checkbox控件
*/
#include "demo_view.h"
#include <rtgui/widgets/checkbox.h>
/* 创建用于演示checkbox控件的视图 */
rtgui_container_t *demo_view_checkbox(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_checkbox_t *checkbox;
rtgui_font_t *font;
/* 先创建一个演示用的视图 */
container = demo_view("CheckBox View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个checkbox控件 */
checkbox = rtgui_checkbox_create("Red", RT_TRUE);
/* 设置前景色为红色 */
RTGUI_WIDGET_FOREGROUND(checkbox) = red;
/* 设置checkbox的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(checkbox), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(checkbox));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个checkbox控件 */
checkbox = rtgui_checkbox_create("Blue", RT_TRUE);
/* 设置前景色为蓝色 */
RTGUI_WIDGET_FOREGROUND(checkbox) = blue;
/* 设置checkbox的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(checkbox), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(checkbox));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个checkbox控件 */
checkbox = rtgui_checkbox_create("12 font", RT_TRUE);
/* 设置字体为12点阵 */
font = rtgui_font_refer("asc", 12);
RTGUI_WIDGET_FONT(checkbox) = font;
/* 设置checkbox的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(checkbox), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(checkbox));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个checkbox控件 */
checkbox = rtgui_checkbox_create("16 font", RT_TRUE);
/* 设置字体为16点阵 */
font = rtgui_font_refer("asc", 16);
RTGUI_WIDGET_FONT(checkbox) = font;
/* 设置checkbox的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(checkbox), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(checkbox));
return container;
}

40
examples/gui/demo_view_combobox.c
View File

@ -1,40 +0,0 @@
/*
* 程序清单：label控件演示
*
* 这个例子会在创建出的container上添加几个不同类型的label控件
*/
#include "demo_view.h"
#include <rtgui/widgets/combobox.h>
struct rtgui_listbox_item items[] =
{
{"item 1", RT_NULL},
{"item 2", RT_NULL},
{"item 3", RT_NULL},
{"item 4", RT_NULL},
{"item 5", RT_NULL},
};
/* 创建用于演示combobox控件的视图 */
rtgui_container_t *demo_view_combobox(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_combobox_t *box;
/* 先创建一个演示用的视图 */
container = demo_view("ComboBox View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
box = rtgui_combobox_create(items, sizeof(items) / sizeof(items[0]), &rect);
/* container是一个container控件，调用add_child方法添加这个box控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(box));
return container;
}

194
examples/gui/demo_view_dc.c
View File

@ -1,194 +0,0 @@
/*
* 程序清单：DC操作演示
*
* 这个例子会在创建出的view上进行DC操作的演示
*/
#include "demo_view.h"
#include <rtgui/dc.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/slider.h>
#include <rtgui/image_hdc.h>
#include "play.hdh"
#include "stop.hdh"
struct rtgui_image_hdcmm play_image = RTGUI_IMAGE_HDC_DEF(2, 0x1c, 0x16, play_hdh);
struct rtgui_image_hdcmm stop_image = RTGUI_IMAGE_HDC_DEF(2, 0x1c, 0x16, stop_hdh);
/*
* view的事件处理函数
*/
rt_bool_t dc_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
/* 仅对PAINT事件进行处理 */
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
const int vx[] = {20, 50, 60, 45, 60, 20};
const int vy[] = {150, 50, 90, 60, 45, 50};
/*
* 因为用的是demo view，上面本身有一部分控件，所以在绘图时先要让demo view
* 先绘图
*/
rtgui_container_event_handler(RTGUI_OBJECT(widget), event);
/************************************************************************/
/* 下面的是DC的操作 */
/************************************************************************/
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
/* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
if (dc == RT_NULL)
return RT_FALSE;
/* 获得demo view允许绘图的区域 */
demo_view_get_logic_rect(RTGUI_CONTAINER(widget), &rect);
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_BOTTOM | RTGUI_ALIGN_CENTER_HORIZONTAL;
/* 显示GUI的版本信息 */
#ifdef RTGUI_USING_SMALL_SIZE
rtgui_dc_draw_text(dc, "RT-Thread/GUI小型版本", &rect);
#else
rtgui_dc_draw_text(dc, "RT-Thread/GUI标准版本", &rect);
#endif
{
rtgui_rect_t rect = {0, 0, 0x1c, 0x16};
rtgui_rect_moveto(&rect, 80, 80);
rtgui_image_blit((rtgui_image_t *)&play_image, dc, &rect);
rect.x1 = 0;
rect.y1 = 0;
rect.x2 = 0x1c;
rect.y2 = 0x16;
rtgui_rect_moveto(&rect, 130, 80);
rtgui_image_blit((rtgui_image_t *)&stop_image, dc, &rect);
}
/* 绘制一个圆形 */
RTGUI_DC_FC(dc) = red;
rtgui_dc_draw_circle(dc, rect.x1 + 10, rect.y1 + 10, 10);
/* 填充一个圆形 */
RTGUI_DC_FC(dc) = green;
rtgui_dc_fill_circle(dc, rect.x1 + 30, rect.y1 + 10, 10);
#if 0
/* 画一个圆角矩形 */
rect.x1 = 150;
rect.y1 = 180;
rect.x2 = 210;
rect.y2 = 260;
RTGUI_DC_FC(dc) = RTGUI_RGB(25, 70, 150);
rtgui_dc_draw_round_rect(dc, &rect, 10);
rect.x1 = 160;
rect.y1 = 190;
rect.x2 = 200;
rect.y2 = 250;
RTGUI_DC_FC(dc) = RTGUI_RGB(170, 7, 80);
rtgui_dc_fill_round_rect(dc, &rect, 7);
/* 画一个圆弧 */
RTGUI_DC_FC(dc) = RTGUI_RGB(250, 120, 120);
rtgui_dc_draw_arc(dc, rect.x1 + 120, rect.y1 + 60, 30, 0, 120);
/* 画一个扇形圆环 */
RTGUI_DC_FC(dc) = RTGUI_RGB(150, 23, 100);
rtgui_dc_draw_annulus(dc, 180, 170, 30, 50, 210, 330);
/* 多边形 */
RTGUI_DC_FC(dc) = blue;
rtgui_dc_draw_polygon(dc, vx, vy, 6);
#endif
RTGUI_DC_FC(dc) = blue;
/* 绘制不同的边框 */
{
rtgui_rect_t rect = {0, 0, 16, 16};
rtgui_rect_moveto(&rect, 30, 120);
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_RAISE);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "raise", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_SIMPLE);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "simple", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_SUNKEN);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "sunken", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_BOX);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "box", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_STATIC);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "static", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
rtgui_dc_draw_border(dc, &rect, RTGUI_BORDER_EXTRA);
rect.x1 += 20;
rect.x2 += 20 + 50;
rtgui_dc_draw_text(dc, "extera", &rect);
rect.x1 -= 20;
rect.x2 -= 20 + 50;
rect.y1 += 20;
rect.y2 += 20;
}
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
else
{
/* 其他事件，调用默认的事件处理函数 */
return rtgui_container_event_handler(object, event);
}
return RT_FALSE;
}
/* 创建用于DC操作演示用的视图 */
rtgui_container_t *demo_view_dc(void)
{
rtgui_container_t *view;
view = demo_view("DC Demo");
if (view != RT_NULL)
/* 设置成自己的事件处理函数 */
rtgui_object_set_event_handler(RTGUI_OBJECT(view), dc_event_handler);
return view;
}

85
examples/gui/demo_view_dc_buffer.c
View File

@ -1,85 +0,0 @@
/*
* 程序清单：DC Buffer演示
*
* 这个例子会在创建出的view上进行DC Buffer的演示
*/
#include "demo_view.h"
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/slider.h>
#include <rtgui/image.h>
/*
* view的事件处理函数
*/
static rt_bool_t dc_buffer_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
struct rtgui_dc *dc_buffer;
/* 仅对PAINT事件进行处理 */
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
/*
* 因为用的是demo view，上面本身有一部分控件，所以在绘图时先要让demo view
* 先绘图
*/
rtgui_container_event_handler(object, event);
dc_buffer = (struct rtgui_dc*)widget->user_data;
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
/* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
if (dc == RT_NULL)
return RT_FALSE;
/* 获得demo view允许绘图的区域 */
demo_view_get_logic_rect(RTGUI_CONTAINER(widget), &rect);
rect.x1 += 10;
rect.y1 += 10;
rtgui_dc_blit(dc_buffer, NULL, dc, &rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
else
{
/* 其他事件，调用默认的事件处理函数 */
return rtgui_container_event_handler(object, event);
}
return RT_FALSE;
}
/* 创建用于DC Buffer操作演示用的视图 */
rtgui_container_t *demo_view_dc_buffer()
{
rtgui_container_t *view;
struct rtgui_dc *dc_buffer=RT_NULL;
if (dc_buffer == RT_NULL)
{
rtgui_rect_t rect = {0, 0, 50, 50};
/* 创建 DC Buffer，长 50，宽 50 */
dc_buffer = rtgui_dc_buffer_create(50, 50);
RTGUI_DC_BC(dc_buffer) = blue;
rtgui_dc_fill_rect(dc_buffer, &rect);
RTGUI_DC_FC(dc_buffer) = red;
rtgui_dc_draw_circle(dc_buffer, 25, 25, 10);
}
view = demo_view("缓冲DC演示");
if (view != RT_NULL)
/* 设置成自己的事件处理函数 */
rtgui_object_set_event_handler(RTGUI_OBJECT(view), dc_buffer_event_handler);
RTGUI_WIDGET(view)->user_data = (rt_uint32_t)dc_buffer;
return view;
}

56
examples/gui/demo_view_digtube.c
View File

@ -1,56 +0,0 @@
#include "demo_view.h"
#include <rtgui/widgets/digtube.h>
/* digit tube codes: "ERROR" */
static char digitbuf[5] = {0x79, 0x77, 0x77, 0x3F, 0x77};
rtgui_container_t * demo_view_digtube(void)
{
struct rtgui_rect rect;
rtgui_container_t *container;
struct rtgui_digtube * digtube;
struct rtgui_digitfont digitfont;
container = demo_view("Digit Tube View");
/* add digtube 1: use the default digit font */
digtube = rtgui_digtube_create(RT_NULL, 5, (void *)4213, 0);
rtgui_container_add_child(container, RTGUI_WIDGET(digtube));
demo_view_get_rect(container, &rect);
rect.y2 = rect.y1 + 80;
rtgui_widget_set_rect(RTGUI_WIDGET(digtube), &rect);
/* add digtube 2: show hex */
digitfont.seg1_len = 20;
digitfont.seg1_hspace = 4;
digitfont.seg1_nr = 3;
digitfont.seg2_len = 20;
digitfont.seg3_len = 20;
digitfont.seg1_vspace = 1;
digitfont.data = RT_NULL;
digtube = rtgui_digtube_create(&digitfont, 5, (void *)0xABC, RTGUI_DIGTUBE_STYLE_NOBACKFONT | RTGUI_DIGTUBE_STYLE_DISHEXNUM);
rtgui_container_add_child(container, RTGUI_WIDGET(digtube));
rect.y1 = rect.y2 + 10;;
rect.y2 = rect.y1 + 60;
rtgui_widget_set_rect(RTGUI_WIDGET(digtube), &rect);
/* add digtube 3: show custom codes table */
digitfont.seg1_len = 25;
digitfont.seg1_hspace = 5;
digitfont.seg1_nr = 5;
digitfont.seg2_len = 25;
digitfont.seg3_len = 25;
digitfont.seg1_vspace = 1;
digitfont.data = RT_NULL;
digtube = rtgui_digtube_create(&digitfont, 5, (void *)digitbuf, RTGUI_DIGTUBE_STYLE_DISCODES);
rtgui_container_add_child(container, RTGUI_WIDGET(digtube));
rect.y1 = rect.y2 + 5;
rect.y2 = rect.y1 + 80;
rtgui_widget_set_rect(RTGUI_WIDGET(digtube), &rect);
RTGUI_WIDGET_BACKGROUND(digtube) = RTGUI_RGB(0x00, 0x00, 0x00);
RTGUI_WIDGET_FOREGROUND(digtube) = RTGUI_RGB(0x00, 0xFF, 0x00);
digtube->digit_bc = RTGUI_RGB(0x00, 0xFF, 0xFF);
return container;
}

182
examples/gui/demo_view_edit.c
View File

@ -1,182 +0,0 @@
/*
* 程序清单：edit控件演示
*
* 这个例子会在conatiner上进行edit控件的演示
*/
#include "demo_view.h"
#include <rtgui/dc.h>
#include <rtgui/filerw.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/edit.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/button.h>
#ifdef RTGUI_USING_DFS_FILERW
void demo_edit_readin_file(struct rtgui_object *object, struct rtgui_event *event)
{
rtgui_button_t *button;
struct rtgui_edit *edit;
const char *filename = "/test_readin.txt";
struct rtgui_filerw *file;
RT_ASSERT(object != RT_NULL);
button = RTGUI_BUTTON(object);
/* 取得edit指针 */
edit = RTGUI_EDIT(RTGUI_WIDGET(button)->user_data);
/* 判断文件是否存在 */
file = rtgui_filerw_create_file(filename, "rb");
if (file == RT_NULL)
{
/* 不存在存在,则创建它 */
rt_kprintf("file:\"%s\" does not exist!\n", filename);
return;
}
rtgui_filerw_close(file);
rt_kprintf("read-in file:\"%s\"\n", filename);
rtgui_edit_readin_file(edit, filename);
}
void demo_edit_saveas_file(struct rtgui_object *object, struct rtgui_event *event)
{
rtgui_button_t *button;
struct rtgui_edit *edit;
const char* filename = "/test_saveas.txt";
struct rtgui_filerw *file;
RT_ASSERT(object != RT_NULL);
button = RTGUI_BUTTON(object);
/* 取得edit指针 */
edit = RTGUI_EDIT(RTGUI_WIDGET(button)->user_data);
/* 判断文件是否存在, 如果存在则删除之 */
file = rtgui_filerw_create_file(filename, "rb");
if (file != RT_NULL)
{
rtgui_filerw_close(file);
/* 如果是在win32中调试, 请手工删除该文件吧, NT中文件是只读的,unlink删除不掉 */
if (rtgui_filerw_unlink(filename) == -1)
rt_kprintf("Could not delete %s\n", filename);
}
rt_kprintf("save as file:\"%s\"\n", filename);
rtgui_edit_saveas_file(edit, filename);
}
void demo_edit_get_mem(struct rtgui_object* object, struct rtgui_event* event)
{
rtgui_button_t *button;
struct rtgui_edit *edit;
RT_ASSERT(object != RT_NULL);
button = RTGUI_BUTTON(object);
edit = RTGUI_EDIT( RTGUI_WIDGET(button)->user_data );
rt_kprintf("edit mem consume: %d\n", rtgui_edit_get_mem_consume(edit));
}
rt_bool_t demo_edit_event_handler(struct rtgui_object* object, struct rtgui_event *event)
{
rt_bool_t result;
char buf[32];
rtgui_point_t p;
struct rtgui_edit *edit = RTGUI_EDIT(object);
struct rtgui_label *label = (struct rtgui_label*)RTGUI_WIDGET(edit)->user_data;
result = rtgui_edit_event_handler(object, event);
p = rtgui_edit_get_current_point(edit);
rt_sprintf(buf, "TRACK: line:%d, col:%d", p.y, p.x);
rtgui_label_set_text(label, buf);
return result;
}
/* 创建用于演示edit控件的视图 */
rtgui_container_t *demo_view_edit(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
struct rtgui_edit *edit;
struct rtgui_label *label;
struct rtgui_button *button;
/* 先创建一个演示用的视图 */
container = demo_view("Edit View");
edit = rtgui_edit_create(container, 10, 35, 220, 200);
rtgui_edit_set_text(edit,
"Edit beta v0.1\n"
"Hello RT-Thread\n"
"this's edit demo\n"
"rtgui_edit_create\n"
"rtgui_edit_append_line\n"
"rtgui_edit_insert_line\n"
"rtgui_edit_delete_line\n"
"rtgui_edit_connect_line\n"
"双字节测试\n"
"a\n"
"b\n"
"c\n"
"d\n"
"1234567890\n");
/* 创建一个按钮, 读取某个文件 */
demo_view_get_rect(container, &rect);
rect.x1 += 10;
rect.x2 = rect.x1 + 100;
rect.y1 += 200;
rect.y2 = rect.y1 + 22;
button = rtgui_button_create("ReadIn File");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_edit_readin_file);
/* 使用user_data传递edit指针 */
RTGUI_WIDGET(button)->user_data = (rt_uint32_t)edit;
/* 创建一个按钮, 保存为某个文件 */
demo_view_get_rect(container, &rect);
rect.x1 += 130;
rect.x2 = rect.x1 + 100;
rect.y1 += 200;
rect.y2 = rect.y1 + 22;
button = rtgui_button_create("SaveAs File");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_edit_saveas_file);
/* 使用user_data传递edit指针 */
RTGUI_WIDGET(button)->user_data = (rt_uint32_t)edit;
/* 创建一个标签, 显示EDIT的主要参数 */
demo_view_get_rect(container, &rect);
rect.x1 += 10;
rect.x2 = rect.x1 + 220;
rect.y1 += 225;
rect.y2 = rect.y1 + 18;
label = rtgui_label_create("TRACK:");
RTGUI_WIDGET_TEXTALIGN(label) = RTGUI_ALIGN_LEFT | RTGUI_ALIGN_CENTER_VERTICAL;
RTGUI_WIDGET_FOREGROUND(label) = blue;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(label));
RTGUI_WIDGET(edit)->user_data = (rt_uint32_t)label;
rtgui_object_set_event_handler(RTGUI_OBJECT(edit), demo_edit_event_handler);
/* 创建一个按钮, 读取EDIT的内存消耗 */
demo_view_get_rect(container, &rect);
rect.x1 += 150;
rect.x2 = rect.x1 + 80;
rect.y1 -= 42;
rect.y2 = rect.y1 + 20;
button = rtgui_button_create("Get Mem");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_edit_get_mem);
RTGUI_WIDGET(button)->user_data = (rt_uint32_t)edit;
return container;
}
#endif

128
examples/gui/demo_view_image.c
View File

@ -1,128 +0,0 @@
/*
* 程序清单：DC上显示图像演示
*
* 这个例子会在创建出的container上显示图像
*/
#include "demo_view.h"
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/filelist_view.h>
#include <string.h>
static rtgui_image_t *image = RT_NULL;
static rtgui_container_t *_container = RT_NULL;
#if defined(RTGUI_USING_DFS_FILERW) || defined(RTGUI_USING_STDIO_FILERW)
/* 打开按钮的回调函数 */
static void open_btn_onbutton(rtgui_widget_t *widget, struct rtgui_event *event)
{
rtgui_filelist_view_t *filelist;
struct rtgui_rect rect = {0, 100, 240, 280};
/* WIN32平台上和真实设备上的初始路径处理 */
#ifdef _WIN32
filelist = rtgui_filelist_view_create("e:\\", "*.*", &rect);
#else
filelist = rtgui_filelist_view_create("/", "*.*", &rect);
#endif
/* 模态显示一个文件列表视图，以提供给用户选择图像文件 */
if (rtgui_widget_show(RTGUI_WIDGET(filelist), RT_TRUE) == RTGUI_MODAL_OK)
{
char path[32], image_type[8];
/* 设置文件路径的标签 */
rtgui_filelist_view_get_fullpath(filelist, path, sizeof(path));
if (image != RT_NULL)
{
rtgui_image_destroy(image);
image = RT_NULL;
}
rt_memset(image_type, 0, sizeof(image_type));
/* 获得图像的类型 */
if (rt_strstr(path, ".bmp") != RT_NULL ||
rt_strstr(path, ".BMP") != RT_NULL)
strcat(image_type, "bmp");
if (rt_strstr(path, ".png") != RT_NULL ||
rt_strstr(path, ".PNG") != RT_NULL)
strcat(image_type, "png");
if (rt_strstr(path, ".jpg") != RT_NULL ||
rt_strstr(path, ".JPG") != RT_NULL)
strcat(image_type, "jpeg");
if (rt_strstr(path, ".hdc") != RT_NULL ||
rt_strstr(path, ".HDC") != RT_NULL)
strcat(image_type, "hdc");
/* 如果图像文件有效，创建相应的rtgui_image对象 */
if (image_type[0] != '\0')
image = rtgui_image_create_from_file(image_type, path, RT_TRUE);
}
/* 删除 文件列表 视图 */
rtgui_container_destroy(RTGUI_CONTAINER(filelist));
rtgui_container_show(_container, RT_FALSE);
}
/* 演示视图的事件处理函数 */
static rt_bool_t demo_view_event_handler(rtgui_widget_t *widget, rtgui_event_t *event)
{
rt_bool_t result;
/* 先调用默认的事件处理函数(这里只关心PAINT事件，但演示视图还有本身的一些控件) */
result = rtgui_container_event_handler(widget, event);
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL)
/* 如果不能正常获得DC，返回(如果控件或父控件是隐藏状态，DC是获取不成功的) */
return RT_FALSE;
/* 获得demo container允许绘图的区域 */
demo_view_get_rect(RTGUI_CONTAINER(widget), &rect);
/* 获得图像显示区域 */
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 30;
if (image != RT_NULL)
rtgui_image_blit(image, dc, &rect);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
return result;
}
/* 创建用于显示图像的演示视图 */
rtgui_container_t *demo_view_image(void)
{
rtgui_rect_t rect;
rtgui_button_t *open_btn;
/* 先创建一个演示视图 */
_container = demo_view("图像演示");
if (_container != RT_NULL)
/* 设置默认的事件处理函数到demo_view_event_handler函数 */
rtgui_object_set_event_handler(RTGUI_WIDGET(_container), demo_view_event_handler);
/* 添加一个按钮 */
demo_view_get_rect(_container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 120;
rect.y2 = rect.y1 + 20;
open_btn = rtgui_button_create("打开图像文件");
rtgui_container_add_child(RTGUI_CONTAINER(_container), RTGUI_WIDGET(open_btn));
rtgui_widget_set_rect(RTGUI_WIDGET(open_btn), &rect);
rtgui_button_set_onbutton(open_btn, open_btn_onbutton);
return _container;
}
#endif

149
examples/gui/demo_view_instrument_panel.c
View File

@ -1,149 +0,0 @@
/*
* 程序清单：DC操作演示
*
* 这个例子会在创建出的container上进行DC操作的演示
*/
#include "demo_view.h"
#include <rtgui/dc.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/slider.h>
#include <rtgui/image_hdc.h>
#include <math.h>
/*
* container的事件处理函数
*/
rt_bool_t instrument_panel_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
char ac[4];
int i;
int x0 = 120;
int y0 = 170;
int x, y;
int default_color;
/* 仅对PAINT事件进行处理 */
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
const int arrowx[] = {120 + 75, 120 + 75, 120 + 85};
const int arrowy[] = {170 - 5, 170 + 5, 170};
/*
* 因为用的是demo container，上面本身有一部分控件，所以在绘图时先要让demo container
* 先绘图
*/
rtgui_container_event_handler(RTGUI_OBJECT(widget), event);
/************************************************************************/
/* 下面的是DC的操作 */
/************************************************************************/
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
/* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
if (dc == RT_NULL)
return RT_FALSE;
/* 获得demo container允许绘图的区域 */
demo_view_get_rect(RTGUI_CONTAINER(widget), &rect);
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_BOTTOM | RTGUI_ALIGN_CENTER_HORIZONTAL;
/* 显示GUI的版本信息 */
#ifdef RTGUI_USING_SMALL_SIZE
rtgui_dc_draw_text(dc, "RT-Thread/GUI小型版本", &rect);
#else
rtgui_dc_draw_text(dc, "RT-Thread/GUI标准版本", &rect);
#endif
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_CENTER_VERTICAL | RTGUI_ALIGN_CENTER_HORIZONTAL;
RTGUI_DC_FC(dc) = blue;
rect.y2 = 270;
rtgui_dc_draw_text(dc, "rtgui-panel", &rect);
for (i = 0; i < 6; i++)
{
rtgui_dc_draw_arc(dc, x0, y0, 117 - i, 150, 30);
}
RTGUI_DC_FC(dc) = black;
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_LEFT;
for (i = 0; i <= 23; i++)
{
if (i < 12)
{
x = x0 + 105 * cos((150 + i * 10) * 3.1415926 / 180);
y = y0 + 105 * sin((150 + i * 10) * 3.1415926 / 180);
rect.x1 = x;
rect.y1 = y;
rect.x2 = rect.x1 + 12 * 3;
rect.y2 = rect.y1 + 12;
rt_sprintf(ac, "%d", 10 * i);
rtgui_dc_draw_text(dc, ac, &rect);
}
else
{
RTGUI_DC_TEXTALIGN(dc) = RTGUI_ALIGN_RIGHT;
x = x0 + 105 * cos((160 + i * 10) * 3.1415926 / 180);
y = y0 + 105 * sin((160 + i * 10) * 3.1415926 / 180);
rect.x1 = x - 12 * 3;
rect.y1 = y;
rect.x2 = rect.x1 + 12 * 3;
rect.y2 = rect.y1 + 12;
rt_sprintf(ac, "%d", 10 * i);
rtgui_dc_draw_text(dc, ac, &rect);
}
x = x0 + 107 * cos((150 + i * 10) * 3.1415926 / 180);
y = y0 + 107 * sin((150 + i * 10) * 3.1415926 / 180);
rtgui_dc_fill_circle(dc, x, y, 3);
}
RTGUI_DC_FC(dc) = RTGUI_RGB(166, 0, 166);
rtgui_dc_fill_circle(dc, x0, y0, 3);
RTGUI_DC_FC(dc) = RTGUI_RGB(120, 141, 30);
rtgui_dc_draw_circle(dc, x0, y0, 5);
default_color = RTGUI_DC_BC(dc);
RTGUI_DC_BC(dc) = red;
rect.x1 = x0 + 7;
rect.y1 = y0 - 1;
rect.x2 = x0 + 75;
rect.y2 = y0 + 1;
rtgui_dc_fill_rect(dc, &rect);
RTGUI_DC_BC(dc) = default_color;
rtgui_dc_fill_polygon(dc, arrowx, arrowy, 3);
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
else
{
/* 其他事件，调用默认的事件处理函数 */
return rtgui_container_event_handler(RTGUI_OBJECT(widget), event);
}
return RT_FALSE;
}
/* 创建用于DC操作演示用的视图 */
rtgui_container_t *demo_view_instrument_panel(void)
{
rtgui_container_t *container;
container = demo_view("instrument panel Demo");
if (container != RT_NULL)
/* 设置成自己的事件处理函数 */
rtgui_object_set_event_handler(RTGUI_OBJECT(container), instrument_panel_event_handler);
return container;
}

104
examples/gui/demo_view_label.c
View File

@ -1,104 +0,0 @@
/*
* 程序清单：label控件演示
*
* 这个例子会在创建出的container上添加几个不同类型的label控件
*/
#include "demo_view.h"
#include <rtgui/widgets/label.h>
/* 创建用于演示label控件的视图 */
rtgui_container_t *demo_view_label(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_label_t *label;
rtgui_font_t *font;
/* 先创建一个演示用的视图 */
container = demo_view("Label View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("Red Left");
/* 设置label控件上的文本对齐方式为：左对齐 */
RTGUI_WIDGET_TEXTALIGN(label) = RTGUI_ALIGN_LEFT;
/* 设置label控件的前景色为红色 */
RTGUI_WIDGET_FOREGROUND(label) = red;
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* container是一个container控件，调用add_child方法添加这个label控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("Blue Right");
/* 设置label控件上的文本对齐方式为：右对齐 */
RTGUI_WIDGET_TEXTALIGN(label) = RTGUI_ALIGN_RIGHT;
/* 设置label控件的前景色为蓝色 */
RTGUI_WIDGET_FOREGROUND(label) = blue;
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* container是一个container控件，调用add_child方法添加这个label控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("Green Center");
/* 设置label控件的前景色为绿色 */
RTGUI_WIDGET_FOREGROUND(label) = green;
/* 设置label控件上的文本对齐方式为：右对齐 */
RTGUI_WIDGET_TEXTALIGN(label) = RTGUI_ALIGN_CENTER_HORIZONTAL;
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* container是一个container控件，调用add_child方法添加这个label控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5 + 25 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("12 font");
/* 设置字体为12点阵的asc字体 */
font = rtgui_font_refer("asc", 12);
RTGUI_WIDGET_FONT(label) = font;
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* container是一个container控件，调用add_child方法添加这个label控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.y1 += 5 + 25 + 25 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("16 font");
/* 设置字体为16点阵的asc字体 */
font = rtgui_font_refer("asc", 16);
RTGUI_WIDGET_FONT(label) = font;
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* container是一个container控件，调用add_child方法添加这个label控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
return container;
}

195
examples/gui/demo_view_listbox.c
View File

@ -1,195 +0,0 @@
/*
* 程序清单：label控件演示
*
* 这个例子会在创建出的container上添加几个不同类型的label控件
*/
#include "demo_view.h"
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/listbox.h>
static rtgui_image_t *item_icon = RT_NULL;
static const char *image_xpm[] =
{
"16 16 106 2",
" c None",
". c #D0C83F",
"+ c #D0C840",
"@ c #D0C030",
"# c #D0B820",
"$ c #D0B020",
"% c #D0B01F",
"& c #5F571F",
"* c #F0F0C0",
"= c #FFF8D0",
"- c #FFF8C0",
"; c #FFF8B0",
"> c #FFF8A0",
", c #F0E870",
"' c #707030",
") c #4F87EF",
"! c #4F78C0",
"~ c #5088E0",
"{ c #5078C0",
"] c #C0D0F0",
"^ c #FFF8E0",
"/ c #FFF090",
"( c #F0E070",
"_ c #6F97D0",
": c #C0D8FE",
"< c #80A8F0",
"[ c #7088D0",
"} c #B0D0FF",
"| c #90B0F0",
"1 c #1040A0",
"2 c #F0F080",
"3 c #707040",
"4 c #7098F0",
"5 c #3068E0",
"6 c #A0B8F0",
"7 c #4070C0",
"8 c #002880",
"9 c #404040",
"0 c #505050",
"a c #F0F090",
"b c #F0E860",
"c c #F0D860",
"d c #807840",
"e c #2F5FC0",
"f c #1050D0",
"g c #1048B0",
"h c #002870",
"i c #C0C080",
"j c #C0C070",
"k c #F0F070",
"l c #F0E060",
"m c #E0D050",
"n c #00277F",
"o c #00287F",
"p c #1F3F6F",
"q c #1048C0",
"r c #0040B0",
"s c #204080",
"t c #FFF890",
"u c #F0D850",
"v c #E0C840",
"w c #807040",
"x c #A0B06F",
"y c #204880",
"z c #2048A0",
"A c #90A8C0",
"B c #FFF080",
"C c #F0D050",
"D c #C0A830",
"E c #6F682F",
"F c #F0F0A0",
"G c #E0D060",
"H c #B0A040",
"I c #D0B840",
"J c #E0C040",
"K c #D0B030",
"L c #706820",
"M c #5F581F",
"N c #CFBF3F",
"O c #FFF0A0",
"P c #A09830",
"Q c #A08820",
"R c #908030",
"S c #807830",
"T c #707020",
"U c #605820",
"V c #6F672F",
"W c #D0C040",
"X c #F0E880",
"Y c #907820",
"Z c #B09820",
"` c #B09010",
" . c #B08820",
".. c #806820",
"+. c #5F5F1F",
"@. c #F0E080",
"#. c #B09020",
"$. c #C0B040",
"%. c #A09030",
"&. c #908020",
"*. c #606020",
"=. c #6F5F1F",
"-. c #9F982F",
";. c #A0872F",
">. c #6F681F",
",. c #706020",
" ",
" . + + + @ @ # # $ % & ",
" + * = = = = - ; > , ' ",
" ) ! ~ { ] ^ = - - > / ( ' ",
"_ : < { [ } | 1 - ; > > / 2 ( 3 ",
"{ 4 5 1 6 7 5 8 9 0 a / , b c d ",
"e f g h 8 8 g h i j / k l c m d ",
" n o p q r s t 2 , l c u v w ",
" x y z A B , l u C v D E ",
" @ F > t k G H I J K L M ",
" N @ O / 2 l P Q R S T U V ",
" W m 2 X l I Y Z ` ...+. ",
" W @.l u I R #.Z Y U M ",
" $.G I $.%.R &.Y *.& =. ",
" -.;.>.,.L L ,.& M ",
" "
};
static struct rtgui_listbox_item items[] =
{
{"list #0", RT_NULL},
{"list #1", RT_NULL},
{"list #2", RT_NULL},
{"list #3", RT_NULL},
};
static rt_bool_t on_items(struct rtgui_object *object, struct rtgui_event *event)
{
rtgui_listbox_t *box;
/* get listbox */
box = RTGUI_LISTBOX(object);
/* 打印当前的项 */
rt_kprintf("current item: %d\n", box->current_item);
return RT_TRUE;
}
/* 创建用于演示label控件的视图 */
rtgui_container_t *demo_view_listbox(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_label_t *label;
rtgui_listbox_t *box;
/* 先创建一个演示用的视图 */
container = demo_view("ListBox Demo");
if (item_icon == RT_NULL)
item_icon = rtgui_image_create_from_mem("xpm",
(const rt_uint8_t *)image_xpm, sizeof(image_xpm), RT_TRUE);
items[1].image = item_icon;
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("listbox: ");
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* container是一个container控件，调用add_child方法添加这个label控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
rect.y1 = rect.y2 + 3;
rect.y2 = 250;
box = rtgui_listbox_create(items, sizeof(items) / sizeof(struct rtgui_listbox_item), &rect);
rtgui_listbox_set_onitem(box, on_items);
/* container是一个container控件，调用add_child方法添加这个listbox控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(box));
return container;
}

264
examples/gui/demo_view_listctrl.c
View File

@ -1,264 +0,0 @@
/*
* 程序清单：label控件演示
*
* 这个例子会在创建出的container上添加几个不同类型的label控件
*/
#include "demo_view.h"
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/listctrl.h>
static rtgui_image_t *item_icon = RT_NULL;
static const char *image_xpm[] =
{
"16 16 106 2",
" c None",
". c #D0C83F",
"+ c #D0C840",
"@ c #D0C030",
"# c #D0B820",
"$ c #D0B020",
"% c #D0B01F",
"& c #5F571F",
"* c #F0F0C0",
"= c #FFF8D0",
"- c #FFF8C0",
"; c #FFF8B0",
"> c #FFF8A0",
", c #F0E870",
"' c #707030",
") c #4F87EF",
"! c #4F78C0",
"~ c #5088E0",
"{ c #5078C0",
"] c #C0D0F0",
"^ c #FFF8E0",
"/ c #FFF090",
"( c #F0E070",
"_ c #6F97D0",
": c #C0D8FE",
"< c #80A8F0",
"[ c #7088D0",
"} c #B0D0FF",
"| c #90B0F0",
"1 c #1040A0",
"2 c #F0F080",
"3 c #707040",
"4 c #7098F0",
"5 c #3068E0",
"6 c #A0B8F0",
"7 c #4070C0",
"8 c #002880",
"9 c #404040",
"0 c #505050",
"a c #F0F090",
"b c #F0E860",
"c c #F0D860",
"d c #807840",
"e c #2F5FC0",
"f c #1050D0",
"g c #1048B0",
"h c #002870",
"i c #C0C080",
"j c #C0C070",
"k c #F0F070",
"l c #F0E060",
"m c #E0D050",
"n c #00277F",
"o c #00287F",
"p c #1F3F6F",
"q c #1048C0",
"r c #0040B0",
"s c #204080",
"t c #FFF890",
"u c #F0D850",
"v c #E0C840",
"w c #807040",
"x c #A0B06F",
"y c #204880",
"z c #2048A0",
"A c #90A8C0",
"B c #FFF080",
"C c #F0D050",
"D c #C0A830",
"E c #6F682F",
"F c #F0F0A0",
"G c #E0D060",
"H c #B0A040",
"I c #D0B840",
"J c #E0C040",
"K c #D0B030",
"L c #706820",
"M c #5F581F",
"N c #CFBF3F",
"O c #FFF0A0",
"P c #A09830",
"Q c #A08820",
"R c #908030",
"S c #807830",
"T c #707020",
"U c #605820",
"V c #6F672F",
"W c #D0C040",
"X c #F0E880",
"Y c #907820",
"Z c #B09820",
"` c #B09010",
" . c #B08820",
".. c #806820",
"+. c #5F5F1F",
"@. c #F0E080",
"#. c #B09020",
"$. c #C0B040",
"%. c #A09030",
"&. c #908020",
"*. c #606020",
"=. c #6F5F1F",
"-. c #9F982F",
";. c #A0872F",
">. c #6F681F",
",. c #706020",
" ",
" . + + + @ @ # # $ % & ",
" + * = = = = - ; > , ' ",
" ) ! ~ { ] ^ = - - > / ( ' ",
"_ : < { [ } | 1 - ; > > / 2 ( 3 ",
"{ 4 5 1 6 7 5 8 9 0 a / , b c d ",
"e f g h 8 8 g h i j / k l c m d ",
" n o p q r s t 2 , l c u v w ",
" x y z A B , l u C v D E ",
" @ F > t k G H I J K L M ",
" N @ O / 2 l P Q R S T U V ",
" W m 2 X l I Y Z ` ...+. ",
" W @.l u I R #.Z Y U M ",
" $.G I $.%.R &.Y *.& =. ",
" -.;.>.,.L L ,.& M ",
" "
};
static struct list_item
{
const char *name;
const char *gender;
int age;
rtgui_image_t *image;
} items[] =
{
{"index0", "00", 30, RT_NULL},
{"index1", "m1", 30, RT_NULL},
{"index2", "m2", 30, RT_NULL},
{"index3", "m3", 30, RT_NULL},
{"index4", "m4", 30, RT_NULL},
{"index5", "m5", 30, RT_NULL},
{"index6", "m6", 30, RT_NULL},
{"index7", "m7", 30, RT_NULL},
{"index8", "m8", 30, RT_NULL},
{"index9", "m9", 30, RT_NULL},
{"index10", "m10", 30, RT_NULL},
{"index11", "m11", 30, RT_NULL},
{"index12", "m12", 30, RT_NULL},
{"index13", "m13", 30, RT_NULL},
{"index14", "m14", 30, RT_NULL},
{"index15", "m15", 30, RT_NULL},
{"index16", "m16", 30, RT_NULL},
{"index17", "m17", 30, RT_NULL},
{"index18", "m18", 30, RT_NULL},
{"index19", "m19", 30, RT_NULL},
};
void _rtgui_listctrl_item_draw(struct rtgui_listctrl *list,
struct rtgui_dc *dc,
rtgui_rect_t *rect,
rt_uint16_t index)
{
char age_str[8];
rtgui_rect_t item_rect;
struct list_item *items, *item;
item_rect = *rect;
item_rect.x1 += 5;
items = (struct list_item *)list->items;
item = &items[index];
/* draw text */
rtgui_dc_draw_text(dc, item->name, &item_rect);
item_rect.x1 += 60;
rtgui_dc_draw_vline(dc, item_rect.x1, item_rect.y1, item_rect.y2);
item_rect.x1 += 5;
rtgui_dc_draw_text(dc, item->gender, &item_rect);
item_rect.x1 += 60;
rtgui_dc_draw_vline(dc, item_rect.x1, item_rect.y1, item_rect.y2);
item_rect.x1 += 5;
rt_snprintf(age_str, sizeof(age_str), "%d", item->age);
rtgui_dc_draw_text(dc, age_str, &item_rect);
item_rect.x1 += 40;
rtgui_dc_draw_vline(dc, item_rect.x1, item_rect.y1, item_rect.y2);
item_rect.x1 += 5;
/* draw image */
if (item->image != RT_NULL)
{
rtgui_rect_t image_rect;
image_rect.x1 = 0;
image_rect.y1 = 0;
image_rect.x2 = item->image->w;
image_rect.y2 = item->image->h;
rtgui_rect_moveto_align(&item_rect, &image_rect, RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_image_blit(item->image, dc, &image_rect);
}
}
static rt_bool_t on_items(struct rtgui_object *object, struct rtgui_event *event)
{
rtgui_listctrl_t *ctrl;
/* get listctrl */
ctrl = RTGUI_LISTCTRL(object);
/* 打印当前的项 */
rt_kprintf("current item: %d\n", ctrl->current_item);
return RT_TRUE;
}
/* 创建用于演示label控件的视图 */
rtgui_container_t *demo_view_listctrl(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_label_t *label;
rtgui_listctrl_t *box;
/* 先创建一个演示用的视图 */
container = demo_view("List Control Demo");
if (item_icon == RT_NULL)
item_icon = rtgui_image_create_from_mem("xpm",
(const rt_uint8_t *)image_xpm, sizeof(image_xpm), RT_TRUE);
items[1].image = item_icon;
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("List Control: ");
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* container是一个container控件，调用add_child方法添加这个label控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
rect.y1 = rect.y2 + 3;
rect.y2 = 250;
box = rtgui_listctrl_create((rt_uint32_t)items, sizeof(items) / sizeof(items[0]), &rect,
_rtgui_listctrl_item_draw);
rtgui_listctrl_set_onitem(box, on_items);
/* container是一个container控件，调用add_child方法添加这个listctrl控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(box));
return container;
}

76
examples/gui/demo_view_menu.c
View File

@ -1,76 +0,0 @@
/*
* 程序清单：menu控件演示
*
* 这个例子会在创建出的container上添加几个不同类型的label控件
*/
#include "demo_view.h"
#include <rtgui/widgets/menu.h>
#include <rtgui/widgets/button.h>
static rt_bool_t _onmenuitem(struct rtgui_object *object, struct rtgui_event *event)
{
rt_kprintf("menu action!!\n");
return RT_TRUE;
}
static const rtgui_menu_item_t sub_items[] =
{
{RTGUI_ITEM_NORMAL, "item #1", RT_NULL, RT_NULL, 0, _onmenuitem},
{RTGUI_ITEM_NORMAL, "item #2", RT_NULL, RT_NULL, 0, RT_NULL},
{RTGUI_ITEM_SEPARATOR, RT_NULL, RT_NULL, RT_NULL, 0, RT_NULL},
{RTGUI_ITEM_NORMAL, "item #3", RT_NULL, RT_NULL, 0, RT_NULL},
};
static const rtgui_menu_item_t items[] =
{
{RTGUI_ITEM_NORMAL, "item #1", RT_NULL, RT_NULL, 0, RT_NULL},
{RTGUI_ITEM_NORMAL, "item #2", RT_NULL, RT_NULL, 0, RT_NULL},
{RTGUI_ITEM_SEPARATOR, RT_NULL, RT_NULL, RT_NULL, 0, RT_NULL},
{
RTGUI_ITEM_SUBMENU, "item #3", RT_NULL,
(struct rtgui_menu_item_t *)sub_items,
sizeof(sub_items) / sizeof(sub_items[0]), RT_NULL
},
};
static rtgui_menu_t *menu;
static rt_bool_t _onmenu(struct rtgui_object *object, struct rtgui_event *event)
{
rtgui_rect_t rect;
rtgui_widget_get_rect(RTGUI_WIDGET(object), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(object), &rect);
if (menu != RT_NULL)
rtgui_menu_pop(menu, rect.x1, rect.y2 + 5);
return RT_TRUE;
}
/* 创建用于演示menu控件的视图 */
rtgui_container_t *demo_view_menu(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_button_t *button;
/* 先创建一个演示用的视图 */
container = demo_view("MENU View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个button控件 */
button = rtgui_button_create("Pop Menu");
/* 设置button的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
/* container是一个container控件，调用add_child方法添加这个button控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, _onmenu);
menu = rtgui_menu_create("Menu Test", RT_NULL, items, sizeof(items) / sizeof(items[0]));
return container;
}

78
examples/gui/demo_view_module.c
View File

@ -1,78 +0,0 @@
/*
* 程序清单：DC上显示图像演示
*
* 这个例子会在创建出的view上显示图像
*/
#include "demo_view.h"
#include <rtgui/widgets/button.h>
#include <rtgui/widgets/filelist_view.h>
#include <string.h>
#ifdef RT_USING_MODULE
#if defined(RTGUI_USING_DFS_FILERW)
static rtgui_container_t *_view = RT_NULL;
/* 打开按钮的回调函数 */
static void open_btn_onbutton(rtgui_widget_t *widget, struct rtgui_event *event)
{
rtgui_filelist_view_t *view;
rtgui_workbench_t *workbench;
rtgui_rect_t rect;
/* 获得顶层的workbench */
workbench = RTGUI_WORKBENCH(rtgui_widget_get_toplevel(widget));
rtgui_widget_get_rect(RTGUI_WIDGET(workbench), &rect);
/* WIN32平台上和真实设备上的初始路径处理 */
#ifdef _WIN32
view = rtgui_filelist_view_create(workbench, "d:\\", "*.*", &rect);
#else
view = rtgui_filelist_view_create(workbench, "/", "*.*", &rect);
#endif
/* 模态显示一个文件列表视图，以提供给用户选择图像文件 */
if (rtgui_container_show(RTGUI_CONTAINER(view), RT_TRUE) == RTGUI_MODAL_OK)
{
char path[32], name[8];
/* 设置文件路径的标签 */
rtgui_filelist_view_get_fullpath(view, path, sizeof(path));
rt_memset(name, 0, sizeof(name));
/* 获得应用模块的类型 */
if (rt_strstr(path, ".mo") != RT_NULL || rt_strstr(path, ".so") != RT_NULL)
{
rt_module_open(path);
}
}
/* 删除 文件列表 视图 */
rtgui_container_destroy(RTGUI_CONTAINER(view));
rtgui_container_show(_view, RT_FALSE);
}
/* 创建用于显示应用模块的演示视图 */
rtgui_container_t *demo_view_module(rtgui_workbench_t *workbench)
{
rtgui_rect_t rect;
rtgui_button_t *open_btn;
/* 先创建一个演示视图 */
_view = demo_view(workbench, "应用模块演示");
/* 添加一个按钮 */
demo_view_get_rect(_view, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 120;
rect.y2 = rect.y1 + 20;
open_btn = rtgui_button_create("打开应用模块");
rtgui_container_add_child(RTGUI_CONTAINER(_view), RTGUI_WIDGET(open_btn));
rtgui_widget_set_rect(RTGUI_WIDGET(open_btn), &rect);
rtgui_button_set_onbutton(open_btn, open_btn_onbutton);
return _view;
}
#endif
#endif

42
examples/gui/demo_view_mywidget.c
View File

@ -1,42 +0,0 @@
/*
* 程序清单：自定义控件演示
*
* 这个例子会在创建出的container上添加两个自定义控件
*/
#include "demo_view.h"
#include "mywidget.h"
/* 创建用于演示自定义控件的视图 */
rtgui_container_t *demo_view_mywidget(void)
{
rtgui_container_t *container;
rtgui_rect_t rect;
rtgui_mywidget_t *mywidget;
/* 先创建一个演示用的视图 */
container = demo_view("MyWidget View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.y1 + 80;
rect.y1 += 5;
rect.y2 = rect.y1 + 80;
/* 创建一个自定义控件 */
mywidget = rtgui_mywidget_create(&rect);
/* container是一个container控件，调用add_child方法添加这个自控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(mywidget));
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 25;
rect.x2 = rect.y1 + 40;
rect.y1 += 5 + 100;
rect.y2 = rect.y1 + 40;
/* 创建一个自定义控件 */
mywidget = rtgui_mywidget_create(&rect);
/* container是一个container控件，调用add_child方法添加这个自控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(mywidget));
return container;
}

53
examples/gui/demo_view_notebook.c
View File

@ -1,53 +0,0 @@
/*
* 程序清单：notebook控件演示
*
* 这个例子会在创建出的container上演示notebook控件
*/
#include "demo_view.h"
#include <rtgui/widgets/notebook.h>
#include <rtgui/widgets/listbox.h>
const static struct rtgui_listbox_item items[] =
{
{"list #0", RT_NULL},
{"list #1", RT_NULL},
{"list #2", RT_NULL},
{"list #3", RT_NULL},
};
const static struct rtgui_listbox_item items2[] =
{
{"list #0", RT_NULL},
{"list #1", RT_NULL},
{"list #2", RT_NULL},
{"new list #1", RT_NULL},
{"new list #2", RT_NULL},
};
/* 创建用于演示notebook控件的视图 */
rtgui_container_t *demo_view_notebook(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
struct rtgui_notebook *notebook;
rtgui_listbox_t *box;
/* 先创建一个演示用的视图 */
container = demo_view("Notebook View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
notebook = rtgui_notebook_create(&rect, RTGUI_NOTEBOOK_BOTTOM);
/* container是一个container控件，调用add_child方法添加这个notebook控件 */
rtgui_container_add_child(container, RTGUI_WIDGET(notebook));
box = rtgui_listbox_create(items, sizeof(items) / sizeof(struct rtgui_listbox_item), &rect);
rtgui_notebook_add(notebook, "Tab 1", RTGUI_WIDGET(box));
box = rtgui_listbox_create(items2, sizeof(items2) / sizeof(struct rtgui_listbox_item), &rect);
rtgui_notebook_add(notebook, "Tab 2", RTGUI_WIDGET(box));
return container;
}

103
examples/gui/demo_view_progressbar.c
View File

@ -1,103 +0,0 @@
#include "demo_view.h"
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/progressbar.h>
static rtgui_progressbar_t *hbar;
static rtgui_progressbar_t *vbar;
static rtgui_timer_t *bar_timer = RT_NULL;
void progressbar_timeout(struct rtgui_timer *timer, void *parameter)
{
static rt_uint32_t value = 0;
value++;
if (value == 100)
value = 0;
rtgui_progressbar_set_value(hbar, value);
rtgui_progressbar_set_value(vbar, value);
}
static rt_bool_t start_timer(struct rtgui_object *object, struct rtgui_event *event)
{
if (bar_timer != RT_NULL)
rtgui_timer_start(bar_timer);
return RT_TRUE;
}
static rt_bool_t stop_timer(struct rtgui_object *object, struct rtgui_event *event)
{
if (bar_timer != RT_NULL)
rtgui_timer_stop(bar_timer);
return RT_TRUE;
}
static rt_bool_t progressbar_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
if (event->type == RTGUI_EVENT_SHOW)
{
rtgui_container_event_handler(object, event);
start_timer(object, event);
}
else if (event->type == RTGUI_EVENT_HIDE)
{
rtgui_container_event_handler(object, event);
stop_timer(object, event);
}
else
{
/* 调用默认的事件处理函数 */
return rtgui_progressbar_event_handler(object, event);
}
return RT_FALSE;
}
rtgui_container_t *demo_view_progressbar(void)
{
rtgui_container_t *container;
rtgui_rect_t rect;
rtgui_label_t *label;
/* create a demo container */
container = demo_view("ProgressBar View");
/* get demo container rect */
demo_view_get_rect(container, &rect);
label = rtgui_label_create("水平进度条:");
rtgui_container_add_child(container, RTGUI_WIDGET(label));
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 18;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rect.y1 += 20;
rect.y2 = rect.y1 + 18;
hbar = rtgui_progressbar_create(RTGUI_HORIZONTAL, 100, &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(hbar));
/* get demo container rect */
demo_view_get_rect(container, &rect);
label = rtgui_label_create("垂直进度条:");
rtgui_container_add_child(container, RTGUI_WIDGET(label));
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 45;
rect.y2 = rect.y1 + 18;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rect.x1 += 110;
rect.x2 = rect.x1 + 20;
rect.y1 += 18 + 5;
rect.y2 = rect.y1 + 150;
vbar = rtgui_progressbar_create(RTGUI_VERTICAL, 100, &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(vbar));
bar_timer = rtgui_timer_create(50, RT_TIMER_FLAG_PERIODIC,
progressbar_timeout, RT_NULL);
return container;
}

69
examples/gui/demo_view_radiobox.c
View File

@ -1,69 +0,0 @@
/*
* 程序清单：radiobox控件演示
*
* 这个例子会在创建出的container上添加两个不同方向的radiobox控件
*/
#include "demo_view.h"
#include <rtgui/widgets/radiobox.h>
/* 用于显示垂直方向的radio文本项数组 */
static char *radio_item_v[5] =
{
"one",
"two",
"three",
"item 1",
"item 2"
};
/* 用于显示水平方向的radio文本项数组 */
static char *radio_item_h[3] =
{
"one", "two", "three"
};
/* 创建用于演示radiobox控件的视图 */
rtgui_container_t *demo_view_radiobox(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_radiobox_t *radiobox;
/* 先创建一个演示用的视图 */
container = demo_view("RadioBox View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 5 * 25;
/* 创建一个垂直方向显示的radiobox控件，文本项是radio_item_v数组，共5个项 */
radiobox = rtgui_radiobox_create("Radio Box", RTGUI_VERTICAL, radio_item_v, 5);
/* 设置当前选择的数组是第0项 */
rtgui_radiobox_set_selection(radiobox, 0);
/* 添加radiobox控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(radiobox));
/* 设置radiobox控件的位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(radiobox), &rect);
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5 + 5 * 25;
rect.y2 = rect.y1 + 60;
/* 创建一个水平方向显示的radiobox控件，文本项是radio_item_h数组，共3个项 */
radiobox = rtgui_radiobox_create("Radio Box", RTGUI_HORIZONTAL, radio_item_h, 3);
/* 设置当前选择的数组是第0项 */
rtgui_radiobox_set_selection(radiobox, 0);
/* 添加radiobox控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(radiobox));
/* 设置radiobox控件的位置信息 */
rtgui_widget_set_rect(RTGUI_WIDGET(radiobox), &rect);
return container;
}

48
examples/gui/demo_view_scrollbar.c
View File

@ -1,48 +0,0 @@
#include "demo_view.h"
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/scrollbar.h>
rtgui_container_t *demo_view_scrollbar(void)
{
rtgui_container_t *container;
rtgui_rect_t rect;
rtgui_label_t *label;
rtgui_scrollbar_t *hbar;
rtgui_scrollbar_t *vbar;
/* create a demo container */
container = demo_view("ScrollBar View");
/* get demo container rect */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
label = rtgui_label_create("horizontal bar:");
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(label));
hbar = rtgui_scrollbar_create(container, 5, 70, 20, 200, RTGUI_HORIZONTAL);
rtgui_scrollbar_set_line_step(hbar, 1);
rtgui_scrollbar_set_page_step(hbar, 3);
rtgui_scrollbar_set_range(hbar, 20);
/* get demo container rect */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5+40;
rect.y2 = rect.y1 + 20;
label = rtgui_label_create("vertical bar:");
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(label));
vbar = rtgui_scrollbar_create(container, 10, 110, 20, 200, RTGUI_VERTICAL);
rtgui_scrollbar_set_line_step(vbar, 1);
rtgui_scrollbar_set_page_step(vbar, 5);
rtgui_scrollbar_set_range(vbar, 20);
return container;
}

49
examples/gui/demo_view_slider.c
View File

@ -1,49 +0,0 @@
#include "demo_view.h"
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/slider.h>
rtgui_container_t *demo_view_slider(void)
{
rtgui_container_t *container;
rtgui_rect_t rect;
rtgui_label_t *label;
rtgui_slider_t *slider;
/* create a demo container */
container = demo_view("Slider View");
/* get demo container rect */
demo_view_get_rect(container, &rect);
label = rtgui_label_create("horizontal slider:");
rtgui_container_add_child(container, RTGUI_WIDGET(label));
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 18;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rect.y1 += 20;
rect.y2 = rect.y1 + 18;
slider = rtgui_slider_create(0, 100, RTGUI_HORIZONTAL);
rtgui_container_add_child(container, RTGUI_WIDGET(slider));
rtgui_widget_set_rect(RTGUI_WIDGET(slider), &rect);
/* get demo container rect */
demo_view_get_rect(container, &rect);
label = rtgui_label_create("vertical slider:");
rtgui_container_add_child(container, RTGUI_WIDGET(label));
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 50;
rect.y2 = rect.y1 + 18;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rect.x1 += 110;
rect.x2 = rect.x1 + 20;
rect.y1 += 18 + 5;
rect.y2 = rect.y1 + 150;
slider = rtgui_slider_create(0, 100, RTGUI_VERTICAL);
rtgui_container_add_child(container, RTGUI_WIDGET(slider));
rtgui_widget_set_rect(RTGUI_WIDGET(slider), &rect);
return container;
}

102
examples/gui/demo_view_textbox.c
View File

@ -1,102 +0,0 @@
/*
* 程序清单：texbox控件演示
*
* 这个例子会在创建出的container上添加几个不同类型的textbox控件
*/
#include "demo_view.h"
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/textbox.h>
/* 创建用于演示textbox控件的视图 */
rtgui_container_t *demo_view_textbox(void)
{
rtgui_rect_t rect, textbox_rect;
rtgui_container_t *container;
rtgui_label_t *label;
rtgui_textbox_t *text;
/* 先创建一个演示用的视图 */
container = demo_view("TextBox View");
/* 获得视图的位置信息 */
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 30;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("名字: ");
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(container, RTGUI_WIDGET(label));
/* 让textbox_rect赋值到rect，以计算textbox控件的位置 */
textbox_rect = rect;
textbox_rect.x1 = textbox_rect.x2 + 5;
textbox_rect.x2 = textbox_rect.x1 + 160;
/* 创建一个textbox控件 */
text = rtgui_textbox_create("bernard", RTGUI_TEXTBOX_SINGLE);
/* 设置textbox控件的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(text), &textbox_rect);
/* 添加textbox控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(text));
/* 计算下一个label控件的位置 */
rect.y1 += 23;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("邮件: ");
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* 添加label控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
textbox_rect = rect;
textbox_rect.x1 = textbox_rect.x2 + 5;
textbox_rect.x2 = textbox_rect.x1 + 160;
/* 创建一个textbox控件 */
text = rtgui_textbox_create("bernard.xiong@gmail.com", RTGUI_TEXTBOX_SINGLE);
/* 设置textbox控件的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(text), &textbox_rect);
/* 添加textbox控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(text));
rect.y1 += 23;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("密码: ");
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* 添加label控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
textbox_rect = rect;
textbox_rect.x1 = textbox_rect.x2 + 5;
textbox_rect.x2 = textbox_rect.x1 + 160;
/* 创建一个textbox控件 */
text = rtgui_textbox_create("rt-thread", RTGUI_TEXTBOX_SINGLE);
/* 设置textbox显示文本为掩码形式(即显示为*号，适合于显示密码的情况) */
text->flag |= RTGUI_TEXTBOX_MASK;
/* 设置textbox控件的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(text), &textbox_rect);
/* 添加textbox控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(text));
rect.y1 += 23;
rect.y2 = rect.y1 + 20;
/* 创建一个label控件 */
label = rtgui_label_create("主页: ");
/* 设置label的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
/* 添加label控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(label));
textbox_rect = rect;
textbox_rect.x1 = textbox_rect.x2 + 5;
textbox_rect.x2 = textbox_rect.x1 + 160;
/* 创建一个textbox控件 */
text = rtgui_textbox_create("http://www.rt-thread.org", RTGUI_TEXTBOX_SINGLE);
/* 设置textbox控件的位置 */
rtgui_widget_set_rect(RTGUI_WIDGET(text), &textbox_rect);
/* 添加textbox控件到视图中 */
rtgui_container_add_child(container, RTGUI_WIDGET(text));
return container;
}

98
examples/gui/demo_view_ttf.c
View File

@ -1,98 +0,0 @@
/*
* 程序清单：TTF字体显示演示
*
* 这个例子会在创建出的container上进行TTF字体显示的演示
*/
#include "demo_view.h"
#include <rtgui/dc.h>
#include <rtgui/font.h>
#include <rtgui/rtgui_system.h>
#ifdef RTGUI_USING_TTF
static rtgui_font_t *font_16, *font_24, *font_36, *font_48;
/*
* container的事件处理函数
*/
rt_bool_t ttf_event_handler(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_widget *widget = RTGUI_WIDGET(object);
/* 仅对PAINT事件进行处理 */
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc *dc;
rtgui_rect_t rect;
rtgui_font_t *saved;
/*
* 因为用的是demo container，上面本身有一部分控件，所以在绘图时先要让demo container
* 先绘图
*/
rtgui_container_event_handler(widget, event);
/************************************************************************/
/* 下面的是DC的操作 */
/************************************************************************/
/* 获得控件所属的DC */
dc = rtgui_dc_begin_drawing(widget);
/* 如果不能正常获得DC，返回（如果控件或父控件是隐藏状态，DC是获取不成功的） */
if (dc == RT_NULL)
return RT_FALSE;
/* 获得demo container允许绘图的区域 */
demo_view_get_rect(RTGUI_CONTAINER(widget), &rect);
saved = RTGUI_WIDGET_FONT(widget);
RTGUI_WIDGET_FONT(widget) = font_16;
rtgui_dc_draw_text(dc, "ABCD中文", &rect);
rect.y1 += 18;
RTGUI_WIDGET_FONT(widget) = font_24;
rtgui_dc_draw_text(dc, "ABCD中文", &rect);
rect.y1 += 26;
RTGUI_WIDGET_FONT(widget) = font_36;
rtgui_dc_draw_text(dc, "ABCD中文", &rect);
rect.y1 += 38;
RTGUI_WIDGET_FONT(widget) = font_48;
rtgui_dc_draw_text(dc, "ABCD中文", &rect);
RTGUI_WIDGET_FONT(widget) = saved;
/* 绘图完成 */
rtgui_dc_end_drawing(dc);
}
else
{
/* 其他事件，调用默认的事件处理函数 */
return rtgui_container_event_handler(widget, event);
}
return RT_FALSE;
}
/* 创建用于TTF字体显示演示用的视图 */
rtgui_container_t *demo_view_ttf()
{
rtgui_container_t *container;
font_16 = rtgui_freetype_font_create("d:/simsun.ttf", 0, 0, 16);
font_24 = rtgui_freetype_font_create("d:/simsun.ttf", 0, 0, 24);
font_36 = rtgui_freetype_font_create("d:/simsun.ttf", 0, 0, 36);
font_48 = rtgui_freetype_font_create("d:/simsun.TTF", 0, 0, 72);
container = demo_view("TTF 演示");
if (container != RT_NULL)
{
RTGUI_WIDGET_BACKGROUND(container) = white;
/* 设置成自己的事件处理函数 */
rtgui_object_set_event_handler(RTGUI_OBJECT(container), ttf_event_handler);
}
return container;
}
#endif

299
examples/gui/demo_view_window.c
View File

@ -1,299 +0,0 @@
/*
* 程序清单：窗口演示
*
* 这个例子会先创建出一个演示用的container，当点击上面的按钮时会不同的模式创建窗口
*/
#include <rtgui/rtgui.h>
#include <rtgui/rtgui_system.h>
#include <rtgui/widgets/window.h>
#include <rtgui/widgets/label.h>
#include <rtgui/widgets/button.h>
#include "demo_view.h"
#include <string.h>
static struct rtgui_timer *timer;
static struct rtgui_label *label;
static struct rtgui_win *autowin = RT_NULL;
static char label_text[80];
static rt_uint8_t cnt = 5;
rtgui_win_t *normal_window;
rtgui_label_t *normal_window_label;
static char normal_window_label_text[16];
static unsigned char normal_window_show_count = 1;
extern struct rtgui_win *main_win;
static rt_bool_t normal_window_onclose(struct rtgui_object *win,
struct rtgui_event *event)
{
normal_window_show_count++;
return RT_TRUE;
}
static void create_normal_win(void)
{
rtgui_rect_t rect = {30, 40, 150, 80};
normal_window = rtgui_win_create(RT_NULL, "普通窗口",
&rect, RTGUI_WIN_STYLE_DEFAULT);
rect.x1 += 20;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 添加一个文本标签 */
rt_sprintf(normal_window_label_text,
"第 %d 次显示", normal_window_show_count);
normal_window_label = rtgui_label_create(normal_window_label_text);
rtgui_widget_set_rect(RTGUI_WIDGET(normal_window_label), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(normal_window),
RTGUI_WIDGET(normal_window_label));
rtgui_win_set_onclose(normal_window,
normal_window_onclose);
}
/* 触发正常窗口显示 */
static void demo_normal_window_onbutton(struct rtgui_object *object, rtgui_event_t *event)
{
rt_sprintf(normal_window_label_text,
"第 %d 次显示", normal_window_show_count);
rtgui_label_set_text(normal_window_label,
normal_window_label_text);
if (RTGUI_WIDGET_IS_HIDE(normal_window))
rtgui_win_show(normal_window, RT_FALSE);
else
rtgui_win_activate(normal_window);
}
/* 获取一个递增的窗口标题 */
static char *get_win_title()
{
static rt_uint8_t win_no = 0;
static char win_title[16];
rt_sprintf(win_title, "窗口 %d", ++win_no);
return win_title;
}
/* 关闭对话框时的回调函数 */
void diag_close(struct rtgui_timer *timer, void *parameter)
{
cnt --;
rt_sprintf(label_text, "closed then %d second!", cnt);
/* 设置标签文本并更新控件 */
rtgui_label_set_text(label, label_text);
rtgui_widget_update(RTGUI_WIDGET(label));
if (cnt == 0)
{
/* 超时，关闭对话框 */
rtgui_win_destroy(autowin);
}
}
/* AUTO窗口关闭时的事件处理 */
rt_bool_t auto_window_close(struct rtgui_object *object, struct rtgui_event *event)
{
if (timer != RT_NULL)
{
/* 停止并删除定时器 */
rtgui_timer_stop(timer);
rtgui_timer_destory(timer);
timer = RT_NULL;
}
autowin = RT_NULL;
return RT_TRUE;
}
static rt_uint16_t delta_x = 20;
static rt_uint16_t delta_y = 40;
/* 触发自动窗口显示 */
static void demo_autowin_onbutton(struct rtgui_object *object, rtgui_event_t *event)
{
struct rtgui_rect rect = {50, 50, 200, 200};
/* don't create the window twice */
if (autowin)
return;
autowin = rtgui_win_create(main_win, "Information",
&rect, RTGUI_WIN_STYLE_DEFAULT | RTGUI_WIN_STYLE_DESTROY_ON_CLOSE);
if (autowin == RT_NULL)
return;
cnt = 5;
rt_sprintf(label_text, "closed then %d second!", cnt);
label = rtgui_label_create(label_text);
rect.x1 += 5;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(autowin),
RTGUI_WIDGET(label));
/* 设置关闭窗口时的动作 */
rtgui_win_set_onclose(autowin, auto_window_close);
rtgui_win_show(autowin, RT_FALSE);
/* 创建一个定时器 */
timer = rtgui_timer_create(100, RT_TIMER_FLAG_PERIODIC, diag_close, RT_NULL);
rtgui_timer_start(timer);
}
/* 触发模态窗口显示 */
static void demo_modalwin_onbutton(struct rtgui_object *object, rtgui_event_t *event)
{
rtgui_win_t *win;
rtgui_label_t *label;
rtgui_rect_t rect = {0, 0, 150, 80};
rtgui_rect_moveto(&rect, delta_x, delta_y);
delta_x += 20;
delta_y += 20;
/* 创建一个窗口 */
win = rtgui_win_create(main_win,
get_win_title(), &rect, RTGUI_WIN_STYLE_DEFAULT);
rect.x1 += 20;
rect.x2 -= 5;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
label = rtgui_label_create("这是一个模式窗口");
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(win), RTGUI_WIDGET(label));
/* 模态显示窗口 */
rtgui_win_show(win, RT_TRUE);
/* 删除非自动删除窗口 */
rtgui_win_destroy(win);
}
static void demo_close_ntitle_window(struct rtgui_object *object, rtgui_event_t *event)
{
rtgui_win_t *win;
/* 获得最顶层控件 */
win = RTGUI_WIN(rtgui_widget_get_toplevel(RTGUI_WIDGET(object)));
/* 销毁窗口 */
rtgui_win_destroy(win);
}
/* 触发无标题窗口显示 */
static void demo_ntitlewin_onbutton(struct rtgui_object *object, rtgui_event_t *event)
{
rtgui_win_t *win;
rtgui_label_t *label;
rtgui_button_t *button;
rtgui_rect_t widget_rect, rect = {0, 0, 150, 80};
rtgui_rect_moveto(&rect, delta_x, delta_y);
delta_x += 20;
delta_y += 20;
/* 创建一个窗口，风格为无标题及无边框 */
win = rtgui_win_create(main_win,
"no title", &rect, RTGUI_WIN_STYLE_NO_TITLE |
RTGUI_WIN_STYLE_NO_BORDER |
RTGUI_WIN_STYLE_DESTROY_ON_CLOSE);
RTGUI_WIDGET_BACKGROUND(win) = white;
/* 创建一个文本标签 */
label = rtgui_label_create("无边框窗口");
rtgui_font_get_metrics(RTGUI_WIDGET_FONT(label), "无边框窗口", &widget_rect);
rtgui_rect_moveto_align(&rect, &widget_rect, RTGUI_ALIGN_CENTER_HORIZONTAL);
widget_rect.y1 += 20;
widget_rect.y2 += 20;
rtgui_widget_set_rect(RTGUI_WIDGET(label), &widget_rect);
rtgui_container_add_child(RTGUI_CONTAINER(win), RTGUI_WIDGET(label));
RTGUI_WIDGET_BACKGROUND(label) = white;
/* 创建一个关闭按钮 */
widget_rect.x1 = 0;
widget_rect.y1 = 0;
widget_rect.x2 = 40;
widget_rect.y2 = 20;
rtgui_rect_moveto_align(&rect, &widget_rect, RTGUI_ALIGN_CENTER_HORIZONTAL);
widget_rect.y1 += 40;
widget_rect.y2 += 40;
button = rtgui_button_create("关闭");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &widget_rect);
rtgui_container_add_child(RTGUI_CONTAINER(win), RTGUI_WIDGET(button));
rtgui_button_set_onbutton(button, demo_close_ntitle_window);
rtgui_win_show(win, RT_FALSE);
}
rtgui_container_t *demo_view_window(void)
{
rtgui_rect_t rect;
rtgui_container_t *container;
rtgui_button_t *button;
/* 创建一个演示用的视图 */
container = demo_view("Window Demo");
create_normal_win();
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5;
rect.y2 = rect.y1 + 20;
/* 创建按钮用于显示正常窗口 */
button = rtgui_button_create("Normal Win");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(container), RTGUI_WIDGET(button));
/* 设置onbutton为demo_win_onbutton函数 */
rtgui_button_set_onbutton(button, demo_normal_window_onbutton);
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25;
rect.y2 = rect.y1 + 20;
/* 创建按钮用于显示一个自动关闭的窗口 */
button = rtgui_button_create("Auto Win");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(container), RTGUI_WIDGET(button));
/* 设置onbutton为demo_autowin_onbutton函数 */
rtgui_button_set_onbutton(button, demo_autowin_onbutton);
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建按钮用于触发一个模式窗口 */
button = rtgui_button_create("Modal Win");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(container), RTGUI_WIDGET(button));
/* 设置onbutton为demo_modalwin_onbutton函数 */
rtgui_button_set_onbutton(button, demo_modalwin_onbutton);
demo_view_get_rect(container, &rect);
rect.x1 += 5;
rect.x2 = rect.x1 + 100;
rect.y1 += 5 + 25 + 25 + 25;
rect.y2 = rect.y1 + 20;
/* 创建按钮用于触发一个不包含标题的窗口 */
button = rtgui_button_create("NoTitle Win");
rtgui_widget_set_rect(RTGUI_WIDGET(button), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(container), RTGUI_WIDGET(button));
/* 设置onbutton为demo_ntitlewin_onbutton函数 */
rtgui_button_set_onbutton(button, demo_ntitlewin_onbutton);
return container;
}

26
examples/gui/demo_xml.c
View File

@ -1,26 +0,0 @@
#include <rtthread.h>
#include <rtgui/rtgui_xml.h>
static int xml_event_handler(rt_uint8_t event, const char *text, rt_size_t len, void *user)
{
rt_kprintf("%s: %s\n", rtgui_xml_event_str(event), text);
return 1;
}
const char xml_str[] = "<?xml version=\"1.0\"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>";
void demo_xml()
{
rtgui_xml_t *xml;
xml = rtgui_xml_create(512, xml_event_handler, RT_NULL);
if (xml != RT_NULL)
{
rtgui_xml_parse(xml, xml_str, sizeof(xml_str));
rtgui_xml_destroy(xml);
}
}
#ifdef RT_USING_FINSH
#include <finsh.h>
FINSH_FUNCTION_EXPORT(demo_xml, show the demo of xml parser);
#endif

108
examples/gui/mywidget.c
View File

@ -1,108 +0,0 @@
#include <rtgui/dc.h>
#include "mywidget.h"
static void rtgui_mywidget_ondraw(struct rtgui_mywidget *me)
{
struct rtgui_dc *dc;
struct rtgui_rect rect;
rt_uint16_t x, y;
dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(me));
if (dc == RT_NULL) return;
rtgui_widget_get_rect(RTGUI_WIDGET(me), &rect);
RTGUI_DC_BC(dc) = white;
rtgui_dc_fill_rect(dc, &rect);
x = (rect.x2 + rect.x1) / 2;
y = (rect.y2 + rect.y1) / 2;
RTGUI_DC_FC(dc) = black;
rtgui_dc_draw_hline(dc, rect.x1, rect.x2, y);
rtgui_dc_draw_vline(dc, x, rect.y1, rect.y2);
if (me->status == MYWIDGET_STATUS_ON)
RTGUI_DC_FC(dc) = green;
else
RTGUI_DC_FC(dc) = red;
rtgui_dc_fill_circle(dc, x, y, 5);
rtgui_dc_end_drawing(dc);
return;
}
static void rtgui_mywidget_onmouse(struct rtgui_mywidget *me, struct rtgui_event_mouse *mouse)
{
struct rtgui_rect rect;
rt_uint16_t x, y;
if (!(mouse->button & RTGUI_MOUSE_BUTTON_UP)) return;
rtgui_widget_get_rect(RTGUI_WIDGET(me), &rect);
rtgui_widget_rect_to_device(RTGUI_WIDGET(me), &rect);
x = (rect.x2 + rect.x1) / 2;
y = (rect.y2 + rect.y1) / 2;
if ((mouse->x < x + 5 && mouse->x > x - 5) &&
(mouse->y < y + 5 && mouse->y > y - 5))
{
if (me->status & MYWIDGET_STATUS_ON) me->status = MYWIDGET_STATUS_OFF;
else me->status = MYWIDGET_STATUS_ON;
rtgui_mywidget_ondraw(me);
}
}
rt_bool_t rtgui_mywidget_event_handler(struct rtgui_object *object, struct rtgui_event *event)
{
struct rtgui_mywidget *me = RTGUI_MYWIDGET(object);
switch (event->type)
{
case RTGUI_EVENT_PAINT:
rtgui_mywidget_ondraw(me);
break;
case RTGUI_EVENT_MOUSE_BUTTON:
rtgui_mywidget_onmouse(RTGUI_MYWIDGET(me), (struct rtgui_event_mouse *) event);
break;
default:
return rtgui_widget_event_handler(object, event);
}
return RT_FALSE;
}
static void _rtgui_mywidget_constructor(rtgui_mywidget_t *mywidget)
{
RTGUI_WIDGET(mywidget)->flag |= RTGUI_WIDGET_FLAG_FOCUSABLE;
rtgui_object_set_event_handler(RTGUI_OBJECT(mywidget), rtgui_mywidget_event_handler);
mywidget->status = MYWIDGET_STATUS_OFF;
}
DEFINE_CLASS_TYPE(mywidget, "mywidget",
RTGUI_WIDGET_TYPE,
_rtgui_mywidget_constructor,
RT_NULL,
sizeof(struct rtgui_mywidget));
struct rtgui_mywidget *rtgui_mywidget_create(rtgui_rect_t *r)
{
struct rtgui_mywidget *me;
me = (struct rtgui_mywidget *) rtgui_widget_create(RTGUI_MYWIDGET_TYPE);
if (me != RT_NULL)
{
rtgui_widget_set_rect(RTGUI_WIDGET(me), r);
}
return me;
}
void rtgui_mywidget_destroy(struct rtgui_mywidget *me)
{
rtgui_widget_destroy(RTGUI_WIDGET(me));
}

50
examples/gui/mywidget.h
View File

@ -1,50 +0,0 @@
/*
* 程åº<EFBFBD>清å<EFBFBD>•ï¼šè‡ªå®šä¹‰æŽ§ä»
*
* 这个例å­<EFBFBD>是è¦<EFBFBD>实现一个自定义控ä»ï¼Œå¤–观大致如
* |
* --o--
* |
* çš„å½¢çŠï¼Œä¸­é—´çš„o色彩表示了当å‰<EFBFBD>çš„çŠæ€<EFBFBD>，ONçŠæ€<EFBFBD>æ—是绿色，OFFçŠæ€<EFBFBD>æ—是红色ã€?
* å¹ä¸”，这个oä½<EFBFBD>置接å<EFBFBD>—鼠标点击，点击下切æ<EFBFBD>¢ä¸‹ç›¸åº”çš„çŠæ€<EFBFBD>ã€?
*/
#ifndef __MY_WIDGET_H__
#define __MY_WIDGET_H__
#include <rtgui/rtgui.h>
#include <rtgui/widgets/widget.h>
/* 自定义控件的状æ€<C3A6>值定ä¹?*/
#define MYWIDGET_STATUS_ON 1
#define MYWIDGET_STATUS_OFF 0
DECLARE_CLASS_TYPE(mywidget);
/** æ¯<C3A6>个控件会有一个类型，通过如下的å®<C3A5>获得控件相应的类型信æ<C2A1>?*/
#define RTGUI_MYWIDGET_TYPE (RTGUI_TYPE(mywidget))
/** 对一个对象实例，å<C592>¯ä»¥é€šè¿‡ä¸‹é<E280B9>¢çš„å®<C3A5>实现类型转æ<C2AC>¢ */
#define RTGUI_MYWIDGET(obj) (RTGUI_OBJECT_CAST((obj), RTGUI_MYWIDGET_TYPE, rtgui_mywidget_t))
/** å<>¯ä»¥é€šè¿‡ä¸‹é<E280B9>¢çš„å®<C3A5>以决定一个具体实例是å<C2AF>¦æ˜¯è‡ªå®šä¹‰æŽ§ä»¶ç±»åž?*/
#define RTGUI_IS_MYWIDGET(obj) (RTGUI_OBJECT_CHECK_TYPE((obj), RTGUI_MYWIDGET_TYPE))
/* 个性化控件类定�*/
struct rtgui_mywidget
{
/* 这个控件是继承自rtgui_widget控件 */
struct rtgui_widget parent;
/* 状æ€<C3A6>：ONã€<C3A3>OFF */
rt_uint8_t status;
};
typedef struct rtgui_mywidget rtgui_mywidget_t;
/* 控件的创建和删除 */
struct rtgui_mywidget *rtgui_mywidget_create(rtgui_rect_t *r);
void rtgui_mywidget_destroy(struct rtgui_mywidget *me);
/* 控件的默认事件处ç<E2809E>†å‡½æ•°ã€?
* 对一个控ä»è€Œè¨€ï¼Œå¦‚果派生自它的å­<EFBFBD>控ä»å¾ˆå<EFBFBD>¯èƒ½ä¼šè°ƒç”¨çˆæŽ§ä»çš„事ä»å¤„ç<EFBFBD>†å‡½æ•°ï¼Œ
* 所以这里采用公开声明的方å¼<EFBFBD>ã€?
*/
rt_bool_t rtgui_mywidget_event_handler(struct rtgui_object *object, struct rtgui_event *event);
#endif

107
examples/gui/play.hdh
View File

@ -1,107 +0,0 @@
static const unsigned char play_hdh[] = {
0x48, 0x44, 0x43, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0x9d, 0xae, 0xdf, 0xef, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0x9d, 0xae,
0x9d, 0xae, 0xdf, 0xef, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0xdf, 0xef, 0x9d, 0xae, 0x7d, 0xae, 0xbf, 0xef,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0xbf, 0xef, 0x7d, 0xae, 0x7d, 0xae, 0xbf, 0xe7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0xbf, 0xe7, 0x7d, 0xae,
0x7d, 0xa6, 0xbf, 0xe7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7,
0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x7a, 0x6d, 0x1a, 0x4d, 0x1a, 0x4d,
0x7a, 0x6d, 0x5f, 0xd7, 0x5f, 0xd7, 0x7a, 0x6d, 0x1a, 0x4d, 0x1a, 0x4d,
0x7a, 0x6d, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7,
0x5f, 0xd7, 0x5f, 0xd7, 0xbf, 0xe7, 0x7d, 0xa6, 0x5d, 0xa6, 0x9f, 0xe7,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0x5f, 0xcf, 0xf9, 0x4c, 0x7c, 0x55, 0x7c, 0x55, 0xf9, 0x4c, 0x5f, 0xcf,
0x5f, 0xcf, 0xf9, 0x4c, 0x7c, 0x55, 0x7c, 0x55, 0xf9, 0x4c, 0x5f, 0xcf,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0x9f, 0xe7, 0x5d, 0xa6, 0x5d, 0xa6, 0x9f, 0xdf, 0x5f, 0xcf, 0x5f, 0xcf,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0xf9, 0x4c,
0x5b, 0x55, 0x5b, 0x55, 0xf9, 0x4c, 0x5f, 0xcf, 0x5f, 0xcf, 0xf9, 0x4c,
0x5b, 0x55, 0x5b, 0x55, 0xf9, 0x4c, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x9f, 0xdf, 0x5d, 0xa6,
0x5c, 0xa6, 0x9f, 0xdf, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7,
0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0xd9, 0x4c, 0x3b, 0x4d, 0x3b, 0x4d,
0xd9, 0x4c, 0x3f, 0xc7, 0x3f, 0xc7, 0xd9, 0x4c, 0x3b, 0x4d, 0x3b, 0x4d,
0xd9, 0x4c, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7,
0x3f, 0xc7, 0x3f, 0xc7, 0x9f, 0xdf, 0x5c, 0xa6, 0x3c, 0xa6, 0x7f, 0xdf,
0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7,
0x3e, 0xc7, 0xb8, 0x44, 0x1a, 0x4d, 0x1a, 0x4d, 0xb8, 0x44, 0x3e, 0xc7,
0x3e, 0xc7, 0xb8, 0x44, 0x1a, 0x4d, 0x1a, 0x4d, 0xb8, 0x44, 0x3e, 0xc7,
0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7,
0x7f, 0xdf, 0x3c, 0xa6, 0x3c, 0x9e, 0x7f, 0xd7, 0x1e, 0xbf, 0x1e, 0xbf,
0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x98, 0x3c,
0xfa, 0x44, 0xfa, 0x44, 0x98, 0x3c, 0x1e, 0xbf, 0x1e, 0xbf, 0x98, 0x3c,
0xfa, 0x44, 0xfa, 0x44, 0x98, 0x3c, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf,
0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x7f, 0xd7, 0x3c, 0x9e,
0x1c, 0x9e, 0x7f, 0xd7, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0x77, 0x3c, 0xd9, 0x3c, 0xd9, 0x3c,
0x77, 0x3c, 0xfe, 0xbe, 0xfe, 0xbe, 0x77, 0x3c, 0xd9, 0x3c, 0xd9, 0x3c,
0x77, 0x3c, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0x7f, 0xd7, 0x1c, 0x9e, 0x1c, 0x9e, 0x5e, 0xcf,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0x56, 0x34, 0x98, 0x3c, 0x98, 0x3c, 0x56, 0x34, 0xfe, 0xbe,
0xfe, 0xbe, 0x56, 0x34, 0x98, 0x3c, 0x98, 0x3c, 0x56, 0x34, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0x5e, 0xcf, 0x1c, 0x9e, 0xfc, 0x95, 0x5e, 0xcf, 0xfe, 0xb6, 0xfe, 0xb6,
0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0x36, 0x34,
0x78, 0x34, 0x78, 0x34, 0x36, 0x34, 0xfe, 0xb6, 0xfe, 0xb6, 0x36, 0x34,
0x78, 0x34, 0x78, 0x34, 0x36, 0x34, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6,
0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0x5e, 0xcf, 0xfc, 0x95,
0xfb, 0x95, 0x3e, 0xcf, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6,
0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xf5, 0x2b, 0x57, 0x34, 0x57, 0x34,
0xf5, 0x2b, 0xde, 0xb6, 0xde, 0xb6, 0xf5, 0x2b, 0x57, 0x34, 0x57, 0x34,
0xf5, 0x2b, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6,
0xde, 0xb6, 0xde, 0xb6, 0x3e, 0xcf, 0xfb, 0x95, 0xdb, 0x95, 0x3e, 0xc7,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xd5, 0x2b, 0x36, 0x2c, 0x36, 0x2c, 0xd5, 0x2b, 0xbe, 0xae,
0xbe, 0xae, 0xd5, 0x2b, 0x36, 0x2c, 0x36, 0x2c, 0xd5, 0x2b, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0x3e, 0xc7, 0xdb, 0x95, 0xdb, 0x95, 0x3e, 0xc7, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0x56, 0x44,
0xd4, 0x23, 0xd4, 0x23, 0x56, 0x44, 0xbe, 0xae, 0xbe, 0xae, 0x56, 0x44,
0xd4, 0x23, 0xd4, 0x23, 0x56, 0x44, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0x3e, 0xc7, 0xdb, 0x95,
0xdb, 0x8d, 0x1e, 0xc7, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x1e, 0xc7, 0xdb, 0x8d, 0xbb, 0x8d, 0x1e, 0xbf,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x1e, 0xbf, 0xbb, 0x8d, 0xbb, 0x8d, 0x1e, 0xbf, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x1e, 0xbf, 0xbb, 0x8d,
0xbb, 0x8d, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xbb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d,
};

107
examples/gui/stop.hdh
View File

@ -1,107 +0,0 @@
static const unsigned char stop_hdh[] = {
0x48, 0x44, 0x43, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0x9d, 0xae, 0xdf, 0xef, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7,
0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0xbf, 0xe7, 0x9d, 0xae,
0x9d, 0xae, 0xdf, 0xef, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0xdf, 0xef, 0x9d, 0xae, 0x7d, 0xae, 0xbf, 0xef,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf, 0x9f, 0xdf,
0xbf, 0xef, 0x7d, 0xae, 0x7d, 0xae, 0xbf, 0xe7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7,
0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0x7f, 0xd7, 0xbf, 0xe7, 0x7d, 0xae,
0x7d, 0xa6, 0xbf, 0xe7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7,
0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0xfb, 0x8d, 0x3c, 0x96,
0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7,
0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7, 0x5f, 0xd7,
0x5f, 0xd7, 0x5f, 0xd7, 0xbf, 0xe7, 0x7d, 0xa6, 0x5d, 0xa6, 0x9f, 0xe7,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0x5f, 0xcf, 0x5f, 0xcf, 0xf9, 0x4c, 0x3a, 0x55, 0x5a, 0x65, 0x9d, 0xae,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0x9f, 0xe7, 0x5d, 0xa6, 0x5d, 0xa6, 0x9f, 0xdf, 0x5f, 0xcf, 0x5f, 0xcf,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0xf9, 0x4c, 0x5b, 0x55, 0x3b, 0x55, 0x1a, 0x4d, 0xba, 0x7d, 0x1e, 0xc7,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf,
0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x5f, 0xcf, 0x9f, 0xdf, 0x5d, 0xa6,
0x5c, 0xa6, 0x9f, 0xdf, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7,
0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0xd9, 0x4c, 0x3b, 0x4d,
0x3b, 0x4d, 0x3b, 0x4d, 0x1a, 0x4d, 0xf9, 0x4c, 0xfb, 0x8d, 0x3f, 0xc7,
0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7, 0x3f, 0xc7,
0x3f, 0xc7, 0x3f, 0xc7, 0x9f, 0xdf, 0x5c, 0xa6, 0x3c, 0xa6, 0x7f, 0xdf,
0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7,
0x3e, 0xc7, 0x3e, 0xc7, 0xb8, 0x44, 0x1a, 0x4d, 0x1a, 0x4d, 0x1a, 0x4d,
0x1a, 0x4d, 0x1a, 0x4d, 0xd9, 0x44, 0x19, 0x5d, 0x7c, 0xa6, 0x3e, 0xc7,
0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7, 0x3e, 0xc7,
0x7f, 0xdf, 0x3c, 0xa6, 0x3c, 0x9e, 0x7f, 0xd7, 0x1e, 0xbf, 0x1e, 0xbf,
0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf,
0x98, 0x44, 0xfa, 0x44, 0xfa, 0x44, 0xfa, 0x44, 0xfa, 0x44, 0xfa, 0x44,
0xf9, 0x44, 0xd9, 0x44, 0x98, 0x44, 0x39, 0x6d, 0x1e, 0xbf, 0x1e, 0xbf,
0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x1e, 0xbf, 0x7f, 0xd7, 0x3c, 0x9e,
0x1c, 0x9e, 0x7f, 0xd7, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0x77, 0x3c, 0xd9, 0x44,
0xd9, 0x44, 0xd9, 0x44, 0xd9, 0x44, 0xd9, 0x44, 0xb9, 0x44, 0xb8, 0x3c,
0x77, 0x3c, 0x38, 0x6d, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0x7f, 0xd7, 0x1c, 0x9e, 0x1c, 0x9e, 0x5e, 0xcf,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0x56, 0x34, 0x98, 0x3c, 0x98, 0x3c, 0x98, 0x3c,
0x98, 0x3c, 0x98, 0x3c, 0x77, 0x3c, 0xb7, 0x4c, 0x3c, 0x96, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0x5e, 0xcf, 0x1c, 0x9e, 0xfc, 0x95, 0x5e, 0xcf, 0xfe, 0xb6, 0xfe, 0xb6,
0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6,
0x36, 0x34, 0x78, 0x34, 0x78, 0x34, 0x78, 0x34, 0x57, 0x34, 0x56, 0x3c,
0x9a, 0x7d, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6,
0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0xfe, 0xb6, 0x5e, 0xcf, 0xfc, 0x95,
0xfb, 0x95, 0x3e, 0xcf, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6,
0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0x15, 0x2c, 0x57, 0x34,
0x37, 0x34, 0x16, 0x2c, 0xf8, 0x5c, 0x9d, 0xae, 0xde, 0xb6, 0xde, 0xb6,
0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6, 0xde, 0xb6,
0xde, 0xb6, 0xde, 0xb6, 0x3e, 0xcf, 0xfb, 0x95, 0xdb, 0x95, 0x3e, 0xc7,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xd4, 0x2b, 0xf5, 0x2b, 0x56, 0x44, 0xfb, 0x8d,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0x3e, 0xc7, 0xdb, 0x95, 0xdb, 0x95, 0x3e, 0xc7, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0xf8, 0x64, 0x39, 0x6d, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae,
0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0xbe, 0xae, 0x3e, 0xc7, 0xdb, 0x95,
0xdb, 0x8d, 0x1e, 0xc7, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x1e, 0xc7, 0xdb, 0x8d, 0xbb, 0x8d, 0x1e, 0xbf,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x1e, 0xbf, 0xbb, 0x8d, 0xbb, 0x8d, 0x1e, 0xbf, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6,
0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x9d, 0xa6, 0x1e, 0xbf, 0xbb, 0x8d,
0xbb, 0x8d, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe,
0xfe, 0xbe, 0xfe, 0xbe, 0xfe, 0xbe, 0xbb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d, 0xdb, 0x8d,
0xdb, 0x8d, 0xdb, 0x8d,
};

5
include/rtm.h
View File

@ -21,6 +21,9 @@ struct rt_module_symtab
const char *name; const char *name;
}; };
#if defined(_MSC_VER) || defined(__MINGW32__)
#define RTM_EXPORT(symbol)
#else
#define RTM_EXPORT(symbol) \ #define RTM_EXPORT(symbol) \
const char __rtmsym_##symbol##_name[] = #symbol; \ const char __rtmsym_##symbol##_name[] = #symbol; \
const struct rt_module_symtab __rtmsym_##symbol SECTION("RTMSymTab")= \ const struct rt_module_symtab __rtmsym_##symbol SECTION("RTMSymTab")= \
@ -28,6 +31,8 @@ const struct rt_module_symtab __rtmsym_##symbol SECTION("RTMSymTab")= \
(void *)&symbol, \ (void *)&symbol, \
__rtmsym_##symbol##_name \ __rtmsym_##symbol##_name \
}; };
#endif
#else #else
#define RTM_EXPORT(symbol) #define RTM_EXPORT(symbol)
#endif #endif

3
libcpu/SConscript
View File

@ -18,6 +18,9 @@ if rtconfig.PLATFORM == 'iar':
if rtconfig.PLATFORM == 'cl': if rtconfig.PLATFORM == 'cl':
src = Glob(path + '/*.c') src = Glob(path + '/*.c')
if rtconfig.PLATFORM == 'mingw':
src = Glob(path + '/*.c')
CPPPATH = [RTT_ROOT + '/libcpu/' + rtconfig.ARCH + '/' + rtconfig.CPU, RTT_ROOT + '/libcpu/' + rtconfig.ARCH + '/common'] CPPPATH = [RTT_ROOT + '/libcpu/' + rtconfig.ARCH + '/' + rtconfig.CPU, RTT_ROOT + '/libcpu/' + rtconfig.ARCH + '/common']
group = DefineGroup(rtconfig.CPU.upper(), src, depend = [''], CPPPATH = CPPPATH) group = DefineGroup(rtconfig.CPU.upper(), src, depend = [''], CPPPATH = CPPPATH)

2
libcpu/sim/win32/cpu_port.c
View File

@ -111,6 +111,7 @@ static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam);
static void SetThreadName(DWORD dwThreadID, char* threadName) static void SetThreadName(DWORD dwThreadID, char* threadName)
{ {
#if defined(_MSC_VER)
THREADNAME_INFO info; THREADNAME_INFO info;
info.dwType = 0x1000; info.dwType = 0x1000;
info.szName = threadName; info.szName = threadName;
@ -124,6 +125,7 @@ static void SetThreadName(DWORD dwThreadID, char* threadName)
__except(EXCEPTION_EXECUTE_HANDLER) __except(EXCEPTION_EXECUTE_HANDLER)
{ {
} }
#endif
} }
/* /*

7
tools/building.py
View File

@ -48,6 +48,7 @@ def PrepareBuilding(env, root_directory, has_libcpu=False, remove_components = [
if not os.path.isfile(os.path.join(rtconfig.EXEC_PATH, 'armcc.exe')): if not os.path.isfile(os.path.join(rtconfig.EXEC_PATH, 'armcc.exe')):
if rtconfig.EXEC_PATH.find('bin40') > 0: if rtconfig.EXEC_PATH.find('bin40') > 0:
rtconfig.EXEC_PATH = rtconfig.EXEC_PATH.replace('bin40', 'armcc/bin') rtconfig.EXEC_PATH = rtconfig.EXEC_PATH.replace('bin40', 'armcc/bin')
Env['LINKFLAGS']=Env['LINKFLAGS'].replace('RV31', 'armcc')
# patch for win32 spawn # patch for win32 spawn
if env['PLATFORM'] == 'win32' and rtconfig.PLATFORM == 'gcc': if env['PLATFORM'] == 'win32' and rtconfig.PLATFORM == 'gcc':
@ -134,13 +135,13 @@ def PrepareBuilding(env, root_directory, has_libcpu=False, remove_components = [
objs = SConscript('SConscript', variant_dir='build', duplicate=0) objs = SConscript('SConscript', variant_dir='build', duplicate=0)
Repository(Rtt_Root) Repository(Rtt_Root)
# include kernel # include kernel
objs.append(SConscript(Rtt_Root + '/src/SConscript', variant_dir='build/src', duplicate=0)) objs.extend(SConscript(Rtt_Root + '/src/SConscript', variant_dir='build/src', duplicate=0))
# include libcpu # include libcpu
if not has_libcpu: if not has_libcpu:
objs.append(SConscript(Rtt_Root + '/libcpu/SConscript', variant_dir='build/libcpu', duplicate=0)) objs.extend(SConscript(Rtt_Root + '/libcpu/SConscript', variant_dir='build/libcpu', duplicate=0))
# include components # include components
objs.append(SConscript(Rtt_Root + '/components/SConscript', objs.extend(SConscript(Rtt_Root + '/components/SConscript',
variant_dir='build/components', variant_dir='build/components',
duplicate=0, duplicate=0,
exports='remove_components')) exports='remove_components'))