CSS::SAC::LexicalUnit - SAC units

  use CSS::SAC::LexicalUnit qw(:constants);
  foo if $lu->is_type(LU_TYPE_CONSTANT);

###
# CSS::SAC::LexicalUnit - SAC units
# Robin Berjon <robin@knowscape.com>
# 24/02/2001
###

package CSS::SAC::LexicalUnit;
use strict;
use vars qw($VERSION);
$VERSION = $CSS::SAC::VERSION || '0.03';

#---------------------------------------------------------------------#
# build the fields for an array based object
#---------------------------------------------------------------------#
use Class::ArrayObjects define => {
                                   fields => [qw(
                                                 _type_
                                                 _value_
                                                 _text_
                                               )],
                                  };
#---------------------------------------------------------------------#


### Constants #########################################################
#                                                                     #
#                                                                     #


sub ATTR                () {  1 }
sub CENTIMETER          () {  2 }
sub COUNTER_FUNCTION    () {  3 }
sub COUNTERS_FUNCTION   () {  4 }
sub DEGREE              () {  5 }
sub DIMENSION           () {  6 }
sub EM                  () {  7 }
sub EX                  () {  8 }
sub FUNCTION            () {  9 }
sub GRADIAN             () { 10 }
sub HERTZ               () { 11 }
sub IDENT               () { 12 }
sub INCH                () { 13 }
sub INHERIT             () { 14 }
sub INTEGER             () { 15 }
sub KILOHERTZ           () { 16 }
sub MILLIMETER          () { 17 }
sub MILLISECOND         () { 18 }
sub OPERATOR_COMMA      () { 19 }
sub OPERATOR_EXP        () { 20 }
sub OPERATOR_GE         () { 21 }
sub OPERATOR_GT         () { 22 }
sub OPERATOR_LE         () { 23 }
sub OPERATOR_LT         () { 24 }
sub OPERATOR_MINUS      () { 25 }
sub OPERATOR_MOD        () { 26 }
sub OPERATOR_MULTIPLY   () { 27 }
sub OPERATOR_PLUS       () { 28 }
sub OPERATOR_SLASH      () { 29 }
sub OPERATOR_TILDE      () { 30 }
sub PERCENTAGE          () { 31 }
sub PICA                () { 32 }
sub PIXEL               () { 33 }
sub POINT               () { 34 }
sub RADIAN              () { 35 }
sub REAL                () { 36 }
sub RECT_FUNCTION       () { 37 }
sub RGBCOLOR            () { 38 }
sub SECOND              () { 39 }
sub STRING_VALUE        () { 40 }
sub SUB_EXPRESSION      () { 41 }
sub UNICODERANGE        () { 42 }
sub URI                 () { 43 }



#---------------------------------------------------------------------#
# import()
# all import can do is export the constants
#---------------------------------------------------------------------#
sub import {
    my $class = shift;
    my $tag = shift || '';

    # check that we have the right tag
    return unless $tag eq ':constants';

    # define some useful vars
    my $pkg = caller;
    my @constants = qw(
                        ATTR CENTIMETER COUNTER_FUNCTION COUNTERS_FUNCTION
                        DEGREE DIMENSION EM EX FUNCTION GRADIAN HERTZ
                        IDENT INCH INHERIT INTEGER KILOHERTZ MILLIMETER
                        MILLISECOND OPERATOR_COMMA OPERATOR_EXP OPERATOR_GE
                        OPERATOR_GT OPERATOR_LE OPERATOR_LT OPERATOR_MINUS
                        OPERATOR_MOD OPERATOR_MULTIPLY OPERATOR_PLUS
                        OPERATOR_SLASH OPERATOR_TILDE PERCENTAGE PICA PIXEL
                        POINT RADIAN REAL RECT_FUNCTION RGBCOLOR SECOND
                        STRING_VALUE SUB_EXPRESSION UNICODERANGE URI
                      );

    # now lets create the constants in the caller's package
    no strict 'refs';
    for my $c (@constants) {
        my $qname = "${pkg}::$c";
        *$qname = \&{$c};
    }
}
#---------------------------------------------------------------------#


#                                                                     #
#                                                                     #
### Constants #########################################################


### Constructor #######################################################
#                                                                     #
#                                                                     #


#---------------------------------------------------------------------#
# CSS::SAC::LexicalUnit->new($type,$text,$value)
# creates a new sac lexical unit object
#---------------------------------------------------------------------#
sub new {
    my $class = ref($_[0])?ref(shift):shift;
    my $type  = shift;
    my $text  = shift;
    my $value = shift;

    # define our fields
    my $self = [];
    $self->[_type_]  = $type;
    $self->[_text_]  = $text;
    $self->[_value_] = $value;

    return bless $self, $class;
}
#---------------------------------------------------------------------#


#                                                                     #
#                                                                     #
### Constructor #######################################################




### Accessors #########################################################
#                                                                     #
#                                                                     #

# defined aliases
*CSS::SAC::LexicalUnit::getDimensionUnitText = \&DimensionUnitText;
*CSS::SAC::LexicalUnit::getFunctionName = \&FunctionName;
*CSS::SAC::LexicalUnit::getValue = \&Value;
*CSS::SAC::LexicalUnit::getLexicalUnitType = \&LexicalUnitType;

#---------------------------------------------------------------------#
# my $dut = $lu->DimensionUnitText
# $lu->DimensionUnitText($dut)
# get/set the text of the dimension unit (eg cm, px, etc...)
#---------------------------------------------------------------------#
sub DimensionUnitText {
    (@_==2) ? $_[0]->[_text_] = $_[1] :
              $_[0]->[_text_];
}
#---------------------------------------------------------------------#


#---------------------------------------------------------------------#
# my $fn = $lu->FunctionName
# $lu->FunctionName($fn)
# get/set the name of the function (eg attr, uri, etc...)
#---------------------------------------------------------------------#
sub FunctionName {
    (@_==2) ? $_[0]->[_text_] = $_[1] :
              $_[0]->[_text_];
}
#---------------------------------------------------------------------#


#---------------------------------------------------------------------#
# my $value = $lu->Value
# $lu->Value($value)
# get/set the value of the lu (which may be another lu, or a lu list)
#---------------------------------------------------------------------#
sub Value {
    (@_==2) ? $_[0]->[_value_] = $_[1] :
              $_[0]->[_value_];
}
#---------------------------------------------------------------------#


#---------------------------------------------------------------------#
# my $type = $lu->LexicalUnitType
# $lu->LexicalUnitType($type)
# get/set the type of the lu
#---------------------------------------------------------------------#
sub LexicalUnitType {
    (@_==2) ? $_[0]->[_type_] = $_[1] :
              $_[0]->[_type_];
}
#---------------------------------------------------------------------#


#---------------------------------------------------------------------#
# $lu->is_type($lu_constant)
# returns true is this lu is of type $lu_constant
#---------------------------------------------------------------------#
sub is_type {
    return $_[0]->[_type_] == $_[1];
}
#---------------------------------------------------------------------#


#                                                                     #
#                                                                     #
### Accessors #########################################################


1;