fltk_test_11

// Cartesian.H,v 1.0

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Library General Public License

// version 2 as published by the Free Software Foundation.

//

// This library is distributed WITHOUT ANY WARRANTY;

// without even the implied warranty of MERCHANTABILITY

// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

// Library General Public License for more details.

// You should have received a copy of the GNU Library General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

#ifndef _Cartesian_h_

#define _Cartesian_h_

#include <FL/Fl_Box.H>

#define DEFAULT_POINT_SIZE 4

#define CA_DEFAULT_LABEL_SIZE 12

enum Ca_Damage {CA_DAMAGE_ALL=1, CA_DAMAGE_ADD=2};

enum Ca_When{CA_WHEN_MIN=1,CA_WHEN_MAX=2};

enum Ca_AxisAlign{CA_LEFT=0, CA_RIGHT=1, CA_BOTTOM=CA_LEFT, CA_TOP=CA_RIGHT,

CA_CENTER=3,CA_ALIGNMENT=3,CA_NO_LABELS=32, CA_NO_TICS=64, CA_LINE=128};

enum Ca_PointStyle{CA_SIMPLE=0,CA_ROUND=1,CA_SQUARE=2,CA_UP_TRIANGLE=3, CA_DOWN_TRIANGLE=4,

CA_DIAMOND=5,CA_NO_POINT=6, CA_POINT_STYLE=127, CA_BORDER=128};

enum Ca_GridVisible{

CA_MINOR_GRID=0xF,CA_LEFT_MINOR_TICK=0x1, CA_BOTTOM_MINOR_TICK=CA_LEFT_MINOR_TICK,CA_RIGHT_MINOR_TICK=0x2, CA_TOP_MINOR_TICK=CA_RIGHT_MINOR_TICK, CA_MINOR_TICK=0x3,

CA_MAJOR_GRID=0xF0, CA_LEFT_MAJOR_TICK=0x10, CA_BOTTOM_MAJOR_TICK=CA_LEFT_MAJOR_TICK,CA_RIGHT_MAJOR_TICK=0x20, CA_TOP_MAJOR_TICK=CA_RIGHT_MAJOR_TICK,CA_MAJOR_TICK=0x30,

CA_LABEL_GRID=0xF00,CA_LEFT_LABEL_TICK=0x100,CA_BOTTOM_LABEL_TICK=CA_LEFT_LABEL_TICK,CA_RIGHT_LABEL_TICK=0x200, CA_TOP_LABEL_TICK=CA_RIGHT_LABEL_TICK, CA_LABEL_TICK=0x300,

CA_ALWAYS_VISIBLE=0x1000,CA_FRONT=0x2000};

enum Ca_AxisType{CA_LIN=0, CA_LOG=1, CA_REV=2};

class Ca_Canvas;

class Ca_Axis_;

class Ca_Object_;

class Ca_ObjectChain;

//class Cartesian;

///////////////////////////////////////////////////////////////////////////

class Ca_ObjectChain{

public:

Ca_Object_ *object;

Ca_ObjectChain *next;

};

///////////////////////////////////////////////////////////////////////////

class Ca_Canvas:public Fl_Box{

friend class Ca_Axis_;

friend class Ca_X_Axis;

friend class Ca_Y_Axis;

friend class Ca_Object_;

static Ca_Canvas *current_;

int replot_;

Ca_Axis_ * last_axis_;

int border_;

Ca_Axis_ *current_x_;

Ca_Axis_ *current_y_;

Ca_ObjectChain * first_object_;

Ca_ObjectChain * last_object_;

Ca_ObjectChain * last_plotted_;

void add_object(Ca_Object_ *object);

/* No function body - prevents copy construction/assignment */

Ca_Canvas(const Ca_Canvas &);

const Ca_Canvas & operator=(const Ca_Canvas &);

int dx_, dy_, dw_, dh_;

protected:

void draw();

public:

static Ca_Canvas * current(){return current_;};

static void current(Ca_Canvas * _current){current_=_current;}

void current_x(Ca_Axis_ * axis){current_x_=axis;};

void current_y(Ca_Axis_ * axis){current_y_=axis;};

Ca_Axis_ * current_x(){return current_x_;};

Ca_Axis_ * current_y(){return current_y_;};

void clear();

int border(){return border_;};

void border(int border);

void clip_border(int dx, int dy, int dw, int dh){ dx_ = dx; dy_ = dy; dw_ = dw; dh_ = dh;}

void clip_border(int * dx, int * dy, int *dw, int *dh){ *dx = dx_; *dy = dy_; *dw = dw_; *dh = dh_;}

Ca_ObjectChain * objects(){return first_object_;};

Ca_Canvas(int x, int y, int w, int h, const char *label=0);

~Ca_Canvas();

};

///////////////////////////////////////////////////////////////////////////

class Ca_Axis_:public Fl_Box{

friend class Ca_Canvas;

Ca_Axis_ *previous_axis_;

protected:

int scale_;

int next_tick(int &tick_index, double &tick_value, int &tick_order, double &interval_);

bool valid_;

double k_;

double q_;

const char *label_format_;

Fl_Color minor_grid_color_;

Fl_Color major_grid_color_;

Fl_Color label_grid_color_;

int minor_grid_style_;

int major_grid_style_;

int label_grid_style_;

int minor_grid_width_;

int major_grid_width_;

int label_grid_width_;

char * minor_grid_dashes_;

char * major_grid_dashes_;

char * label_grid_dashes_;

int grid_visible_;

double tick_interval_;

int tick_separation_;

int tick_length_;

int tick_width_;

int major_step_;

int label_step_;

Ca_Canvas * canvas_;

unsigned char axis_align_;

Fl_Font label_font_face_;

int label_font_size_;

double min_;

double max_;

int min_pos_;

int max_pos_;

int border_;

Fl_Color axis_color_;

virtual int min_pos()=0;

virtual int max_pos()=0;

int update();

virtual void draw_grid()=0;

public:

virtual void current()=0;

double position(double);

double value(double);

Ca_Canvas * canvas(){return canvas_;};

int border(){return border_;};

void border(int border){border_=border;damage(CA_DAMAGE_ALL);}

double minimum(){return min_;};

double maximum(){return max_;};

void minimum(double x);

void maximum(double x);

void clear(){valid_=0;};

int cleared(){return !valid_;};

void rescale(int when, double x);

void rescale_move(int when, double x);

void tick_interval(double interval) {tick_interval_=interval; damage(CA_DAMAGE_ALL);};

double tick_interval(){return tick_interval_;};

void tick_separation(int separation) {tick_separation_=separation; damage(CA_DAMAGE_ALL);};

int tick_separation(){return tick_separation_;};

void tick_length(int length){tick_length_=length; damage(CA_DAMAGE_ALL);};

int tick_length(){return tick_length_;};

void tick_width(int width){tick_width_=width; damage(CA_DAMAGE_ALL);};

int tick_width(){return tick_width_;};

void major_step(int step){major_step_=step;damage(CA_DAMAGE_ALL);};

int major_step(){return major_step_;};

void label_step(int step){label_step_=step;damage(CA_DAMAGE_ALL);};

int label_step(){return label_step_;};

void label_format(const char *format){label_format_=format; damage(CA_DAMAGE_ALL);};

const char* label_format(){return label_format_;};

void label_font(Fl_Font face){label_font_face_=face; damage(CA_DAMAGE_ALL);};

Fl_Font label_font(){return label_font_face_;};

void label_size(int size){label_font_size_=size; damage(CA_DAMAGE_ALL);};

int label_size(){return label_font_size_;};

void axis_color(Fl_Color _axis_color){axis_color_=_axis_color; damage(CA_DAMAGE_ALL);};

Fl_Color axis_color(){ return axis_color_;};

void minor_grid_color(Fl_Color color){minor_grid_color_=color; canvas_->damage(CA_DAMAGE_ALL);};

Fl_Color minor_grid_color(){return minor_grid_color_;};

void minor_grid_style(int style, int width=0, char * dashes=0){minor_grid_style_=style;minor_grid_width_=width;minor_grid_dashes_=dashes; canvas_->damage(CA_DAMAGE_ALL);};

void minor_grid_style(int * style, int * width=0, char ** dashes=0){

if (style) *style=minor_grid_style_;

if (width) *width=minor_grid_width_;

if (dashes) *dashes=minor_grid_dashes_;

};

void major_grid_color(Fl_Color color){major_grid_color_=color; canvas_->damage(CA_DAMAGE_ALL);};

Fl_Color major_grid_color(){return major_grid_color_;};

void major_grid_style(int style, int width=0, char * dashes=0){major_grid_style_=style; major_grid_width_=width; major_grid_dashes_=dashes; canvas_->damage(CA_DAMAGE_ALL);};

void major_grid_style(int * style, int * width=0, char ** dashes=0){

if (style) *style=major_grid_style_;

if (width) *width=major_grid_width_;

if (dashes) *dashes=major_grid_dashes_;

};

void label_grid_color(Fl_Color color){label_grid_color_=color; canvas_->damage(CA_DAMAGE_ALL);};

Fl_Color label_grid_color(){return label_grid_color_;};

void label_grid_style(int style, int width=0, char * dashes=0){label_grid_style_=style; label_grid_width_=width; label_grid_dashes_=dashes; canvas_->damage(CA_DAMAGE_ALL);};

void label_grid_style(int * style, int * width=0, char ** dashes=0){

if (style) *style=label_grid_style_;

if (width) *width=label_grid_width_;

if (dashes) *dashes=label_grid_dashes_;

};

void grid_visible(int visible){grid_visible_=visible;canvas_->damage(CA_DAMAGE_ALL);};

int grid_visible(){return grid_visible_;};

void axis_align(unsigned char align){axis_align_=align; damage(CA_DAMAGE_ALL);};

unsigned char axis_align(){return axis_align_;};

void scale(int s){if(s!=scale_){redraw(); canvas_->redraw();} scale_=s;};

int scale(){return scale_;};

Ca_Axis_(int x, int y, int w, int h, const char * label=0);

~Ca_Axis_();

};

//////////////////////////////////////////////////////////////////////

class Ca_X_Axis: public Ca_Axis_{

protected:

int min_pos();

int max_pos();

void draw();

void draw_grid();

public:

void current();

Ca_X_Axis(int x, int y, int w, int h, const char * label=0);

~Ca_X_Axis();

};

///////////////////////////////////////////////////////////////////////////

class Ca_Y_Axis: public Ca_Axis_{

int min_pos();

int max_pos();

void draw();

void draw_grid();

public:

void current();

Ca_Y_Axis(int x, int y, int w, int h, const char * label=0);

~Ca_Y_Axis();

};

///////////////////////////////////////////////////////////////////////////

class Ca_Object_{

friend class Ca_Canvas;

friend class Ca_Axis_;

friend class Ca_Y_Axis;

friend class Ca_X_Axis;

// No function body - prevents copy construction/assignment

Ca_Object_(const Ca_Object_ &);

const Ca_Object_ & operator=(const Ca_Object_ &);

protected:

Ca_Canvas *canvas_;

Ca_Axis_ *x_axis_;

Ca_Axis_ *y_axis_;

virtual void draw()=0;

public:

Ca_Object_(Ca_Canvas * canvas=0);

virtual ~Ca_Object_();

};

///////////////////////////////////////////////////////////////////////////

class Ca_Point:public Ca_Object_{

protected:

void draw();

public:

double x;

double y;

int style;

int size;

Fl_Color color;

Fl_Color border_color;

int border_width;

Ca_Point(double _x, double _y, Fl_Color color=FL_BLACK, int style=CA_SIMPLE, int size=DEFAULT_POINT_SIZE, Fl_Color border_color=FL_BLACK, int border_width=0);

};

///////////////////////////////////////////////////////////////////////////

class Ca_LinePoint:public Ca_Point{

protected:

void draw();

public:

Ca_LinePoint *previous;

int line_width;

Ca_LinePoint(Ca_LinePoint *_previous, double _x, double _y, int line_width, Fl_Color color=FL_BLACK, int style=CA_SIMPLE, int size=DEFAULT_POINT_SIZE, Fl_Color border_color=FL_BLACK, int border_width=0);

Ca_LinePoint(Ca_LinePoint *_previous, double _x, double _y);

};

///////////////////////////////////////////////////////////////////////////

class Ca_PolyLine:public Ca_LinePoint{

protected:

void draw();

public:

int line_style;

Ca_PolyLine * next;

Ca_PolyLine(Ca_PolyLine *_previous, double _x, double _y,int line_style, int line_width=0, Fl_Color color=FL_BLACK, int style=CA_SIMPLE, int size=DEFAULT_POINT_SIZE, Fl_Color border_color=FL_BLACK, int border_width=0);

Ca_PolyLine(Ca_PolyLine *_previous, double _x, double _y);

};

///////////////////////////////////////////////////////////////////////////

class Ca_Line:protected Ca_Point{

protected:

void draw();

public:

Ca_Point::style; //just making public usefull data

Ca_Point::size;

Ca_Point::color;

Ca_Point::border_color;

Ca_Point::border_width;

int line_style;

int line_width;

int n;

double * data;

double * data_2;

Ca_Line(int _n, double *_data, double *_data_2, int _line_style, int _line_width=0, Fl_Color color=FL_BLACK, int style=CA_SIMPLE, int size=DEFAULT_POINT_SIZE, Fl_Color border_color=FL_BLACK, int border_width=0);

Ca_Line(int _n, double *_data, int _line_style, int _line_width=0, Fl_Color _color=FL_BLACK, int style=CA_SIMPLE, int size=DEFAULT_POINT_SIZE, Fl_Color border_color=FL_BLACK, int border_width=0);

};

///////////////////////////////////////////////////////////////////////////

class Ca_Text:public Ca_Object_{

protected:

void draw();

public:

double x1,x2,y1,y2;

char * label;

uchar align;

Fl_Color label_color;

Fl_Font label_font;

int label_size;

Ca_Text(double _x1, double _x2, double _y1, double _y2, char *_label, uchar _align=FL_ALIGN_CENTER, Fl_Font _label_font=FL_HELVETICA, int _label_size=CA_DEFAULT_LABEL_SIZE, Fl_Color _label_color=FL_BLACK);

Ca_Text(double x, double y, char *_label=0, uchar _align=FL_ALIGN_CENTER, Fl_Font _label_font=FL_HELVETICA, int _label_size=CA_DEFAULT_LABEL_SIZE, Fl_Color _label_color=FL_BLACK);

};

///////////////////////////////////////////////////////////////////////////

class Ca_Bar:public Ca_Text{

protected:

void draw();

public:

Fl_Color color;

Fl_Color border_color;

int border_width;

Ca_Bar(double _x1, double _x2, double _y1, double _y2, Fl_Color _color=FL_RED, Fl_Color _border_color=FL_BLACK, int _border_width=0, char *_label=0, uchar _align=FL_ALIGN_CENTER, Fl_Font _label_font=FL_HELVETICA, int _label_size=CA_DEFAULT_LABEL_SIZE, Fl_Color _label_color=FL_BLACK);

};

#endif

////////////////////////////////////////////////////////////////////////////////////////

// Cartesian.cpp,v 1.0

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Library General Public License

// version 2 as published by the Free Software Foundation.

//

// This library is distributed WITHOUT ANY WARRANTY;

// WITHOUT even the implied warranty of MERCHANTABILITY

// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

// Library General Public License for more details.

// You should have received a copy of the GNU Library General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

#include "Cartesian.H"

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <stdlib.h>

#include <FL/fl_draw.H>

#include <FL/Fl.H>

#include <FL/Fl_Group.H>

static const int CANVAS_BORDER = 0; //gap between the graphics and surrounding"box"

static const int AXIS_BORDER = 0; //gap between axis drawing(i.e.axis line) and its "box"

static const int MINOR_INTERVAL = 0; //0 stands for automatic choice in default_*_intervals array

static const int MINOR_SEPARATION = 18;

static const int MAJOR_STEP = 5;

static const int LABEL_STEP = 10;

static const int LABEL_SIZE = CA_DEFAULT_LABEL_SIZE;

static const Fl_Font LABEL_FONT = FL_HELVETICA;

static const int MAX_LABEL_FORMAT = 16;

static const int MAX_LABEL_LENGTH = 32;

static const int NO_LIN_DEFAULTS=3;

static const double default_lin_intervals[NO_LIN_DEFAULTS] = {1, 2, 5};

static const int default_lin_major_steps[NO_LIN_DEFAULTS] = {5, 5, 2};

static const int default_lin_label_steps[NO_LIN_DEFAULTS] = {10, 5, 4};

static const int NO_LOG_DEFAULTS = 3;

static const double default_log_intervals[NO_LOG_DEFAULTS] = {1, 2, 5};

static const int default_log_major_steps[NO_LOG_DEFAULTS] = {5, 5, 2};

static const int default_log_label_steps[NO_LOG_DEFAULTS] = {10, 5, 2};

/// float drawings for more precise placement (especialy for PS output for Fl_Device!) /////

static inline void ca_rect(double x, double y, double w, double h){

fl_begin_loop();

fl_vertex(x,y);

fl_vertex(x+w,y);

fl_vertex(x+w,y+h);

fl_vertex(x,y+h);

fl_end_loop();

};

static inline void ca_rectf(double x, double y, double w, double h){

fl_begin_polygon();

fl_vertex(x,y);

fl_vertex(x+w,y);

fl_vertex(x+w,y+h);

fl_vertex(x,y+h);

fl_end_polygon();

};

static inline void ca_loop(double x1, double y1, double x2, double y2, double x3, double y3){

fl_begin_loop();

fl_vertex(x1,y1); fl_vertex(x2,y2); fl_vertex(x3,y3);

fl_end_loop();

};

static inline void ca_polygon(double x1, double y1, double x2, double y2, double x3, double y3){

fl_begin_polygon();

fl_vertex(x1,y1); fl_vertex(x2,y2); fl_vertex(x3,y3);

fl_end_polygon();

};

static inline void ca_loop(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4){

fl_begin_loop();

fl_vertex(x1,y1); fl_vertex(x2,y2); fl_vertex(x3,y3); fl_vertex(x4,y4);

fl_end_loop();

};

static inline void ca_polygon(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4){

fl_begin_polygon();

fl_vertex(x1,y1); fl_vertex(x2,y2); fl_vertex(x3,y3); fl_vertex(x4,y4);

fl_end_polygon();

};

static inline void ca_text(const char *label, double x, double y){

fl_draw(label,(int)(x+.5),(int)(y+.5));

};

static inline void ca_point(double x, double y){

fl_point((int)(x+.5),(int)(y+.5));

};

/*

static inline void ca_pie(double x, double y, double w, double h, double a1, double a2){

fl_pie((int)(x+.5), (int)(y+.5),(int)(w+.5),(int)(h+.5),0,270.0);

};

*/

static inline void ca_filled_circle(double x, double y, double r){

fl_begin_polygon();

//fl_arc(x,y,r,0,360);

fl_circle(x,y,r);

fl_end_polygon();

};

static inline void ca_text(const char *label, double x, double y, double w, double h, Fl_Align align){

fl_draw(label, (int)(x+.5), (int)(y+.5), (int)(w+.5), (int)(h+.5), align);

};

//////////////////// Ca_Axis_ ////////////////////////////

void Ca_Axis_::minimum(double x){

min_=x;

if(!valid_){

max_=x;

valid_=1;

}

damage(CA_DAMAGE_ALL);

canvas_->damage(CA_DAMAGE_ALL);

update();

};

void Ca_Axis_::maximum(double x){

max_=x;

if(!valid_){

min_=x;

valid_=1;

}

damage(CA_DAMAGE_ALL);

canvas_->damage(CA_DAMAGE_ALL);

update();

};

int Ca_Axis_::update(){

double _k=k_;

double _q=q_;

min_pos_=min_pos();

max_pos_=max_pos();

if (min_==max_)

k_=0;

else

if(scale_ & CA_LOG){

k_=(max_pos_-min_pos_)/(log(max_)-log(min_));

q_=min_pos_-k_*log(min_);

}else{

k_=(max_pos_-min_pos_)/(max_-min_);

q_=min_pos_;

}

if((_k!=k_)||(_q!=q_))

return 1;

else

return 0;

};

void Ca_Axis_::rescale_move(int when, double x){

if((when&CA_WHEN_MAX)&&(x>max_)){

if(scale_ & CA_LOG)

min_ *=x/max_;

else

min_ += x-max_;

max_=x;

damage(CA_DAMAGE_ALL);

canvas_->damage(CA_DAMAGE_ALL);

}

if((when&CA_WHEN_MIN)&&(x<min_)){

if(scale_ & CA_LOG)

max_ *=x/min_;

else

max_ -= min_-x;

min_=x;

damage(CA_DAMAGE_ALL);

canvas_->damage(CA_DAMAGE_ALL);

}

valid_=1;

};

double Ca_Axis_::position(double value){

if (k_==0) return (min_pos_+max_pos_)/2;

if(scale_ & CA_LOG)

return (int)(q_+k_*log(value));

else

return min_pos_+k_*(value-min_);

};

double Ca_Axis_::value(double pos){

if (max_==min_)

return min_;

if(scale_ & CA_LOG)

return exp((pos-q_)/k_);

else

return (min_ +(pos-min_pos_)/k_);

};

int Ca_Axis_::next_tick(int &tick_index, double &tick_value, int &tick_order, double &interval ){

////////// I know snakes are evil creatures, but sometimes they work so there is such a serpent....

////////// How many if...else can be in in a function? this is going to be a record in the G. book of r.

static int number_per_order;

double _tick_interval;

double minor_number_;

if(scale_ & CA_LOG){ ///////////// begin logarithmic /////////////////

if (!interval){

tick_order=(int)(floor(log10(min_)));

if (tick_interval_!=0){

interval=fabs(tick_interval_);

number_per_order=(int)floor(10/interval+0.5);

}else{

number_per_order=(int)(abs(min_pos_-max_pos_)/(tick_separation_*log10(max_/min_)));

if(number_per_order<=1){

label_step_=major_step_=3;

tick_order = 3*(tick_order/3);

interval=1;

number_per_order=0;

}else{

int _no_per_o=number_per_order;

for(int i=NO_LOG_DEFAULTS-1;i>=0;i--){

major_step_=default_log_major_steps[i];

label_step_=default_log_label_steps[i];

interval=default_log_intervals[i];

number_per_order=(int)floor(10/interval+0.5);

if((10/interval)>=_no_per_o)

break;

}

tick_index=number_per_order;

tick_order--;

tick_value=pow(10,tick_order);

interval*=tick_value;

if(!number_per_order){

tick_order--;

tick_value /=10;

tick_index=1;

}else

tick_value *=10;

return 1;

}else{

if (tick_value>(max_)){

tick_index-=1;

return 0;

}else{

if(number_per_order){

if(tick_index==number_per_order){

tick_order++;

interval*=10;

if(number_per_order<10){

tick_index=1;

tick_value=interval;

}else{

tick_index=2;

tick_value=2*interval;

}

}else{

tick_value +=interval;

tick_index++;

}

}else{

tick_order++;

tick_index++;

tick_value *=10;

}

return 1;

}

}else{ /////////////// begin linear //////////////////////

if (!interval){

minor_number_= (double)abs(min_pos_-max_pos_)/(double)tick_separation_;

_tick_interval=tick_interval_;

if (tick_interval_<0){

interval=_tick_interval=-_tick_interval;

tick_order=(int)floor(log10(_tick_interval));

}else{

if(_tick_interval!=0){

tick_order=(int)floor(log10(fabs(max_-min_)/minor_number_));

interval= pow(10,tick_order) * _tick_interval;

}else

for(int i=NO_LIN_DEFAULTS-1;i>=0;i--){

tick_order=(int)floor(log10(fabs(max_-min_)/minor_number_));

interval= pow(10,tick_order)*(_tick_interval=default_lin_intervals[i]);

major_step_=default_lin_major_steps[i];

label_step_=default_lin_label_steps[i];

if(((max_-min_)/interval)>=minor_number_)

break;

}

tick_value = floor(minimum()/interval);

tick_value *= interval;

tick_index=(int) floor((tick_value /interval)+0.5);

return 1;

}else{

if (tick_value>(max_)){

tick_index=-1;

return 0;

}else{

tick_value +=interval;

tick_index++;

return 1;

}

} ///// Uf, this is the end of the leg-less beast! //////

};

void Ca_Axis_::rescale(int when, double x){

if(!valid_){

max_=x;

min_=x;

damage(CA_DAMAGE_ALL);

canvas_->damage(CA_DAMAGE_ALL);

valid_=1;

return;

}

if((when&CA_WHEN_MAX)&&(x>max_)){

max_=x;

damage(CA_DAMAGE_ALL);

canvas_->damage(CA_DAMAGE_ALL);

}

if((when&CA_WHEN_MIN)&&(x<min_)){

min_=x;

damage(CA_DAMAGE_ALL);

canvas_->damage(CA_DAMAGE_ALL);

}

};

Ca_Axis_::Ca_Axis_(int x, int y, int w, int h, const char * label)

:Fl_Box(x,y,w,h,label),

scale_(CA_LIN), valid_(0), k_(0), q_(0), label_format_(0),

minor_grid_color_(FL_BLACK), major_grid_color_(FL_BLACK), label_grid_color_(FL_BLACK),

minor_grid_style_(FL_SOLID), major_grid_style_(FL_SOLID), label_grid_style_(FL_SOLID),

minor_grid_width_(0), major_grid_width_(0), label_grid_width_(0),

minor_grid_dashes_(0), major_grid_dashes_(0),label_grid_dashes_(0),

grid_visible_(0), tick_interval_(MINOR_INTERVAL), tick_separation_(MINOR_SEPARATION),

tick_length_(0), tick_width_(0), major_step_(MAJOR_STEP),label_step_(LABEL_STEP),

axis_align_(CA_BOTTOM),label_font_face_(FL_HELVETICA), label_font_size_(LABEL_SIZE),

min_(0),max_(0),min_pos_(0),max_pos_(0),border_(AXIS_BORDER),axis_color_(FL_BLACK)

{

box(FL_NO_BOX);

canvas_=Ca_Canvas::current();

previous_axis_=canvas_->last_axis_;

canvas_->last_axis_=this;

labelsize(LABEL_SIZE);

};

Ca_Axis_::~Ca_Axis_(){

if(!canvas_)return;

if (canvas_->last_axis_==this)

canvas_->last_axis_=previous_axis_;

else{

Ca_Axis_ *axis=canvas_->last_axis_;

while(axis){

if(axis->previous_axis_==this){

axis->previous_axis_=previous_axis_;

break;

}

axis=axis->previous_axis_;

}

};

/////////////////////// Ca_X_Axis ///////////////////////////////////////////////

int Ca_X_Axis::min_pos(){

if(scale_&CA_REV)

return canvas_->x()+canvas_->w()-canvas_->border()+Fl::box_dx(canvas_->box())-Fl::box_dw(canvas_->box());

else

return canvas_->x()+canvas_->border()+Fl::box_dx(canvas_->box());

};

int Ca_X_Axis::max_pos(){

if(scale_&CA_REV)

return canvas_->x()+canvas_->border()+Fl::box_dx(canvas_->box());

else

return canvas_->x()+canvas_->w()-canvas_->border()+Fl::box_dx(canvas_->box())-Fl::box_dw(canvas_->box());

};

void Ca_X_Axis::draw(){

int tick_index=-1;

double tick_value;

int tick_order;//, tick_number;

double _interval=0;

const char * label_format=label_format_;

if(damage()|FL_DAMAGE_ALL)

draw_label();

if (damage()&(FL_DAMAGE_ALL|CA_DAMAGE_ALL)){

update();

if (box()==FL_NO_BOX){

fl_color(parent()->color());

fl_rectf(x(),y(),w(),h());

}else

draw_box();

if(!valid_) return;

fl_font(label_font_face_,label_font_size_);

int l1=0;

int l2=0;

int m1=0;

int m2=0;

int l=0;

int _y=0;

int _w=0;

int _h=0; //temporary coordinates for ticks

double _pos,_x;

fl_clip(x()+Fl::box_dx(box()),y()+Fl::box_dy(box()),w()-Fl::box_dw(box()),h()-Fl::box_dh(box()));

fl_color(axis_color_);

int a=y()+Fl::box_dh(box())+border_;

int b=a+h()-Fl::box_dh(box())-2*border_;

switch(axis_align_ & CA_ALIGNMENT){

case CA_BOTTOM:

l=l1=m1=a;

if(axis_align_&CA_NO_TICS)

m2=m1;

else

if (tick_length_)

m2=m1+tick_length_;

else

m2=m1+label_font_size_;

l2=(m1+m2)/2;

break;

case CA_TOP:

l=l2=m2=b-1;

if(axis_align_&CA_NO_TICS)

m1=m2;

else

if (tick_length_)

m1=m2-tick_length_;

else

m1=m2-label_font_size_;

l1=(m1+m2)/2;

break;

case CA_CENTER:

m1=a;

m2=b;

l=(a+b)/2;

l1=(a+l)/2;

l2=(l+b)/2;

break;

}

fl_line_style(FL_SOLID|FL_CAP_FLAT,tick_width_);

if(axis_align_ & CA_LINE){

fl_begin_line();

fl_vertex(min_pos(),l);

fl_vertex(max_pos(),l);

fl_vertex(canvas_->x()+Fl::box_dx(canvas_->box()),l);

fl_vertex(canvas_->x()+canvas_->w()+Fl::box_dx(canvas_->box())-Fl::box_dw(canvas_->box()),l);

//fl_vertex(x()+border_,l);

//fl_vertex(x()+w()-border_,l);

fl_end_line();

}

while(next_tick(tick_index, tick_value, tick_order, _interval)){

_pos=position(tick_value);

if(scale_&CA_REV){

if(_pos<max_pos_-canvas_->border()) break;

if(_pos>min_pos_+canvas_->border()) continue;

}else{

if(_pos<min_pos_-canvas_->border()) continue;

if(_pos>max_pos_+canvas_->border()) break;

}

if(!(axis_align_&CA_NO_TICS)){

if(tick_index % major_step_){

fl_begin_loop();

fl_vertex(_pos,l1);

fl_vertex(_pos,l2);

fl_end_loop();

}else{

fl_begin_loop();

fl_vertex(_pos,m1);

fl_vertex(_pos,m2);

fl_end_loop();

}

if(!((tick_index % label_step_)|(axis_align_&CA_NO_LABELS))){

char label[MAX_LABEL_LENGTH];

char _label_format[MAX_LABEL_FORMAT];

if(!label_format){

int _tick_order;

if (tick_order>=0)

_tick_order=0;

else

_tick_order=-tick_order;

sprintf(_label_format,"%s.%if","%",_tick_order);

}

else

strcpy(_label_format,label_format);

sprintf(label, _label_format,tick_value);

fl_measure(label,_w,_h);

_x=_pos-_w/double(2);

switch (axis_align_ & CA_ALIGNMENT){

case CA_TOP:

_y=m1-_h/3;

break;

case CA_BOTTOM:

_y=m2+_h;

break;

case CA_CENTER:

_y=l+_h/3;

Fl_Color _color=fl_color();

fl_color(color());

ca_rectf(_x-_h/6,l-_h/2,_w+_h/3,_h);

fl_color(_color);

break;

}

ca_text(label,_x,_y);

}

fl_line_style(0,0);

fl_pop_clip();

}

};

void Ca_X_Axis::current(){

canvas_->current_x(this);

};

void Ca_X_Axis::draw_grid(){

if(!valid_)return;

int tick_index=-1;

double tick_value;

int tick_order;

double _interval=0;

int l1,l2;

double _pos;

l1=canvas_->y()+Fl::box_dy(canvas_->box());

l2=canvas_->y()+canvas_->h()+Fl::box_dy(canvas_->box())-Fl::box_dh(canvas_->box());

int tcl;

if(!(tcl=tick_length_))

tcl=label_font_size_;

while(next_tick(tick_index, tick_value, tick_order, _interval)){

_pos=position(tick_value);

if(scale_&CA_REV){

if(_pos<max_pos_-canvas_->border()) break;

if(_pos>min_pos_+canvas_->border()) continue;

}else{

if(_pos<min_pos_-canvas_->border()) continue;

if(_pos>max_pos_+canvas_->border()) break;

}

int grt;

if((grt=grid_visible_ & CA_LABEL_GRID) && !(tick_index % label_step_)){

fl_color(label_grid_color_);

fl_line_style(label_grid_style_,label_grid_width_);

if(grt==CA_LABEL_GRID){

fl_begin_loop();

fl_vertex(_pos,l1);

fl_vertex(_pos,l2);

fl_end_loop();

}else{

if(grt&CA_LEFT_LABEL_TICK){

fl_begin_loop();

fl_vertex(_pos,l1);

fl_vertex(_pos,l1+tcl);

fl_end_loop();

}

if(grt&CA_RIGHT_LABEL_TICK){

fl_begin_loop();

fl_vertex(_pos,l2-tcl);

fl_vertex(_pos,l2);

fl_end_loop();

}

}else if((grt=grid_visible_ & CA_MAJOR_GRID) && !(tick_index % major_step_)){

fl_color(major_grid_color_);

fl_line_style(major_grid_style_,major_grid_width_);

if(grt==CA_MAJOR_GRID){

fl_begin_loop();

fl_vertex(_pos,l1);

fl_vertex(_pos,l2);

fl_end_loop();

}else{

if(grt&CA_LEFT_MAJOR_TICK){

fl_begin_loop();

fl_vertex(_pos,l1);

fl_vertex(_pos,l1+tcl);

fl_end_loop();

}

if(grt&CA_RIGHT_MAJOR_TICK){

fl_begin_loop();

fl_vertex(_pos,l2-tcl);

fl_vertex(_pos,l2);

fl_end_loop();

}

}else if((grt=grid_visible_&CA_MINOR_GRID)){

fl_color(minor_grid_color_);

fl_line_style(minor_grid_style_,minor_grid_width_);

if(grt==CA_MINOR_GRID){

fl_begin_loop();

fl_vertex(_pos,l1);

fl_vertex(_pos,l2);

fl_end_loop();

}else{

if(grt&CA_LEFT_MINOR_TICK){

fl_begin_loop();

fl_vertex(_pos,l1);

fl_vertex(_pos,l1+tcl/2);

fl_end_loop();

}

if(grt&CA_RIGHT_MINOR_TICK){

fl_begin_loop();

fl_vertex(_pos,l2-tcl/2);

fl_vertex(_pos,l2);

fl_end_loop();

}

fl_line_style(0,0);

fl_color(FL_BLACK);

};

Ca_X_Axis::Ca_X_Axis(int x, int y, int w, int h, const char *label):Ca_Axis_(x, y, w, h, label){

if(!(canvas_->current_x()))

current();

};

Ca_X_Axis::~Ca_X_Axis(){

if(canvas_){

Ca_ObjectChain *ochain=canvas_->first_object_;

Ca_ObjectChain *next;

Ca_ObjectChain *previous=0;

while (ochain){

next=ochain->next;

if(ochain->object->x_axis_==this){

delete ochain->object;

if(previous)

previous->next=next;

else

canvas_->first_object_=next;

delete ochain;

}

ochain=next;

}

//////////////////////////// Ca_Y_Axis //////////////////////////////////////////////////////

int Ca_Y_Axis::min_pos(){

if (scale_&CA_REV)

return canvas_->y()+canvas_->border()+Fl::box_dy(canvas_->box());

else

return canvas_->y()+canvas_->h()-canvas_->border()+Fl::box_dy(canvas_->box())-Fl::box_dh(canvas_->box());

};

int Ca_Y_Axis::max_pos(){

if (scale_&CA_REV)

return canvas_->y()+canvas_->h()-canvas_->border()+Fl::box_dy(canvas_->box())-Fl::box_dh(canvas_->box());

else

return canvas_->y()+canvas_->border()+Fl::box_dy(canvas_->box());

};

void Ca_Y_Axis::draw(){

int tick_index=-1;

double tick_value;

int tick_order;//,tick_number;

double _interval=0;

const char * label_format=label_format_;

// if(damage()|FL_DAMAGE_ALL)

// draw_label();

if (damage()&(FL_DAMAGE_ALL|CA_DAMAGE_ALL)){

update();

if (box()==FL_NO_BOX){

fl_color(parent()->color());

fl_rectf(x(),y(),w(),h());

}else

draw_box();

if(!valid_) return;

fl_font(label_font_face_,label_font_size_);

int l1=0; int l2=0; int m1=0; int m2=0; int l=0; int _x=0; int _w,_h; //temporary coordinates for ticks

double _pos,_y;

fl_clip(x()+Fl::box_dx(box()),y()+Fl::box_dy(box()),w()-Fl::box_dw(box()),h()-Fl::box_dh(box()));

fl_color(axis_color_);

int a=x()+Fl::box_dx(box())+border_;

int b=a+w()-Fl::box_dw(box())-2*border_;

switch(axis_align_ & CA_ALIGNMENT){

case CA_RIGHT:

l=l1=m1=a;

if(axis_align_&CA_NO_TICS)

m2=m1;

else

if (tick_length_)

m2=m1+tick_length_;

else

m2=m1+label_font_size_;

l2=(l1+m2)/2;

break;

case CA_LEFT:

l=l2=m2=b-1;

if(axis_align_&CA_NO_TICS)

m1=m2;

else

if (tick_length_)

m1=m2-tick_length_;

else

m1=m2-label_font_size_;

l1=(m1+m2)/2;

break;

case CA_CENTER:

m1=a;

m2=b;

l=(a+b)/2;

l1=(a+l)/2;

l2=(l+b)/2;

break;

}

fl_line_style(FL_SOLID|FL_CAP_FLAT,tick_width_);

// double minp,maxp;

if(axis_align_ & CA_LINE){

fl_begin_line();

fl_vertex(l,canvas_->y()+Fl::box_dy(canvas_->box()));

fl_vertex(l,canvas_->y()+canvas_->h()+Fl::box_dy(canvas_->box())-Fl::box_dh(canvas_->box()));

//fl_vertex(x()+border_,l);

//fl_vertex(x()+w()-border_,l);

fl_end_line();

}

while(next_tick(tick_index, tick_value, tick_order, _interval)){

_pos=position(tick_value);

if(scale_&CA_REV){

if(_pos<min_pos_-canvas_->border()) continue;

if(_pos>max_pos_+canvas_->border()) break;

}else{

if(_pos<max_pos_-canvas_->border()) break;

if(_pos>min_pos_+canvas_->border()) continue;

}

if(!(axis_align_&CA_NO_TICS)){

fl_begin_loop();

if(tick_index % major_step_){

fl_vertex(l1,_pos);

fl_vertex(l2,_pos);

}else{

fl_vertex(m1,_pos);

fl_vertex(m2,_pos);

}

fl_end_loop();

}

if(!((tick_index % label_step_)|(axis_align_&CA_NO_LABELS))){

char label[MAX_LABEL_LENGTH];

char _label_format[MAX_LABEL_FORMAT];

if(!label_format){

int _tick_order;

if (tick_order>=0)

_tick_order=0;

else

_tick_order=-tick_order;

sprintf(_label_format,"%s.%if","%",_tick_order);

}

else

strcpy(_label_format,label_format);

sprintf(label, _label_format,tick_value);

fl_measure(label,_w,_h);

_y=_pos+_h/3;

switch (axis_align_ & CA_ALIGNMENT){

case CA_LEFT:

_x=m1-_h/3-_w;

break;

case CA_RIGHT:

_x=m2+_h/3;

break;

case CA_CENTER:

_x=(m1+m2)/2-_w/2;

Fl_Color _color=fl_color();

fl_color(color());

ca_rectf(_x-_h/6,_pos-_h/2,_w+_h/3,_h);

fl_color(_color);

break;

}

ca_text(label,_x,_y);

}

fl_line_style(0);

fl_pop_clip();

}

};

void Ca_Y_Axis::current(){

canvas_->current_y(this);

};

void Ca_Y_Axis::draw_grid(){

if(!valid_)return;

int tick_index=-1;

double tick_value;

int tick_order;

double _interval=0;

int l1,l2;

l1=canvas_->x()+Fl::box_dx(canvas_->box());

l2=canvas_->x()+canvas_->w()+Fl::box_dx(canvas_->box())-Fl::box_dw(canvas_->box());

int tcl;

if(!(tcl=tick_length_))

tcl=label_font_size_;

while(next_tick(tick_index, tick_value, tick_order,_interval)){

double _pos=position(tick_value);

if(scale_&CA_REV){

if(_pos<min_pos_-canvas_->border()) continue;

if(_pos>max_pos_+canvas_->border()) break;

}else{

if(_pos<max_pos_-canvas_->border()) break;

if(_pos>min_pos_+canvas_->border()) continue;

}

int grt;

if((grt=grid_visible_&CA_LABEL_GRID) && !(tick_index % label_step_)){

fl_color(label_grid_color_);

fl_line_style(label_grid_style_,label_grid_width_);

if(grt==CA_LABEL_GRID){

fl_begin_loop();

fl_vertex(l1,_pos);

fl_vertex(l2,_pos);

fl_end_loop();

}else{

if(grt&CA_LEFT_LABEL_TICK){

fl_begin_loop();

fl_vertex(l1,_pos);

fl_vertex(l1+tcl,_pos);

fl_end_loop();

}

if(grt&CA_RIGHT_LABEL_TICK){

fl_begin_loop();

fl_vertex(l2-tcl,_pos);

fl_vertex(l2,_pos);

fl_end_loop();

}

}else if((grt=grid_visible_&CA_MAJOR_GRID) && !(tick_index % major_step_)){

fl_color(major_grid_color_);

fl_line_style(major_grid_style_,major_grid_width_);

if(grt==CA_MAJOR_GRID){

fl_begin_loop();

fl_vertex(l1,_pos);

fl_vertex(l2,_pos);

fl_end_loop();

}else{

if(grt&CA_LEFT_MAJOR_TICK){

fl_begin_loop();

fl_vertex(l1,_pos);

fl_vertex(l1+tcl,_pos);

fl_end_loop();

}

if(grt&CA_RIGHT_MAJOR_TICK){

fl_begin_loop();

fl_vertex(l2-tcl,_pos);

fl_vertex(l2,_pos);

fl_end_loop();

}

}else if((grt=(grid_visible_&CA_MINOR_GRID))){

fl_color(minor_grid_color_);

fl_line_style(minor_grid_style_,minor_grid_width_);

if(grt==CA_MINOR_GRID){

fl_begin_loop();

fl_vertex(l1,_pos);

fl_vertex(l2,_pos);

fl_end_loop();

}else{

if(grt&CA_LEFT_MINOR_TICK){

fl_begin_loop();

fl_vertex(l1,_pos);

fl_vertex(l1+tcl/2,_pos);

fl_end_loop();

}

if(grt&CA_RIGHT_MINOR_TICK){

fl_begin_loop();

fl_vertex(l2-tcl/2,_pos);

fl_vertex(l2,_pos);

fl_end_loop();

}

fl_line_style(0,0);

fl_color(FL_BLACK);

};

Ca_Y_Axis::Ca_Y_Axis(int x, int y, int w, int h, const char * label):Ca_Axis_(x, y, w, h, label){

if(!(canvas_->current_y()))

current();

axis_align(CA_LEFT|CA_LINE);

};

Ca_Y_Axis::~Ca_Y_Axis(){

if(canvas_){

Ca_ObjectChain *ochain=canvas_->first_object_;

Ca_ObjectChain *next;

Ca_ObjectChain *previous=0;

while (ochain){

next=ochain->next;

if(ochain->object->y_axis_==this){

delete ochain->object;

if(previous)

previous->next=next;

else

canvas_->first_object_=next;

delete ochain;

}

ochain=next;

}

/////////////////////////////// Ca_Canvas ////////////////////////////////////////////

Ca_Canvas *Ca_Canvas::current_=0;

void Ca_Canvas::draw(){

uchar damage_= damage();

// int _b=border_/2;

// int _x=x()+_b;

// int _y=y()+_b;

// int _w=w()-2*_b;

// int _h=h()-2*_b;

int replot=0;

Ca_Axis_ *axis = last_axis_;

/// something similar will go in the future into the lauout layer...

while (axis){

replot |= axis->update();

axis=axis->previous_axis_;

}

///

if(damage_!=CA_DAMAGE_ADD)

draw_box();

if((damage_!=CA_DAMAGE_ADD)||replot){

last_plotted_=0;

axis=last_axis_;

while(axis){

if(!(axis->grid_visible()&CA_FRONT)&&(axis->visible()||(axis->grid_visible()&CA_ALWAYS_VISIBLE)))

axis->draw_grid();

axis=axis->previous_axis_;

}

fl_clip(x()+Fl::box_dx(box())+dx_, y()+Fl::box_dy(box())+border_+dy_, w()-Fl::box_dw(box()) - dw_, h()-Fl::box_dh(box()) - dh_);

if (last_plotted_)

last_plotted_=last_plotted_->next;

else

last_plotted_=first_object_;

while(last_plotted_){

last_plotted_->object->draw();

last_plotted_=last_plotted_->next;

}

last_plotted_=last_object_;

fl_pop_clip();

axis=last_axis_;

while(axis){

if((axis->grid_visible()&CA_FRONT)&&(axis->visible()||(axis->grid_visible()&CA_ALWAYS_VISIBLE)))

axis->draw_grid();

axis=axis->previous_axis_;

}

if (damage_&FL_DAMAGE_ALL)

draw_label();

};

void Ca_Canvas::add_object(Ca_Object_ * object){

last_object_=last_object_->next=new Ca_ObjectChain();

last_object_->object=object;

};

void Ca_Canvas::clear(){

while(first_object_)

delete first_object_->object;

damage(CA_DAMAGE_ALL);

};

Ca_Canvas::Ca_Canvas(int x, int y, int w, int h, const char *label)

:Fl_Box(x,y,w,h,label),

last_axis_(0),border_(CANVAS_BORDER), current_x_(0), current_y_(0),

first_object_(0),last_object_(0),last_plotted_(0), dx_(0), dy_(0), dw_(0), dh_(0)

{

current(this);

};

void Ca_Canvas::border(int border){

border_=border;

damage(CA_DAMAGE_ALL);

Ca_Axis_ *axis=last_axis_;

while(axis){

axis->damage(CA_DAMAGE_ALL);

axis=axis->previous_axis_;

}

};

Ca_Canvas::~Ca_Canvas(){

clear();

Ca_Axis_ *axis=last_axis_;

while(axis){

last_axis_=axis->previous_axis_;

axis->canvas_=0;

axis = last_axis_;

}

};

//////////////////////// Ca_Object //////////////////////

Ca_Object_::Ca_Object_(Ca_Canvas * canvas)

:canvas_(canvas)

{

if(!canvas_)

canvas_=Ca_Canvas::current();

Ca_ObjectChain *objectchain=new(Ca_ObjectChain);

objectchain->object=this;

objectchain->next=0;

if(canvas_->last_object_)

canvas_->last_object_=canvas_->last_object_->next=objectchain;

else

canvas_->last_object_=canvas_->first_object_=objectchain;

x_axis_=canvas_->current_x();

y_axis_=canvas_->current_y();

canvas_->damage(CA_DAMAGE_ADD);

};

Ca_Object_::~Ca_Object_(){

Ca_ObjectChain * objectchain=canvas_->first_object_;

Ca_ObjectChain * previouschain=0;

while(objectchain->object!=this){

previouschain=objectchain;

objectchain=objectchain->next;

}

if(previouschain)

previouschain->next=objectchain->next;

else

canvas_->first_object_=objectchain->next;

if(canvas_->last_object_==objectchain)

canvas_->last_object_=previouschain;

delete objectchain;

canvas_->last_plotted_=0;

canvas_->damage(CA_DAMAGE_ALL);

};

///////////////////////// Ca_Point //////////////////////////////////////////////////////

void Ca_Point::draw(){

fl_color(color);

double s,t;

double _x=x_axis_->position(x);

double _y=y_axis_->position(y);

switch(style & CA_POINT_STYLE){

case CA_NO_POINT:

break;

case CA_SIMPLE:

ca_point(_x,_y);

break;

case CA_ROUND:

ca_filled_circle(_x,_y,size);

//ca_pie(_x-size,_y-size,2*size,2*size,0,360);

if (style & CA_BORDER){

fl_color(border_color);

fl_line_style(0,border_width);

fl_begin_loop();

fl_circle(_x,_y,size);

fl_end_loop();

fl_line_style(0,0);

}

break;

case CA_SQUARE:

ca_rectf(_x-size,_y-size,2*size,2*size);

if (style & CA_BORDER){

fl_color(border_color);

fl_line_style(0,border_width);

ca_rect(_x-size,_y-size,2*size,2*size);

fl_line_style(0,0);

}

break;

case CA_UP_TRIANGLE:

s=(int)(1.12*size+0.5);

t=_y+size/3;

ca_polygon(_x,t-2*size,_x-s,t,_x+s,t);

if (style & CA_BORDER){

fl_color(border_color);

fl_line_style(0,border_width);

ca_loop(_x,t-2*size,_x-s,t,_x+s,t);

fl_line_style(0,0);

}

break;

case CA_DOWN_TRIANGLE:

s=(int)(1.12*size+0.5);

t=_y-size/3;

ca_polygon(_x,t+2*size,_x-s,t,_x+s,t);

if (style & CA_BORDER){

fl_color(border_color);

fl_line_style(0,border_width);

ca_loop(_x,t+2*size,_x-s,t,_x+s,t);

fl_line_style(0,0);

}

break;

case CA_DIAMOND:

s=(int)(1.3*size+0.5);

ca_polygon(_x,_y-s,_x-s,_y,_x,_y+s,_x+s,_y);

if (style & CA_BORDER){

fl_color(border_color);

fl_line_style(0,border_width);

ca_loop(_x,_y-s,_x-s,_y,_x,_y+s,_x+s,_y);

fl_line_style(0,0);

}

break;

}

};

Ca_Point::Ca_Point(double _x, double _y, Fl_Color _color, int _style, int _size, Fl_Color _border_color, int _border_width)

:Ca_Object_(0),

x(_x),

y(_y),

style(_style),

size(_size),

color(_color),

border_color(_border_color),

border_width(_border_width)

{

};

//////////////////////////// Ca_LinePoint ////////////////////////////////////////////////////////

void Ca_LinePoint::draw(){

Ca_Point::draw();

if(previous){

fl_color(color);

fl_line_style(0,line_width);

fl_begin_line();

fl_vertex(previous->x_axis_->position(previous->x),previous->y_axis_->position(previous->y));

fl_vertex(x_axis_->position(x),y_axis_->position(y));

fl_end_line();

fl_line_style(0,0);

}

};

Ca_LinePoint::Ca_LinePoint( Ca_LinePoint *_previous, double _x, double _y,int _line_width, Fl_Color color, int style, int size, Fl_Color border_color, int _border_width):Ca_Point(_x, _y, color, style, size, border_color, _border_width){

previous=_previous;

line_width=_line_width;

};

Ca_LinePoint::Ca_LinePoint(Ca_LinePoint *_previous, double _x, double _y)

:Ca_Point(_x, _y, previous->color, previous->style, previous->size,previous->border_color, previous->border_width),

previous(_previous)

{

if(_previous)

line_width=_previous->line_width;

else

line_width=0;

};

//////////////////////////// Ca_PolyLine ////////////////////////////////////////////////////////

Ca_PolyLine::Ca_PolyLine(Ca_PolyLine *_previous, double _x, double _y,int _line_style, int _line_width, Fl_Color color, int style, int size, Fl_Color border_color,int _border_width)

:Ca_LinePoint(_previous, _x, _y, _line_width, color, style, size, border_color, _border_width),

line_style(_line_style)

{

next=0;

if(_previous) _previous->next=this;

canvas_->damage(CA_DAMAGE_ALL);

};

Ca_PolyLine::Ca_PolyLine(Ca_PolyLine *_previous, double _x, double _y):Ca_LinePoint(_previous,x,y){

next=0;

if(_previous){

line_style=_previous->line_style;

_previous->next=this;

}

canvas_->damage(CA_DAMAGE_ALL);

};

void Ca_PolyLine::draw(){

Ca_Point::draw();

if(next) return;

Ca_PolyLine * temp;

int c=color;

int style=line_style;

int size=line_width;

fl_color(c);

fl_line_style(style,size);

fl_begin_line();

fl_vertex(x_axis_->position(x),y_axis_->position(y));

temp=(Ca_PolyLine *)previous;

while(temp){

fl_vertex(temp->x_axis_->position(temp->x),temp->y_axis_->position(temp->y));

if((temp->line_style != style)||(temp->color!=c)||(temp->line_width!=size)){

fl_end_line();

c=temp->color;

style=temp->line_style;

size=temp->line_width;

fl_color(c);

fl_line_style(style,size);

fl_begin_line();

fl_vertex(temp->x_axis_->position(x),temp->y_axis_->position(y));

}

temp=(Ca_PolyLine *)(temp->previous);

}

fl_end_line();

fl_line_style(0,0);

};

Ca_Line::Ca_Line(int _n, double *_data, double *_data_2, int _line_style, int _line_width, Fl_Color color, int style, int size, Fl_Color border_color, int border_width)

:Ca_Point(0, 0, color, style, size, border_color, border_width),

line_style(_line_style),

line_width(_line_width),

n(_n),

data(_data),

data_2(_data_2)

{};

Ca_Line::Ca_Line(int _n, double *_data, int _line_style, int _line_width, Fl_Color color, int style, int size, Fl_Color border_color, int border_width)

:Ca_Point(0, 0, color, style, size, border_color, border_width),

line_style(_line_style),

line_width(_line_width),

n(_n),

data(_data),

data_2(0)

{};

void Ca_Line::draw(){

fl_color(color);

fl_line_style(line_style,line_width);

fl_begin_line();

int i;

if(data_2){

for(i=0;i<n;i++)

fl_vertex(x_axis_->position(data[i]),y_axis_->position(data_2[i]));

fl_end_line();

fl_line_style(0,0);

for(i=0;i<n;i++){

x=data[i];

y=data_2[i];

Ca_Point::draw();

}

}else{

for(i=0;i<n;i++)

fl_vertex(x_axis_->position(data[2*i]),y_axis_->position(data[2*i+1]));

fl_end_line();

for(i=0;i<n;i++){

x=data[2*i];

y=data[2*i+1];

Ca_Point::draw();

}

fl_line_style(0,0);

}

};

void Ca_Text::draw(){

uchar align_=align;

double X,Y,W,H;

double X1,Y1;

X = x_axis_->position(x1);

X1 = x_axis_->position(x2);

if(X1>X)

W=X1-X;

else{

W=X-X1;

X=X1;

}

Y = y_axis_->position(y1);

Y1 = y_axis_->position(y2);

if(Y1>Y)

H = Y1-Y;

else{

H = Y-Y1;

Y = Y1;

}

fl_color(label_color);

fl_font(label_font,label_size);

ca_text(label,X,Y,W,H,(Fl_Align)align_);

};

Ca_Text::Ca_Text(double _x1, double _x2, double _y1, double _y2, char *_label, uchar _align, Fl_Font _label_font, int _label_size, Fl_Color _label_color)

:Ca_Object_(0),

x1(_x1), x2(_x2), y1(_y1), y2(_y2),

label(_label),

align(_align),

label_color(_label_color),

label_font(_label_font),

label_size(_label_size)

{};

Ca_Text::Ca_Text(double x, double y,char *_label, uchar _align, Fl_Font _label_font, int _label_size, Fl_Color _label_color)

:Ca_Object_(0),

x1(x), x2(x), y1(y), y2(y),

label(_label),

align(_align),

label_color(_label_color),

label_font(_label_font),

label_size(_label_size)

{};

void Ca_Bar::draw(){

uchar align_=align;

double X,Y,W,H;

double X1,Y1;

X = x_axis_->position(x1);

X1 = x_axis_->position(x2);

if(X1>X)

W=X1-X;

else{

W=X-X1;

X=X1;

}

Y = y_axis_->position(y1);

Y1 = y_axis_->position(y2);

if(Y1>Y)

H = Y1-Y;

else{

H = Y-Y1;

Y = Y1;

}

fl_color(color);

ca_rectf(X,Y,W,H);

if(border_width>=0){

fl_color(border_color);

fl_line_style(FL_SOLID|FL_CAP_SQUARE, border_width);

ca_rect(X,Y,W,H);

}

fl_line_style(0,0);

if(!(align_&15)||(align_&FL_ALIGN_INSIDE)){

X += border_width/2;

W -= border_width;

Y += border_width/2;

H -= border_width;

}else{

X -= border_width/2;

W += border_width;

Y -= border_width/2;

H += border_width;

if (align_ & FL_ALIGN_TOP){

align_ ^= (FL_ALIGN_BOTTOM|FL_ALIGN_TOP);

H=Y;

Y=canvas_->y()+Fl::box_dy(canvas_->box());

H-=Y;

}else if(align_ & FL_ALIGN_BOTTOM){

align_^=(FL_ALIGN_BOTTOM|FL_ALIGN_TOP);

Y=Y+H;

H=canvas_->y()+canvas_->h()+Fl::box_dy(canvas_->box())-Fl::box_dh(canvas_->box())-Y;

}else if(align_ & FL_ALIGN_LEFT){

align_^=(FL_ALIGN_LEFT|FL_ALIGN_RIGHT);

W=X;

X=canvas_->x()+Fl::box_dx(canvas_->box());

W=W-X-3;

}else if(align_ & FL_ALIGN_RIGHT){

align_ ^=(FL_ALIGN_LEFT|FL_ALIGN_RIGHT);

X=X+W+3;

W=canvas_->x()+Fl::box_dx(canvas_->box())+canvas_->w()-Fl::box_dw(canvas_->box())-X;

}

fl_color(label_color);

fl_font(label_font,label_size);

ca_text(label,X,Y,W,H,(Fl_Align)align_);

};

Ca_Bar::Ca_Bar(double _x1, double _x2, double _y1, double _y2, Fl_Color _color, Fl_Color _border_color, int _border_width, char *_label, uchar _align, Fl_Font _label_font, int _label_size, Fl_Color _label_color)

:Ca_Text(_x1, _x2, _y1, _y2, _label, _align, _label_font, _label_size, _label_color),

color(_color),

border_color(_border_color),

border_width(_border_width)

{

};

////////////////////////////////////////////////////////////////////////////////////////

// Cartesian.H,v 0.9

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Library General Public License

// version 2 as published by the Free Software Foundation.

//

// This library is distributed WITHOUT ANY WARRANTY;

// WITHOUT even the implied warranty of MERCHANTABILITY

// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

// Library General Public License for more details.

// You should have received a copy of the GNU Library General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

#include <math.h>

#include <FL/Fl.H>

#include <FL/Fl_Overlay_Window.H>

#include <FL/Fl_Light_Button.H>

#include "Cartesian.H"

#include <FL/fl_draw.H>

#ifdef FL_DEVICE // this is for printing using Fl_Device patch

#include <FL/Fl_Printer.H>

#include <FL/Fl_PostScript.H>

#include <FL/fl_file_chooser.H>

void print(Fl_Widget *, void *w) {

Fl_Widget * g = (Fl_Widget *)w;

char * filename = fl_file_chooser("Print to file...","*.ps","*.ps");

if(!filename) return;

FILE * f = fopen(filename,"w");

if(!f) return;

Fl_Printer * p = new Fl_PostScript(f, 3, Fl_Printer::A4, Fl_Printer::PORTRAIT);

p->page();

p->fit(g, FL_ALIGN_CENTER);

p->draw(g);

delete p;

};

void print2(Fl_Widget *, void *w) {

Fl_Widget * g = (Fl_Widget *)w;

Fl_Printer * p = fl_gdi_printer_chooser();

if(!p) return;

p->page();

p->fit(g, FL_ALIGN_CENTER);

p->draw(g);

delete p;

};

#endif

const double PI=3.1416;

const double MIN_FREQ=90;

const double MAX_FREQ=25000;

const double FREQ_COEF=1.15;

Ca_X_Axis* frequency;

Ca_Y_Axis* current;

Ca_Y_Axis* power;

Ca_Y_Axis* phase;

Fl_Light_Button *logarithmic;

Fl_Light_Button *reversed;

double R=600;

double L=0.16;

double C=1.6e-7;

double U=1;

Ca_Canvas *canvas;

void type_callback(Fl_Widget *, void *){

power->scale((CA_LOG*logarithmic->value())|CA_REV*reversed->value());

}

void next_freq(void *){

static double f=MIN_FREQ;

static Ca_LinePoint *P_I=0;

static Ca_PolyLine *P_P=0;

double XL=2*PI*f*L;

double XC=1/(2*PI*f*C);

double I,P,fi;

I=U/sqrt(R*R+(XL-XC)*(XL-XC));

P=I*I*R;

fi=atan((XL-XC)/R);

phase->current(); //setting coordinate

new Ca_Point(f,fi,FL_YELLOW,CA_DIAMOND|CA_BORDER);current->current(); //setting coordinate

current->rescale(CA_WHEN_MAX,I*1100); //different rescalling for max and min just to get some extra gap

current->rescale(CA_WHEN_MIN,I*1000); //above maximum

P_I=new Ca_LinePoint(P_I,f,I*1000,0,FL_BLUE,CA_ROUND|CA_BORDER);

power->current(); //setting coordinate

power->rescale(CA_WHEN_MIN|CA_WHEN_MAX,P*1000);

P_P=new Ca_PolyLine(P_P,f,P*1000,FL_DASHDOT,2,FL_RED,CA_NO_POINT);

f =f* FREQ_COEF;

if(f<=MAX_FREQ)

Fl::add_timeout(.1,next_freq);

else{

power->current();

//new Ca_Text(1000,1,"Text\ntest!");

}

};

int main(int argc, char ** argv) {

Fl_Double_Window *w= new Fl_Double_Window(580, 380, "Cartesian graphics example");

w->size_range(450,250);

Fl_Group *c =new Fl_Group(0, 35, 580, 345 );

c->box(FL_DOWN_BOX);

c->align(FL_ALIGN_TOP|FL_ALIGN_INSIDE);

canvas = new Ca_Canvas(180, 75, 300, 225, "RLC resonance circuit");

canvas->box(FL_DOWN_BOX);

canvas->color(7);

canvas->align(FL_ALIGN_TOP);

Fl_Group::current()->resizable(canvas);

// w->resizable(canvas);

canvas->border(15);

frequency = new Ca_X_Axis(180, 305, 300, 30, "Frequency [Hz]");

frequency->align(FL_ALIGN_BOTTOM);

frequency->scale(CA_LOG);

frequency->minimum(MIN_FREQ);

frequency->maximum(MAX_FREQ);

frequency->label_format("%g");

frequency->minor_grid_color(fl_gray_ramp(20));

frequency->major_grid_color(fl_gray_ramp(15));

frequency->label_grid_color(fl_gray_ramp(10));

frequency->grid_visible(CA_MINOR_GRID|CA_MAJOR_GRID|CA_LABEL_GRID);

frequency->major_step(10);

frequency->label_step(10);

frequency->axis_color(FL_BLACK);

frequency->axis_align(CA_BOTTOM|CA_LINE);

current = new Ca_Y_Axis(100, 70, 78, 235, "I [mA]");

current->align(FL_ALIGN_TOP_RIGHT);

current->minor_grid_style(FL_DASH);

current->axis_align(CA_LEFT);

current->axis_color(FL_BLACK);

power = new Ca_Y_Axis(10, 70, 75, 235, "P [mW]");

power->box(FL_DOWN_BOX);

power->align(FL_ALIGN_TOP);

power->grid_visible(CA_MINOR_TICK|CA_MAJOR_TICK|CA_LABEL_GRID|CA_ALWAYS_VISIBLE);

//power->minor_grid_style(FL_DOT);

power->minor_grid_color(FL_RED);

power->major_grid_color(FL_RED);

power->label_grid_color(FL_RED);

power->minimum(0.01); //setting beggining range

power->maximum(1);

//power->hide();

phase = new Ca_Y_Axis(480, 70, 60, 235, "Phase [rad]");

phase->align(FL_ALIGN_TOP_LEFT);

phase->minimum(-PI);

phase->maximum(PI);

phase->axis_align(CA_RIGHT);

phase->tick_interval(-PI/4); //fixed ticks setting

phase->major_step(2);

phase->label_step(4);

phase->label_format("%.2f");

power->current();

//double d1[]={100,300,1000,3000,10000};

//double d2[]={.2,1,0.5,0.7,0.2};

//double d3[]={100,.2,300,1,1000,.5,3000,.7,10000,.2};

//new Ca_Line(5, d3, FL_DOT,0,FL_RED,CA_ROUND|CA_BORDER);

new Ca_Bar(7000, 12000, 0.0011, 0.9, FL_RED, FL_BLACK, 4, "Bar", FL_ALIGN_TOP, FL_HELVETICA);

new Ca_Bar(5000, 10000, 0.0011, 0.4, FL_GREEN, FL_BLACK, 4, "Sec.\nbar", FL_ALIGN_TOP|FL_ALIGN_INSIDE, FL_HELVETICA);

logarithmic=new Fl_Light_Button(10,310, 75, 25, "Log");

logarithmic->callback(&type_callback);

reversed= new Fl_Light_Button(10,340, 75, 25, "Rev");

reversed->callback(&type_callback);

c->end();

#ifdef FL_DEVICE

Fl_Button *b2 = new Fl_Button(5,5, 90, 25, "Print to file");

b2->callback(print,c);

Fl_Button *b3 = new Fl_Button(105,5, 90, 25, "Print");

b3->callback(print2,c);

#endif

Fl_Group::current()->resizable(c);

w->end();

w->show();

Fl::add_timeout(0,next_freq);

Fl::run();

return 0;

};