You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tqscintilla/qt/qextscintillalexerpov.cpp

491 lines
12 KiB

// This module implements the QextScintillaLexerPOV class.
//
// Copyright (c) 2006
// Riverbank Computing Limited <info@riverbankcomputing.co.uk>
//
// This file is part of TQScintilla.
//
// This copy of TQScintilla 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, or (at your option) any
// later version.
//
// TQScintilla is supplied 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
// TQScintilla; see the file LICENSE. If not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <tqcolor.h>
#include <tqfont.h>
#include <tqsettings.h>
#include "qextscintillalexerpov.h"
// The ctor.
QextScintillaLexerPOV::QextScintillaLexerPOV(TQObject *parent,const char *name)
: QextScintillaLexer(parent,name), fold_comments(FALSE),
fold_compact(TRUE), fold_directives(FALSE)
{
}
// The dtor.
QextScintillaLexerPOV::~QextScintillaLexerPOV()
{
}
// Returns the language name.
const char *QextScintillaLexerPOV::language() const
{
return "POV";
}
// Returns the lexer name.
const char *QextScintillaLexerPOV::lexer() const
{
return "pov";
}
// Return the style used for braces.
int QextScintillaLexerPOV::braceStyle() const
{
return Operator;
}
// Return the string of characters that comprise a word.
const char *QextScintillaLexerPOV::wordCharacters() const
{
return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_#";
}
// Returns the foreground colour of the text for a style.
TQColor QextScintillaLexerPOV::color(int style) const
{
switch (style)
{
case Default:
return TQColor(0xff,0x00,0x80);
case Comment:
case CommentLine:
return TQColor(0x00,0x7f,0x00);
case Number:
return TQColor(0x00,0x7f,0x7f);
case Operator:
return TQColor(0x00,0x00,0x00);
case String:
return TQColor(0x7f,0x00,0x7f);
case Directive:
return TQColor(0x7f,0x7f,0x00);
case BadDirective:
return TQColor(0x80,0x40,0x20);
case ObjectsCSGAppearance:
case TypesModifiersItems:
case PredefinedIdentifiers:
case PredefinedFunctions:
case KeywordSet6:
case KeywordSet7:
case KeywordSet8:
return TQColor(0x00,0x00,0x7f);
}
return QextScintillaLexer::color(style);
}
// Returns the end-of-line fill for a style.
bool QextScintillaLexerPOV::eolFill(int style) const
{
return (style == UnclosedString);
}
// Returns the font of the text for a style.
TQFont QextScintillaLexerPOV::font(int style) const
{
TQFont f;
switch (style)
{
case Comment:
case CommentLine:
#if defined(Q_OS_WIN)
f = TQFont("Comic Sans MS",9);
#else
f = TQFont("Bitstream Vera Serif",9);
#endif
break;
case UnclosedString:
case PredefinedIdentifiers:
f = QextScintillaLexer::font(style);
f.setBold(TRUE);
break;
case BadDirective:
#if defined(Q_OS_WIN)
f = TQFont("Comic Sans MS",9);
#else
f = TQFont("Bitstream Vera Serif",9);
#endif
f.setItalic(TRUE);
break;
default:
f = QextScintillaLexer::font(style);
}
return f;
}
// Returns the set of keywords.
const char *QextScintillaLexerPOV::keywords(int set) const
{
if (set == 1)
return
"declare local include undef fopen fclose read write "
"default version case range break debug error "
"warning if ifdef ifndef switch while macro else end";
if (set == 2)
return
"camera light_source light_group object blob sphere "
"cylinder box cone height_field julia_fractal lathe "
"prism sphere_sweep superellipsoid sor text torus "
"bicubic_patch disc mesh mesh2 polygon triangle "
"smooth_triangle plane poly cubic quartic quadric "
"isosurface parametric union intersection difference "
"merge function array spline vertex_vectors "
"normal_vectors uv_vectors face_indices "
"normal_indices uv_indices texture texture_list "
"interior_texture texture_map material_map image_map "
"color_map colour_map pigment_map normal_map "
"slope_map bump_map density_map pigment normal "
"material interior finish reflection irid slope "
"pigment_pattern image_pattern warp media scattering "
"density background fog sky_sphere rainbow "
"global_settings radiosity photons pattern transform "
"looks_like projected_through contained_by "
"clipped_by bounded_by";
if (set == 3)
return
"linear_spline quadratic_spline cubic_spline "
"natural_spline bezier_spline b_spline read write "
"append inverse open perspective orthographic "
"fisheye ultra_wide_angle omnimax panoramic "
"spherical spotlight jitter circular orient "
"media_attenuation media_interaction shadowless "
"parallel refraction collect pass_through "
"global_lights hierarchy sturm smooth gif tga iff "
"pot png pgm ppm jpeg tiff sys ttf quaternion "
"hypercomplex linear_sweep conic_sweep type "
"all_intersections split_union cutaway_textures "
"no_shadow no_image no_reflection double_illuminate "
"hollow uv_mapping all use_index use_color "
"use_colour no_bump_scale conserve_energy fresnel "
"average agate boxed bozo bumps cells crackle "
"cylindrical density_file dents facets granite "
"leopard marble onion planar quilted radial ripples "
"spotted waves wood wrinkles solid use_alpha "
"interpolate magnet noise_generator toroidal "
"ramp_wave triangle_wave sine_wave scallop_wave "
"cubic_wave poly_wave once map_type method fog_type "
"hf_gray_16 charset ascii utf8 rotate scale "
"translate matrix location right up direction sky "
"angle look_at aperture blur_samples focal_point "
"confidence variance radius falloff tightness "
"point_at area_light adaptive fade_distance "
"fade_power threshold strength water_level tolerance "
"max_iteration precision slice u_steps v_steps "
"flatness inside_vector accuracy max_gradient "
"evaluate max_trace precompute target ior dispersion "
"dispersion_samples caustics color colour rgb rgbf "
"rgbt rgbft red green blue filter transmit gray hf "
"fade_color fade_colour quick_color quick_colour "
"brick checker hexagon brick_size mortar bump_size "
"ambient diffuse brilliance crand phong phong_size "
"metallic specular roughness reflection_exponent "
"exponent thickness gradient spiral1 spiral2 "
"agate_turb form metric offset df3 coords size "
"mandel exterior julia control0 control1 altitude "
"turbulence octaves omega lambda repeat flip "
"black-hole orientation dist_exp major_radius "
"frequency phase intervals samples ratio absorption "
"emission aa_threshold aa_level eccentricity "
"extinction distance turb_depth fog_offset fog_alt "
"width arc_angle falloff_angle adc_bailout "
"ambient_light assumed_gamma irid_wavelength "
"number_of_waves always_sample brigthness count "
"error_bound gray_threshold load_file "
"low_error_factor max_sample minimum_reuse "
"nearest_count pretrace_end pretrace_start "
"recursion_limit save_file spacing gather "
"max_trace_level autostop expand_thresholds";
if (set == 4)
return
"x y z t u v yes no true false on off clock "
"clock_delta clock_on final_clock final_frame "
"frame_number image_height image_width initial_clock "
"initial_frame pi version";
if (set == 5)
return
"abs acos acosh asc asin asinh atan atanh atan2 ceil "
"cos cosh defined degrees dimensions dimension_size "
"div exp file_exists floor inside int ln log max min "
"mod pow prod radians rand seed select sin sinh sqrt "
"strcmp strlen sum tan tanh val vdot vlength "
"min_extent max_extent trace vaxis_rotate vcross "
"vrotate vnormalize vturbulence chr concat str "
"strlwr strupr substr vstr sqr cube reciprocal pwr";
return 0;
}
// Returns the user name of a style.
TQString QextScintillaLexerPOV::description(int style) const
{
switch (style)
{
case Default:
return tr("Default");
case Comment:
return tr("Comment");
case CommentLine:
return tr("Comment line");
case Number:
return tr("Number");
case Operator:
return tr("Operator");
case Identifier:
return tr("Identifier");
case String:
return tr("String");
case UnclosedString:
return tr("Unclosed string");
case Directive:
return tr("Directive");
case BadDirective:
return tr("Bad directive");
case ObjectsCSGAppearance:
return tr("Objects, CSG and appearance");
case TypesModifiersItems:
return tr("Types, modifiers and items");
case PredefinedIdentifiers:
return tr("Predefined identifiers");
case PredefinedFunctions:
return tr("Predefined functions");
case KeywordSet6:
return tr("User defined 1");
case KeywordSet7:
return tr("User defined 2");
case KeywordSet8:
return tr("User defined 3");
}
return TQString();
}
// Returns the background colour of the text for a style.
TQColor QextScintillaLexerPOV::paper(int style) const
{
switch (style)
{
case UnclosedString:
return TQColor(0xe0,0xc0,0xe0);
case ObjectsCSGAppearance:
return TQColor(0xff,0xd0,0xd0);
case TypesModifiersItems:
return TQColor(0xff,0xff,0xd0);
case PredefinedFunctions:
return TQColor(0xd0,0xd0,0xff);
case KeywordSet6:
return TQColor(0xd0,0xff,0xd0);
case KeywordSet7:
return TQColor(0xd0,0xd0,0xd0);
case KeywordSet8:
return TQColor(0xe0,0xe0,0xe0);
}
return QextScintillaLexer::paper(style);
}
// Refresh all properties.
void QextScintillaLexerPOV::refreshProperties()
{
setCommentProp();
setCompactProp();
setDirectiveProp();
}
// Read properties from the settings.
bool QextScintillaLexerPOV::readProperties(TQSettings &qs,const TQString &prefix)
{
int rc = TRUE;
bool ok, flag;
// Read the fold comments flag.
flag = qs.readBoolEntry(prefix + "foldcomments",FALSE,&ok);
if (ok)
fold_comments = flag;
else
rc = FALSE;
// Read the fold compact flag.
flag = qs.readBoolEntry(prefix + "foldcompact",TRUE,&ok);
if (ok)
fold_compact = flag;
else
rc = FALSE;
// Read the fold directives flag.
flag = qs.readBoolEntry(prefix + "folddirectives",FALSE,&ok);
if (ok)
fold_directives = flag;
else
rc = FALSE;
return rc;
}
// Write properties to the settings.
bool QextScintillaLexerPOV::writeProperties(TQSettings &qs,const TQString &prefix) const
{
int rc = TRUE;
// Write the fold comments flag.
if (!qs.writeEntry(prefix + "foldcomments",fold_comments))
rc = FALSE;
// Write the fold compact flag.
if (!qs.writeEntry(prefix + "foldcompact",fold_compact))
rc = FALSE;
// Write the fold directives flag.
if (!qs.writeEntry(prefix + "folddirectives",fold_directives))
rc = FALSE;
return rc;
}
// Return TRUE if comments can be folded.
bool QextScintillaLexerPOV::foldComments() const
{
return fold_comments;
}
// Set if comments can be folded.
void QextScintillaLexerPOV::setFoldComments(bool fold)
{
fold_comments = fold;
setCommentProp();
}
// Set the "fold.comment" property.
void QextScintillaLexerPOV::setCommentProp()
{
emit propertyChanged("fold.comment",(fold_comments ? "1" : "0"));
}
// Return TRUE if folds are compact.
bool QextScintillaLexerPOV::foldCompact() const
{
return fold_compact;
}
// Set if folds are compact
void QextScintillaLexerPOV::setFoldCompact(bool fold)
{
fold_compact = fold;
setCompactProp();
}
// Set the "fold.compact" property.
void QextScintillaLexerPOV::setCompactProp()
{
emit propertyChanged("fold.compact",(fold_compact ? "1" : "0"));
}
// Return TRUE if directives can be folded.
bool QextScintillaLexerPOV::foldDirectives() const
{
return fold_directives;
}
// Set if directives can be folded.
void QextScintillaLexerPOV::setFoldDirectives(bool fold)
{
fold_directives = fold;
setDirectiveProp();
}
// Set the "fold.directive" property.
void QextScintillaLexerPOV::setDirectiveProp()
{
emit propertyChanged("fold.directive",(fold_directives ? "1" : "0"));
}
#include "qextscintillalexerpov.moc"