* gcc does not like missing characters in keywords

[lyx.git] / src / Text3.cpp

diff --git a/src/Text3.cpp b/src/Text3.cpp
index aa31f32932d26cfc176c226a550d247fa833ec64..5b250647bde53d64309425f6aded5bdae868b469 100644 (file)
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -33,6 +33,7 @@
 #include "factory.h"
 #include "FuncRequest.h"
 #include "gettext.h"
+#include "InsetList.h"
 #include "Intl.h"
 #include "Language.h"
 #include "Layout.h"
@@ -89,7 +90,7 @@ using support::isStrUnsignedInt;
 using support::token;
 
 // globals...
-static Font freefont(Font::ALL_IGNORE);
+static Font freefont(ignore_font);
 static bool toggleall = false;
 
 static void toggleAndShow(Cursor & cur, Text * text,
@@ -98,7 +99,7 @@ static void toggleAndShow(Cursor & cur, Text * text,
        text->toggleFree(cur, font, toggleall);
 
        if (font.language() != ignore_language ||
-                       font.number() != Font::IGNORE) {
+                       font.fontInfo().number() != FONT_IGNORE) {
                TextMetrics const & tm = cur.bv().textMetrics(text);
                if (cur.boundary() != tm.isRTLBoundary(cur.pit(),
                                                                                                                cur.pos(), cur.real_current_font))
@@ -245,9 +246,9 @@ string const freefont2string()
 
 void Text::number(Cursor & cur)
 {
-       Font font(Font::ALL_IGNORE);
-       font.setNumber(Font::TOGGLE);
-       toggleAndShow(cur, this, font);
+       FontInfo font = ignore_font;
+       font.setNumber(FONT_TOGGLE);
+       toggleAndShow(cur, this, Font(font));
 }
 
 
@@ -499,22 +500,44 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                needsUpdate |= tm.cursorEnd(cur);
                break;
 
+       case LFUN_WORD_RIGHT:
+       case LFUN_WORD_RIGHT_SELECT:
+               //FIXME: for visual cursor mode, really move right
+               if (reverseDirectionNeeded(cur)) {
+                       lyx::dispatch(FuncRequest(
+                               cmd.action == LFUN_WORD_RIGHT_SELECT ?
+                                       LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD));
+               } else {
+                       lyx::dispatch(FuncRequest(
+                               cmd.action == LFUN_WORD_RIGHT_SELECT ?
+                                       LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD));
+               }
+               break;
+
        case LFUN_WORD_FORWARD:
        case LFUN_WORD_FORWARD_SELECT:
                needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT);
-               if (reverseDirectionNeeded(cur))
-                       needsUpdate |= cursorLeftOneWord(cur);
-               else
-                       needsUpdate |= cursorRightOneWord(cur);
+               needsUpdate |= cursorForwardOneWord(cur);
+               break;
+
+       case LFUN_WORD_LEFT:
+       case LFUN_WORD_LEFT_SELECT:
+               //FIXME: for visual cursor mode, really move left
+               if (reverseDirectionNeeded(cur)) {
+                       lyx::dispatch(FuncRequest(
+                               cmd.action == LFUN_WORD_LEFT_SELECT ?
+                                       LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD));
+               } else {
+                       lyx::dispatch(FuncRequest(
+                               cmd.action == LFUN_WORD_LEFT_SELECT ?
+                                       LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD));
+               }
                break;
 
        case LFUN_WORD_BACKWARD:
        case LFUN_WORD_BACKWARD_SELECT:
                needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT);
-               if (reverseDirectionNeeded(cur))
-                       needsUpdate |= cursorRightOneWord(cur);
-               else
-                       needsUpdate |= cursorLeftOneWord(cur);
+               needsUpdate |= cursorBackwardOneWord(cur);
                break;
 
        case LFUN_WORD_SELECT: {
@@ -732,15 +755,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                break;
 
        case LFUN_WORD_UPCASE:
-               changeCase(cur, Text::text_uppercase);
+               changeCase(cur, text_uppercase);
                break;
 
        case LFUN_WORD_LOWCASE:
-               changeCase(cur, Text::text_lowercase);
+               changeCase(cur, text_lowercase);
                break;
 
        case LFUN_WORD_CAPITALIZE:
-               changeCase(cur, Text::text_capitalization);
+               changeCase(cur, text_capitalization);
                break;
 
        case LFUN_CHARS_TRANSPOSE:
@@ -794,9 +817,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
        }
 
        case LFUN_SERVER_GET_FONT:
-               if (cur.current_font.shape() == Font::ITALIC_SHAPE)
+               if (cur.current_font.fontInfo().shape() == ITALIC_SHAPE)
                        cur.message(from_ascii("E"));
-               else if (cur.current_font.shape() == Font::SMALLCAPS_SHAPE)
+               else if (cur.current_font.fontInfo().shape() == SMALLCAPS_SHAPE)
                        cur.message(from_ascii("N"));
                else
                        cur.message(from_ascii("0"));
@@ -1306,63 +1329,63 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
        }
 
        case LFUN_FONT_EMPH: {
-               Font font(Font::ALL_IGNORE);
-               font.setEmph(Font::TOGGLE);
+               Font font(ignore_font);
+               font.fontInfo().setEmph(FONT_TOGGLE);
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_BOLD: {
-               Font font(Font::ALL_IGNORE);
-               font.setSeries(Font::BOLD_SERIES);
+               Font font(ignore_font);
+               font.fontInfo().setSeries(BOLD_SERIES);
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_NOUN: {
-               Font font(Font::ALL_IGNORE);
-               font.setNoun(Font::TOGGLE);
+               Font font(ignore_font);
+               font.fontInfo().setNoun(FONT_TOGGLE);
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_TYPEWRITER: {
-               Font font(Font::ALL_IGNORE);
-               font.setFamily(Font::TYPEWRITER_FAMILY); // no good
+               Font font(ignore_font);
+               font.fontInfo().setFamily(TYPEWRITER_FAMILY); // no good
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_SANS: {
-               Font font(Font::ALL_IGNORE);
-               font.setFamily(Font::SANS_FAMILY);
+               Font font(ignore_font);
+               font.fontInfo().setFamily(SANS_FAMILY);
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_ROMAN: {
-               Font font(Font::ALL_IGNORE);
-               font.setFamily(Font::ROMAN_FAMILY);
+               Font font(ignore_font);
+               font.fontInfo().setFamily(ROMAN_FAMILY);
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_DEFAULT: {
-               Font font(Font::ALL_INHERIT, ignore_language);
+               Font font(inherit_font, ignore_language);
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_UNDERLINE: {
-               Font font(Font::ALL_IGNORE);
-               font.setUnderbar(Font::TOGGLE);
+               Font font(ignore_font);
+               font.fontInfo().setUnderbar(FONT_TOGGLE);
                toggleAndShow(cur, this, font);
                break;
        }
 
        case LFUN_FONT_SIZE: {
-               Font font(Font::ALL_IGNORE);
-               font.setLyXSize(to_utf8(cmd.argument()));
+               Font font(ignore_font);
+               setLyXSize(to_utf8(cmd.argument()), font.fontInfo());
                toggleAndShow(cur, this, font);
                break;
        }
@@ -1371,7 +1394,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                Language const * lang = languages.getLanguage(to_utf8(cmd.argument()));
                if (!lang)
                        break;
-               Font font(Font::ALL_IGNORE);
+               Font font(ignore_font);
                font.setLanguage(lang);
                toggleAndShow(cur, this, font);
                break;
@@ -1392,6 +1415,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                        toggleall = toggle;
                        toggleAndShow(cur, this, freefont, toggleall);
                        cur.message(_("Character set"));
+               } else {
+                       lyxerr << "Argument not ok";
                }
                break;
        }
@@ -1612,6 +1637,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
        BOOST_ASSERT(cur.text() == this);
 
        Font const & font = cur.real_current_font;
+       FontInfo const & fontinfo = font.fontInfo();
        bool enable = true;
        InsetCode code = NO_CODE;
 
@@ -1742,7 +1768,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
                break;
        case LFUN_OPTIONAL_INSERT:
                code = OPTARG_CODE;
-               enable = cur.paragraph().numberOfOptArgs()
+               enable = cur.paragraph().insetList().count(OPTARG_CODE)
                        < cur.paragraph().layout()->optionalargs;
                break;
        case LFUN_ENVIRONMENT_INSERT:
@@ -1793,27 +1819,27 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
                break;
 
        case LFUN_FONT_EMPH:
-               flag.setOnOff(font.emph() == Font::ON);
+               flag.setOnOff(fontinfo.emph() == FONT_ON);
                return true;
 
        case LFUN_FONT_NOUN:
-               flag.setOnOff(font.noun() == Font::ON);
+               flag.setOnOff(fontinfo.noun() == FONT_ON);
                return true;
 
        case LFUN_FONT_BOLD:
-               flag.setOnOff(font.series() == Font::BOLD_SERIES);
+               flag.setOnOff(fontinfo.series() == BOLD_SERIES);
                return true;
 
        case LFUN_FONT_SANS:
-               flag.setOnOff(font.family() == Font::SANS_FAMILY);
+               flag.setOnOff(fontinfo.family() == SANS_FAMILY);
                return true;
 
        case LFUN_FONT_ROMAN:
-               flag.setOnOff(font.family() == Font::ROMAN_FAMILY);
+               flag.setOnOff(fontinfo.family() == ROMAN_FAMILY);
                return true;
 
        case LFUN_FONT_TYPEWRITER:
-               flag.setOnOff(font.family() == Font::TYPEWRITER_FAMILY);
+               flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
                return true;
 
        case LFUN_CUT:
@@ -1881,6 +1907,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
        case LFUN_LINE_DELETE:
        case LFUN_WORD_FORWARD:
        case LFUN_WORD_BACKWARD:
+       case LFUN_WORD_RIGHT:
+       case LFUN_WORD_LEFT:
        case LFUN_CHAR_FORWARD:
        case LFUN_CHAR_FORWARD_SELECT:
        case LFUN_CHAR_BACKWARD:
@@ -1901,6 +1929,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
        case LFUN_LINE_END_SELECT:
        case LFUN_WORD_FORWARD_SELECT:
        case LFUN_WORD_BACKWARD_SELECT:
+       case LFUN_WORD_RIGHT_SELECT:
+       case LFUN_WORD_LEFT_SELECT:
        case LFUN_WORD_SELECT:
        case LFUN_PARAGRAPH_UP:
        case LFUN_PARAGRAPH_DOWN: