Author: uwestoehr
Date: Sun Nov  6 16:15:13 2011
New Revision: 40137
URL: http://www.lyx.org/trac/changeset/40137

Log:
backporting tex2lyx: fix bug #7843

Modified:
   
lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/box-color-size-space-align.tex
   lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/test-structure.tex
   lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/text.cpp
   lyx-devel/branches/BRANCH_2_0_X/status.20x

Modified: 
lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/box-color-size-space-align.tex
==============================================================================
--- 
lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/box-color-size-space-align.tex 
    Sun Nov  6 16:06:19 2011        (r40136)
+++ 
lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/box-color-size-space-align.tex 
    Sun Nov  6 16:15:13 2011        (r40137)
@@ -19,6 +19,8 @@
 \usepackage{framed}
 \usepackage{calc}
 \usepackage{fancybox}
+\PassOptionsToPackage{normalem}{ulem}
+\usepackage{ulem}
 
 \setlength{\parskip}{3mm}
 \setlength{\parindent}{0sp}
@@ -36,6 +38,8 @@
 
 \definecolor{darkgreen}{cmyk}{0.5, 0, 1, 0.5}
 
+\color[rgb]{0,0,0}
+
 \usepackage{ifpdf} % part of the hyperref bundle
 \ifpdf % if pdflatex is used
 
@@ -223,9 +227,11 @@
 
 Strike out: \sout{test}
 
+Crossed out: \xout{test}
+
 Noun: \noun{test}
 
-Underbar, ephasized, stikreout: \emph{\uline{\sout{test}}}
+Underbar, emphasized, strikeout: \emph{\uline{\sout{test}}}
 
 
 \section{Paragraph spacing}

Modified: lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/test-structure.tex
==============================================================================
--- lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/test-structure.tex Sun Nov 
 6 16:06:19 2011        (r40136)
+++ lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/test/test-structure.tex Sun Nov 
 6 16:15:13 2011        (r40137)
@@ -25,10 +25,13 @@
  \addtolength{\leftmargin}{\labelsep}
  \renewcommand{\makelabel}[1]{##1\hfil}}}
 {\end{list}}
+\newcommand{\strong}[1]{\textbf{#1}}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% User specified LaTeX commands.
 \newenvironment{foo}{==[}{]==}
 
+\usepackage{fixltx2e} % this should cause the fixltx2e module to be loaded
+
 \date{}
 
 \@ifundefined{showcaptionsetup}{}{%
@@ -78,6 +81,8 @@
 
 \section[Hello!]{A section with optional argument}
 
+This causes the \strong{logikalmkup} module to be loaded.
+
 \begin{quote}
 An environment
 \end{quote}

Modified: lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/text.cpp
==============================================================================
--- lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/text.cpp        Sun Nov  6 
16:06:19 2011        (r40136)
+++ lyx-devel/branches/BRANCH_2_0_X/src/tex2lyx/text.cpp        Sun Nov  6 
16:15:13 2011        (r40137)
@@ -781,6 +781,23 @@
        } else
                latex_width = p.verbatim_item();
        translate_len(latex_width, width_value, width_unit);
+       bool shadedparbox = false;
+       if (inner_type == "shaded") {
+               eat_whitespace(p, os, parent_context, false);
+               if (outer_type == "parbox") {
+                       // Eat '{'
+                       if (p.next_token().cat() == catBegin)
+                               p.get_token();
+                       eat_whitespace(p, os, parent_context, false);
+                       shadedparbox = true;
+               }
+               p.get_token();
+               p.getArg('{', '}');
+       }
+       // If we already read the inner box we have to push the inner env
+       if (!outer_type.empty() && !inner_type.empty() &&
+           (inner_flags & FLAG_END))
+               active_environments.push_back(inner_type);
        // LyX can't handle length variables
        bool use_ert = contains(width_unit, '\\') || contains(height_unit, 
'\\');
        if (!use_ert && !outer_type.empty() && !inner_type.empty()) {
@@ -793,8 +810,9 @@
                else
                        p.verbatim_item();
                p.skip_spaces(true);
-               if ((outer_type == "framed" && p.next_token().asInput() != 
"\\end") ||
-                   (outer_type != "framed" && p.next_token().cat() != catEnd)) 
{
+               bool const outer_env(outer_type == "framed" || outer_type == 
"minipage");
+               if ((outer_env && p.next_token().asInput() != "\\end") ||
+                   (!outer_env && p.next_token().cat() != catEnd)) {
                        // something is between the end of the inner box and
                        // the end of the outer box, so we need to use ERT.
                        use_ert = true;
@@ -813,10 +831,12 @@
                        }
                }
                if (!inner_type.empty()) {
-                       if (inner_flags & FLAG_END)
-                               ss << "\\begin{" << inner_type << '}';
-                       else
-                               ss << '\\' << inner_type;
+                       if (inner_type != "shaded") {
+                               if (inner_flags & FLAG_END)
+                                       ss << "\\begin{" << inner_type << '}';
+                               else
+                                       ss << '\\' << inner_type;
+                       }
                        if (!position.empty())
                                ss << '[' << position << ']';
                        if (!latex_height.empty())
@@ -827,6 +847,8 @@
                        if (!(inner_flags & FLAG_END))
                                ss << '{';
                }
+               if (inner_type == "shaded")
+                       ss << "\\begin{shaded}";
                handle_ert(os, ss.str(), parent_context);
                if (!inner_type.empty()) {
                        parse_text(p, os, inner_flags, outer, parent_context);
@@ -837,6 +859,10 @@
                                handle_ert(os, "}", parent_context);
                }
                if (!outer_type.empty()) {
+                       // If we already read the inner box we have to pop
+                       // the inner env
+                       if (!inner_type.empty() && (inner_flags & FLAG_END))
+                               active_environments.pop_back();
                        parse_text(p, os, outer_flags, outer, parent_context);
                        if (outer_flags & FLAG_END)
                                handle_ert(os, "\\end{" + outer_type + '}',
@@ -851,6 +877,8 @@
                        position = "c";
                if (inner_pos.empty())
                        inner_pos = position;
+               // FIXME: Support makebox
+               bool const use_makebox = false;
                parent_context.check_layout(os);
                begin_inset(os, "Box ");
                if (outer_type == "framed")
@@ -859,9 +887,11 @@
                        os << "Boxed\n";
                else if (outer_type == "shadowbox")
                        os << "Shadowbox\n";
-               else if (outer_type == "shaded")
+               else if ((outer_type == "shaded" && inner_type.empty()) ||
+                            (outer_type == "minipage" && inner_type == 
"shaded") ||
+                            (outer_type == "parbox" && inner_type == 
"shaded")) {
                        os << "Shaded\n";
-               else if (outer_type == "doublebox")
+               } else if (outer_type == "doublebox")
                        os << "Doublebox\n";
                else if (outer_type.empty())
                        os << "Frameless\n";
@@ -871,17 +901,30 @@
                os << "hor_pos \"" << hor_pos << "\"\n";
                os << "has_inner_box " << !inner_type.empty() << "\n";
                os << "inner_pos \"" << inner_pos << "\"\n";
-               os << "use_parbox " << (inner_type == "parbox") << '\n';
-               os << "use_makebox 0\n";
+               os << "use_parbox " << (inner_type == "parbox" || shadedparbox)
+                       << '\n';
+               os << "use_makebox " << use_makebox << '\n';
                os << "width \"" << width_value << width_unit << "\"\n";
                os << "special \"none\"\n";
                os << "height \"" << height_value << height_unit << "\"\n";
                os << "height_special \"" << height_special << "\"\n";
                os << "status open\n\n";
+
+               // Unfortunately we can't use parse_text_in_inset:
+               // InsetBox::forcePlainLayout() is hard coded and does not
+               // use the inset layout. Apart from that do we call parse_text
+               // up to two times, but need only one check_end_layout.
+
+               bool const forcePlainLayout =
+                       (!inner_type.empty() || use_makebox) &&
+                       outer_type != "shaded" && outer_type != "framed";
                Context context(true, parent_context.textclass);
-               context.font = parent_context.font;
+               if (forcePlainLayout)
+                       context.layout = &context.textclass.plainLayout();
+               else
+                       context.font = parent_context.font;
 
-               // If we have no inner box the contens will be read with the 
outer box
+               // If we have no inner box the contents will be read with the 
outer box
                if (!inner_type.empty())
                        parse_text(p, os, inner_flags, outer, context);
 
@@ -895,6 +938,10 @@
                // Find end of outer box, output contents if inner_type is
                // empty and output possible comments
                if (!outer_type.empty()) {
+                       // If we already read the inner box we have to pop
+                       // the inner env
+                       if (!inner_type.empty() && (inner_flags & FLAG_END))
+                               active_environments.pop_back();
                        // This does not output anything but comments if
                        // inner_type is not empty (see use_ert)
                        parse_text(p, os, outer_flags, outer, context);
@@ -942,6 +989,22 @@
        }
        string inner;
        unsigned int inner_flags = 0;
+       p.pushPosition();
+       if (outer_type == "minipage" || outer_type == "parbox") {
+               p.skip_spaces(true);
+               while (p.hasOpt()) {
+                       p.getArg('[', ']');
+                       p.skip_spaces(true);
+               }
+               p.getArg('{', '}');
+               p.skip_spaces(true);
+               if (outer_type == "parbox") {
+                       // Eat '{'
+                       if (p.next_token().cat() == catBegin)
+                               p.get_token();
+                       eat_whitespace(p, os, parent_context, false);
+               }
+       }
        if (outer_type == "shaded") {
                // These boxes never have an inner box
                ;
@@ -949,25 +1012,31 @@
                inner = p.get_token().cs();
                inner_flags = FLAG_ITEM;
        } else if (p.next_token().asInput() == "\\begin") {
-               // Is this a minipage?
+               // Is this a minipage or shaded box?
                p.pushPosition();
                p.get_token();
                inner = p.getArg('{', '}');
                p.popPosition();
-               if (inner == "minipage") {
-                       p.get_token();
-                       p.getArg('{', '}');
-                       eat_whitespace(p, os, parent_context, false);
+               if (inner == "minipage" || inner == "shaded")
                        inner_flags = FLAG_END;
-               } else
+               else
                        inner = "";
        }
+       p.popPosition();
        if (inner_flags == FLAG_END) {
-               active_environments.push_back(inner);
+               if (inner != "shaded")
+               {
+                       p.get_token();
+                       p.getArg('{', '}');
+                       eat_whitespace(p, os, parent_context, false);
+               }
                parse_box(p, os, flags, FLAG_END, outer, parent_context,
                          outer_type, special, inner);
-               active_environments.pop_back();
        } else {
+               if (inner_flags == FLAG_ITEM) {
+                       p.get_token();
+                       eat_whitespace(p, os, parent_context, false);
+               }
                parse_box(p, os, flags, inner_flags, outer, parent_context,
                          outer_type, special, inner);
        }
@@ -1136,7 +1205,29 @@
 
        else if (name == "minipage") {
                eat_whitespace(p, os, parent_context, false);
-               parse_box(p, os, 0, FLAG_END, outer, parent_context, "", "", 
name);
+               // Test whether this is an outer box of a shaded box
+               p.pushPosition();
+               // swallow arguments
+               while (p.hasOpt()) {
+                       p.getArg('[', ']');
+                       p.skip_spaces(true);
+               }
+               p.getArg('{', '}');
+               p.skip_spaces(true);
+               Token t = p.get_token();
+               bool shaded = false;
+               if (t.asInput() == "\\begin") {
+                       p.skip_spaces(true);
+                       if (p.getArg('{', '}') == "shaded")
+                               shaded = true;
+               }
+               p.popPosition();
+               if (shaded)
+                       parse_outer_box(p, os, FLAG_END, outer,
+                                       parent_context, name, "shaded");
+               else
+                       parse_box(p, os, 0, FLAG_END, outer, parent_context,
+                                 "", "", name);
                p.skip_spaces();
        }
 
@@ -3297,8 +3388,35 @@
                        end_inset(os);
                }
 
-               else if (t.cs() == "parbox")
-                       parse_box(p, os, 0, FLAG_ITEM, outer, context, "", "", 
t.cs());
+               else if (t.cs() == "parbox") {
+                       // Test whether this is an outer box of a shaded box
+                       p.pushPosition();
+                       // swallow arguments
+                       while (p.hasOpt()) {
+                               p.getArg('[', ']');
+                               p.skip_spaces(true);
+                       }
+                       p.getArg('{', '}');
+                       p.skip_spaces(true);
+                       // eat the '{'
+                       if (p.next_token().cat() == catBegin)
+                               p.get_token();
+                       p.skip_spaces(true);
+                       Token to = p.get_token();
+                       bool shaded = false;
+                       if (to.asInput() == "\\begin") {
+                               p.skip_spaces(true);
+                               if (p.getArg('{', '}') == "shaded")
+                                       shaded = true;
+                       }
+                       p.popPosition();
+                       if (shaded) {
+                               parse_outer_box(p, os, FLAG_ITEM, outer,
+                                               context, "parbox", "shaded");
+                       } else
+                               parse_box(p, os, 0, FLAG_ITEM, outer, context,
+                                         "", "", t.cs());
+               }
 
                else if (t.cs() == "ovalbox" || t.cs() == "Ovalbox" ||
                         t.cs() == "shadowbox" || t.cs() == "doublebox")

Modified: lyx-devel/branches/BRANCH_2_0_X/status.20x
==============================================================================
--- lyx-devel/branches/BRANCH_2_0_X/status.20x  Sun Nov  6 16:06:19 2011        
(r40136)
+++ lyx-devel/branches/BRANCH_2_0_X/status.20x  Sun Nov  6 16:15:13 2011        
(r40137)
@@ -156,6 +156,8 @@
 
 - Fix tex2lyx handling of inputenc encoding settings (bug 7863).
 
+- Fix (La)TeX import of shaded boxes (bug 7843).
+
 - Store the autosave files of unnamed buffers in the correct directory
   and make sure they are not left behind after saving (bug 7793).
 

Reply via email to