infilon

///-----------------------------------------------
// INITIALIZATION:
//-----------------------------------------------
 
inf_border_size = 32
 
if INF_GET_SCREEN_INFO { INF_GET_SCREEN_INFO }
 
inf_layers = 4
inf_l = new_array( inf_layers )        //Layers
inf_al = new_array( inf_layers )    //Layers (alpha channel)
inf_a = 0
inf_next_layer:
inf_l[ inf_a ] = 0
inf_al[ inf_a ] = 0
inf_a + 1
if inf_a < inf_layers { go inf_next_layer }
inf_l[ 0 ] = new_pixi( 128, 128, 1 )
inf_al[ 0 ] = new_pixi( 128, 128, 1 )
pixi_alpha( inf_l[ 0 ], inf_al[ 0 ] )
 
inf_cur_layer = 0
inf_cur_frame = 0
inf_xoffset = 0
inf_yoffset = 0
inf_zoom = 256
inf_color_r = 255
inf_color_g = 255
inf_color_b = 255
inf_color_t = 255
inf_draw_pixel_procedure = INF_DRAW_PIXEL_NORMAL
 
inf_click_x = 0
inf_click_y = 0
inf_clicked_on = 0
//1 - left/right/top border
//2 - bottom border
//3 - drawing area
//4 - color button
 
//-----------------------------------------------
// MAIN LOOP:
//-----------------------------------------------
 
INF_START:
    clear( 0 )
    if INF_DRAW_IMAGE { INF_DRAW_IMAGE }
    if INF_DRAW_STD_GUI { INF_DRAW_STD_GUI }
    if INF_CONTROL { INF_CONTROL }
    frame( 0 )
go INF_START
 
//-----------------------------------------------
// DIFFERENT MODULES:
//-----------------------------------------------
 
INF_GET_SCREEN_INFO:
    inf_screen = 0
    inf_xsize = get_pixi_xsize( inf_screen )
    inf_ysize = get_pixi_ysize( inf_screen )
    inf_hx = inf_xsize / 2
    inf_hy = inf_ysize / 2
ret
 
INF_CONTROL:
    if ( get_window_xsize != get_pixi_xsize( inf_screen ) ) | ( get_window_ysize != get_pixi_ysize( inf_screen ) )
    {
    //Resize main screen:
    resize_pixi( inf_screen, get_window_xsize, get_window_ysize )
    if INF_GET_SCREEN_INFO { INF_GET_SCREEN_INFO }
    }
 
    //Handle pen keys:
    handle_keys(
    {
        //Press:
        inf_click_x = gpx
        inf_click_y = gpy
        inf_xoffset_start = inf_xoffset
        inf_yoffset_start = inf_yoffset
        inf_zoom_start = inf_zoom
        if gpy < -inf_hy + inf_border_size { inf_clicked_on = 1 }
        if gpx < -inf_hx + inf_border_size
        {
        inf_clicked_on = 1
        if ( ( gpy + inf_hy ) + 8 ) / 16 = 1 { inf_clicked_on = 4 } //COLOR
        }
        if gpx > inf_hx - inf_border_size { inf_clicked_on = 1 }
        if gpy > inf_hy - inf_border_size { inf_clicked_on = 2 }
        if inf_clicked_on = 0 {
        inf_clicked_on = 3
        INF_DRAWING
        }
    },
    {
        //Move:
        inf_delta_x = gpx - inf_click_x
        inf_delta_y = gpy - inf_click_y
        if inf_clicked_on = 1 {
        //Image move:
        inf_xoffset = inf_xoffset_start + ( inf_delta_x * 256 ) / inf_zoom
        inf_yoffset = inf_yoffset_start + ( inf_delta_y * 256 ) / inf_zoom
        }
        if inf_clicked_on = 2 {
        //Image zoom:
        inf_zoom = inf_zoom_start + inf_delta_x * 4
        if inf_zoom < 4 { inf_zoom = 4 }
        if ( inf_zoom > 240 ) & ( inf_zoom < 280 ) { inf_zoom = 256 }
        }
        if inf_clicked_on = 3 {
        INF_DRAWING
        }
    },
    {
        //Up:
        if inf_clicked_on = 4 { need_color_dialog = 1 }
        inf_clicked_on = 0
    }
    )
    if need_color_dialog { INF_COLOR_DIALOG }
    need_color_dialog = 0
ret
 
INF_DRAW_PIXEL_NORMAL:
    if ( inf_x >= 0 ) & ( inf_x < inf_img_xsize ) & ( inf_y >= 0 ) & ( inf_y < inf_img_ysize )
    {
    inf_img_ptr = inf_y * inf_img_xsize + inf_x
    inf_img_ptr + inf_cur_frame * inf_img_xsize * inf_img_ysize
    inf_color2 = get_color( inf_color_r, inf_color_g, inf_color_b )
    inf_color1 = inf_img[ inf_img_ptr ];
    a = get_red( inf_aimg[ inf_img_ptr ] )
    inf_img[ inf_img_ptr ] = get_blend( inf_color1, inf_color2, ( inf_color_t * a ) / 256 + ( 255 - a ) )
    a = a + ( ( 255 - a ) * inf_color_t ) / 256
    inf_aimg[ inf_img_ptr ] = get_color( a, a, a )
    }
ret
 
INF_DRAWING:
    inf_img = inf_l[ inf_cur_layer ]
    inf_aimg = inf_al[ inf_cur_layer ]
    if inf_img {
    inf_img_xsize = get_pixi_xsize( inf_img )
    inf_img_ysize = get_pixi_ysize( inf_img )
    inf_img_x = ( inf_xoffset * inf_zoom ) / 256
    inf_img_y = ( inf_yoffset * inf_zoom ) / 256    
    inf_img_x - ( (inf_img_xsize / 2) * inf_zoom ) / 256
    inf_img_y - ( (inf_img_ysize / 2) * inf_zoom ) / 256
    inf_x = ( ( gpx - inf_img_x ) * 256 ) / inf_zoom
    inf_y = ( ( gpy - inf_img_y ) * 256 ) / inf_zoom
    INF_DRAW_PIXEL_NORMAL
    }
ret
 
INF_DRAW_STD_GUI:
    box( -inf_hx + inf_border_size, -inf_hy + inf_border_size, inf_xsize - inf_border_size * 2, inf_ysize - inf_border_size * 2, WHITE )
    inf_logo = "
9.9..9.999.9.9...999.9..9
9.99.9.9...9.9...9.9.99.9
9.9.99.99..9.9...9.9.9.99
9.9..9.9...9.999.999.9..9
    "
    inf_menux = -inf_hx + 1
    inf_menuy = -inf_hy + 1
    make_pixi( inf_logo )
    pixi( inf_logo, inf_menux + 15, inf_menuy + 4, 1, 0 )
    inf_zoom_img = "
..9..99999.9999.9999.9...9..9..
.99.....9..9..9.9..9.99.99..99.
999....9...9..9.9..9.9.9.9..999
.99...9....9..9.9..9.9...9..99.
..9..99999.9999.9999.9...9..9..
    "
    make_pixi( inf_zoom_img )
    pixi( inf_zoom_img, 0, inf_hy - inf_border_size / 2, 1, 0 )
    inf_move_img = "
..............9
.............999
............99999
.    
.
..9..9...9.9999.9...9.9999..9..
.99..99.99.9..9.9...9.9.....99.
999..9.9.9.9..9..9.9..999...999
.99..9...9.9..9..9.9..9.....99.
..9..9...9.9999...9...9999..9..
.
.
............99999
.............999
..............9
    "
    make_pixi( inf_move_img )
    pixi( inf_move_img, 0, -inf_hy + inf_border_size / 2, 1, 0 )
    inf_color_img = "
9876543210
9876543210
9876543210
9876543210
9876543210
9876543210
    "
    make_pixi( inf_color_img )
    pixi( inf_color_img, -inf_hx + 9, -inf_hy + 16, 1, 0 )
ret
 
INF_DRAW_IMAGE:
    inf_a = 0
    inf_next_layer2:
    inf_img = inf_l[ inf_a ]
    inf_aimg = inf_al[ inf_a ]
    if inf_img {
    inf_img_xsize = get_pixi_xsize( inf_img )
    inf_img_ysize = get_pixi_ysize( inf_img )
    inf_tx = ( inf_xoffset * inf_zoom ) / 256
    inf_ty = ( inf_yoffset * inf_zoom ) / 256
    inf_czoom = inf_zoom - 256;
    pixi( inf_img, inf_tx, inf_ty, 1, inf_czoom )
    inf_tx - ( (inf_img_xsize / 2) * inf_zoom ) / 256
    inf_ty - ( (inf_img_ysize / 2) * inf_zoom ) / 256
    box( inf_tx - 1, inf_ty - 1, ( inf_img_xsize * inf_zoom ) / 256 + 2, ( inf_img_ysize * inf_zoom ) / 256 + 2, WHITE )
    }
    inf_a + 1
    if inf_a < inf_layers { go inf_next_layer2 }    
ret
 
//-----------------------------------------------
// Dialogs
//-----------------------------------------------
 
INF_COLOR_DIALOG:
    need_to_exit = 0
    inf_pal = "
0123456789
..........
    "
    make_pixi( inf_pal )
    inf_pal[ 10 ] = RED
    inf_pal[ 11 ] = GREEN
    inf_pal[ 12 ] = BLUE
    inf_pal[ 13 ] = YELLOW
    inf_pal[ 14 ] = get_color( 255, 128, 0 )
    inf_cursor = "
99999
99999
99999
99999
99999
99999
99999
    "
    make_pixi( inf_cursor )
    inf_cd_loop:
        clear( BLACK )
    if INF_DRAW_IMAGE { INF_DRAW_IMAGE }
    pixi( inf_pal, 0, -inf_hy + 32, 16, 0 )
    transp( inf_color_t )
    fbox( inf_hx-inf_border_size, -inf_hy, inf_border_size, inf_ysize, get_color( inf_color_r, inf_color_g, inf_color_b ) )
    transp( 256 )
    print( "<- BACK", -inf_hx + 8, -inf_hy + 28, WHITE )
    fbox( -inf_hx, -inf_hy+64, inf_xsize, 16, RED )
    fbox( -inf_hx, -inf_hy+64+16, inf_xsize, 16, GREEN )
    fbox( -inf_hx, -inf_hy+64+32, inf_xsize, 16, BLUE )
    fbox( -inf_hx, -inf_hy+64+48, inf_xsize, 16, get_color( 128, 128, 128 ) )
    print( "RED $inf_color_r", -inf_hx + 8, -inf_hy+4+64, WHITE )
    print( "GREEN $inf_color_g", -inf_hx + 8, -inf_hy+4+64+16, WHITE )
    print( "BLUE $inf_color_b", -inf_hx + 8, -inf_hy+4+64+32, WHITE )
    print( "TRANSPARENCY $inf_color_t", -inf_hx + 8, -inf_hy+4+64+48, WHITE )
    pixi( inf_cursor, -inf_hx + ( inf_color_r * inf_xsize ) / 256, -inf_hy+64 + 8, 1, 0 )
    pixi( inf_cursor, -inf_hx + ( inf_color_g * inf_xsize ) / 256, -inf_hy+64+16 + 8, 1, 0 )
    pixi( inf_cursor, -inf_hx + ( inf_color_b * inf_xsize ) / 256, -inf_hy+64+32 + 8, 1, 0 )
    pixi( inf_cursor, -inf_hx + ( inf_color_t * inf_xsize ) / 256, -inf_hy+64+48 + 8, 1, 0 )
    check_pushed_component = {
        if ( gpy > -inf_hy+64 ) & ( gpy < -inf_hy+64+64 ) {
        item = ( gpy + (inf_hy-64) ) / 16
        } else {
        item = 255
        if ( gpy < -inf_hy+64 ) & ( gpx < -inf_hx+70 ) { item = 4 }
        }
    }
    execute_pushed = {
        if item = 0 { inf_color_r = ( ( gpx + inf_hx ) * 256 ) / inf_xsize }
        if item = 1 { inf_color_g = ( ( gpx + inf_hx ) * 256 ) / inf_xsize }
        if item = 2 { inf_color_b = ( ( gpx + inf_hx ) * 256 ) / inf_xsize }
        if item = 3 { inf_color_t = ( ( gpx + inf_hx ) * 256 ) / inf_xsize }
        if item = 255 {
        inf_color_r = get_red( get_dot( gpx, gpy ) )
        inf_color_g = get_green( get_dot( gpx, gpy ) )
        inf_color_b = get_blue( get_dot( gpx, gpy ) )
        }
    }
    handle_keys(
        {
        //Down:
        check_pushed_component    
        execute_pushed        
        },
        {
        //Move:
        execute_pushed        
        },
        {
        //Up:
        if item = 4 { need_to_exit = 1 }
        item = -1
        } )
    frame( 0 )
    if need_to_exit { go inf_color_exit }
    go inf_cd_loop
    inf_color_exit:
ret