struct rtgui_dc *rtgui_dc_buffer_create_pixformat(rt_uint8_t pixel_format, int w, int h) { struct rtgui_dc_buffer *dc; dc = (struct rtgui_dc_buffer *)rtgui_malloc(sizeof(struct rtgui_dc_buffer)); dc->parent.type = RTGUI_DC_BUFFER; dc->parent.engine = &dc_buffer_engine; dc->gc.foreground = default_foreground; dc->gc.background = default_background; dc->gc.font = rtgui_font_default(); dc->gc.textalign = RTGUI_ALIGN_LEFT | RTGUI_ALIGN_TOP; dc->pixel_format = pixel_format; dc->width = w; dc->height = h; dc->pitch = w * rtgui_color_get_bpp(pixel_format); dc->pixel = rtgui_malloc(h * dc->pitch); if (!dc->pixel) { rtgui_free(dc); return RT_NULL; } rt_memset(dc->pixel, 0, h * dc->pitch); return &(dc->parent); }
rtgui_xml_t* rtgui_xml_create(rt_size_t buffer_size, rtgui_xml_event_handler_t handler, void* user) { rtgui_xml_t* xml = (rtgui_xml_t*) rtgui_malloc(sizeof(struct rtgui_xml)); rt_memset(xml, 0, sizeof(rtgui_xml_t)); xml->event_handler = handler; xml->user = user; /* create buffer */ xml->buffer_size = buffer_size; xml->buffer = (char*)rtgui_malloc(xml->buffer_size); return xml; }
static rt_bool_t rtgui_image_hdc_load(struct rtgui_image *image, struct rtgui_filerw *file, rt_bool_t load) { rt_uint32_t header[5]; struct rtgui_image_hdc *hdc; hdc = (struct rtgui_image_hdc *) rtgui_malloc(sizeof(struct rtgui_image_hdc)); if (hdc == RT_NULL) return RT_FALSE; hdc->hw_driver = rtgui_graphic_driver_get_default(); if (hdc->hw_driver == RT_NULL) { rtgui_free(hdc); return RT_FALSE; } rtgui_filerw_read(file, (char *)&header, 1, sizeof(header)); /* set image information */ image->w = (rt_uint16_t)header[1]; image->h = (rt_uint16_t)header[2]; image->engine = &rtgui_image_hdc_engine; image->data = hdc; hdc->filerw = file; hdc->byte_per_pixel = hdc->hw_driver->bits_per_pixel / 8; hdc->pitch = image->w * hdc->byte_per_pixel; hdc->pixel_offset = rtgui_filerw_tell(file); if (load == RT_TRUE) { /* load all pixels */ hdc->pixels = rtgui_malloc(image->h * hdc->pitch); if (hdc->pixels == RT_NULL) { /* release data */ rtgui_free(hdc); return RT_FALSE; } rtgui_filerw_read(hdc->filerw, hdc->pixels, 1, image->h * hdc->pitch); rtgui_filerw_close(hdc->filerw); hdc->filerw = RT_NULL; hdc->pixel_offset = 0; } else { hdc->pixels = RT_NULL; } return RT_TRUE; }
void rtgui_textbox_set_value(struct rtgui_textbox* box, const char* text) { if (box->text != RT_NULL) { if (box->line_length > rt_strlen(text) + 1) { rt_memcpy(box->text, text, rt_strlen(text) + 1); /* set current position */ box->position = 0; return; } else { /* free the old text */ rtgui_free(box->text); box->text = RT_NULL; } } box->line_length = RTGUI_TEXTBOX_LINE_MAX > rt_strlen(text) + 1 ? RTGUI_TEXTBOX_LINE_MAX : rt_strlen(text) + 1; /* allocate line buffer */ box->text = rtgui_malloc(box->line_length); rt_memset(box->text, 0, box->line_length); /* copy text */ rt_memcpy(box->text, text, rt_strlen(text) + 1); /* set current position */ box->position = 0; }
struct rtgui_dc *rtgui_img_dc_create_pixformat(rt_uint8_t pixel_format, rt_uint8_t *pixel, struct rtgui_image_item *image_item) { struct rtgui_dc_buffer *dc; dc = (struct rtgui_dc_buffer *)rtgui_malloc(sizeof(struct rtgui_dc_buffer)); if (dc) { dc->parent.type = RTGUI_DC_BUFFER; dc->parent.engine = &dc_buffer_engine; dc->gc.foreground = default_foreground; dc->gc.background = default_background; dc->gc.font = rtgui_font_default(); dc->gc.textalign = RTGUI_ALIGN_LEFT | RTGUI_ALIGN_TOP; dc->pixel_format = pixel_format; dc->pixel_alpha = 255; dc->width = image_item->image->w; dc->height = image_item->image->h; dc->pitch = image_item->image->w * rtgui_color_get_bpp(pixel_format); dc->image_item = image_item; dc->pixel = pixel; return &(dc->parent); } return RT_NULL; }
static void rtgui_edit_init_caret(struct rtgui_edit *edit, rtgui_point_t visual) { struct rtgui_gdev *grp = rtgui_gdev_get(); int x, y; rtgui_color_t color; rtgui_rect_t rect; int ofs=0; RT_ASSERT(edit != RT_NULL); if(!RTGUI_WIDGET_IS_FOCUSED(edit)) return; rtgui_edit_get_caret_rect(edit, &edit->caret_rect, visual); rect = edit->caret_rect; rtgui_widget_rect_to_device(RTGUI_WIDGET(edit), &rect); if(edit->caret == RT_NULL) edit->caret = (rtgui_color_t*)rtgui_malloc(RC_W(rect) * RC_H(rect)*sizeof(rtgui_color_t)); rtgui_timer_stop(edit->caret_timer); for(x=rect.x1; x<rect.x2; x++) { for(y=rect.y1; y<rect.y2; y++) { grp->ops->get_pixel(&color,x,y); *(edit->caret + ofs++) = color; } } rtgui_timer_start(edit->caret_timer); }
struct rtgui_filerw* rtgui_filerw_create_file(const char* filename, const char* mode) { int fd; struct rtgui_filerw_stdio *rw; RT_ASSERT(filename != RT_NULL); rw = RT_NULL; fd = open(filename, parse_mode(mode), 0); if ( fd >= 0 ) { rw = (struct rtgui_filerw_stdio*) rtgui_malloc(sizeof(struct rtgui_filerw_stdio)); if (rw != RT_NULL) { rw->parent.seek = stdio_seek; rw->parent.read = stdio_read; rw->parent.write = stdio_write; rw->parent.tell = stdio_tell; rw->parent.close = stdio_close; rw->parent.eof = stdio_eof; rw->fd = fd; rw->eof = RT_FALSE; } } return &(rw->parent); }
struct rtgui_filerw* rtgui_filerw_create_file(const char* filename, const char* mode) { FILE *fp; struct rtgui_filerw_stdio *rw; RT_ASSERT(filename != RT_NULL); rw = RT_NULL; fp = fopen(filename, mode); if ( fp != NULL ) { rw = (struct rtgui_filerw_stdio*) rtgui_malloc(sizeof(struct rtgui_filerw_stdio)); if (rw != RT_NULL) { rw->parent.seek = stdio_seek; rw->parent.read = stdio_read; rw->parent.write = stdio_write; rw->parent.tell = stdio_tell; rw->parent.close = stdio_close; rw->parent.eof = stdio_eof; rw->fp = fp; } } return &(rw->parent); }
static void rtgui_textbox_init_caret(rtgui_textbox_t *box, rt_uint16_t position) { int x, y; rtgui_color_t color; rtgui_rect_t rect; int ofs = 0; RT_ASSERT(box != RT_NULL); if (!RTGUI_WIDGET_IS_FOCUSED(box)) return; rtgui_textbox_get_caret_rect(box, &box->caret_rect, position); rect = box->caret_rect; rtgui_widget_rect_to_device(RTGUI_WIDGET(box), &rect); if (box->caret == RT_NULL) box->caret = rtgui_malloc(rtgui_rect_width(rect) * rtgui_rect_height(rect) * sizeof(rtgui_color_t)); for (x = rect.x1; x < rect.x2; x++) { for (y = rect.y1; y < rect.y2; y++) { rtgui_graphic_driver_get_default()->ops->get_pixel(&color, x, y); *(box->caret + ofs) = color; ofs++; } } }
struct rtgui_animation* rtgui_anim_create(struct rtgui_widget *parent, int interval) { struct rtgui_animation *anim = rtgui_malloc(sizeof(*anim)); if (anim == RT_NULL) return RT_NULL; anim->timer = rtgui_timer_create(interval, RT_TIMER_FLAG_PERIODIC, _anim_timeout, anim); if (anim->timer == RT_NULL) { rtgui_free(anim); return RT_NULL; } anim->parent = parent; anim->fg_buf = RT_NULL; anim->dc_cnt = 0; anim->tick = 0; anim->tick_interval = interval; anim->max_tick = 0; /* Set default handlers. */ anim->motion = rtgui_anim_motion_linear; anim->engine = RT_NULL; anim->eng_ctx = RT_NULL; anim->on_finish = _animation_default_finish; anim->state = _ANIM_STOPPED; return anim; }
void rtgui_textbox_ondraw(rtgui_textbox_t *box) { /* draw button */ rtgui_rect_t rect; struct rtgui_dc *dc; rtgui_color_t fc; RT_ASSERT(box != RT_NULL); /* begin drawing */ dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(box)); if (dc == RT_NULL) return; /* get widget rect */ rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect); fc = RTGUI_WIDGET_FOREGROUND(box); rtgui_rect_inflate(&rect, -1); /* fill widget rect with white color */ RTGUI_WIDGET_BACKGROUND(box) = white; rtgui_dc_fill_rect(dc, &rect); rtgui_rect_inflate(&rect, 1); /* draw border */ RTGUI_WIDGET_FOREGROUND(box) = RTGUI_RGB(123, 158, 189); rtgui_dc_draw_rect(dc, &rect); /* draw text */ RTGUI_WIDGET_FOREGROUND(box) = fc; if (box->text != RT_NULL) { rect.x1 += RTGUI_WIDGET_DEFAULT_MARGIN; /* draw single text */ if (box->flag & RTGUI_TEXTBOX_MASK) { /* draw mask char */ rt_size_t len = rt_strlen(box->text); if (len > 0) { char *text_mask = rtgui_malloc(len + 1); rt_memset(text_mask, box->mask_char, len + 1); text_mask[len] = 0; rtgui_dc_draw_text(dc, text_mask+box->first_pos, &rect); rtgui_free(text_mask); } } else { rtgui_dc_draw_text(dc, box->text+box->first_pos, &rect); } } rtgui_dc_end_drawing(dc); }
void load_img_test(char *fname) { struct rtgui_filerw *filerw; struct rtgui_image image; struct rtgui_rect rect; struct rtgui_dc_hw *dc; struct rtgui_image_engine *img_eng; printf_syn("fun:%s, line:%d, fn:%s\n", __FUNCTION__, __LINE__, fname); filerw = rtgui_filerw_create_file(fname, "rb"); if (NULL == filerw) { printf_syn("fun:%s, line:%d, fn:%s\n", __FUNCTION__, __LINE__, fname); return; } img_eng = &rtgui_image_hdc_engine; if (RT_TRUE != img_eng->image_check(filerw)) { printf_syn("fun:%s, line:%d\n", __FUNCTION__, __LINE__); return; } if (RT_TRUE != img_eng->image_load(&image, filerw, RT_FALSE)) { printf_syn("fun:%s, line:%d\n", __FUNCTION__, __LINE__); return; } dc = (struct rtgui_dc_hw*) rtgui_malloc(sizeof(struct rtgui_dc_hw)); dc->parent.type = RTGUI_DC_HW; dc->parent.engine = &dc_hw_engine; dc->owner = NULL; dc->hw_driver = rtgui_graphic_driver_get_default(); rect.x1 = 0; rect.y1 = 0; rect.x2 = rtgui_graphic_driver_get_default()->width; rect.y2 = rtgui_graphic_driver_get_default()->height; printf_syn("fun:%s, line:%d, 0x%x\n", __FUNCTION__, __LINE__, img_eng->image_blit); img_eng->image_blit(&image, (struct rtgui_dc*)dc, &rect); rt_thread_delay(get_ticks_of_ms(5000)); printf_syn("fun:%s, line:%d, fn:%s\n", __FUNCTION__, __LINE__, fname); img_eng->image_unload(&image); printf_syn("fun:%s, line:%d, fn:%s\n", __FUNCTION__, __LINE__, fname); //rect.x1 = rtgui_filerw_close(filerw); /* unload 已close */ printf_syn("fun:%s, line:%d, ret:%d, fn:%s\n", __FUNCTION__, __LINE__, rect.x1, fname); rtgui_free(dc); return; }
static void rtgui_image_hdc_blit(struct rtgui_image *image, struct rtgui_dc *dc, struct rtgui_rect *dst_rect) { rt_uint16_t y, w, h; struct rtgui_image_hdc *hdc; RT_ASSERT(image != RT_NULL || dc != RT_NULL || dst_rect != RT_NULL); /* this dc is not visible */ if (rtgui_dc_get_visible(dc) != RT_TRUE) return; hdc = (struct rtgui_image_hdc *) image->data; RT_ASSERT(hdc != RT_NULL); /* the minimum rect */ if (image->w < rtgui_rect_width(*dst_rect)) w = image->w; else w = rtgui_rect_width(*dst_rect); if (image->h < rtgui_rect_height(*dst_rect)) h = image->h; else h = rtgui_rect_height(*dst_rect); if (hdc->pixels != RT_NULL) { rt_uint8_t *ptr; /* get pixel pointer */ ptr = hdc->pixels; for (y = 0; y < h; y ++) { dc->engine->blit_line(dc, dst_rect->x1, dst_rect->x1 + w, dst_rect->y1 + y, ptr); ptr += hdc->pitch; } } else { rt_uint8_t *ptr; ptr = rtgui_malloc(hdc->pitch); if (ptr == RT_NULL) return; /* no memory */ /* seek to the begin of pixel data */ rtgui_filerw_seek(hdc->filerw, hdc->pixel_offset, RTGUI_FILE_SEEK_SET); for (y = 0; y < h; y ++) { /* read pixel data */ if (rtgui_filerw_read(hdc->filerw, ptr, 1, hdc->pitch) != hdc->pitch) break; /* read data failed */ dc->engine->blit_line(dc, dst_rect->x1, dst_rect->x1 + w, dst_rect->y1 + y, ptr); } rtgui_free(ptr); } }
rt_bool_t rtgui_edit_readin_file(struct rtgui_edit *edit, const char *filename) { int fd, num=0, read_bytes, size ,len=0; char *text ,ch; fd = open(filename, O_RDONLY, 0); if (fd < 0) { return RT_FALSE; } while(edit->max_rows > 0) rtgui_edit_delete_line(edit, edit->head); edit->max_rows = 0; size = edit->bzsize; text = rtgui_malloc(size); if(text == RT_NULL) return RT_FALSE; do { if ( (read_bytes = read(fd, &ch, 1)) > 0 ) { if(num >= size - 1) text = rt_realloc(text, rtgui_edit_alloc_len(size, num)); if(ch == 0x09) { len = edit->tabsize - num%edit->tabsize; while(len--) *(text + num++) = ' '; } else *(text + num++) = ch; if(ch == 0x0A) { rtgui_edit_append_line(edit, text); num = 0; } } else if(num > 0) { /* last line does not exist the end operator */ *(text + num) = '\0'; rtgui_edit_append_line(edit, text); } } while(read_bytes); close(fd); rtgui_free(text); rtgui_edit_ondraw(edit); return RT_TRUE; }
rt_bool_t rtgui_edit_append_line(struct rtgui_edit* edit, const char *text) { rt_size_t len; struct edit_line *line, *node; RT_ASSERT(edit != RT_NULL); line = rtgui_malloc(sizeof(struct edit_line)); if(line == RT_NULL) return RT_FALSE; len = rtgui_edit_line_strlen(text); line->zsize = rtgui_edit_alloc_len(edit->bzsize, len+1); line->text = rtgui_malloc(line->zsize); rt_memcpy(line->text, text, len); *(line->text+len) = '\0'; line->len = rtgui_edit_line_strlen(line->text); line->next = RT_NULL; edit->max_rows++; if(edit->max_cols < len) edit->max_cols = len; node = edit->head; if(node == RT_NULL) { edit->head = line; edit->tail = line; line->prev = RT_NULL; edit->first_line = line; return RT_TRUE; } while(node->next != RT_NULL) node = node->next; /* to tail item on to queue */ node->next = line; line->prev = node; /* re-fixed position tail */ edit->tail = line; return RT_TRUE; }
rt_bool_t rtgui_edit_insert_line(struct rtgui_edit *edit, struct edit_line *p, char *text) { rt_size_t len; struct edit_line *line; RT_ASSERT(edit != RT_NULL); RT_ASSERT(p != RT_NULL); if(p->next == RT_NULL) { rtgui_edit_append_line(edit, text); return RT_TRUE; } line = rtgui_malloc(sizeof(struct edit_line)); if(line == RT_NULL) return RT_FALSE; line->prev = p; line->next = p->next; p->next = line; if(line->next != RT_NULL) { line->next->prev = line; } len = rtgui_edit_line_strlen(text); line->zsize = rtgui_edit_alloc_len(edit->bzsize, len+1); line->text = rtgui_malloc(line->zsize); rt_memset(line->text, 0, line->zsize); rt_memcpy(line->text, text, len); *(line->text+len) = '\0'; edit->max_rows ++; line->len = rtgui_edit_line_strlen(line->text); return RT_TRUE; }
rtgui_timer_t* rtgui_timer_create(rt_int32_t time, rt_base_t flag, rtgui_timeout_func timeout, void* parameter) { rtgui_timer_t* timer; timer = (rtgui_timer_t*) rtgui_malloc(sizeof(struct rtgui_timer)); timer->tid = rt_thread_self(); timer->timeout = timeout; timer->user_data = parameter; /* init rt-thread timer */ rt_timer_init(&(timer->timer), "rtgui", rtgui_time_out, timer, time, (rt_uint8_t)flag); return timer; }
struct rtgui_dc_trans* rtgui_dc_trans_create(struct rtgui_dc *owner) { struct rtgui_dc_trans *dct; dct = (struct rtgui_dc_trans*)rtgui_malloc(sizeof(*dct)); if (!dct) return RT_NULL; rtgu_matrix_identity(&dct->m); dct->owner = owner; dct->use_aa = 0; return dct; }
static void rtgui_freetype_font_get_metrics(struct rtgui_font *font, const char *text, rtgui_rect_t *rect) { int index = 0, len; FT_Error err = 0; rt_uint16_t w = 0, h = 0; rt_uint16_t *text_short, *text_ptr; struct rtgui_freetype_font *freetype; RT_ASSERT(font != RT_NULL); RT_ASSERT(rect != RT_NULL); freetype = (struct rtgui_freetype_font *) font->data; RT_ASSERT(freetype != RT_NULL); len = strlen(text); memset(rect, 0, sizeof(struct rtgui_rect)); /* allocate unicode buffer */ text_short = (rt_uint16_t *)rtgui_malloc((len + 1) * 2); if (text_short == RT_NULL) return ; /* out of memory */ /* convert gbk to unicode */ gbk_to_unicode(text_short, text, len); text_ptr = text_short; while (*text_ptr) { index = FT_Get_Char_Index(freetype->face, *text_ptr); err = FT_Load_Glyph(freetype->face, index, FT_LOAD_DEFAULT); if (err == 0) { w += freetype->face->glyph->bitmap.width; if (freetype->face->glyph->bitmap.rows > h) { h = freetype->face->glyph->bitmap.rows; } } text_ptr ++; } rect->x1 = 0; rect->y1 = 0; rect->x2 = w; rect->y2 = h; /* release unicode buffer */ rtgui_free(text_short); }
rtgui_timer_t *rtgui_timer_create(rt_int32_t time, rt_int32_t flag, rtgui_timeout_func timeout, void *parameter) { rtgui_timer_t *timer; timer = (rtgui_timer_t *) rtgui_malloc(sizeof(rtgui_timer_t)); timer->app = rtgui_app_self(); timer->timeout = timeout; timer->pending_cnt = 0; timer->state = RTGUI_TIMER_ST_INIT; timer->user_data = parameter; /* init rt-thread timer */ rt_timer_init(&(timer->timer), "rtgui", rtgui_time_out, timer, time, (rt_uint8_t)flag); return timer; }
static void rtgui_freetype_font_draw_text(struct rtgui_font* font, struct rtgui_dc* dc, const char* text, rt_ubase_t len, struct rtgui_rect* rect) { int index = 0; FT_Error err = 0; rt_uint16_t *text_short, *text_ptr; struct rtgui_freetype_font* freetype; RT_ASSERT(font != RT_NULL); freetype = (struct rtgui_freetype_font*) font->data; RT_ASSERT(freetype != RT_NULL); /* allocate unicode buffer */ text_short = (rt_uint16_t*)rtgui_malloc((len + 1)* 2); if (text_short == RT_NULL) return ; /* out of memory */ /* convert gbk to unicode */ gbk_to_unicode(text_short, text, len); text_ptr = text_short; while (*text_ptr) { index = FT_Get_Char_Index(freetype->face, *text_ptr); err = FT_Load_Glyph(freetype->face, index, FT_LOAD_DEFAULT|FT_LOAD_RENDER); if (err == 0) { int rows, x; rt_uint8_t* ptr; /* render font */ ptr = (rt_uint8_t*)freetype->face->glyph->bitmap.buffer; for (rows = 0; rows < freetype->face->glyph->bitmap.rows; rows ++) for (x = 0; x < freetype->face->glyph->bitmap.width; x++) { if (*ptr > 0) rtgui_dc_draw_color_point(dc, rect->x1 + x, rect->y1 + rows, RTGUI_RGB(0xff - *ptr, 0xff - *ptr, 0xff - *ptr)); ptr ++; } } text_ptr ++; rect->x1 += freetype->face->glyph->bitmap.width; } /* release unicode buffer */ rtgui_free(text_short); }
void* rtgui_realloc(void* ptr, rt_size_t size) { void* new_ptr; #ifdef RTGUI_MEM_TRACE new_ptr = rtgui_malloc(size); if ((new_ptr != RT_NULL) && (ptr != RT_NULL)) { rt_memcpy(new_ptr, ptr, size); rtgui_free(ptr); } #else new_ptr = rt_realloc(ptr, size); #endif return new_ptr; }
static void _graphic_driver_vmode_init(void) { if (_vfb_driver.width != _driver.width || _vfb_driver.height != _driver.height) { if (_vfb_driver.framebuffer != RT_NULL) rtgui_free((void*)_vfb_driver.framebuffer); _vfb_driver.device = RT_NULL; _vfb_driver.pixel_format = RTGUI_VFB_PIXEL_FMT; _vfb_driver.bits_per_pixel = rtgui_color_get_bits(RTGUI_VFB_PIXEL_FMT); _vfb_driver.width = _driver.width; _vfb_driver.height = _driver.height; _vfb_driver.pitch = _driver.width * _UI_BITBYTES(_vfb_driver.bits_per_pixel); _vfb_driver.framebuffer = rtgui_malloc(_vfb_driver.height * _vfb_driver.pitch); _vfb_driver.ext_ops = RT_NULL; _vfb_driver.ops = rtgui_framebuffer_get_ops(_vfb_driver.pixel_format); } }
void drawing_update_state_info(struct rtgui_widget* widget) { char* line; struct rtgui_dc* dc; struct rtgui_rect rect; line = rtgui_malloc(256); if (line == RT_NULL) return ; dc = rtgui_dc_begin_drawing(widget); if (dc == RT_NULL) { rt_free(line); return; } rtgui_widget_get_rect(widget, &rect); /* fill background */ rtgui_dc_fill_rect(dc, &rect); rect.y2 = rect.y1 + 18; switch(update_radio_list_state) { case UPDATE_RAIDO_LIST_PROC: sprintf(line, "正在更新电台列表......"); break ; case UPDATE_RADIO_LIST_CONNECT_FAILED: sprintf(line, "更新电台列表失败,请返回"); break; case UPDATE_RADIO_LIST_SUCCEED: sprintf(line, "更新电台列表成功,请返回"); break; } rtgui_dc_draw_text(dc, line, &rect); rtgui_dc_end_drawing(dc); rtgui_free(line); }
rtgui_thread_t* rtgui_thread_register(rt_thread_t tid, rt_mq_t mq) { rtgui_thread_t* thread = rtgui_malloc(sizeof(struct rtgui_thread)); if (thread != RT_NULL) { DBG_MSG(("register a rtgui thread: %s, tid: 0x%p\n", tid->name, tid)); /* set tid and mq */ thread->tid = tid; thread->mq = mq; thread->widget = RT_NULL; thread->on_idle = RT_NULL; /* set user thread */ tid->user_data = (rt_uint32_t)thread; } return thread; }
/* 打开列表视图用的按钮触发函数 */ static void open_btn_onbutton(rtgui_widget_t* widget, struct rtgui_event* event) { rtgui_rect_t rect; rt_uint32_t index; /* 获得顶层的workbench */ workbench = RTGUI_WORKBENCH(rtgui_widget_get_toplevel(widget)); rtgui_widget_get_rect(RTGUI_WIDGET(workbench), &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); /* 在workbench中添加相应的视图 */ rtgui_workbench_add_view(workbench, RTGUI_VIEW(_view)); /* 模式显示视图 */ rtgui_view_show(RTGUI_VIEW(_view), RT_TRUE); rtgui_view_destroy(RTGUI_VIEW(_view)); _view = RT_NULL; }
static rt_bool_t rtgui_filelist_view_on_folder_item(rtgui_object_t *object, struct rtgui_event *event) { rtgui_win_t *menu; rtgui_listbox_t *listbox; rtgui_filelist_view_t *view; listbox = RTGUI_LISTBOX(object); menu = RTGUI_WIN(rtgui_widget_get_toplevel(RTGUI_WIDGET(object))); view = RTGUI_FILELIST_VIEW(menu->user_data); /* hide window */ rtgui_win_hide(menu); switch (listbox->current_item) { case 0: { char *dir_ptr; /* destroy menu window */ rtgui_win_destroy(menu); dir_ptr = (char *) rtgui_malloc(256); rtgui_filelist_view_get_fullpath(view, dir_ptr, 256); rtgui_filelist_view_set_directory(view, dir_ptr); rtgui_free(dir_ptr); } break; case 1: /* destroy menu window */ rtgui_win_destroy(menu); break; default: /* destroy menu window */ rtgui_win_destroy(menu); break; } return RT_TRUE; }
struct rtgui_filerw* rtgui_filerw_create_mem(const rt_uint8_t* mem, rt_size_t size) { struct rtgui_filerw_mem* rw; RT_ASSERT(mem != RT_NULL); rw = (struct rtgui_filerw_mem*) rtgui_malloc(sizeof(struct rtgui_filerw_mem)); if (rw != RT_NULL) { rw->parent.seek = mem_seek; rw->parent.read = mem_read; rw->parent.write = mem_write; rw->parent.tell = mem_tell; rw->parent.eof = mem_eof; rw->parent.close = mem_close; rw->mem_base = mem; rw->mem_position = mem; rw->mem_end = mem + size; } return &(rw->parent); }
static void _handle_app_create(struct rtgui_event_application* event) { rt_uint32_t index; rt_int32_t status; struct rtgui_app* app; status = RTGUI_STATUS_OK; for (index = 0; index < app_count; index ++) { app = (struct rtgui_app*)app_items[index].app; if (app == event->app) { /* application is created already */ status = RTGUI_STATUS_ERROR; goto __exit; } } app_count += 1; if (app_items == RT_NULL) app_items = (struct rtgui_application_item*) rtgui_malloc(sizeof(struct rtgui_application_item)); else app_items = (struct rtgui_application_item*) rtgui_realloc(app_items, sizeof(struct rtgui_application_item) * app_count); if (app_items == RT_NULL) { status = RTGUI_STATUS_ERROR; goto __exit; } app = event->app; app_items[app_count - 1].app = app; rtgui_listctrl_set_items(app_list, (rt_uint32_t)app_items, app_count); __exit: /* send ack to the application */ rtgui_ack(RTGUI_EVENT(event), status); return; }
/* set textbox text */ void rtgui_textbox_set_value(rtgui_textbox_t* box, const char* text) { if(box->text != RT_NULL) {/* yet exist something */ /* free the old text */ rtgui_free(box->text); box->text = RT_NULL; } /* no something */ box->line_length = ((rt_strlen(text)+1)/RTGUI_TEXTBOX_LINE_MAX+1)*RTGUI_TEXTBOX_LINE_MAX; /* allocate line buffer */ box->text = rtgui_malloc(box->line_length); rt_memset(box->text, 0, box->line_length); /* copy text */ rt_memcpy(box->text, text, rt_strlen(text) + 1); /* set current position */ box->position = rt_strlen(text); }