void get_scaled_rect(rect_t *rc_tvsrc, rect_t *rc_icon)
{
double scale;
u16 half_width, half_height;
u16 full_width, full_height;
s16 offset;
u16 width, height;
scale = g_zoom_scale[g_zoom_curn];
full_width = (u16)(ZOOM_BOUND_W / scale);
full_height = (u16)(ZOOM_BOUND_H / scale);
half_width = full_width / 2;
half_height = full_height / 2;
if(g_zoom_center.x < half_width)
{
g_zoom_center.x = half_width;
}
if(g_zoom_center.x > ZOOM_BOUND_W - half_width)
{
g_zoom_center.x = ZOOM_BOUND_W - half_width;
}
if(g_zoom_center.y < half_height)
{
g_zoom_center.y = half_height;
}
if(g_zoom_center.y > ZOOM_BOUND_H - half_height)
{
g_zoom_center.y = ZOOM_BOUND_H - half_height;
}
rc_icon->left = ZOOM_BOUND_X + (g_zoom_center.x - half_width);
rc_icon->top = ZOOM_BOUND_Y + (g_zoom_center.y - half_height);
rc_icon->right = rc_icon->left + full_width;
rc_icon->bottom = rc_icon->top + full_height;
offset = (ZOOM_BOUND_X + ZOOM_BOUND_W) - rc_icon->right;
if(offset < 0)
{
offset_rect(rc_icon, offset, 0);
}
offset = (ZOOM_BOUND_Y + ZOOM_BOUND_H) - rc_icon->bottom;
if(offset < 0)
{
offset_rect(rc_icon, 0, offset);
}
width = g_tvsrc_fullrc.right - g_tvsrc_fullrc.left + 1;
height = g_tvsrc_fullrc.bottom - g_tvsrc_fullrc.top + 1;
rc_tvsrc->left = g_tvsrc_fullrc.left + (rc_icon->left - ZOOM_BOUND_X) * width / ZOOM_BOUND_W;
rc_tvsrc->top = g_tvsrc_fullrc.top + (rc_icon->top - ZOOM_BOUND_Y) * height / ZOOM_BOUND_H;
rc_tvsrc->right = (full_width * width / ZOOM_BOUND_W) + rc_tvsrc->left - 1;
rc_tvsrc->bottom = (full_height * height / ZOOM_BOUND_H) + rc_tvsrc->top - 1;
}
BOOL intersect_vis_rectangles( struct bitblt_coords *dst, struct bitblt_coords *src )
{
RECT rect;
/* intersect the rectangles */
if ((src->width == dst->width) && (src->height == dst->height)) /* no stretching */
{
offset_rect( &src->visrect, dst->x - src->x, dst->y - src->y );
if (!intersect_rect( &rect, &src->visrect, &dst->visrect )) return FALSE;
src->visrect = dst->visrect = rect;
offset_rect( &src->visrect, src->x - dst->x, src->y - dst->y );
}
else /* stretching */
{
/* map source rectangle into destination coordinates */
rect = src->visrect;
offset_rect( &rect, -min( src->x, src->x + src->width + 1),
-min( src->y, src->y + src->height + 1) );
rect.left = dst->x + rect.left * dst->width / abs(src->width);
rect.top = dst->y + rect.top * dst->height / abs(src->height);
rect.right = dst->x + rect.right * dst->width / abs(src->width);
rect.bottom = dst->y + rect.bottom * dst->height / abs(src->height);
if (rect.left > rect.right) swap_ints( &rect.left, &rect.right );
if (rect.top > rect.bottom) swap_ints( &rect.top, &rect.bottom );
/* avoid rounding errors */
rect.left--;
rect.top--;
rect.right++;
rect.bottom++;
if (!intersect_rect( &dst->visrect, &rect, &dst->visrect )) return FALSE;
/* map destination rectangle back to source coordinates */
rect = dst->visrect;
offset_rect( &rect, -min( dst->x, dst->x + dst->width + 1),
-min( dst->y, dst->y + dst->height + 1) );
rect.left = src->x + rect.left * src->width / abs(dst->width);
rect.top = src->y + rect.top * src->height / abs(dst->height);
rect.right = src->x + rect.right * src->width / abs(dst->width);
rect.bottom = src->y + rect.bottom * src->height / abs(dst->height);
if (rect.left > rect.right) swap_ints( &rect.left, &rect.right );
if (rect.top > rect.bottom) swap_ints( &rect.top, &rect.bottom );
/* avoid rounding errors */
rect.left--;
rect.top--;
rect.right++;
rect.bottom++;
if (!intersect_rect( &src->visrect, &rect, &src->visrect )) return FALSE;
}
return TRUE;
}
/*!
offsets the region.
*/
void gdi_offset_cliprgn(cliprgn_t *p_rgn, s16 x, s16 y)
{
cliprc_t *p_crc = p_rgn->p_head;
while(p_crc != NULL)
{
offset_rect(&p_crc->rc, x, y);
p_crc = p_crc->p_next;
}
if(NULL != (p_rgn->p_head))
{
offset_rect(&p_rgn->bound, x, y);
}
}
DWORD convert_bitmapinfo( const BITMAPINFO *src_info, void *src_bits, struct bitblt_coords *src,
const BITMAPINFO *dst_info, void *dst_bits )
{
dib_info src_dib, dst_dib;
DWORD ret;
init_dib_info_from_bitmapinfo( &src_dib, src_info, src_bits );
init_dib_info_from_bitmapinfo( &dst_dib, dst_info, dst_bits );
__TRY
{
dst_dib.funcs->convert_to( &dst_dib, &src_dib, &src->visrect, FALSE );
ret = TRUE;
}
__EXCEPT_PAGE_FAULT
{
WARN( "invalid bits pointer %p\n", src_bits );
ret = FALSE;
}
__ENDTRY
if(!ret) return ERROR_BAD_FORMAT;
/* update coordinates, the destination rectangle is always stored at 0,0 */
src->x -= src->visrect.left;
src->y -= src->visrect.top;
offset_rect( &src->visrect, -src->visrect.left, -src->visrect.top );
return ERROR_SUCCESS;
}
void button::draw(sdl_surface & screen)
{
surface_region & reg = m_hot ? m_res.bg_hot : m_res.bg;
SDL_BlitSurface(reg.surface, ®.src, screen, &m_pos);
rect fg_dst = offset_rect(m_pos, point(7,8));
SDL_BlitSurface(m_res.fg.surface, &m_res.fg.src, screen, &fg_dst);
}
static void recalc_children_invrgn(control_t *p_ctrl,
BOOL is_add,
const rect_t *p_rc_in_parent)
{
rect_t rc_client, rc_frame, rc_parent;
while(p_ctrl != NULL)
{
if(p_ctrl->attr != OBJ_ATTR_HIDDEN)
{
rc_parent = *p_rc_in_parent;
ctrl_get_frame(p_ctrl, &rc_frame);
if(intersect_rect(&rc_parent, &rc_parent, &rc_frame))
{
offset_rect(&rc_parent, (s16)(0 - p_ctrl->frame.left),
(s16)(0 - p_ctrl->frame.top));
ctrl_get_client_rect(p_ctrl, &rc_client);
update_invrgn_by_rect(&p_ctrl->invrgn_info,
is_add,
&rc_parent,
&rc_client);
if(p_ctrl->p_child != NULL)
{
recalc_children_invrgn(p_ctrl->p_child, is_add, &rc_parent);
}
}
}
p_ctrl = p_ctrl->p_next;
}
}
void ui_config_normal_osd(void)
{
rect_t rc_scr =
{ 0, 0,
SCREEN_WIDTH,
SCREEN_HEIGHT };
s16 x, y;
disp_sys_t video_std = 0;
video_std = avc_get_video_mode_1(class_get_handle_by_id(AVC_CLASS_ID));
switch (video_std)
{
case VID_SYS_NTSC_J:
case VID_SYS_NTSC_M:
case VID_SYS_NTSC_443:
case VID_SYS_PAL_M:
x = SCREEN_POS_NTSC_L;
y = SCREEN_POS_NTSC_T;
break;
default:
x = SCREEN_POS_PAL_L;
y = SCREEN_POS_PAL_T;
}
offset_rect(&rc_scr, x, y);
_config_osd(&rc_scr);
}
void dibdrv_set_window_surface( DC *dc, struct window_surface *surface )
{
char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
BITMAPINFO *info = (BITMAPINFO *)buffer;
RECT rect;
void *bits;
PHYSDEV windev;
struct windrv_physdev *physdev;
struct dibdrv_physdev *dibdrv;
TRACE( "%p %p\n", dc->hSelf, surface );
windev = pop_dc_driver( dc, &window_driver );
if (surface)
{
if (windev) push_dc_driver( &dc->physDev, windev, windev->funcs );
else
{
if (!window_driver.pCreateDC( &dc->physDev, NULL, NULL, NULL, NULL )) return;
windev = find_dc_driver( dc, &window_driver );
}
physdev = get_windrv_physdev( windev );
window_surface_add_ref( surface );
if (physdev->surface) window_surface_release( physdev->surface );
physdev->surface = surface;
dibdrv = physdev->dibdrv;
bits = surface->funcs->get_info( surface, info );
init_dib_info_from_bitmapinfo( &dibdrv->dib, info, bits );
/* clip the device rect to the surface */
rect = surface->rect;
offset_rect( &rect, dc->device_rect.left, dc->device_rect.top );
intersect_rect( &dc->device_rect, &dc->device_rect, &rect );
dibdrv->dib.rect = dc->vis_rect;
offset_rect( &dibdrv->dib.rect, -rect.left, -rect.top );
dibdrv->bounds = surface->funcs->get_bounds( surface );
DC_InitDC( dc );
}
else if (windev)
{
dib_driver.pDeleteDC( pop_dc_driver( dc, &dib_driver ));
windev->funcs->pDeleteDC( windev );
DC_InitDC( dc );
}
}
gboolean cw_picture_window_draw(GtkWidget *widget,
cairo_t *cr,
gpointer user_data)
{
CWPictureWindowPrivate* priv = CW_PICTURE_WINDOW_GET_PRIVATE(widget);
if (NULL == priv || NULL == priv->store_item)
return TRUE;
GdkRectangle window_rect = {
0,
0,
gtk_widget_get_allocated_width(widget),
gtk_widget_get_allocated_height(widget)
};
int pw, ph;
cw_store_item_get_image_size(priv->store_item, &pw, &ph);
GdkRectangle image_rect = { 0, 0, pw, ph};
double scale = site_picture_rect(&window_rect, &image_rect);
GdkRectangle shadow_rect;
calc_shadow_rect(&image_rect, &shadow_rect);
offset_rect(&shadow_rect,
get_image_shadow_offset_x(),
get_image_shadow_offset_y());
draw_shadow_rgba(cr, shadow_rect, get_image_shadow_radius(), SHADOW_TRANSPARENT);
cairo_rectangle(
cr, image_rect.x, image_rect.y,
image_rect.width,
image_rect.height);
cairo_set_source_rgba(cr, 1, 1, 1, 1);
cairo_fill(cr);
offset_rect(&image_rect, get_image_border_size(), get_image_border_size());
cairo_translate(cr, image_rect.x, image_rect.y);
cairo_scale(cr, scale, scale);
gdk_cairo_set_source_pixbuf(cr,
cw_store_item_get_pixbuf(priv->store_item), 0, 0);
cairo_paint(cr);
return TRUE;
}
void
RoomContainer::_DrawSearchMap(GFX::rect visibleArea)
{
if ((fSearchMap != NULL && fDrawSearchMap > 0)) {
GFX::rect destRect(0, AreaRect().h - fSearchMap->Height(),
AreaRect().w, AreaRect().h);
GraphicsEngine::Get()->BlitToScreen(fSearchMap, NULL, &destRect);
visibleArea.x /= fMapHorizontalRatio;
visibleArea.y /= fMapVerticalRatio;
visibleArea.w /= fMapHorizontalRatio;
visibleArea.h /= fMapVerticalRatio;
visibleArea = offset_rect(visibleArea, 0, AreaRect().h - fSearchMap->Height());
GraphicsEngine::Get()->ScreenBitmap()->StrokeRect(visibleArea, 500);
}
}
DWORD convert_bitmapinfo( const BITMAPINFO *src_info, void *src_bits, struct bitblt_coords *src,
const BITMAPINFO *dst_info, void *dst_bits, BOOL add_alpha )
{
dib_info src_dib, dst_dib;
DWORD ret;
if ( !init_dib_info_from_bitmapinfo( &src_dib, src_info, src_bits, 0 ) )
return ERROR_BAD_FORMAT;
if ( !init_dib_info_from_bitmapinfo( &dst_dib, dst_info, dst_bits, 0 ) )
return ERROR_BAD_FORMAT;
__TRY
{
dst_dib.funcs->convert_to( &dst_dib, &src_dib, &src->visrect );
ret = TRUE;
}
__EXCEPT_PAGE_FAULT
{
WARN( "invalid bits pointer %p\n", src_bits );
ret = FALSE;
}
__ENDTRY
/* We shared the color tables, so there's no need to free the dib_infos here */
if(!ret) return ERROR_BAD_FORMAT;
/* update coordinates, the destination rectangle is always stored at 0,0 */
src->x -= src->visrect.left;
src->y -= src->visrect.top;
offset_rect( &src->visrect, -src->visrect.left, -src->visrect.top );
if (add_alpha && dst_dib.funcs == &funcs_8888 && src_dib.funcs != &funcs_8888)
{
DWORD *pixel = dst_dib.bits.ptr;
int x, y;
for (y = src->visrect.top; y < src->visrect.bottom; y++, pixel += dst_dib.stride / 4)
for (x = src->visrect.left; x < src->visrect.right; x++)
pixel[x] |= 0xff000000;
}
return ERROR_SUCCESS;
}
void add_clipped_bounds( dibdrv_physdev *dev, const RECT *rect, HRGN clip )
{
const WINEREGION *region;
RECT rc;
if (!dev->bounds) return;
if (clip)
{
if (!(region = get_wine_region( clip ))) return;
if (!rect) rc = region->extents;
else intersect_rect( &rc, rect, ®ion->extents );
release_wine_region( clip );
}
else rc = *rect;
if (is_rect_empty( &rc )) return;
offset_rect( &rc, dev->dib.rect.left, dev->dib.rect.top );
add_bounds_rect( dev->bounds, &rc );
}
void
RoomContainer::DrawObject(const Bitmap* bitmap, const IE::point& point, bool mask)
{
if (bitmap == NULL)
return;
IE::point leftTop = offset_point(point,
-(bitmap->Frame().x + bitmap->Frame().w / 2),
-(bitmap->Frame().y + bitmap->Frame().h / 2));
GFX::rect rect(leftTop.x, leftTop.y, bitmap->Width(), bitmap->Height());
if (rects_intersect(fMapArea, rect)) {
GFX::rect offsetRect = offset_rect(rect, -fAreaOffset.x, -fAreaOffset.y);
if (mask)
GraphicsEngine::BlitBitmapWithMask(bitmap, NULL,
fBackMap->Image(), &offsetRect, fBlitMask, &rect);
else
GraphicsEngine::BlitBitmap(bitmap, NULL, fBackMap->Image(), &offsetRect);
}
}
BOOL nulldrv_GradientFill( PHYSDEV dev, TRIVERTEX *vert_array, ULONG nvert,
void * grad_array, ULONG ngrad, ULONG mode )
{
DC *dc = get_nulldrv_dc( dev );
char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
BITMAPINFO *info = (BITMAPINFO *)buffer;
struct bitblt_coords src, dst;
struct gdi_image_bits bits;
unsigned int i;
POINT *pts;
BOOL ret = FALSE;
DWORD err;
HRGN rgn;
if (!(pts = HeapAlloc( GetProcessHeap(), 0, nvert * sizeof(*pts) ))) return FALSE;
for (i = 0; i < nvert; i++)
{
pts[i].x = vert_array[i].x;
pts[i].y = vert_array[i].y;
}
LPtoDP( dev->hdc, pts, nvert );
/* compute bounding rect of all the rectangles/triangles */
reset_bounds( &dst.visrect );
for (i = 0; i < ngrad * (mode == GRADIENT_FILL_TRIANGLE ? 3 : 2); i++)
{
ULONG v = ((ULONG *)grad_array)[i];
dst.visrect.left = min( dst.visrect.left, pts[v].x );
dst.visrect.top = min( dst.visrect.top, pts[v].y );
dst.visrect.right = max( dst.visrect.right, pts[v].x );
dst.visrect.bottom = max( dst.visrect.bottom, pts[v].y );
}
dst.x = dst.visrect.left;
dst.y = dst.visrect.top;
dst.width = dst.visrect.right - dst.visrect.left;
dst.height = dst.visrect.bottom - dst.visrect.top;
if (!clip_visrect( dc, &dst.visrect, &dst.visrect )) goto done;
/* query the bitmap format */
info->bmiHeader.biSize = sizeof(info->bmiHeader);
info->bmiHeader.biPlanes = 1;
info->bmiHeader.biBitCount = 0;
info->bmiHeader.biCompression = BI_RGB;
info->bmiHeader.biXPelsPerMeter = 0;
info->bmiHeader.biYPelsPerMeter = 0;
info->bmiHeader.biClrUsed = 0;
info->bmiHeader.biClrImportant = 0;
info->bmiHeader.biWidth = dst.visrect.right - dst.visrect.left;
info->bmiHeader.biHeight = dst.visrect.bottom - dst.visrect.top;
info->bmiHeader.biSizeImage = 0;
dev = GET_DC_PHYSDEV( dc, pPutImage );
err = dev->funcs->pPutImage( dev, 0, info, NULL, NULL, NULL, 0 );
if (err && err != ERROR_BAD_FORMAT) goto done;
info->bmiHeader.biSizeImage = get_dib_image_size( info );
if (!(bits.ptr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage )))
goto done;
bits.is_copy = TRUE;
bits.free = free_heap_bits;
/* make src and points relative to the bitmap */
src = dst;
src.x -= dst.visrect.left;
src.y -= dst.visrect.top;
offset_rect( &src.visrect, -dst.visrect.left, -dst.visrect.top );
for (i = 0; i < nvert; i++)
{
pts[i].x -= dst.visrect.left;
pts[i].y -= dst.visrect.top;
}
rgn = CreateRectRgn( 0, 0, 0, 0 );
gradient_bitmapinfo( info, bits.ptr, vert_array, nvert, grad_array, ngrad, mode, pts, rgn );
OffsetRgn( rgn, dst.visrect.left, dst.visrect.top );
ret = !dev->funcs->pPutImage( dev, rgn, info, &bits, &src, &dst, SRCCOPY );
if (bits.free) bits.free( &bits );
DeleteObject( rgn );
done:
HeapFree( GetProcessHeap(), 0, pts );
return ret;
}
static BOOL news_update_pic()
{
news_t *p_news = NULL;
mul_pic_param_t pic_param = {{0},};
u8 i;
control_t *p_icont = NULL, *p_item = NULL, *p_page_cont = NULL, *p_page_title = NULL,
*p_text = NULL, *p_cont = NULL, *p_page = NULL, *p_help = NULL;
u16 curn_page = 0, total_page = 0;
u32 total_vod = 0;
//u8 i = 0;
p_news = ui_news_get_news();
total_vod = p_news->count;
p_cont = fw_find_root_by_id(ROOT_ID_NEWS_TITLE);
if(p_news == NULL)
{
return ERR_FAILURE;
}
g_news_load_curn = 0;
for(; g_news_load_curn < NEWS_ITEM_PAGE && g_show_curn + g_news_load_curn < p_news->count;
g_news_load_curn ++)
{
if(p_news->p_item[g_show_curn + g_news_load_curn].media_content.p_url == NULL)
{
continue;
}
ui_pic_set_url((u8*)p_news->p_item[g_show_curn + g_news_load_curn].media_content.p_url);
pic_param.anim = REND_ANIM_NONE;
pic_param.style = REND_STYLE_CENTER;
pic_param.flip = PIC_NO_F_NO_R;
pic_param.win_rect.left = NEWS_ITEM_PREWX;
pic_param.win_rect.top = NEWS_ITEM_PREWY;
pic_param.win_rect.right = (pic_param.win_rect.left + NEWS_ITEM_PREWW);
pic_param.win_rect.bottom = (pic_param.win_rect.top + NEWS_ITEM_PREWH);
pic_param.file_size = 0;
pic_param.handle = 0;
offset_rect(&pic_param.win_rect, NEWS_ITEM_X, (s16)(NEWS_ITEM_Y + g_news_load_curn * (NEWS_ITEM_H + NEWS_VGAP)));
offset_rect(&pic_param.win_rect, NEWS_ICONT_X, NEWS_ICONT_Y);
offset_rect(&pic_param.win_rect, NEWS_CONT_X, NEWS_CONT_Y);
pic_start(&pic_param);
break;
}
for(i = 0;
i < NEWS_ITEM_PAGE && g_show_curn + i < p_news->count;
i ++ )
{
//set text
p_icont = ctrl_get_child_by_id(p_cont, IDC_NEWS_ICONT);
p_item = ctrl_get_child_by_id(p_icont, IDC_NEWS_ITEM1 + i);
p_text = ctrl_get_child_by_id(p_item, IDC_NEWS_ITEM_TEXT);
if(p_news->p_item[g_show_curn + i].p_title != NULL)
{
text_set_content_by_ascstr(p_text, (u8*)p_news->p_item[g_show_curn + i].p_title);
}
else
{
text_set_content_by_ascstr(p_text, (u8*)"No content.");
}
ctrl_paint_ctrl(p_icont, TRUE);
}
//update item text.
p_page_cont = ctrl_get_child_by_id(p_cont, IDC_NEWS_TITLE_CONT);
p_page_title = ctrl_get_child_by_id(p_page_cont, IDC_NEWS_TITLE);
p_page = ctrl_get_child_by_id(p_page_title, IDC_NEWS_PAGE_NUM);
curn_page = g_show_curn / NEWS_ITEM_PAGE + 1;
if(total_vod != 0&&total_vod % NEWS_ITEM_PAGE == 0)
{
total_page = (u16)(total_vod / NEWS_ITEM_PAGE);
}
else
{
total_page = (u16)(total_vod / NEWS_ITEM_PAGE + 1);
}
news_update_page_num(p_page, curn_page, total_page);
ctrl_paint_ctrl(p_page, TRUE);
p_help = ctrl_get_child_by_id(p_cont, IDC_COMM_HELP_CONT);
ctrl_destroy_ctrl(p_help);
ui_comm_help_create_net(&help_data, p_cont);
//ui_comm_help_move_pos(p_cont, 100, 40, 880, 0, 40);
ui_comm_help_move_pos(p_cont, 100, (u16)-60, 880, 0, 40);
//ctrl_add_rect_to_invrgn(p_help, NULL);
g_news_load_curn ++;
return SUCCESS;
}
static RET_CODE news_draw_end(control_t *p_cont, u16 msg, u32 para1, u32 para2)
{
news_t *p_news = NULL;
mul_pic_param_t pic_param = {{0},};
control_t *p_icont = NULL, *p_item = NULL, *p_bmp = NULL;
p_icont = ctrl_get_child_by_id(p_cont, IDC_NEWS_ICONT);
p_item = ctrl_get_child_by_id(p_icont, (u16)(IDC_NEWS_ITEM1 + para1));
p_bmp = ctrl_get_child_by_id(p_item, IDC_NEWS_ITEM_BMP);
if(fw_get_focus_id() != ROOT_ID_NEWS_TITLE)
{
return ERR_FAILURE;
}
p_news = ui_news_get_news();
if(p_news == NULL)
{
return ERR_FAILURE;
}
if(para1 > p_news->count)
{
return ERR_FAILURE;
}
if((para1 + 1) >= p_news->count)
{
return ERR_FAILURE;
}
if(g_news_load_curn >= NEWS_ITEM_PAGE)
{
return ERR_FAILURE;
}
if(g_news_load_curn >= p_news->count)
{
return ERR_FAILURE;
}
for(; g_news_load_curn < NEWS_ITEM_PAGE && g_show_curn + g_news_load_curn < p_news->count;
g_news_load_curn ++)
{
if(p_news->p_item[g_show_curn + g_news_load_curn].media_content.p_url == NULL)
{
continue;
}
pic_stop();
ui_pic_set_url((u8*)p_news->p_item[g_news_load_curn +g_show_curn ].media_content.p_url);
OS_PRINTF("pic url = [%s]\n",p_news->p_item[g_show_curn + g_news_load_curn].media_content.p_url);
pic_param.anim = REND_ANIM_NONE;
pic_param.style = REND_STYLE_CENTER;
pic_param.flip = PIC_NO_F_NO_R;
pic_param.win_rect.left = NEWS_ITEM_PREWX;
pic_param.win_rect.top = NEWS_ITEM_PREWY;
pic_param.win_rect.right = (pic_param.win_rect.left + NEWS_ITEM_PREWW);
pic_param.win_rect.bottom = (pic_param.win_rect.top + NEWS_ITEM_PREWH);
pic_param.file_size = 0;
pic_param.handle = para1 + 1;
offset_rect(&pic_param.win_rect, NEWS_ITEM_X, (u16)(NEWS_ITEM_Y + g_news_load_curn * (NEWS_ITEM_H + NEWS_VGAP)));
offset_rect(&pic_param.win_rect, NEWS_ICONT_X, NEWS_ICONT_Y);
offset_rect(&pic_param.win_rect, NEWS_CONT_X, NEWS_CONT_Y);
bmap_set_content_by_id(p_bmp, RSC_INVALID_ID);
ctrl_paint_ctrl(p_item, TRUE);
pic_start(&pic_param);
break;
}
g_news_load_curn ++;
return SUCCESS;
}
void
RoomContainer::Draw(Bitmap *surface)
{
GraphicsEngine* gfx = GraphicsEngine::Get();
if (fWorldMap != NULL) {
GFX::rect sourceRect = offset_rect(fViewPort,
-fViewPort.x, -fViewPort.y);
sourceRect = offset_rect(sourceRect, fAreaOffset.x, fAreaOffset.y);
if (sourceRect.w < gfx->ScreenFrame().w || sourceRect.h < gfx->ScreenFrame().h) {
GFX::rect clippingRect = fViewPort;
clippingRect.w = gfx->ScreenFrame().w;
clippingRect.h = gfx->ScreenFrame().h;
gfx->SetClipping(&clippingRect);
gfx->ScreenBitmap()->Clear(0);
gfx->SetClipping(NULL);
}
gfx->BlitToScreen(fWorldMapBitmap, &sourceRect, &fViewPort);
} else {
if (sSelectedActorRadius > 22) {
sSelectedActorRadiusStep = -1;
} else if (sSelectedActorRadius < 18) {
sSelectedActorRadiusStep = 1;
}
sSelectedActorRadius += sSelectedActorRadiusStep;
GFX::rect mapRect = offset_rect_to(fViewPort,
fAreaOffset.x, fAreaOffset.y);
bool paused = Core::Get()->IsPaused();
if (!paused) {
assert(fBackMap != NULL);
fBackMap->Update(mapRect);
}
if (fDrawAnimations) {
Timer* timer = Timer::Get("ANIMATIONS");
bool advance = timer != NULL && timer->Expired() && !paused;
_DrawAnimations(advance);
}
_DrawActors();
if (fDrawPolygons) {
fBackMap->Image()->Lock();
for (uint32 p = 0; p < fWed->CountPolygons(); p++) {
const Polygon* poly = fWed->PolygonAt(p);
if (poly != NULL && poly->CountPoints() > 0) {
if (rects_intersect(poly->Frame(), mapRect)) {
uint32 color = 0;
if (poly->Flags() & IE::POLY_SHADE_WALL)
color = 200;
else if (poly->Flags() & IE::POLY_HOVERING)
color = 500;
else if (poly->Flags() & IE::POLY_COVER_ANIMATIONS)
color = 1000;
fBackMap->Image()->FillPolygon(*poly, color,
-fAreaOffset.x, -fAreaOffset.y);
fBackMap->Image()->StrokePolygon(*poly, color,
-fAreaOffset.x, -fAreaOffset.y);
}
}
}
fBackMap->Image()->Unlock();
}
// TODO: handle this better
if (Door* door = dynamic_cast<Door*>(fMouseOverObject.Target())) {
GFX::rect rect = rect_to_gfx_rect(door->Frame());
rect = offset_rect(rect, -mapRect.x, -mapRect.y);
fBackMap->Image()->Lock();
fBackMap->Image()->StrokeRect(rect, 70);
fBackMap->Image()->Unlock();
} else if (Actor* actor = dynamic_cast<Actor*>(fMouseOverObject.Target())) {
try {
GFX::rect rect = rect_to_gfx_rect(actor->Frame());
rect = offset_rect(rect, -mapRect.x, -mapRect.y);
fBackMap->Image()->Lock();
IE::point position = offset_point(actor->Position(), -mapRect.x, -mapRect.y);
uint32 color = fBackMap->Image()->MapColor(255, 255, 255);
fBackMap->Image()->StrokeCircle(position.x, position.y, 20, color);
fBackMap->Image()->Unlock();
} catch (const char* string) {
std::cerr << string << std::endl;
} catch (...) {
}
} else if (Region* region = dynamic_cast<Region*>(fMouseOverObject.Target())) {
GFX::rect rect = rect_to_gfx_rect(region->Frame());
rect = offset_rect(rect, -mapRect.x, -mapRect.y);
uint32 color = 0;
switch (region->Type()) {
case IE::REGION_TYPE_TRAVEL:
color = fBackMap->Image()->MapColor(0, 125, 0);
break;
case IE::REGION_TYPE_TRIGGER:
color = fBackMap->Image()->MapColor(125, 0, 0);
break;
default:
color = fBackMap->Image()->MapColor(255, 255, 255);
break;
}
fBackMap->Image()->Lock();
if (region->Polygon().CountPoints() > 2) {
fBackMap->Image()->StrokePolygon(region->Polygon(), color,
-mapRect.x, -mapRect.y);
} else
fBackMap->Image()->StrokeRect(rect, color);
fBackMap->Image()->Unlock();
} else if (Container* container = dynamic_cast<Container*>(fMouseOverObject.Target())) {
uint32 color = 0;
color = fBackMap->Image()->MapColor(0, 125, 0);
// TODO: Different colors for trapped/nontrapped
fBackMap->Image()->Lock();
if (container->Polygon().CountPoints() > 2) {
fBackMap->Image()->StrokePolygon(container->Polygon(), color,
-mapRect.x, -mapRect.y);
}
fBackMap->Image()->Unlock();
}
gfx->BlitToScreen(fBackMap->Image(), NULL, &fViewPort);
_DrawSearchMap(mapRect);
}
}
/* return the DC device rectangle if not empty */
static inline BOOL get_dc_device_rect( DC *dc, RECT *rect )
{
*rect = dc->device_rect;
offset_rect( rect, -dc->vis_rect.left, -dc->vis_rect.top );
return !is_rect_empty( rect );
}
static RET_CODE news_success(control_t *p_cont, u16 msg, u32 para1, u32 para2)
{
control_t *p_icont = NULL, *p_item = NULL, *p_text = NULL, *p_page_cont = NULL, *p_page_title = NULL, *p_page = NULL;
news_t *p_news = NULL;
mul_pic_param_t pic_param = {{0},};
u16 curn_page = 0, total_page = 0;
u32 total_vod = 0;
u16 i = 0;
OS_PRINTF("@# news_success\n");
if(fw_get_focus_id() != ROOT_ID_NEWS_TITLE)
{
return ERR_FAILURE;
}
if(para1 != NEWS_EVT_GET_NEWS)
{
return ERR_FAILURE;
}
p_news =(news_t *)para2;
total_vod = p_news->count;
if(p_news == NULL)
{
return ERR_FAILURE;
}
if(p_news->count == 0)
{
return ERR_FAILURE;
}
//request picture.
for(g_news_load_curn = 0;
g_news_load_curn < NEWS_ITEM_PAGE && g_show_curn + g_news_load_curn < p_news->count;
g_news_load_curn ++)
{
if(p_news->p_item[g_show_curn + g_news_load_curn].media_content.p_url == NULL)
{
continue;
}
//OS_PRINTF("pic url = [%s]\n",p_news->p_item[g_show_curn + g_news_load_curn].media_content.p_url);
ui_pic_set_url((u8*)p_news->p_item[g_show_curn + g_news_load_curn].media_content.p_url);
pic_param.anim = REND_ANIM_NONE;
pic_param.style = REND_STYLE_CENTER;
pic_param.flip = PIC_NO_F_NO_R;
pic_param.win_rect.left = NEWS_ITEM_PREWX;
pic_param.win_rect.top = NEWS_ITEM_PREWY;
pic_param.win_rect.right = (pic_param.win_rect.left + NEWS_ITEM_PREWW);
pic_param.win_rect.bottom = (pic_param.win_rect.top + NEWS_ITEM_PREWH);
pic_param.file_size = 0;
pic_param.handle = 0;
offset_rect(&pic_param.win_rect, NEWS_ITEM_X, (s16)(NEWS_ITEM_Y + g_news_load_curn * (NEWS_ITEM_H + NEWS_VGAP)));
offset_rect(&pic_param.win_rect, NEWS_ICONT_X, NEWS_ICONT_Y);
offset_rect(&pic_param.win_rect, NEWS_CONT_X, NEWS_CONT_Y);
pic_start(&pic_param);
break;
}
for(i = 0;
i < NEWS_ITEM_PAGE && g_show_curn + i < p_news->count;
i ++ )
{
//set text
p_icont = ctrl_get_child_by_id(p_cont, IDC_NEWS_ICONT);
p_item = ctrl_get_child_by_id(p_icont, IDC_NEWS_ITEM1 + i);
p_text = ctrl_get_child_by_id(p_item, IDC_NEWS_ITEM_TEXT);
if(p_news->p_item[g_show_curn + i].p_title != NULL)
{
text_set_content_by_ascstr(p_text, (u8*)p_news->p_item[g_show_curn + i].p_title);
}
else
{
text_set_content_by_ascstr(p_text, (u8*)"No content.");
}
}
//update item text.
p_page_cont = ctrl_get_child_by_id(p_cont, IDC_NEWS_TITLE_CONT);
p_page_title = ctrl_get_child_by_id(p_page_cont, IDC_NEWS_TITLE);
p_page = ctrl_get_child_by_id(p_page_title, IDC_NEWS_PAGE_NUM);
curn_page = g_show_curn / NEWS_ITEM_PAGE + 1;
if(total_vod != 0&&total_vod % NEWS_ITEM_PAGE == 0)
{
total_page = (u16)(total_vod / NEWS_ITEM_PAGE);
}
else
{
total_page = (u16)(total_vod / NEWS_ITEM_PAGE + 1);
}
news_update_page_num(p_page, curn_page, total_page);
ctrl_paint_ctrl(ctrl_get_parent(p_item), TRUE);
ctrl_paint_ctrl(p_page_title, TRUE);
g_news_load_curn ++;
return SUCCESS;
}
