void
acfilter(int width, int height)
{
glClear(GL_COLOR_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);
glMatrixMode(GL_TEXTURE);
if (pause) {
draw_rect(width, height);
stop();
glClear(GL_COLOR_BUFFER_BIT);
}
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glTranslatef(1.0 / width, 0, 0);
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glLoadIdentity();
glTranslatef(0, 1.0 / height, 0);
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glLoadIdentity();
glTranslatef(1.0 / width, 1.0 / height, 0);
draw_rect(width / 2, height / 2);
stop();
glAccum(GL_ACCUM, 0.25);
glAccum(GL_RETURN, 1.0);
glMatrixMode(GL_MODELVIEW);
}
// helper function for drawing - no more need to go mess with
// the main function when just want to change what to draw...
void draw() {
int x;
// some pixels
for (x = 0; x < vinfo.xres; x+=5) {
put_pixel(x, vinfo.yres / 2, WHITE);
}
// some lines (note the quite likely 'Moire pattern')
for (x = 0; x < vinfo.xres; x+=20) {
draw_line(0, 0, x, vinfo.yres - 1, GREEN);
}
// some rectangles
draw_rect(vinfo.xres / 4, vinfo.yres / 2 + 10, vinfo.xres / 4, vinfo.yres / 4, PURPLE);
draw_rect(vinfo.xres / 4 + 10, vinfo.yres / 2 + 20, vinfo.xres / 4 - 20, vinfo.yres / 4 - 20, PURPLE);
fill_rect(vinfo.xres / 4 + 20, vinfo.yres / 2 + 30, vinfo.xres / 4 - 40, vinfo.yres / 4 - 40, YELLOW);
// some circles
int d;
for(d = 10; d < vinfo.yres / 6; d+=10) {
draw_circle(3 * vinfo.xres / 4, vinfo.yres / 4, d, RED);
}
fill_circle(3 * vinfo.xres / 4, 3 * vinfo.yres / 4, vinfo.yres / 6, ORANGE);
fill_circle(3 * vinfo.xres / 4, 3 * vinfo.yres / 4, vinfo.yres / 8, RED);
}
void draw_rectangles(struct msm_frame* newFrame)
{
struct fd_roi_t *p_fd_roi;
#ifdef DRAW_RECTANGLES
uint8_t i;
for (i = 0; i < camframe_roi.num_roi; i++) {
CDBG("%s: camframe_roi: i=%d, x=%d, y=%d, dx=%d, dy=%d\n", __func__,
i, camframe_roi.roi[i].x, camframe_roi.roi[i].y,
camframe_roi.roi[i].dx, camframe_roi.roi[i].dy);
draw_rect((char*)newFrame->buffer, 640,
camframe_roi.roi[i].x, camframe_roi.roi[i].y,
camframe_roi.roi[i].dx, camframe_roi.roi[i].dy);
}
#endif
#ifdef CAM_FRM_DRAW_FD_RECT
p_fd_roi = (struct fd_roi_t *)newFrame->roi_info.info;
if(p_fd_roi && p_fd_roi->rect_num > 0){
int i;
for(i =0; i < p_fd_roi->rect_num; i++)
{
draw_rect((char*)newFrame->buffer, 800,
p_fd_roi->faces[i].x, p_fd_roi->faces[i].y,
p_fd_roi->faces[i].dx, p_fd_roi->faces[i].dy);
}
}
#endif
}
static void draw_buttons(void)
{
if (cidx == CIDX_DEFAULT) {
wattrset(dialogw, GET_PAIR_FOR(stgs.colors->def) | A_REVERSE);
mvwaddstr(dialogw, left_pos.y, left_pos.x, dialog_cdef_msg);
return;
}
int ymid = DIALOG_BUTTON_HEIGHT/2, xmid = DIALOG_BUTTON_WIDTH/2;
wattrset(dialogw, GET_PAIR_FOR((picked_color != COLOR_NONE) ? picked_color : DIALOG_BUTTON_COLOR));
draw_rect(dialogw, left_pos, DIALOG_BUTTON_WIDTH, DIALOG_BUTTON_HEIGHT);
draw_rect(dialogw, right_pos, DIALOG_BUTTON_WIDTH, DIALOG_BUTTON_HEIGHT);
wattron(dialogw, A_REVERSE);
mvwaddch(dialogw, left_pos.y+ymid, left_pos.x+xmid, turn2arrow(TURN_LEFT));
mvwaddch(dialogw, right_pos.y+ymid, right_pos.x+xmid, turn2arrow(TURN_RIGHT));
if (picked_turn != TURN_NONE) {
draw_border(dialogw, (picked_turn == TURN_LEFT) ? left_pos : right_pos,
DIALOG_BUTTON_WIDTH, DIALOG_BUTTON_HEIGHT);
}
if (cidx >= 0) {
ymid = DIALOG_DELETE_HEIGHT/2, xmid = DIALOG_DELETE_WIDTH/2;
wattrset(dialogw, GET_PAIR_FOR(DIALOG_DELETE_COLOR));
draw_rect(dialogw, delete_pos, DIALOG_DELETE_WIDTH, DIALOG_DELETE_HEIGHT);
wattron(dialogw, A_REVERSE);
mvwaddstr(dialogw, delete_pos.y+ymid, delete_pos.x+xmid, "X");
}
}
static void movePos(int x1, int y1, int x2,int y2, int richting)
{
int ret,wall,i,bo=1;
ret=1;
wall=Maze[x1][y1];
if (wall&richting)
{
gc_sound_play_ogg ("sounds/brick.wav", NULL);
ret=0;
}
if (ret)
{
gc_sound_play_ogg ("sounds/prompt.wav", NULL);
if (Maze[x2][y2]&SET)
{
for (i=(ind); i>=0 && bo; i--)
{
if(position[i][0]==x2 && position[i][1]==y2)
{
bo=0;
move_image(mazegroup,x2,y2,tuxgroup);
// draw_rect(mazegroup,x2,y2,"blue");
}
else
{
Maze[position[i][0]][position[i][1]]&=~SET;
draw_rect(mazegroup, position[i][0], position[i][1], "red");
draw_combined_rect(mazegroup,
position[i-1][0],position[i-1][1],
position[i][0],position[i][1],
"red");
ind--;
}
}
}
else
{
ind++;
position[ind][0]=x2;
position[ind][1]=y2;
Maze[x2][y2]|=SET;
if (position[ind][0]==(breedte-1) && position[ind][1]==(end))
{
gamewon = TRUE;
twoDdisplay();
gc_bonus_display(gamewon, GC_BONUS_LION);
}
else
{
draw_combined_rect(mazegroup, x1, y1, x2, y2, "green");
draw_rect(mazegroup,x1,y1,"green");
move_image(mazegroup,x2,y2,tuxgroup);
}
}
}
}
//draw a header with draw_rect and draw_text
void draw_header()
{
draw_rect(40, 20, 560, 60, colors[0]);
draw_rect(50, 30, 540, 40, colors[2]);
draw_rect(60, 40, 520, 20, colors[0]);
draw_text(64, 44, "It'sa meeee!", colors[4]);
}
static void draw_control_buttons(void)
{
Vector2i o = { (MENU_BUTTON_HEIGHT-5)/2, (MENU_BUTTON_WIDTH-5)/2 };
Vector2i pos1 = { menu_play_pos.y + o.y, menu_play_pos.x + o.x };
Vector2i pos2 = { menu_pause_pos.y + o.y, menu_pause_pos.x + o.x };
Vector2i pos3 = { menu_stop_pos.y + o.y, menu_stop_pos.x + o.x };
wattrset(menuw, ui_pair);
draw_rect(menuw, menu_play_pos, MENU_BUTTON_WIDTH, MENU_BUTTON_HEIGHT);
draw_rect(menuw, menu_pause_pos, MENU_BUTTON_WIDTH, MENU_BUTTON_HEIGHT);
draw_rect(menuw, menu_stop_pos, MENU_BUTTON_WIDTH, MENU_BUTTON_HEIGHT);
wattrset(menuw, GET_PAIR_FOR(has_enough_colors(stgs.colors) ? MENU_PLAY_COLOR : MENU_INACTIVE_COLOR));
draw_sprite(menuw, (SpriteInfo) { button_sprites[0], 5, 5 }, pos1, FALSE);
wattrset(menuw, GET_PAIR_FOR(is_simulation_running(stgs.linked_sim) ? MENU_PAUSE_COLOR : MENU_INACTIVE_COLOR));
draw_sprite(menuw, (SpriteInfo) { button_sprites[1], 5, 5 }, pos2, FALSE);
if (has_simulation_started(stgs.linked_sim)) {
wattrset(menuw, GET_PAIR_FOR(MENU_STOP_COLOR));
draw_sprite(menuw, (SpriteInfo) { button_sprites[2], 5, 5 }, pos3, FALSE);
} else {
wattrset(menuw, GET_PAIR_FOR(!is_colors_empty(stgs.colors) ? MENU_CLEAR_COLOR : MENU_INACTIVE_COLOR));
draw_sprite(menuw, (SpriteInfo) { button_sprites[3], 5, 5 }, pos3, FALSE);
}
}
void tooltip_update()
{
if (!g_tooltip.tooltip_text) {
tooltip_hide(0);
return;
}
tooltip_update_geometry();
if (just_shown) {
if (!panel_horizontal)
y -= height / 2; // center vertically
just_shown = FALSE;
}
tooltip_adjust_geometry();
XMoveResizeWindow(server.display, g_tooltip.window, x, y, width, height);
// Stuff for drawing the tooltip
cairo_surface_t *cs = cairo_xlib_surface_create(server.display, g_tooltip.window, server.visual, width, height);
cairo_t *c = cairo_create(cs);
Color bc = g_tooltip.bg->fill_color;
Border b = g_tooltip.bg->border;
if (server.real_transparency) {
clear_pixmap(g_tooltip.window, 0, 0, width, height);
draw_rect(c, b.width, b.width, width - 2 * b.width, height - 2 * b.width, b.radius - b.width / 1.571);
cairo_set_source_rgba(c, bc.rgb[0], bc.rgb[1], bc.rgb[2], bc.alpha);
} else {
cairo_rectangle(c, 0., 0, width, height);
cairo_set_source_rgb(c, bc.rgb[0], bc.rgb[1], bc.rgb[2]);
}
cairo_fill(c);
cairo_set_line_width(c, b.width);
if (server.real_transparency)
draw_rect(c, b.width / 2.0, b.width / 2.0, width - b.width, height - b.width, b.radius);
else
cairo_rectangle(c, b.width / 2.0, b.width / 2.0, width - b.width, height - b.width);
cairo_set_source_rgba(c, b.color.rgb[0], b.color.rgb[1], b.color.rgb[2], b.color.alpha);
cairo_stroke(c);
Color fc = g_tooltip.font_color;
cairo_set_source_rgba(c, fc.rgb[0], fc.rgb[1], fc.rgb[2], fc.alpha);
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, g_tooltip.font_desc);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
pango_layout_set_text(layout, g_tooltip.tooltip_text, -1);
PangoRectangle r1, r2;
pango_layout_get_pixel_extents(layout, &r1, &r2);
pango_layout_set_width(layout, width * PANGO_SCALE);
pango_layout_set_height(layout, height * PANGO_SCALE);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
// I do not know why this is the right way, but with the below cairo_move_to it seems to be centered (horiz. and
// vert.)
cairo_move_to(c,
-r1.x / 2 + g_tooltip.bg->border.width + g_tooltip.paddingx,
-r1.y / 2 + 1 + g_tooltip.bg->border.width + g_tooltip.paddingy);
pango_cairo_show_layout(c, layout);
g_object_unref(layout);
cairo_destroy(c);
cairo_surface_destroy(cs);
}
/// this function will print the given block and "childLevels" number of levels of its children under it.
// this is a recursive function.
// dest is the destination SDL_Surface that this will print to
// focus is the "top" block. "childLevels" of its children will be printed.
// highlight is the "selected" block or the "current" block.
// through the recursiveness, only the valid children will be printed.
short block_print_network_hierarchy(SDL_Surface *dest, struct blockData *focus, struct blockData *highlight, unsigned int childLevelsOrig, unsigned int childLevels, int x, int y, int size, Uint32 colorTop, Uint32 colorBot, Uint32 colorHighlight){
static SDL_Rect highLightRect;
if(dest == NULL) return 1;
if(focus == NULL) return 2;
// draw the focus block
draw_rect(dest, x, y, size, size, 1, 0xff000000, color_mix_weighted(colorTop, colorBot, childLevels, childLevelsOrig-childLevels), 1);
// quit if you have printed all of the necessary children.
if(childLevels <= 0) return 0;
int c;
// print 9 more of this current block's children (if they exist)
for(c=0; c<BLOCK_CHILDREN; c++){
block_print_network_hierarchy(dest, focus->children[c], highlight, childLevelsOrig, childLevels-1, x + (c%((int)(BLOCK_LINEAR_SCALE_FACTOR)))*size/BLOCK_LINEAR_SCALE_FACTOR, y + (c/((int)(BLOCK_LINEAR_SCALE_FACTOR)))*size/BLOCK_LINEAR_SCALE_FACTOR, size/BLOCK_LINEAR_SCALE_FACTOR, colorTop, colorBot, colorHighlight);
}
if(focus == highlight) draw_rect(dest, x, y, size, size, 1, colorHighlight, 0x00000000, 0);
return 0;
}
static void draw_io_buttons(void)
{
Vector2i inner1 = { menu_load_pos.y+1, menu_load_pos.x+1 };
Vector2i inner2 = { menu_save_pos.y+1, menu_save_pos.x+1 };
wattrset(menuw, ui_pair);
draw_rect(menuw, menu_load_pos, MENU_BUTTON_WIDTH, MENU_BUTTON_HEIGHT);
draw_rect(menuw, menu_save_pos, MENU_BUTTON_WIDTH, MENU_BUTTON_HEIGHT);
wattron(menuw, A_REVERSE);
draw_rect(menuw, inner1, MENU_BUTTON_WIDTH-2, MENU_BUTTON_HEIGHT-2);
draw_rect(menuw, inner2, MENU_BUTTON_WIDTH-2, MENU_BUTTON_HEIGHT-2);
wattrset(menuw, fg_pair);
mvwaddstr(menuw, inner1.y+1, inner1.x, " LOAD ");
mvwaddstr(menuw, inner1.y+2, inner1.x, " FROM ");
mvwaddstr(menuw, inner1.y+3, inner1.x, " FILE ");
mvwaddstr(menuw, inner2.y+1, inner2.x, " SAVE ");
mvwaddstr(menuw, inner2.y+2, inner2.x, " TO ");
mvwaddstr(menuw, inner2.y+3, inner2.x, " FILE ");
/* Draw status indicators */
if (load_status != STATUS_NONE) {
wattrset(menuw, GET_PAIR_FOR((load_status == STATUS_SUCCESS) ? COLOR_LIME : COLOR_RED));
mvwvline(menuw, menu_load_pos.y, menu_load_pos.x+MENU_BUTTON_WIDTH, ACS_BLOCK, MENU_BUTTON_HEIGHT);
}
if (save_status != STATUS_NONE) {
wattrset(menuw, GET_PAIR_FOR((save_status == STATUS_SUCCESS) ? COLOR_LIME : COLOR_RED));
mvwvline(menuw, menu_save_pos.y, menu_save_pos.x+MENU_BUTTON_WIDTH, ACS_BLOCK, MENU_BUTTON_HEIGHT);
}
}
static void render(struct widget *w)
{
struct widget_priv *priv = (struct widget_priv*) w->priv;
struct canvas *ca = &w->ca;
unsigned char i;
unsigned int width = ca->width;
int x;
char buf[10];
for (i = 0; i < 8; i++) {
if ((w->cfg->props.mode == 0) || (w->cfg->props.mode == 1))
sprintf(buf, "CH%u %4d", i+1, priv->ch_raw[i]);
else
sprintf(buf, "CH%u", i+1);
draw_str(buf, 0, i*8+1, ca, 0);
if ((w->cfg->props.mode == 0) || (w->cfg->props.mode == 2)) {
x = priv->ch_raw[i] - 1000;
if (x < 0)
x = 0;
else if (x > 1000)
x = 1000;
x = (x * (unsigned int) priv->bar_size) / 1000;
draw_rect(width-priv->bar_size-1, i*8, width-1, i*8+6, 3, ca);
draw_rect(width-priv->bar_size, i*8+1, width-2, i*8+5, 1, ca);
draw_vline(width-priv->bar_size-1+x, i*8+1, i*8+5, 1, ca);
draw_vline(width-priv->bar_size-1+x-1, i*8+1, i*8+5, 3, ca);
draw_vline(width-priv->bar_size-1+x+1, i*8+1, i*8+5, 3, ca);
}
}
}
int main(int argc, char** argv)
{
int i;
init_graphics();
char key;
int x = (640-20)/2;
int y = (480-20)/2;
do
{
//draw a black rectangle to erase the old one
draw_rect(x, y, 20, 20, Black);
key = getkey();
if(key == 'w') y-=10;
else if(key == 's') y+=10;
else if(key == 'a') x-=10;
else if(key == 'd') x+=10;
//draw a blue rectangle
draw_rect(x, y, 20, 20, Blue);
sleep_ms(20);
} while(key != 'q');
exit_graphics();
return 0;
}
/*
* Draws the grid at zoom g->zoom and
* centered at (g->cx, g->cy) on the grid
* coordinate system.
*
* This function is in need of cleanup
* especially for errors.
* The 'for' loops seem duplicated,
* except that sx += tile_size_x goes to sx -= tile_size_x,
* same with the y axis. If there is a way to combine these,
* the code would look so much better.
*/
void render(struct game *g)
{
double tile_size_x = g->screen.width * g->grid.zoom / (GRID_NORMAL_SIZE * 100.0);
double tile_size_y = g->screen.height * g->grid.zoom / (GRID_NORMAL_SIZE * 100.0);
double num_tiles_w = GRID_NORMAL_SIZE * 100.0 / g->grid.zoom;
double num_tiles_h = GRID_NORMAL_SIZE * 100.0 / g->grid.zoom;
int i,j, sx, sy, w, h, cx, cy;
w = round(tile_size_x) + 2;
h = round(tile_size_y) + 2;
cx = g->grid.cx;
cy = g->grid.cy;
for (i = 0, sx = (g->screen.width - tile_size_x) / 2; i < (num_tiles_w + 1)/ 2; i++, sx += tile_size_x) {
for (j = 0, sy = (g->screen.height - tile_size_y) / 2; j < (num_tiles_h + 1) / 2; j++, sy += tile_size_y)
draw_rect(g->screen.renderer, g->grid.data[cx + i][cy + j], sx-1, sy-1, w, h);
for (j = 0, sy = (g->screen.height - tile_size_y) / 2; j < (num_tiles_h + 1) / 2; j++, sy -= tile_size_y)
draw_rect(g->screen.renderer, g->grid.data[cx + i][cy - j], sx-1, sy-1, w, h);
}
for (i = 0, sx = (g->screen.width - tile_size_x) / 2; i < (num_tiles_w + 1)/ 2; i++, sx -= tile_size_x) {
for (j = 0, sy = (g->screen.height - tile_size_y) / 2; j < (num_tiles_h + 1) / 2; j++, sy += tile_size_y)
draw_rect(g->screen.renderer, g->grid.data[cx - i][cy + j], sx-1, sy-1, w, h);
for (j = 0, sy = (g->screen.height - tile_size_y) / 2; j < (num_tiles_h + 1) / 2; j++, sy -= tile_size_y)
draw_rect(g->screen.renderer, g->grid.data[cx - i][cy - j], sx-1, sy-1, w, h);
}
}
static void draw_tile(drawing *dr, game_drawstate *ds, game_state *state,
int x, int y, int tile, int flash_colour)
{
if (tile == 0) {
draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE,
flash_colour);
} else {
int coords[6];
char str[40];
coords[0] = x + TILE_SIZE - 1;
coords[1] = y + TILE_SIZE - 1;
coords[2] = x + TILE_SIZE - 1;
coords[3] = y;
coords[4] = x;
coords[5] = y + TILE_SIZE - 1;
draw_polygon(dr, coords, 3, COL_LOWLIGHT, COL_LOWLIGHT);
coords[0] = x;
coords[1] = y;
draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT);
draw_rect(dr, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
flash_colour);
sprintf(str, "%d", tile);
draw_text(dr, x + TILE_SIZE/2, y + TILE_SIZE/2,
FONT_VARIABLE, TILE_SIZE/3, ALIGN_VCENTRE | ALIGN_HCENTRE,
COL_TEXT, str);
}
draw_update(dr, x, y, TILE_SIZE, TILE_SIZE);
}
void init(void) {
window = window_create();
window_stack_push(window, true /* Animated */);
// TODO(dmnd) try another colour
window_set_background_color(window, GColorBlack);
// TODO(dmnd) try to remember what this does...
// init both frames to 2
draw_rect(0, 0, TILES_X, TILES_Y, 2);
draw_rect(0, 0, TILES_X, TILES_Y, 2);
// Init the layer for the display
Layer *root_layer = window_get_root_layer(window);
GRect frame = layer_get_frame(root_layer);
display_layer = layer_create(frame);
layer_set_update_proc(display_layer, &display_layer_update_cb);
layer_add_child(root_layer, display_layer);
unsigned char units;
if (DEBUG) {
units = SECOND_UNIT;
} else {
units = MINUTE_UNIT;
}
tick_timer_service_subscribe(units, &handle_minute_tick);
}
void draw_rect_outline( float x, float y, float width, float height, float thickness ){
glBegin( GL_POLYGON );
draw_rect( x,y,width, thickness );
draw_rect( x,y,thickness, height );
draw_rect( x+width,y,thickness, height );
draw_rect( x,y+width,width, thickness );
glEnd();
}
static void
draw_rect_set(int y)
{
draw_rect(10, y, 10, 10, -.75);
draw_rect(30, y, 10, 10, -.25);
draw_rect(50, y, 10, 10, .25);
draw_rect(70, y, 10, 10, .75);
}
void InterpolateVideo::draw_vectors(int processed)
{
// Draw arrows
if(config.draw_vectors)
{
create_macroblocks();
for(int i = 0; i < total_macroblocks; i++)
{
OpticFlowMacroblock *mb = macroblocks.get(i);
// printf("InterpolateVideo::optic_flow %d x=%d y=%d dx=%d dy=%d\n",
// __LINE__,
// mb->x,
// mb->y,
// mb->dx / OVERSAMPLE,
// mb->dy / OVERSAMPLE);
if(processed)
{
draw_arrow(get_output(),
mb->x,
mb->y,
mb->x - mb->dx / OVERSAMPLE,
mb->y - mb->dy / OVERSAMPLE);
// debug
// if(mb->is_valid && mb->visible)
// {
// draw_arrow(get_output(),
// mb->x + 1,
// mb->y + 1,
// mb->x - mb->dx / OVERSAMPLE + 1,
// mb->y - mb->dy / OVERSAMPLE + 1);
// }
}
else
{
draw_pixel(get_output(),
mb->x,
mb->y);
}
}
// Draw center macroblock
OpticFlowMacroblock *mb = macroblocks.get(
x_macroblocks / 2 + y_macroblocks / 2 * x_macroblocks);
draw_rect(get_output(),
mb->x - config.macroblock_size / 2,
mb->y - config.macroblock_size / 2,
mb->x + config.macroblock_size / 2,
mb->y + config.macroblock_size / 2);
draw_rect(get_output(),
mb->x - config.macroblock_size / 2 - config.search_radius,
mb->y - config.macroblock_size / 2 - config.search_radius,
mb->x + config.macroblock_size / 2 + config.search_radius,
mb->y + config.macroblock_size / 2 + config.search_radius);
}
}
unsigned long callc vis_message(int id, int mdata, int sdata)
{
if(id == 1 /* keys, lparam */)
{
switch(mdata)
{
case VK_RIGHT: /* add bars */
bars_count++;
draw_rect(vwx, vwy, vww, vwh, 0);
return 1;
case VK_LEFT: /* rem bars */
bars_count--;
if(bars_count < 1)bars_count = 1;
draw_rect(vwx, vwy, vww, vwh, 0);
return 1;
case VK_UP: /* add bars ++ */
bars_count += 10;
draw_rect(vwx, vwy, vww, vwh, 0);
return 1;
case VK_DOWN: /* rem bars ++ */
bars_count -= 10;
if(bars_count < 1)bars_count = 1;
draw_rect(vwx, vwy, vww, vwh, 0);
return 1;
case VK_NEXT:
fallco++;
return 1;
case VK_PRIOR:
if(fallco > 1)
fallco--;
return 1;
case VK_SPACE:
peak_mode_hold ^= 1;
draw_rect(vwx, vwy, vww, vwh, 0);
return 1;
case VK_HOME:
showfall ^= 1;
break;
case VK_END:
showbars ^= 1;
break;
case VK_CONTROL:
intensecolors ^= 1;
break;
}
}
return 0;
}
void draw()
{
if (duck)
draw_rect(int(x - 16), int(y - 32) - 16, 32, 32, 150, 200, 150);
else
draw_rect(int(x - 16), int(y - 64) - 16, 32, 64, 150, 200, 150);
FNT_Print(tty->font, screen, (int)x, (int)y-16, FNT_ALIGN_CENTER, "Hello\nWorld");
}
void draw_background (Area *a, cairo_t *c)
{
if (a->bg->back.alpha > 0.0) {
//printf(" draw_background (%d %d) RGBA (%lf, %lf, %lf, %lf)\n", a->posx, a->posy, pix->back.color[0], pix->back.color[1], pix->back.color[2], pix->back.alpha);
draw_rect(c, a->bg->border.width, a->bg->border.width, a->width-(2.0 * a->bg->border.width), a->height-(2.0*a->bg->border.width), a->bg->border.rounded - a->bg->border.width/1.571);
cairo_set_source_rgba(c, a->bg->back.color[0], a->bg->back.color[1], a->bg->back.color[2], a->bg->back.alpha);
cairo_fill(c);
}
if (a->bg->border.width > 0 && a->bg->border.alpha > 0.0) {
cairo_set_line_width (c, a->bg->border.width);
// draw border inside (x, y, width, height)
draw_rect(c, a->bg->border.width/2.0, a->bg->border.width/2.0, a->width - a->bg->border.width, a->height - a->bg->border.width, a->bg->border.rounded);
/*
// convert : radian = degre * M_PI/180
// definir le degrade dans un carre de (0,0) (100,100)
// ensuite ce degrade est extrapoler selon le ratio width/height
// dans repere (0, 0) (100, 100)
double X0, Y0, X1, Y1, degre;
// x = X * (a->width / 100), y = Y * (a->height / 100)
double x0, y0, x1, y1;
X0 = 0;
Y0 = 100;
X1 = 100;
Y1 = 0;
degre = 45;
// et ensuite faire la changement d'unite du repere
// car ce qui doit reste inchangee est les traits et pas la direction
// il faut d'abord appliquer une rotation de 90 (et -180 si l'angle est superieur a 180)
// ceci peut etre applique une fois pour toute au depart
// ensuite calculer l'angle dans le nouveau repare
// puis faire une rotation de 90
x0 = X0 * ((double)a->width / 100);
x1 = X1 * ((double)a->width / 100);
y0 = Y0 * ((double)a->height / 100);
y1 = Y1 * ((double)a->height / 100);
x0 = X0 * ((double)a->height / 100);
x1 = X1 * ((double)a->height / 100);
y0 = Y0 * ((double)a->width / 100);
y1 = Y1 * ((double)a->width / 100);
cairo_pattern_t *linpat;
linpat = cairo_pattern_create_linear (x0, y0, x1, y1);
cairo_pattern_add_color_stop_rgba (linpat, 0, a->border.color[0], a->border.color[1], a->border.color[2], a->border.alpha);
cairo_pattern_add_color_stop_rgba (linpat, 1, a->border.color[0], a->border.color[1], a->border.color[2], 0);
cairo_set_source (c, linpat);
*/
cairo_set_source_rgba (c, a->bg->border.color[0], a->bg->border.color[1], a->bg->border.color[2], a->bg->border.alpha);
cairo_stroke (c);
//cairo_pattern_destroy (linpat);
}
}
static void draw_gradient(SkCanvas* canvas) {
SkRect r = { 0, 0, SkIntToScalar(256), SkIntToScalar(32) };
SkPoint pts[] = { { r.fLeft, r.fTop }, { r.fRight, r.fTop } };
SkColor colors[] = { 0xFF000000, 0xFFFF0000 };
SkPaint p;
p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
draw_rect(canvas, r, p);
canvas->translate(0, SkIntToScalar(40));
p.setDither(true);
draw_rect(canvas, r, p);
}
static void draw_block_box(fz_context *ctx, fz_html *box, float page_top, float page_bot, fz_device *dev, const fz_matrix *ctm)
{
float x0, y0, x1, y1;
float color[4];
// TODO: background fill
// TODO: border stroke
float *border = box->border;
float *padding = box->padding;
x0 = box->x - padding[L];
y0 = box->y - padding[T];
x1 = box->x + box->w + padding[R];
y1 = box->y + box->h + padding[B];
if (y0 > page_bot || y1 < page_top)
return;
if (box->style.background_color.a > 0)
{
color[0] = box->style.background_color.r / 255.0f;
color[1] = box->style.background_color.g / 255.0f;
color[2] = box->style.background_color.b / 255.0f;
color[3] = box->style.background_color.a / 255.0f;
draw_rect(ctx, dev, ctm, color, x0, y0, x1, y1);
}
if (box->style.border_color.a > 0)
{
color[0] = box->style.border_color.r / 255.0f;
color[1] = box->style.border_color.g / 255.0f;
color[2] = box->style.border_color.b / 255.0f;
color[3] = box->style.border_color.a / 255.0f;
if (border[T] > 0)
draw_rect(ctx, dev, ctm, color, x0 - border[L], y0 - border[T], x1 + border[R], y0);
if (border[B] > 0)
draw_rect(ctx, dev, ctm, color, x0 - border[L], y1, x1 + border[R], y1 + border[B]);
if (border[L] > 0)
draw_rect(ctx, dev, ctm, color, x0 - border[L], y0 - border[T], x0, y1 + border[B]);
if (border[R] > 0)
draw_rect(ctx, dev, ctm, color, x1, y0 - border[T], x1 + border[R], y1 + border[B]);
}
for (box = box->down; box; box = box->next)
{
switch (box->type)
{
case BOX_BLOCK: draw_block_box(ctx, box, page_top, page_bot, dev, ctm); break;
case BOX_FLOW: draw_flow_box(ctx, box, page_top, page_bot, dev, ctm); break;
}
}
}
void handle_init(AppContextRef ctx) {
window_init(&window, "Illusion");
window_stack_push(&window, true /* Animated */);
// init both frames to 2
draw_rect(0, 0, TILES_X, TILES_Y, 2);
draw_rect(0, 0, TILES_X, TILES_Y, 2);
// Init the layer for the display
layer_init(&display_layer, window.layer.frame);
display_layer.update_proc = &display_layer_update_cb;
layer_add_child(&window.layer, &display_layer);
}
void menu::draw_menu() {
if (!is_open) return;
if (current_index[current_menu] + 2 > option_count && current_menu == Players) current_index[current_menu] = option_count - 1;
float difference = ((option_count > MAX_PP ? MAX_PP : option_count) * (.035 * 10)) / 10;
draw_rect(x_axis, y_axis + .018, .205, .074, shader_color);
draw_rect(x_axis, y_axis + .055 + difference / 2, .205, difference, background_color);
draw_rect(x_axis, y_axis + .074 + difference, .205, .038, shader_color);
draw_text(title, 1, 1, x_axis, y_axis - .024, white, center);
draw_text(sub_title, 1, .55, x_axis, y_axis + .022, white, center);
draw_text(creator_text, 1, .455, x_axis - .097, y_axis + difference + .058, white);
draw_text((string)(current_index[current_menu] + 1) + "/" + (string)option_count, 1, .455, x_axis + .095, y_axis + difference + .058, white, right);
draw_sprite("commonmenu", "arrowright", x_axis - .095, y_axis + .074 + (.035 * c_drawing_index), .022, .022, pointer_color);
draw_instructions();
draw_arrows();
}
int callc fennec_visualization_initialize(struct general_visualization_data *sdata, string plgtitle)
{
memcpy(&sfennec, sdata->shared, sizeof(struct fennec));
memcpy(&visdata, sdata, sizeof(struct general_visualization_data));
sdata->uninitialize = visualization_uninitialize;
sdata->refresh = visualization_refresh;
sdata->settings = visualization_settings;
sdata->about = visualization_about;
sdata->fsettings.plugin_settings_getnum("vis.spectrum", "intense", &intensecolors, 0, 0);
sdata->fsettings.plugin_settings_getnum("vis.spectrum", "showfall", &showfall, 0, 0);
sdata->fsettings.plugin_settings_getnum("vis.spectrum", "showbars", &showbars, 0, 0);
sdata->fsettings.plugin_settings_getnum("vis.spectrum", "fallco", &fallco, 0, 0);
sdata->fsettings.plugin_settings_getnum("vis.spectrum", "barscount", &bars_count, 0, 0);
str_cpy(plgtitle, uni("Spectrum Analyzer"));
visdata.getdata(get_visual_dc, 0, &dc, 0);
visdata.getdata(set_msg_proc, 0, vis_message, 0);
visdata.getdata(get_visual, 0, &window_vis, 0);
vwx = visdata.getdata(get_visual_x, 0, 0, 0);
vwy = visdata.getdata(get_visual_y, 0, 0, 0);
vww = visdata.getdata(get_visual_w, 0, 0, 0);
vwh = visdata.getdata(get_visual_h, 0, 0, 0);
draw_rect(vwx, vwy, vww, vwh, 0);
timer_id = SetTimer(0, 0, 30, timer_display);
col_bar_line = color_adjust(visdata.getdata(get_color, color_dark, 0, 0), 0.3);
col_bar_fill = (COLORREF)visdata.getdata(get_color, color_dark, 0, 0);
return 1;
}
void atyfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
{
struct atyfb_par *par = (struct atyfb_par *) info->par;
u32 color = rect->color, dx = rect->dx, width = rect->width, rotation = 0;
if (par->asleep)
return;
if (!rect->width || !rect->height)
return;
if (!par->accel_flags) {
cfb_fillrect(info, rect);
return;
}
color |= (rect->color << 8);
color |= (rect->color << 16);
if (info->var.bits_per_pixel == 24) {
/* In 24 bpp, the engine is in 8 bpp - this requires that all */
/* horizontal coordinates and widths must be adjusted */
dx *= 3;
width *= 3;
rotation = rotation24bpp(dx, DST_X_LEFT_TO_RIGHT);
}
wait_for_fifo(3, par);
aty_st_le32(DP_FRGD_CLR, color, par);
aty_st_le32(DP_SRC,
BKGD_SRC_BKGD_CLR | FRGD_SRC_FRGD_CLR | MONO_SRC_ONE,
par);
aty_st_le32(DST_CNTL,
DST_LAST_PEL | DST_Y_TOP_TO_BOTTOM |
DST_X_LEFT_TO_RIGHT | rotation, par);
draw_rect(dx, rect->dy, width, rect->height, par);
}
bool GraphD3D9::add_bar( size_t thread_idx, size_t depth, const Insight::Token& t )
{
m_max_thread_idx = std::max(thread_idx, m_max_thread_idx);
float start_ms = float(double(t.time_enter - m_min_time) / double(m_cycles_per_ms));
float stop_ms = float(double(t.time_exit - m_min_time) / double(m_cycles_per_ms));
float pos_x1 = start_ms;
float pos_x2 = stop_ms;
float pos_y1 = float(thread_idx) * g_thread_height + float(depth)*g_stack_height;
float pos_y2 = (pos_y1 + g_bar_height) - float(depth)*g_stack_height;
DWORD colour = m_colourman.calculate_colour(t.name);
draw_rect(pos_x1, pos_y1, pos_x2, pos_y2, colour);
BarInfo bi;
bi.x1 = pos_x1;
bi.x2 = pos_x2;
bi.y1 = pos_y1;
bi.y2 = pos_y2;
bi.thread_idx = thread_idx;
bi.name = t.name;
m_bars.push(bi);
return true;
}
static void draw_steps(void)
{
static bool do_draw;
Simulation *sim = stgs.linked_sim;
size_t steps = sim ? sim->steps : 0;
int len = (int)log10(steps) + 1;
Vector2i tl = steps_pos;
char digits[9], *d;
if (steps <= 1) {
do_draw = TRUE;
} else if (!do_draw) {
return;
}
wattrset(menuw, fg_pair);
if (len > 8) {
draw_sprite(menuw, (SpriteInfo) { inf_sprite, 31, 5 }, tl, TRUE);
do_draw = FALSE;
return;
}
sprintf(digits, "%8d", steps);
for (d = digits; d < digits+8; d++) {
if (*d != ' ') {
int digit = *d - '0';
wattroff(menuw, A_REVERSE);
draw_sprite(menuw, (SpriteInfo) { digit_sprites[digit], 3, 5 }, tl, TRUE);
} else {
wattron(menuw, A_REVERSE);
draw_rect(menuw, tl, 3, 5);
}
tl.x += 4;
}
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolShape::update(bool global){
if(!global){
clearTempPathContext(false);
}
if((get_active())&&(get_on_drag())){
if(get_mnu_cmd()==kShapeRect){
if(_ctr){
draw_c_rect();
}
else{
draw_rect();
}
}
else{
if(_ctr){
draw_c_circle();
}
else{
draw_circle();
}
}
}
if(!global){
validTempPathContext();
}
}
