flv_style.cxx

PIXIL is a small footprint operating environment, complete with PDA PIM applications, a browser and

//      ======================================================================
//      File:    Flv_Style.cxx - Flv_Style implementation
//      Program: Flv_Style - FLTK Virtual List/Table Styles Widget
//      Version: 0.1.0
//      Started: 11/21/99
//
//      Copyright (C) 1999 Laurence Charlton
//
//      Description:
//      The styles classes are basically defined to make life easier while
//      working with styles for the virtual classes.
//      ======================================================================

#include <FL/Fl_Widget.H>
#include <Flek/Flv_Style.H>
#include <stdio.h>
#ifdef WIN32
#include <mem.h>
#else
#include <memory.h>
#include <string.h>
#endif

#define ADDSIZE 10

//      Flv_Style bits
#define STYLE_DEFINE_FONT						0x0001
#define STYLE_DEFINE_FONT_SIZE			0x0002
#define STYLE_DEFINE_FOREGROUND			0x0004
#define STYLE_DEFINE_BACKGROUND			0x0008
#define STYLE_DEFINE_ALIGN					0x0010
#define STYLE_DEFINE_FRAME					0x0020
#define STYLE_DEFINE_RESIZABLE			0x0040
#define STYLE_DEFINE_HEIGHT					0x0080
#define STYLE_DEFINE_WIDTH					0x0100
#define STYLE_DEFINE_LOCKED					0x0200
#define STYLE_DEFINE_BORDER					0x0400
#define STYLE_DEFINE_BORDER_COLOR		0x0800
#define STYLE_DEFINE_BORDER_SPACING	0x1000
#define STYLE_DEFINE_X_MARGIN				0x2000
#define STYLE_DEFINE_Y_MARGIN				0x4000
#define STYLE_DEFINE_EDITOR					0x8000

#define CLEAR(n) vdefined &= ~(n)
#define DEFINED(n) ((vdefined & (n))!= 0)
#define DEFINED2(v,n) ((v.vdefined & (n))!= 0)

Flv_Style::Flv_Style()
{
    vdefined = 0;
    vvalue = 0;
    //      I'm not worried about initializing the rest of the private
    //      variables since they are undefined.
}

Flv_Style::Flv_Style(int value)
{
    vdefined = 0;
    vvalue = value;
    //      I'm not worried about initializing the rest of the private
    //      variables since they are undefined.
}

//      ==================================================================
//      Set drawing alignment
const Fl_Align &
Flv_Style::align(const Fl_Align & n)
{
    valign = n;
    vdefined |= STYLE_DEFINE_ALIGN;
    return valign;
}

//      Undefine drawing alignment
void
Flv_Style::clear_align(void)
{
    CLEAR(STYLE_DEFINE_ALIGN);
}

//      Is drawing alignment defined?
bool
Flv_Style::align_defined(void) const
{
    return DEFINED(STYLE_DEFINE_ALIGN);
}

//      ==================================================================
//      Set background color
Fl_Color
Flv_Style::background(Fl_Color n)
{
    vbackground = n;
    vdefined |= STYLE_DEFINE_BACKGROUND;
    return vbackground;
}

//      Undefine background color
void
Flv_Style::clear_background(void)
{
    CLEAR(STYLE_DEFINE_BACKGROUND);
}

//      Is background defined?
bool
Flv_Style::background_defined(void) const
{
    return DEFINED(STYLE_DEFINE_BACKGROUND);
}


//      ==================================================================
//      Set border
int
Flv_Style::border(int n)
{
    vborder = (unsigned char) n;
    vdefined |= STYLE_DEFINE_BORDER;
    return vborder;
}

//      Undefine border
void
Flv_Style::clear_border(void)
{
    CLEAR(STYLE_DEFINE_BORDER);
}

//      Is border defined?
bool
Flv_Style::border_defined(void) const
{
    return DEFINED(STYLE_DEFINE_BORDER);
}

//      ==================================================================
//      Set border_color
Fl_Color
Flv_Style::border_color(Fl_Color n)
{
    vborder_color = n;
    vdefined |= STYLE_DEFINE_BORDER_COLOR;
    return vborder_color;
}

//      Undefine border_color
void
Flv_Style::clear_border_color(void)
{
    CLEAR(STYLE_DEFINE_BORDER_COLOR);
}

//      Is border_color defined?
bool
Flv_Style::border_color_defined(void) const
{
    return DEFINED(STYLE_DEFINE_BORDER_COLOR);
}


//      ==================================================================
//      Set border_spacing
int
Flv_Style::border_spacing(int n)
{
    vborder_spacing = (unsigned char) n;
    vdefined |= STYLE_DEFINE_BORDER_SPACING;
    return vborder_spacing;
}

//      Undefine border_spacing
void
Flv_Style::clear_border_spacing(void)
{
    CLEAR(STYLE_DEFINE_BORDER_SPACING);
}

//      Is border_spacing defined?
bool
Flv_Style::border_spacing_defined(void) const
{
    return DEFINED(STYLE_DEFINE_BORDER_SPACING);
}

//      ==================================================================
//      Set content editor
Fl_Widget *
Flv_Style::editor(Fl_Widget * v)
{
    veditor = v;
    if (Fl::focus() != v && veditor)
	veditor->hide();
    vdefined |= STYLE_DEFINE_EDITOR;
    return veditor;
}

//      Undefine border_spacing
void
Flv_Style::clear_editor(void)
{
    CLEAR(STYLE_DEFINE_EDITOR);
}

//      Is border_spacing defined?
bool
Flv_Style::editor_defined(void) const
{
    return DEFINED(STYLE_DEFINE_EDITOR);
}

//      ==================================================================
//      Set current font
const Fl_Font &
Flv_Style::font(const Fl_Font & n)
{
    vfont = n;
    vdefined |= STYLE_DEFINE_FONT;
    return vfont;
}

//      Undefine font
void
Flv_Style::clear_font(void)
{
    CLEAR(STYLE_DEFINE_FONT);
}

//      Is font defined
bool
Flv_Style::font_defined(void) const
{
    return DEFINED(STYLE_DEFINE_FONT);
}

//      ==================================================================
//      Set font size
int
Flv_Style::font_size(int n)
{
    if (n < 1)			//      Clip at 1 as the smallest font size
	n = 1;
    vfont_size = n;
    vdefined |= STYLE_DEFINE_FONT_SIZE;
    return vfont_size;
}

//      Undefine font size
void
Flv_Style::clear_font_size(void)
{
    CLEAR(STYLE_DEFINE_FONT_SIZE);
}

//      Is font size defined?
bool
Flv_Style::font_size_defined(void) const
{
    return DEFINED(STYLE_DEFINE_FONT_SIZE);
}

//      ==================================================================
//      Set foreground color
Fl_Color
Flv_Style::foreground(Fl_Color n)
{
    vforeground = n;
    vdefined |= STYLE_DEFINE_FOREGROUND;
    return vforeground;
}

//      Undefine foreground color
void
Flv_Style::clear_foreground(void)
{
    CLEAR(STYLE_DEFINE_FOREGROUND);
}

//      Is foreground defined?
bool
Flv_Style::foreground_defined(void) const
{
    return DEFINED(STYLE_DEFINE_FOREGROUND);
}

//      ==================================================================
//      Set frame type
const Fl_Boxtype &
Flv_Style::frame(const Fl_Boxtype & n)
{
    vframe = n;
    vdefined |= STYLE_DEFINE_FRAME;
    return vframe;
}

//      Undefine frame type
void
Flv_Style::clear_frame(void)
{
    CLEAR(STYLE_DEFINE_FRAME);
}

//      Is frame type defined?
bool
Flv_Style::frame_defined(void) const
{
    return DEFINED(STYLE_DEFINE_FRAME);
}

//      ==================================================================
//      Set height
int
Flv_Style::height(int n)
{
    if (n < 0)
	n = 0;
    vdefined |= STYLE_DEFINE_HEIGHT;
    return (vheight = n);
}

//      Undefine row height
void
Flv_Style::clear_height(void)
{
    CLEAR(STYLE_DEFINE_HEIGHT);
}

//      Is row height defined?
bool
Flv_Style::height_defined(void) const
{
    return DEFINED(STYLE_DEFINE_HEIGHT);
}

//      ==================================================================
//      Set locked
bool
Flv_Style::locked(bool n)
{
    vdefined |= STYLE_DEFINE_LOCKED;
    return (vlocked = n);
}

//      Undefine locked
void
Flv_Style::clear_locked(void)
{
    CLEAR(STYLE_DEFINE_LOCKED);
}

//      Is locked defined?
bool
Flv_Style::locked_defined(void) const
{
    return DEFINED(STYLE_DEFINE_LOCKED);
}

//      ==================================================================
//      Set resizable
bool
Flv_Style::resizable(bool n)
{
    vresizable = n;
    vdefined |= STYLE_DEFINE_RESIZABLE;
    return vresizable;
}

//      Undefine resizable
void
Flv_Style::clear_resizable(void)
{
    CLEAR(STYLE_DEFINE_RESIZABLE);
}

//      Is resizable defined?
bool
Flv_Style::resizable_defined(void) const
{
    return DEFINED(STYLE_DEFINE_RESIZABLE);
}

//      ==================================================================
//      Set column width
int
Flv_Style::width(int n)
{
    if (n < 0)
	n = 0;
    vdefined |= STYLE_DEFINE_WIDTH;
    return (vwidth = n);
}