+2003-09-18 Angus Leeming <leeming@lyx.org>
+
+ * LColor.h:
+ * lyxfont.C:
+ * lyxfont.h:
+ * lyxtext.h:
+ * text.C: rename EnumLColor as LColor_color.
+
2003-09-18 Angus Leeming <leeming@lyx.org>
* cursor.[Ch]: use the dispatch_result wrapper class DispatchResult to remove
};
-/** \c EnumLColor is a wrapper for LColor::color. It can be forward-declared and
+/** \c LColor_color is a wrapper for LColor::color. It can be forward-declared and
* passed as a function argument without having to expose LColor.h.
*/
-class EnumLColor {
+class LColor_color {
LColor::color val_;
public:
/** The default constructor is nasty,
- * but allows us to use EnumLColor in STL containers.
+ * but allows us to use LColor_color in STL containers.
*/
- EnumLColor() : val_(static_cast<LColor::color>(-1)) {}
+ LColor_color() : val_(static_cast<LColor::color>(-1)) {}
- EnumLColor(LColor::color val) : val_(val) {}
+ LColor_color(LColor::color val) : val_(val) {}
operator LColor::color() const{ return val_; }
};
+2003-09-18 Angus Leeming <leeming@lyx.org>
+
+ * Painter.C:
+ * Painter.h:
+ * lyx_gui.h: rename EnumLColor as LColor_color.
+
2003-09-18 Angus Leeming <leeming@lyx.org>
* Dialogs.[Ch] (find): renamed as find_or_build.
Painter & Painter::rectText(int x, int baseline,
string const & str,
LyXFont const & font,
- EnumLColor back,
- EnumLColor frame)
+ LColor_color back,
+ LColor_color frame)
{
int width;
int ascent;
#include "support/std_string.h"
-class EnumLColor;
+class LColor_color;
class LyXFont;
namespace lyx {
virtual Painter & line(
int x1, int y1,
int x2, int y2,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin) = 0;
int const * xp,
int const * yp,
int np,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin) = 0;
virtual Painter & rectangle(
int x, int y,
int w, int h,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin) = 0;
virtual Painter & fillRectangle(
int x, int y,
int w, int h,
- EnumLColor) = 0;
+ LColor_color) = 0;
/// draw a filled (irregular) polygon
virtual Painter & fillPolygon(
int const * xp,
int const * yp,
int np,
- EnumLColor) = 0;
+ LColor_color) = 0;
/// draw an arc
virtual Painter & arc(
int x, int y,
unsigned int w, unsigned int h,
int a1, int a2,
- EnumLColor) = 0;
+ LColor_color) = 0;
/// draw a pixel
virtual Painter & point(
int x, int y,
- EnumLColor) = 0;
+ LColor_color) = 0;
/// draw a filled rectangle with the shape of a 3D button
virtual Painter & button(int x, int y,
Painter & rectText(int x, int baseline,
string const & string,
LyXFont const & font,
- EnumLColor back,
- EnumLColor frame);
+ LColor_color back,
+ LColor_color frame);
/// draw a string and enclose it inside a button frame
Painter & buttonText(int x,
+2003-09-18 Angus Leeming <leeming@lyx.org>
+
+ * ControlCharacter.C:
+ * ControlCharacter.h:
+ * ControlPrefs.C:
+ * ControlPrefs.h:
+ * character.h: rename EnumLColor as LColor_color.
+
2003-09-16 Angus Leeming <leeming@lyx.org>
* ControlCharacter.C: add #include "LColor.h".
}
-EnumLColor ControlCharacter::getColor() const
+LColor_color ControlCharacter::getColor() const
{
if (!font_.get())
return LColor::ignore;
}
-void ControlCharacter::setColor(EnumLColor val)
+void ControlCharacter::setColor(LColor_color val)
{
switch (val) {
case LColor::ignore:
#include "character.h"
-class EnumLColor;
+class LColor_color;
class ControlCharacter : public Dialog::Controller {
///
void setBar(frnt::FONT_STATE);
///
- void setColor(EnumLColor);
+ void setColor(LColor_color);
///
void setLanguage(string const &);
///
///
frnt::FONT_STATE getBar() const;
///
- EnumLColor getColor() const;
+ LColor_color getColor() const;
///
string getLanguage() const;
///
}
-void ControlPrefs::setColor(EnumLColor col, string const & hex)
+void ControlPrefs::setColor(LColor_color col, string const & hex)
{
string const s = lcolor.getLyXName(col) + ' ' + hex;
lv_.dispatch(FuncRequest(LFUN_SET_COLOR, s));
class Converters;
-class EnumLColor;
+class LColor_color;
class Formats;
class ControlPrefs : public ControlDialogBI {
void redrawGUI();
/// set a color
- void setColor(EnumLColor col, string const & hex);
+ void setColor(LColor_color col, string const & hex);
/// update the screen fonts after change
void updateScreenFonts();
#include <vector>
-class EnumLColor;
+class LColor_color;
/** Functions of use to the character GUI controller and view */
///
typedef std::pair<string, FONT_STATE> BarPair;
///
-typedef std::pair<string, EnumLColor> ColorPair;
+typedef std::pair<string, LColor_color> ColorPair;
///
std::vector<FamilyPair> const getFamilyData();
+2003-09-18 Angus Leeming <leeming@lyx.org>
+
+ * GPainter.C:
+ * GPainter.h:
+ * GWorkArea.C:
+ * GWorkArea.h:
+ * lyx_gui.C: rename EnumLColor as LColor_color.
+
2003-09-16 Angus Leeming <leeming@lyx.org>
* GScreen.[Ch] (workarea):
}
-void GPainter::setForeground(Glib::RefPtr<Gdk::GC> gc, EnumLColor clr)
+void GPainter::setForeground(Glib::RefPtr<Gdk::GC> gc, LColor_color clr)
{
Gdk::Color * gclr = owner_.getColorHandler().getGdkColor(clr);
gc->set_foreground(*gclr);
}
-Painter & GPainter::point(int x, int y, EnumLColor c)
+Painter & GPainter::point(int x, int y, LColor_color c)
{
setForeground(owner_.getGC(), c);
owner_.getPixmap()->draw_point(owner_.getGC(), x, y);
Painter & GPainter::line(int x1, int y1,
int x2, int y2,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & GPainter::lines(int const * xp, int const * yp,
int np,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & GPainter::rectangle(int x, int y,
int w, int h,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & GPainter::fillRectangle(int x, int y,
int w, int h,
- EnumLColor col)
+ LColor_color col)
{
setForeground(owner_.getGC(), col);
owner_.getPixmap()->draw_rectangle(owner_.getGC(), true, x, y, w, h);
Painter & GPainter::fillPolygon(int const * xp, int const * yp,
- int np, EnumLColor col)
+ int np, LColor_color col)
{
setForeground(owner_.getGC(), col);
std::vector<Gdk::Point> points(np);
Painter & GPainter::arc(int x, int y,
unsigned int w, unsigned int h,
- int a1, int a2, EnumLColor col)
+ int a1, int a2, LColor_color col)
{
setForeground(owner_.getGC(), col);
owner_.getPixmap()->draw_arc(owner_.getGC(),
/// return the height of the work area in pixels
virtual int paperHeight() const;
- void setForeground(Glib::RefPtr<Gdk::GC> gc, EnumLColor clr);
+ void setForeground(Glib::RefPtr<Gdk::GC> gc, LColor_color clr);
void setLineParam(Glib::RefPtr<Gdk::GC> gc,
line_style ls, line_width lw);
- XftColor * getXftColor(EnumLColor clr);
+ XftColor * getXftColor(LColor_color clr);
/// draw a line from point to point
virtual Painter & line(
int x1, int y1,
int x2, int y2,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
int const * xp,
int const * yp,
int np,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
virtual Painter & rectangle(
int x, int y,
int w, int h,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
virtual Painter & fillRectangle(
int x, int y,
int w, int h,
- EnumLColor);
+ LColor_color);
/// draw a filled (irregular) polygon
virtual Painter & fillPolygon(
int const * xp,
int const * yp,
int np,
- EnumLColor);
+ LColor_color);
/// draw an arc
virtual Painter & arc(
int x, int y,
unsigned int w, unsigned int h,
int a1, int a2,
- EnumLColor);
+ LColor_color);
/// draw a pixel
virtual Painter & point(
int x, int y,
- EnumLColor);
+ LColor_color);
/// draw an image from the image cache
virtual Painter & image(int x, int y,
}
-Gdk::Color * ColorCache::getColor(EnumLColor clr)
+Gdk::Color * ColorCache::getColor(LColor_color clr)
{
MapIt it = cache_.find(clr);
return it == cache_.end() ? 0 : it->second;
}
-XftColor * ColorCache::getXftColor(EnumLColor clr)
+XftColor * ColorCache::getXftColor(LColor_color clr)
{
MapIt2 it = cache2_.find(clr);
return it == cache2_.end() ? 0 : it->second;
}
-void ColorCache::cacheColor(EnumLColor clr, Gdk::Color * gclr)
+void ColorCache::cacheColor(LColor_color clr, Gdk::Color * gclr)
{
cache_[clr] = gclr;
}
-void ColorCache::cacheXftColor(EnumLColor clr, XftColor * xclr)
+void ColorCache::cacheXftColor(LColor_color clr, XftColor * xclr)
{
cache2_[clr] = xclr;
}
}
-XftColor * ColorHandler::getXftColor(EnumLColor clr)
+XftColor * ColorHandler::getXftColor(LColor_color clr)
{
XftColor * xclr = colorCache.getXftColor(clr);
if (!xclr) {
}
-Gdk::Color * ColorHandler::getGdkColor(EnumLColor clr)
+Gdk::Color * ColorHandler::getGdkColor(LColor_color clr)
{
Gdk::Color * gclr = colorCache.getColor(clr);
if (!gclr) {
#include <X11/Xft/Xft.h>
-class EnumLColor;
+class LColor_color;
class ColorCache
{
- typedef std::map<EnumLColor, Gdk::Color *> Map;
+ typedef std::map<LColor_color, Gdk::Color *> Map;
typedef Map::iterator MapIt;
- typedef std::map<EnumLColor, XftColor *> Map2;
+ typedef std::map<LColor_color, XftColor *> Map2;
typedef Map2::iterator MapIt2;
public:
~ColorCache();
- Gdk::Color * getColor(EnumLColor);
- XftColor * getXftColor(EnumLColor);
- void cacheColor(EnumLColor, Gdk::Color *);
- void cacheXftColor(EnumLColor, XftColor *);
+ Gdk::Color * getColor(LColor_color);
+ XftColor * getXftColor(LColor_color);
+ void cacheColor(LColor_color, Gdk::Color *);
+ void cacheXftColor(LColor_color, XftColor *);
void clear();
private:
Map cache_;
{
public:
ColorHandler(GWorkArea& owner) : owner_(owner) {}
- XftColor * getXftColor(EnumLColor clr);
- Gdk::Color * getGdkColor(EnumLColor clr);
+ XftColor * getXftColor(LColor_color clr);
+ Gdk::Color * getGdkColor(LColor_color clr);
private:
GWorkArea & owner_;
};
}
-string const lyx_gui::hexname(EnumLColor col)
+string const lyx_gui::hexname(LColor_color col)
{
Gdk::Color gdkColor;
Gdk::Color * gclr = colorCache.getColor(col);
}
-void lyx_gui::update_color(EnumLColor /*col*/)
+void lyx_gui::update_color(LColor_color /*col*/)
{
colorCache.clear();
}
#include <vector>
class Dialogs;
-class EnumLColor;
+class LColor_color;
class LyXFont;
class LyXComm;
class FuncRequest;
/** Eg, passing LColor::black returns "000000",
* passing LColor::white returns "ffffff".
*/
-string const hexname(EnumLColor col);
+string const hexname(LColor_color col);
/**
* update an altered GUI color
*/
-void update_color(EnumLColor col);
+void update_color(LColor_color col);
/**
* update the font cache
+2003-09-18 Angus Leeming <leeming@lyx.org>
+
+ * QLPainter.C:
+ * QLPainter.h:
+ * QPrefsDialog.h:
+ * lcolorcache.C:
+ * lcolorcache.h:
+ * lyx_gui.C: rename EnumLColor as LColor_color.
+
2003-09-16 Angus Leeming <leeming@lyx.org>
* QLImage.[Ch]: separate interface from implementation. Make all the virtual
}
-QPainter & QLPainter::setPen(EnumLColor c,
+QPainter & QLPainter::setPen(LColor_color c,
Painter::line_style ls, Painter::line_width lw)
{
QPen pen = qp_->pen();
}
-Painter & QLPainter::point(int x, int y, EnumLColor c)
+Painter & QLPainter::point(int x, int y, LColor_color c)
{
setPen(c).drawPoint(x, y);
return *this;
Painter & QLPainter::line(int x1, int y1,
int x2, int y2,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & QLPainter::lines(int const * xp, int const * yp,
int np,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & QLPainter::rectangle(int x, int y,
int w, int h,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & QLPainter::fillRectangle(int x, int y,
int w, int h,
- EnumLColor col)
+ LColor_color col)
{
qp_->fillRect(x, y, w, h, lcolorcache.get(col));
return *this;
Painter & QLPainter::fillPolygon(int const * xp, int const * yp,
- int np, EnumLColor col)
+ int np, LColor_color col)
{
// Must use new as np is not known at compile time.
boost::scoped_array<QCOORD> points(new QCOORD[np * 2]);
Painter & QLPainter::arc(int x, int y,
unsigned int w, unsigned int h,
- int a1, int a2, EnumLColor col)
+ int a1, int a2, LColor_color col)
{
// LyX usings 1/64ths degree, Qt usings 1/16th
setPen(col).drawArc(x, y, w, h, a1 / 4, a2 / 4);
virtual Painter & line(
int x1, int y1,
int x2, int y2,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
int const * xp,
int const * yp,
int np,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
virtual Painter & rectangle(
int x, int y,
int w, int h,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
virtual Painter & fillRectangle(
int x, int y,
int w, int h,
- EnumLColor);
+ LColor_color);
/// draw a filled (irregular) polygon
virtual Painter & fillPolygon(
int const * xp,
int const * yp,
int np,
- EnumLColor);
+ LColor_color);
/// draw an arc
virtual Painter & arc(
int x, int y,
unsigned int w, unsigned int h,
int a1, int a2,
- EnumLColor);
+ LColor_color);
/// draw a pixel
virtual Painter & point(
int x, int y,
- EnumLColor);
+ LColor_color);
/// draw an image from the image cache
virtual Painter & image(int x, int y,
QString const & str, LyXFont const & f);
/// set pen parameters
- QPainter & setPen(EnumLColor c,
+ QPainter & setPen(LColor_color c,
line_style ls = line_solid,
line_width lw = line_thin);
#include <vector>
-class EnumLColor;
+class LColor_color;
class QPrefs;
class QPrefAsciiModule;
class QPrefDateModule;
private:
- std::vector<EnumLColor> colors_;
+ std::vector<LColor_color> colors_;
QPrefAsciiModule * asciiModule;
QPrefDateModule * dateModule;
}
-QColor const & LColorCache::get(EnumLColor col) const
+QColor const & LColorCache::get(LColor_color col) const
{
lcolor_map::const_iterator cit = colormap.find(col);
if (cit != colormap.end())
#include <qcolor.h>
-class EnumLColor;
+class LColor_color;
// FIXME: use a fixed-size array not a map ?
LColorCache();
/// get the given color
- QColor const & get(EnumLColor color) const;
+ QColor const & get(LColor_color color) const;
/// clear all colors
void clear();
private:
- typedef std::map<EnumLColor, QColor> lcolor_map;
+ typedef std::map<LColor_color, QColor> lcolor_map;
mutable lcolor_map colormap;
};
}
-string const hexname(EnumLColor col)
+string const hexname(LColor_color col)
{
return ltrim(fromqstr(lcolorcache.get(col).name()), "#");
}
-void update_color(EnumLColor)
+void update_color(LColor_color)
{
// FIXME: Bleh, can't we just clear them all at once ?
lcolorcache.clear();
+2003-09-18 Angus Leeming <leeming@lyx.org>
+
+ * Color.C:
+ * Color.h:
+ * ColorHandler.C:
+ * ColorHandler.h:
+ * FormCharacter.h:
+ * XPainter.C:
+ * XPainter.h:
+ * lyx_gui.C: rename EnumLColor as LColor_color.
+
2003-09-16 Angus Leeming <leeming@lyx.org>
* xformsImage.[Ch]: separate interface from implementation. Make all the virtual
-bool getRGBColor(EnumLColor col,
+bool getRGBColor(LColor_color col,
unsigned int & r, unsigned int & g, unsigned int & b)
{
string const name = lcolor.getX11Name(col);
#include "support/std_string.h"
-class EnumLColor;
+class LColor_color;
/** Given col, fills r, g, b in the range 0-255.
The function returns true if successful.
It returns false on failure and sets r, g, b to 0. */
-bool getRGBColor(EnumLColor col,
+bool getRGBColor(LColor_color col,
unsigned int & r, unsigned int & g, unsigned int & b);
struct RGBColor;
}
-unsigned long LyXColorHandler::colorPixel(EnumLColor c)
+unsigned long LyXColorHandler::colorPixel(LColor_color c)
{
XGCValues val;
XGetGCValues(display, getGCForeground(c), GCForeground, &val);
// Gets GC according to color
// Uses caching
-GC LyXColorHandler::getGCForeground(EnumLColor c)
+GC LyXColorHandler::getGCForeground(LColor_color c)
{
if (static_cast<unsigned>(c) >= colorGCcache.size()) {
colorGCcache.resize(c + 1, 0);
// Gets GC for line
GC LyXColorHandler::getGCLinepars(Painter::line_style ls,
- Painter::line_width lw, EnumLColor c)
+ Painter::line_width lw, LColor_color c)
{
//if (lyxerr.debugging()) {
// lyxerr << "Painter drawable: " << drawable() << endl;
// update GC cache after color redefinition
-void LyXColorHandler::updateColor (EnumLColor c)
+void LyXColorHandler::updateColor (LColor_color c)
{
// color GC cache
GC gc = colorGCcache[c];
// This is only included to provide stuff for the non-public sections
#include <X11/Xlib.h>
-class EnumLColor;
+class LColor_color;
class LyXFont;
/**
///
~LyXColorHandler();
///
- unsigned long colorPixel(EnumLColor c);
+ unsigned long colorPixel(LColor_color c);
///
- GC getGCForeground(EnumLColor c);
+ GC getGCForeground(LColor_color c);
///
GC getGCLinepars(Painter::line_style,
- Painter::line_width, EnumLColor c);
+ Painter::line_width, LColor_color c);
/// update the cache after a color definition change
- void updateColor(EnumLColor c);
+ void updateColor(LColor_color c);
private:
///
#include "FormDialogView.h"
#include "ControlCharacter.h" // for ControlCharacter enum
-struct EnumLColor;
+struct LColor_color;
struct FD_character;
/**
///
std::vector<frnt::FONT_STATE> bar_;
///
- std::vector<EnumLColor> color_;
+ std::vector<LColor_color> color_;
///
std::vector<string> lang_;
};
}
-Painter & XPainter::point(int x, int y, EnumLColor c)
+Painter & XPainter::point(int x, int y, LColor_color c)
{
XDrawPoint(fl_get_display(), owner_.getPixmap(),
lyxColorHandler->getGCForeground(c), x, y);
Painter & XPainter::line(int x1, int y1,
int x2, int y2,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & XPainter::lines(int const * xp, int const * yp,
int np,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & XPainter::rectangle(int x, int y,
int w, int h,
- EnumLColor col,
+ LColor_color col,
line_style ls,
line_width lw)
{
Painter & XPainter::fillRectangle(int x, int y,
int w, int h,
- EnumLColor col)
+ LColor_color col)
{
XFillRectangle(fl_get_display(), owner_.getPixmap(),
lyxColorHandler->getGCForeground(col), x, y, w, h);
Painter & XPainter::fillPolygon(int const * xp, int const * yp,
- int np, EnumLColor col)
+ int np, LColor_color col)
{
boost::scoped_array<XPoint> points(new XPoint[np]);
Painter & XPainter::arc(int x, int y,
unsigned int w, unsigned int h,
- int a1, int a2, EnumLColor col)
+ int a1, int a2, LColor_color col)
{
XDrawArc(fl_get_display(), owner_.getPixmap(),
lyxColorHandler->getGCForeground(col),
virtual Painter & line(
int x1, int y1,
int x2, int y2,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
int const * xp,
int const * yp,
int np,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
virtual Painter & rectangle(
int x, int y,
int w, int h,
- EnumLColor,
+ LColor_color,
line_style = line_solid,
line_width = line_thin);
virtual Painter & fillRectangle(
int x, int y,
int w, int h,
- EnumLColor);
+ LColor_color);
/// draw a filled (irregular) polygon
virtual Painter & fillPolygon(
int const * xp,
int const * yp,
int np,
- EnumLColor);
+ LColor_color);
/// draw an arc
virtual Painter & arc(
int x, int y,
unsigned int w, unsigned int h,
int a1, int a2,
- EnumLColor);
+ LColor_color);
/// draw a pixel
virtual Painter & point(
int x, int y,
- EnumLColor);
+ LColor_color);
/// draw an image from the image cache
virtual Painter & image(int x, int y,
return FuncStatus();
}
-string const hexname(EnumLColor col)
+string const hexname(LColor_color col)
{
unsigned int r, g, b;
bool const success = getRGBColor(col, r, g, b);
}
-void update_color(EnumLColor col)
+void update_color(LColor_color col)
{
lyxColorHandler->updateColor(col);
}
+2003-09-18 Angus Leeming <leeming@lyx.org>
+
+ * inset.C:
+ * inset.h:
+ * insettext.C:
+ * insettext.h: rename EnumLColor as LColor_color.
+
2003-09-18 Angus Leeming <leeming@lyx.org>
* inset.h: add the InsetOld::Code wrapper class InsetOld_code.
}
-void InsetOld::setBackgroundColor(EnumLColor color)
+void InsetOld::setBackgroundColor(LColor_color color)
{
background_color_ = color;
}
-EnumLColor InsetOld::backgroundColor() const
+LColor_color InsetOld::backgroundColor() const
{
if (background_color_ == LColor::inherit) {
if (owner())
#include "ParagraphList_fwd.h"
class Buffer;
-class EnumLColor;
+class LColor_color;
class FuncRequest;
class LatexRunParams;
class LyXCursor;
///
UpdatableInset * owner() const { return owner_; }
///
- void setBackgroundColor(EnumLColor);
+ void setBackgroundColor(LColor_color);
///
- EnumLColor backgroundColor() const;
+ LColor_color backgroundColor() const;
///
int x() const { return top_x; }
///
}
-EnumLColor InsetText::frameColor() const
+LColor_color InsetText::frameColor() const
{
return LColor::color(frame_color_);
}
-void InsetText::setFrameColor(EnumLColor col)
+void InsetText::setFrameColor(LColor_color col)
{
frame_color_ = col;
}
class BufferParams;
class BufferView;
class Dimension;
-class EnumLColor;
+class LColor_color;
class LyXCursor;
class Painter;
class Paragraph;
///
void setDrawFrame(DrawFrame);
///
- EnumLColor frameColor() const;
- void setFrameColor(EnumLColor);
+ LColor_color frameColor() const;
+ void setFrameColor(LColor_color);
///
LyXText * getLyXText(BufferView const *,
bool const recursive = false) const;
}
-EnumLColor LyXFont::color() const
+LColor_color LyXFont::color() const
{
return LColor::color(bits.color);
}
}
-void LyXFont::setColor(EnumLColor c)
+void LyXFont::setColor(LColor_color c)
{
bits.color = int(c);
}
}
-EnumLColor LyXFont::realColor() const
+LColor_color LyXFont::realColor() const
{
if (color() == LColor::none)
return LColor::foreground;
#include "support/std_string.h"
#include <iosfwd>
-class EnumLColor;
+class LColor_color;
class LyXLex;
class BufferParams;
class Language;
FONT_MISC_STATE number() const;
///
- EnumLColor color() const;
+ LColor_color color() const;
///
Language const * language() const;
void setUnderbar(LyXFont::FONT_MISC_STATE u);
void setNoun(LyXFont::FONT_MISC_STATE n);
void setNumber(LyXFont::FONT_MISC_STATE n);
- void setColor(EnumLColor c);
+ void setColor(LColor_color c);
void setLanguage(Language const * l);
/// Set family after LyX text format
string const stateText(BufferParams * params) const;
///
- EnumLColor realColor() const;
+ LColor_color realColor() const;
///
friend
class BufferParams;
class BufferView;
class Dimension;
-class EnumLColor;
+class LColor_color;
class InsetText;
class LyXCursor;
class MetricsInfo;
lyx::pos_type pos, char c, LyXFont const & Font) const;
/// return the color of the canvas
- EnumLColor backgroundColor() const;
+ LColor_color backgroundColor() const;
///
mutable bool bidi_same_direction;
}
-EnumLColor LyXText::backgroundColor() const
+LColor_color LyXText::backgroundColor() const
{
if (inset_owner)
return inset_owner->backgroundColor();
projects / features.git / commitdiff