302 lines
7.9 KiB
C
302 lines
7.9 KiB
C
|
|
/*******************************************************************************/
|
|
/* Copyright (C) 2007-2008 Jonathan Moore Liles */
|
|
/* */
|
|
/* This program is free software; you can redistribute it and/or modify it */
|
|
/* under the terms of the GNU General Public License as published by the */
|
|
/* Free Software Foundation; either version 2 of the License, or (at your */
|
|
/* option) any later version. */
|
|
/* */
|
|
/* This program is distributed in the hope that it will be useful, but WITHOUT */
|
|
/* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or */
|
|
/* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for */
|
|
/* more details. */
|
|
/* */
|
|
/* You should have received a copy of the GNU General Public License along */
|
|
/* with This program; see the file COPYING. If not,write to the Free Software */
|
|
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
|
/*******************************************************************************/
|
|
|
|
/* This file contains ALL platform specific drawing code required by the canvas */
|
|
|
|
#include "ui.H"
|
|
#include "draw.H"
|
|
|
|
#include "../common.h"
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
|
|
#include "../canvas.H"
|
|
|
|
struct color_table {
|
|
int state;
|
|
unsigned char r, g, b;
|
|
};
|
|
|
|
struct color_table color_defs[] = {
|
|
{ EMPTY, 18, 18, 18 },
|
|
{ FULL, 255, 69, 0 },
|
|
{ PARTIAL, 0, 0, 0 },
|
|
{ CONTINUED, 80, 80, 80 },
|
|
{ LINE, 10, 10, 10 },
|
|
{ HIT, 255, 255, 255 },
|
|
{ PLAYHEAD, 10, 69, 10 },
|
|
{ SELECTED, 255, 10, 255 },
|
|
};
|
|
|
|
Fl_Color *state_colors;
|
|
|
|
Fl_Color velocity_colors[128];
|
|
Fl_Color velocity2_colors[128];
|
|
|
|
bool draw_borders = 1;
|
|
|
|
void
|
|
init_colors ( void )
|
|
{
|
|
unsigned int i;
|
|
/* velocity colors */
|
|
|
|
for ( i = 128; i--; )
|
|
{
|
|
velocity_colors[i] = fl_color_average( FL_GRAY, fl_rgb_color( i * 2, 255 - i * 2, 32 ), 0.4 );
|
|
velocity2_colors[i] = fl_color_average( FL_WHITE, velocity_colors[i], 0.5 );
|
|
}
|
|
|
|
state_colors = (Fl_Color*)malloc(sizeof( Fl_Color ) * MAX_STATE );
|
|
|
|
for ( i = elementsof( color_defs ); i--; )
|
|
{
|
|
state_colors[ color_defs[i].state ] = fl_rgb_color( color_defs[i].r,
|
|
color_defs[i].g,
|
|
color_defs[i].b );
|
|
}
|
|
}
|
|
|
|
int
|
|
gui_draw_ruler ( int x, int y, int w, int div_w, int div, int ofs, int p1, int p2 )
|
|
{
|
|
/* Across the top */
|
|
|
|
fl_font( FL_TIMES, ruler_height );
|
|
|
|
int h = ruler_height;
|
|
|
|
fl_color( canvas_background_color );
|
|
|
|
// fl_rectf( x, y, x + (div_w * w), y + h );
|
|
fl_rectf( x, y, (div_w * w), h );
|
|
|
|
fl_color( FL_RED );
|
|
|
|
fl_line( x + div_w / 2, y, x + div_w * w, y );
|
|
|
|
char pat[40];
|
|
int z = div;
|
|
int i;
|
|
for ( i = 0; i < w; i++ )
|
|
if ( 0 == i % z )
|
|
{
|
|
int nx = x + (i * div_w) + (div_w / 2);
|
|
|
|
fl_color( FL_RED );
|
|
|
|
fl_line( nx, y, nx, y + h );
|
|
|
|
int k = ofs + i;
|
|
sprintf( pat, "%i", 1 + (k / z ));
|
|
|
|
fl_color( FL_WHITE );
|
|
fl_draw( pat, nx + div_w / 2, y + h + 1 / 2 );
|
|
}
|
|
|
|
if ( p1 != p2 )
|
|
{
|
|
if ( p1 >= 0 )
|
|
{
|
|
if ( p1 < p2 )
|
|
fl_color( FL_GREEN );
|
|
else
|
|
fl_color( FL_RED );
|
|
|
|
fl_rectf( x + (div_w * p1), y + h / 2, div_w, h / 2 );
|
|
|
|
}
|
|
if ( p2 >= 0 )
|
|
{
|
|
if ( p2 < p1 )
|
|
fl_color( FL_GREEN );
|
|
else
|
|
fl_color( FL_RED );
|
|
fl_rectf( x + (div_w * p2), y + h / 2, div_w, h / 2 );
|
|
|
|
}
|
|
}
|
|
|
|
return h;
|
|
}
|
|
|
|
void
|
|
gui_clear_area ( int x, int y, int w, int h )
|
|
{
|
|
fl_color( canvas_background_color );
|
|
|
|
fl_rectf( x, y, w, h );
|
|
}
|
|
|
|
int
|
|
gui_draw_string ( int x, int y, int w, int h, int color, const char *s, bool draw )
|
|
{
|
|
int rw;
|
|
|
|
if ( ! s )
|
|
return 0;
|
|
|
|
fl_font( FL_COURIER, min( h, 18 ) );
|
|
|
|
rw = fl_width( s );
|
|
|
|
if ( fl_not_clipped( x, y, rw, h ) && draw )
|
|
{
|
|
gui_clear_area( x, y, w, h );
|
|
|
|
if ( color )
|
|
fl_color( velocity_colors[ color ] );
|
|
else
|
|
fl_color( FL_DARK_CYAN );
|
|
|
|
fl_draw( s, x, y + h / 2 + fl_descent() );
|
|
}
|
|
|
|
return rw;
|
|
}
|
|
|
|
void
|
|
gui_draw_shape ( int x, int y, int w, int h, int bw, int shape, int state, int flags, int color )
|
|
{
|
|
/* take advantage of FLTK's clipping */
|
|
if ( ! fl_not_clipped( x, y, w, h ) )
|
|
return;
|
|
|
|
if ( flags & F_PLAYHEAD )
|
|
{
|
|
state = state == FULL ? HIT : PLAYHEAD;
|
|
flags &= ~ F_SELECTION;
|
|
}
|
|
|
|
Fl_Color c1, c2;
|
|
|
|
if ( state == FULL && color )
|
|
{
|
|
c1 = velocity_colors[ color ];
|
|
c2 = velocity2_colors[ color ];
|
|
}
|
|
else
|
|
{
|
|
c1 = state_colors[ state ];
|
|
c2 = fl_color_average( FL_WHITE, c1, 0.1 );
|
|
}
|
|
|
|
|
|
int thickness = 2;
|
|
|
|
/* if ( state == EMPTY && shape == SQUARE ) */
|
|
/* shape = HOLLOW_SQUARE; */
|
|
|
|
if ( flags & F_SELECTION )
|
|
fl_color( fl_darker( fl_color() ) );
|
|
|
|
switch ( shape )
|
|
{
|
|
case CIRCLE:
|
|
fl_color( c1 );
|
|
fl_pie( x + bw / 2, y + bw / 2, w - bw, h - bw, 0, 360 );
|
|
if ( draw_borders )
|
|
{
|
|
fl_color( c2 );
|
|
fl_line_style( FL_SOLID, thickness );
|
|
fl_arc( x + bw / 2, y + bw / 2, w - bw, h - bw, 0, 360 );
|
|
fl_line_style( FL_SOLID, 0 );
|
|
}
|
|
break;
|
|
case SQUARE:
|
|
fl_color( c1 );
|
|
fl_rectf( x + bw, y + bw, w - bw * 2, h - bw * 2 );
|
|
if ( draw_borders )
|
|
{
|
|
fl_color( c2 );
|
|
fl_line_style( FL_SOLID, thickness );
|
|
fl_rect( x + bw, y + bw, w - bw * 2, h - bw * 2 );
|
|
fl_line_style( FL_SOLID, 0 );
|
|
}
|
|
break;
|
|
case HALF_CIRCLE:
|
|
fl_color( c1 );
|
|
fl_pie( x + bw / 2, y + bw / 2, w - bw, h - bw, 0, 360 / 2);
|
|
if ( draw_borders )
|
|
{
|
|
fl_color( c2 );
|
|
fl_line_style( FL_SOLID, thickness );
|
|
fl_pie( x + bw / 2, y + bw / 2, w - bw, h - bw, 0, 360 / 2);
|
|
fl_line_style( FL_SOLID, 0 );
|
|
}
|
|
break;
|
|
case DIAMOND:
|
|
fl_color( c1 );
|
|
fl_polygon( x + w / 2, y + bw / 2, x + w - bw / 2, y + h / 2, x + w / 2, y + h - bw / 2, x + bw / 2, y + h / 2 );
|
|
if ( draw_borders )
|
|
{
|
|
fl_color( c2 );
|
|
fl_line_style( FL_SOLID, thickness );
|
|
fl_loop( x + w / 2, y + bw / 2, x + w - bw / 2, y + h / 2, x + w / 2, y + h - bw / 2, x + bw / 2, y + h / 2 );
|
|
fl_line_style( FL_SOLID, 0 );
|
|
}
|
|
break;
|
|
default:
|
|
ASSERTION( "unknown shape" );
|
|
break;
|
|
}
|
|
|
|
if ( flags & F_P1 || flags & F_P2 )
|
|
{
|
|
if ( flags & F_P1 )
|
|
fl_color( FL_GREEN );
|
|
else
|
|
fl_color( FL_RED );
|
|
|
|
int rw = w / 4;
|
|
int rh = h / 4;
|
|
|
|
fl_rectf( x + (w / 2) - (rw / 2), y + (h / 2) - (rh / 2), rw, rh );
|
|
}
|
|
}
|
|
|
|
extern UI *ui;
|
|
|
|
static
|
|
void
|
|
clear_status ( void * )
|
|
{
|
|
ui->status->label( NULL );
|
|
}
|
|
|
|
/** inform the user of something via a status bar */
|
|
void
|
|
gui_status ( const char *fmt, ... )
|
|
{
|
|
va_list args;
|
|
|
|
static char pat[256];
|
|
|
|
if ( fmt )
|
|
{
|
|
va_start( args, fmt );
|
|
vsnprintf( pat, 256, fmt, args );
|
|
va_end( args );
|
|
}
|
|
|
|
ui->status->label( pat );
|
|
|
|
Fl::add_timeout( 5.0f, clear_status );
|
|
}
|