anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-11-07 12:32:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a020bbc4a8
lyx_mirror/src/RowFlags.h

63 lines
1.9 KiB
C
Raw Normal View History

Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// -*- C++ -*-
/**
* \file RowFlags.h
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
* \author Jean-Marc Lasgouttes
*
* Full author contact details are available in file CREDITS.
*/
#ifndef ROWFLAGS_H
#define ROWFLAGS_H
// Do not include anything here
namespace lyx {
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
/* The list of possible flags, that can be combined. Some flags that
* should logically be here (e.g., AlwaysBreakBefore), do not exist.
* This is because the need has not been identitfied yet.
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
*
* Priorities when before/after disagree:
* AlwaysBreak* > NoBreak* > Break* or CanBreak*.
*/
enum RowFlags {
// Do not break before or after this element, except if really
// needed (between NoBreak* and CanBreak*).
Inline = 0,
// break row before this element if the row is not empty
BreakBefore = 1 << 0,
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
// break row whenever needed before this element
CanBreakBefore = 1 << 1,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// Avoid breaking row before this element
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
NoBreakBefore = 1 << 2,
Improve row flushing Add new row flags Flush and FlushBefore to let insets indicate whether they cause flushing of current row (eg. newline) or of previous row (e.g. display insets).
2021-09-22 13:09:26 +00:00
// flush the row before this element (useful with BreakBefore)
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
FlushBefore = 1 << 3,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// force new (maybe empty) row after this element
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
AlwaysBreakAfter = 1 << 4,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// break row after this element if there are more elements
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
BreakAfter = 1 << 5,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// break row whenever needed after this element
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
CanBreakAfter = 1 << 6,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// Avoid breaking row after this element
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
NoBreakAfter = 1 << 7,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// The contents of the row may be broken in two (e.g. string)
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
CanBreakInside = 1 << 8,
Improve row flushing Add new row flags Flush and FlushBefore to let insets indicate whether they cause flushing of current row (eg. newline) or of previous row (e.g. display insets).
2021-09-22 13:09:26 +00:00
// Flush the row that ends with this element
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
Flush = 1 << 9,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// specify an alignment (left, right) for a display element
// (default is center)
Implement CanBreakBefore row flag This is used for elements that allow to break a row before them (similar to CanBreakAfter).
2022-06-09 19:27:43 +00:00
AlignLeft = 1 << 10,
AlignRight = 1 << 11,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// A display element breaks row at both ends
Improve row flushing Add new row flags Flush and FlushBefore to let insets indicate whether they cause flushing of current row (eg. newline) or of previous row (e.g. display insets).
2021-09-22 13:09:26 +00:00
Display = FlushBefore | BreakBefore | BreakAfter,
Implement Row::Element::row_flags Move the enum definition RowFlags in its own include file, to avoid loading Inset.h. Document it more thoroughly. Rename RowAfter to AlwaysBreakAfter. Add CanBreakInside (rows that can be themselves broken). This allow to differentiate elements before bodyPos() and allows to remove a parameter to shortenIfNeeded(). Make the Inset::rowFlags() method return int instead of RowFlags, as should be done for all the bitwise flags. Remove the hand-made bitwise operators. Set R::E::row_flags when creating elements. * INSET elements use the inset's rowFLags(); * virtual element forbid breaking before them, and inherit the *After flags from the previous element of the row; * STRING elements usr CanBreakInside, except before bodyPos. More stuff may be added later.
2021-07-11 22:07:59 +00:00
// Flags that concern breaking after element
AfterFlags = AlwaysBreakAfter | BreakAfter | CanBreakAfter | NoBreakAfter
};
} // namespace lyx
#endif
Reference in New Issue Copy Permalink