#include <ctime>
#include <unistd.h>
#include <sys/wait.h>
+#include <locale.h>
#ifdef __GNUG__
#pragma implementation
#include "insets/insettext.h"
/// added for Dispatch functions
#include "lyx_cb.h"
-#include "filedlg.h"
+#include "frontends/FileDialog.h"
#include "lyx_main.h"
#include "FloatList.h"
#include "support/filetools.h"
using SigC::slot;
#endif
+using std::vector;
using std::find_if;
using std::pair;
using std::endl;
BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o,
int xpos, int ypos, int width, int height)
- : bv_(b), owner_(o), cursor_timeout(400)
+ : bv_(b), owner_(o), buffer_(0),
+ current_scrollbar_value(0), cursor_timeout(400),
+ workarea_(xpos, ypos, width, height), using_xterm_cursor(false)
{
- buffer_ = 0;
- workarea_ = new WorkArea(xpos, ypos, width, height);
// Setup the signals
- workarea_->scrollCB.connect(slot(this, &BufferView::Pimpl::scrollCB));
- workarea_->workAreaExpose
+ workarea_.scrollCB.connect(slot(this, &BufferView::Pimpl::scrollCB));
+ workarea_.workAreaExpose
.connect(slot(this, &BufferView::Pimpl::workAreaExpose));
- workarea_->workAreaEnter
+ workarea_.workAreaEnter
.connect(slot(this, &BufferView::Pimpl::enterView));
- workarea_->workAreaLeave
+ workarea_.workAreaLeave
.connect(slot(this, &BufferView::Pimpl::leaveView));
- workarea_->workAreaButtonPress
+ workarea_.workAreaButtonPress
.connect(slot(this, &BufferView::Pimpl::workAreaButtonPress));
- workarea_->workAreaButtonRelease
+ workarea_.workAreaButtonRelease
.connect(slot(this,
&BufferView::Pimpl::workAreaButtonRelease));
- workarea_->workAreaMotionNotify
+ workarea_.workAreaMotionNotify
.connect(slot(this, &BufferView::Pimpl::workAreaMotionNotify));
- workarea_->workAreaDoubleClick
+ workarea_.workAreaDoubleClick
.connect(slot(this, &BufferView::Pimpl::doubleClick));
- workarea_->workAreaTripleClick
+ workarea_.workAreaTripleClick
.connect(slot(this, &BufferView::Pimpl::tripleClick));
- workarea_->workAreaKeyPress
+ workarea_.workAreaKeyPress
.connect(slot(this, &BufferView::Pimpl::workAreaKeyPress));
- screen_ = 0;
+ //screen_ = 0;
cursor_timeout.timeout.connect(slot(this,
&BufferView::Pimpl::cursorToggle));
- current_scrollbar_value = 0;
+ //current_scrollbar_value = 0;
cursor_timeout.start();
- workarea_->setFocus();
- using_xterm_cursor = false;
+ workarea_.setFocus();
+ //using_xterm_cursor = false;
saved_positions.resize(saved_positions_num);
}
Painter & BufferView::Pimpl::painter()
{
- return workarea_->getPainter();
+ return workarea_.getPainter();
}
// only if the buffer is still loaded.
// Also set the owner of the test to 0
// bv_->text->owner(0);
- textcache.add(buffer_, workarea_->workWidth(), bv_->text);
+ textcache.add(buffer_, workarea_.workWidth(), bv_->text);
if (lyxerr.debugging())
textcache.show(lyxerr, "BufferView::buffer");
// Nuke old image
// screen is always deleted when the buffer is changed.
- delete screen_;
- screen_ = 0;
+ screen_.reset(0);
+ //delete screen_;
+ //screen_ = 0;
// If we are closing the buffer, use the first buffer as current
if (!buffer_) {
owner_->updateToolbar();
owner_->getDialogs()->hideBufferDependent();
updateScrollbar();
- workarea_->redraw();
+ workarea_.redraw();
// Also remove all remaining text's from the testcache.
// (there should not be any!) (if there is any it is a
void BufferView::Pimpl::resize(int xpos, int ypos, int width, int height)
{
- workarea_->resize(xpos, ypos, width, height);
+ workarea_.resize(xpos, ypos, width, height);
update(bv_->text, SELECT);
redraw();
}
void BufferView::Pimpl::redraw()
{
lyxerr[Debug::INFO] << "BufferView::redraw()" << endl;
- workarea_->redraw();
+ workarea_.redraw();
}
bool BufferView::Pimpl::fitCursor(LyXText * text)
{
- Assert(screen_);
+ Assert(screen_.get());
bool ret = screen_->FitCursor(text, bv_);
if (ret)
LyXParagraph * selendpar = 0;
UpdatableInset * the_locking_inset = 0;
- int pos = 0;
- int selstartpos = 0;
- int selendpos = 0;
- int selection = 0;
- int mark_set = 0;
+ LyXParagraph::size_type pos = 0;
+ LyXParagraph::size_type selstartpos = 0;
+ LyXParagraph::size_type selendpos = 0;
+ bool selection = false;
+ bool mark_set = false;
ProhibitInput(bv_);
} else {
// See if we have a text in TextCache that fits
// the new buffer_ with the correct width.
- bv_->text = textcache.findFit(buffer_, workarea_->workWidth());
+ bv_->text = textcache.findFit(buffer_, workarea_.workWidth());
if (bv_->text) {
if (lyxerr.debugging()) {
lyxerr << "Found a LyXText that fits:\n";
- textcache.show(lyxerr, make_pair(buffer_, make_pair(workarea_->workWidth(), bv_->text)));
+ textcache.show(lyxerr, make_pair(buffer_, make_pair(workarea_.workWidth(), bv_->text)));
}
// Set the owner of the newly found text
// bv_->text->owner(bv_);
bv_->setState();
AllowInput(bv_);
- owner_->getDialogs()->hideSplash();
+ /// get rid of the splash screen if it's not gone already
+ owner_->getDialogs()->destroySplash();
return 0;
}
void BufferView::Pimpl::updateScreen()
{
// Regenerate the screen.
- delete screen_;
- screen_ = new LyXScreen(*workarea_);
+ screen_.reset(new LyXScreen(workarea_));
+ //delete screen_;
+ //screen_ = new LyXScreen(workarea_);
}
* be possible */
if (!buffer_) {
- workarea_->setScrollbar(0, 1.0);
+ workarea_.setScrollbar(0, 1.0);
return;
}
// check if anything has changed.
if (max2 == cbth &&
- height2 == workarea_->height() &&
+ height2 == workarea_.height() &&
current_scrollbar_value == cbsf)
return; // no
max2 = cbth;
- height2 = workarea_->height();
+ height2 = workarea_.height();
current_scrollbar_value = cbsf;
if (cbth <= height2) { // text is smaller than screen
- workarea_->setScrollbar(0, 1.0); // right?
+ workarea_.setScrollbar(0, 1.0); // right?
return;
}
- long maximum_height = workarea_->height() * 3 / 4 + cbth;
+ long maximum_height = workarea_.height() * 3 / 4 + cbth;
long value = cbsf;
// set the scrollbar
- double hfloat = workarea_->height();
+ double hfloat = workarea_.height();
double maxfloat = maximum_height;
float slider_size = 0.0;
int slider_value = value;
- workarea_->setScrollbarBounds(0, bv_->text->height - workarea_->height());
- double lineh = bv_->text->DefaultHeight();
- workarea_->setScrollbarIncrements(lineh);
+ workarea_.setScrollbarBounds(0, bv_->text->height - workarea_.height());
+ double const lineh = bv_->text->DefaultHeight();
+ workarea_.setScrollbarIncrements(lineh);
if (maxfloat > 0.0) {
if ((hfloat / maxfloat) * float(height2) < 3)
slider_size = 3.0/float(height2);
} else
slider_size = hfloat;
- workarea_->setScrollbar(slider_value, slider_size / workarea_->height());
+ workarea_.setScrollbar(slider_value, slider_size / workarea_.height());
}
if (current_scrollbar_value < 0)
current_scrollbar_value = 0;
- if (!screen_)
+ if (!screen_.get())
return;
screen_->Draw(bv_->text, bv_, current_scrollbar_value);
int const height = vbt->DefaultHeight();
int const first = static_cast<int>((bv_->text->first + height));
- int const last = static_cast<int>((bv_->text->first + workarea_->height() - height));
+ int const last = static_cast<int>((bv_->text->first + workarea_.height() - height));
if (vbt->cursor.y() < first)
vbt->SetCursorFromCoordinates(bv_, 0, first);
int BufferView::Pimpl::scrollUp(long time)
{
if (!buffer_) return 0;
- if (!screen_) return 0;
+ if (!screen_.get()) return 0;
- double value = workarea_->getScrollbarValue();
+ double value = workarea_.getScrollbarValue();
if (value == 0) return 0;
float add_value = (bv_->text->DefaultHeight()
+ float(time) * float(time) * 0.125);
- if (add_value > workarea_->height())
- add_value = float(workarea_->height() -
+ if (add_value > workarea_.height())
+ add_value = float(workarea_.height() -
bv_->text->DefaultHeight());
value -= add_value;
if (value < 0)
value = 0;
- workarea_->setScrollbarValue(value);
+ workarea_.setScrollbarValue(value);
scrollCB(value);
return 0;
int BufferView::Pimpl::scrollDown(long time)
{
if (!buffer_) return 0;
- if (!screen_) return 0;
+ if (!screen_.get()) return 0;
- double value= workarea_->getScrollbarValue();
- pair<float, float> p = workarea_->getScrollbarBounds();
+ double value = workarea_.getScrollbarValue();
+ pair<float, float> p = workarea_.getScrollbarBounds();
double max = p.second;
if (value == max) return 0;
float add_value = (bv_->text->DefaultHeight()
+ float(time) * float(time) * 0.125);
- if (add_value > workarea_->height())
- add_value = float(workarea_->height() -
+ if (add_value > workarea_.height())
+ add_value = float(workarea_.height() -
bv_->text->DefaultHeight());
value += add_value;
if (value > max)
value = max;
- workarea_->setScrollbarValue(value);
+ workarea_.setScrollbarValue(value);
scrollCB(value);
return 0;
if (!(state & Button1MotionMask))
return;
- if (!buffer_ || !screen_) return;
+ if (!buffer_ || !screen_.get()) return;
// Check for inset locking
if (bv_->theLockingInset()) {
last_click_x = -1;
last_click_y = -1;
- if (!buffer_ || !screen_) return;
+ if (!buffer_ || !screen_.get()) return;
Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button);
if (text->bv_owner && bv_->theLockingInset())
return;
- if (screen_ && button == 1) {
+ if (screen_.get() && button == 1) {
if (text->bv_owner) {
screen_->HideCursor();
screen_->ToggleSelection(text, bv_);
if (text->bv_owner && bv_->theLockingInset())
return;
- if (screen_ && (button == 1)) {
+ if (screen_.get() && (button == 1)) {
screen_->HideCursor();
screen_->ToggleSelection(text, bv_);
text->CursorHome(bv_);
void BufferView::Pimpl::enterView()
{
if (active() && available()) {
- SetXtermCursor(workarea_->getWin());
+ SetXtermCursor(workarea_.getWin());
using_xterm_cursor = true;
}
}
void BufferView::Pimpl::leaveView()
{
if (using_xterm_cursor) {
- XUndefineCursor(fl_get_display(), workarea_->getWin());
+ XUndefineCursor(fl_get_display(), workarea_.getWin());
using_xterm_cursor = false;
}
}
void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
unsigned int button)
{
- if (!buffer_ || !screen_) return;
+ if (!buffer_ || !screen_.get()) return;
// If we hit an inset, we have the inset coordinates in these
// and inset_hit points to the inset. If we do not hit an
return;
}
+#ifndef NEW_INSETS
// check whether we want to open a float
if (bv_->text) {
bool hit = false;
c = bv_->text->cursor.par()->
GetChar(bv_->text->cursor.pos());
}
-#ifndef NEW_INSETS
if(!bv_->text->selection)
if (c == LyXParagraph::META_FOOTNOTE
|| c == LyXParagraph::META_MARGIN
|| c == LyXParagraph::META_ALGORITHM){
hit = true;
} else
-#endif
if (bv_->text->cursor.pos() - 1 >= 0) {
c = bv_->text->cursor.par()->
GetChar(bv_->text->cursor.pos() - 1);
-#ifndef NEW_INSETS
if (c == LyXParagraph::META_FOOTNOTE
|| c == LyXParagraph::META_MARGIN
|| c == LyXParagraph::META_FIG
bv_->text->CursorLeft(bv_);
hit = true;
}
-#endif
}
if (hit == true) {
-#ifndef NEW_INSETS
bv_->toggleFloat();
-#endif
selection_possible = false;
return;
}
}
-
-#ifndef NEW_INSETS
// Do we want to close a float? (click on the float-label)
if (bv_->text->cursor.row()->par()->footnoteflag ==
LyXParagraph::OPEN_FOOTNOTE
return;
}
}
+#else
+ // check whether we want to open a float
+ if (bv_->text) {
+ bool hit = false;
+ char c = ' ';
+ if (bv_->text->cursor.pos() <
+ bv_->text->cursor.par()->size()) {
+ c = bv_->text->cursor.par()->
+ GetChar(bv_->text->cursor.pos());
+ }
+ if (bv_->text->cursor.pos() - 1 >= 0) {
+ c = bv_->text->cursor.par()->
+ GetChar(bv_->text->cursor.pos() - 1);
+ }
+ if (hit == true) {
+ selection_possible = false;
+ return;
+ }
+ }
#endif
-
// Maybe we want to edit a bibitem ale970302
if (bv_->text->cursor.par()->bibkey && x < 20 +
bibitemMaxWidth(bv_, textclasslist.
Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
unsigned int /* button */)
{
- if (!screen_)
+ if (!screen_.get())
return 0;
int y_tmp = y + text->first;
LyXCursor cursor;
text->SetCursorFromCoordinates(bv_, cursor, x, y_tmp);
+#ifndef NEW_INSETS
if (cursor.pos() < cursor.par()->Last()
+#else
+ if (cursor.pos() < cursor.par()->size()
+#endif
&& cursor.par()->GetChar(cursor.pos()) == LyXParagraph::META_INSET
&& cursor.par()->GetInset(cursor.pos())
&& cursor.par()->GetInset(cursor.pos())->Editable()) {
static int work_area_width = 0;
static unsigned int work_area_height = 0;
- bool widthChange = workarea_->workWidth() != work_area_width;
- bool heightChange = workarea_->height() != work_area_height;
+ bool widthChange = workarea_.workWidth() != work_area_width;
+ bool heightChange = workarea_.height() != work_area_height;
// update from work area
- work_area_width = workarea_->workWidth();
- work_area_height = workarea_->height();
+ work_area_width = workarea_.workWidth();
+ work_area_height = workarea_.height();
if (buffer_ != 0) {
if (widthChange) {
// All buffers need a resize
// ...including the minibuffer
owner_->getMiniBuffer()->Init();
- } else if (screen_)
+ } else if (screen_.get())
screen_->Redraw(bv_->text, bv_);
} else {
// Grey box when we don't have a buffer
- workarea_->greyOut();
+ workarea_.greyOut();
}
// always make sure that the scrollbar is sane.
void BufferView::Pimpl::update()
{
- if (screen_) screen_->Update(bv_->text, bv_);
+ if (screen_.get()) screen_->Update(bv_->text, bv_);
}
// Values used when calling update:
updatelist.update(bv_);
- if (!screen_) {
+ if (!screen_.get()) {
cursor_timeout.restart();
return;
}
text->CursorUp(bv_);
if (text->inset_owner ||
- text->cursor.row()->height() < workarea_->height())
+ text->cursor.row()->height() < workarea_.height())
screen_->Draw(bv_->text, bv_,
text->cursor.y()
- text->cursor.row()->baseline()
+ text->cursor.row()->height()
- - workarea_->height() + 1 );
+ - workarea_.height() + 1 );
updateScrollbar();
}
if (!text->cursor.row()->next())
return;
- int y = text->first + workarea_->height();
+ int y = text->first + workarea_.height();
// if (text->inset_owner)
// y += bv_->text->first;
text->GetRowNearY(y);
text->CursorDown(bv_);
if (text->inset_owner ||
- text->cursor.row()->height() < workarea_->height())
+ text->cursor.row()->height() < workarea_.height())
screen_->Draw(bv_->text, bv_, text->cursor.y() -
text->cursor.row()->baseline());
updateScrollbar();
if (!par)
return;
+#ifndef NEW_INSETS
bv_->text->SetCursor(bv_, par,
min(par->Last(), saved_positions[i].par_pos));
+#else
+ bv_->text->SetCursor(bv_, par,
+ min(par->size(), saved_positions[i].par_pos));
+#endif
update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
if (i > 0)
owner_->getMiniBuffer()->Set(_("Moved to bookmark ") + tostr(i));
bool BufferView::Pimpl::focus() const
{
- return workarea_->hasFocus();
+ return workarea_.hasFocus();
}
void BufferView::Pimpl::focus(bool f)
{
- if (f) workarea_->setFocus();
+ if (f) workarea_.setFocus();
}
bool BufferView::Pimpl::active() const
{
- return workarea_->active();
+ return workarea_.active();
}
bool BufferView::Pimpl::belowMouse() const
{
- return workarea_->belowMouse();
+ return workarea_.belowMouse();
}
void BufferView::Pimpl::showCursor()
{
- if (screen_)
+ if (screen_.get())
screen_->ShowCursor(bv_->text, bv_);
}
void BufferView::Pimpl::hideCursor()
{
- if (screen_)
+ if (screen_.get())
screen_->HideCursor();
}
void BufferView::Pimpl::toggleSelection(bool b)
{
- if (screen_)
+ if (screen_.get())
screen_->ToggleSelection(bv_->text, bv_, b);
}
void BufferView::Pimpl::toggleToggle()
{
- if (screen_)
+ if (screen_.get())
screen_->ToggleToggle(bv_->text, bv_);
}
void BufferView::Pimpl::center()
{
beforeChange(bv_->text);
- if (bv_->text->cursor.y() > static_cast<int>((workarea_->height() / 2))) {
- screen_->Draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_->height() / 2);
+ if (bv_->text->cursor.y() > static_cast<int>((workarea_.height() / 2))) {
+ screen_->Draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_.height() / 2);
} else {
screen_->Draw(bv_->text, bv_, 0);
}
screen_->HideCursor();
beforeChange(bv_->text);
- string const clip(workarea_->getClipboard());
+ string const clip(workarea_.getClipboard());
if (clip.empty()) return;
void BufferView::Pimpl::stuffClipboard(string const & stuff) const
{
- workarea_->putClipboard(stuff);
+ workarea_.putClipboard(stuff);
}
if (filename.empty()) {
// Launch a file browser
string initpath = lyxrc.document_path;
- LyXFileDlg fileDlg;
if (available()) {
string const trypath = owner_->buffer()->filepath;
initpath = trypath;
}
- // launches dialog
- ProhibitInput(bv_);
- fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
- fileDlg.SetButton(1, _("Examples"),
- AddPath(system_lyxdir, "examples"));
- filename = fileDlg.Select(_("Select Document to Insert"),
- initpath, "*.lyx");
- AllowInput(bv_);
+ FileDialog fileDlg(bv_->owner(), _("Select LyX document to insert"),
+ LFUN_FILE_INSERT,
+ make_pair(string(_("Documents")), string(lyxrc.document_path)),
+ make_pair(string(_("Examples")), string(AddPath(system_lyxdir, "examples"))));
+
+ FileDialog::Result result = fileDlg.Select(initpath, _("*.lyx| LyX Documents (*.lyx)"));
+
+ if (result.first == FileDialog::Later)
+ return;
+
+ filename = result.second;
// check selected filename
if (filename.empty()) {
owner_->getMiniBuffer()->Set(_("Canceled."));
return;
}
- }
+ }
// get absolute path of file and make sure the filename ends
// with .lyx
}
break;
+ case LFUN_FILE_INSERT_ASCII_PARA:
+ InsertAsciiFile(bv_, argument, true);
+ break;
+
case LFUN_FILE_INSERT_ASCII:
- {
- bool asPara = (argument == "paragraph");
- InsertAsciiFile(bv_, string(), asPara);
- }
- break;
+ InsertAsciiFile(bv_, argument, false);
+ break;
case LFUN_LAYOUT:
{
update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
if (is_rtl)
TEXT(bv_)->CursorLeft(bv_, false);
+#ifndef NEW_INSETS
if (TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last()
+#else
+ if (TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->size()
+#endif
&& TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos())
== LyXParagraph::META_INSET
&& TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())
if (!is_rtl)
TEXT(bv_)->CursorLeft(bv_, false);
if ((is_rtl || cur != TEXT(bv_)->cursor) && // only if really moved!
+#ifndef NEW_INSETS
TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last() &&
+#else
+ TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->size() &&
+#endif
(TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos()) ==
LyXParagraph::META_INSET) &&
TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()) &&
LyXCursor cursor = TEXT(bv_)->cursor;
if (!TEXT(bv_)->selection) {
+#ifndef NEW_INSETS
if (cursor.pos() == cursor.par()->Last()) {
+#else
+ if (cursor.pos() == cursor.par()->size()) {
+#endif
TEXT(bv_)->CursorRight(bv_);
cursor = TEXT(bv_)->cursor;
if (cursor.pos() == 0
- && !(cursor.par()->added_space_top
+ && !(cursor.par()->params.spaceTop()
== VSpace (VSpace::NONE))) {
TEXT(bv_)->SetParagraph
(bv_,
- cursor.par()->line_top,
- cursor.par()->line_bottom,
- cursor.par()->pagebreak_top,
- cursor.par()->pagebreak_bottom,
+ cursor.par()->params.lineTop(),
+ cursor.par()->params.lineBottom(),
+ cursor.par()->params.pagebreakTop(),
+ cursor.par()->params.pagebreakBottom(),
VSpace(VSpace::NONE),
- cursor.par()->added_space_bottom,
- cursor.par()->align,
- cursor.par()->labelwidthstring, 0);
+ cursor.par()->params.spaceBottom(),
+ cursor.par()->params.align(),
+ cursor.par()->params.labelWidthString(), 0);
TEXT(bv_)->CursorLeft(bv_);
update(TEXT(bv_),
BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
if (!TEXT(bv_)->selection) {
if (cursor.pos() == 0
- && !(cursor.par()->added_space_top
+ && !(cursor.par()->params.spaceTop()
== VSpace (VSpace::NONE))) {
TEXT(bv_)->SetParagraph
(bv_,
- cursor.par()->line_top,
- cursor.par()->line_bottom,
- cursor.par()->pagebreak_top,
- cursor.par()->pagebreak_bottom,
- VSpace(VSpace::NONE), cursor.par()->added_space_bottom,
- cursor.par()->align,
- cursor.par()->labelwidthstring, 0);
+ cursor.par()->params.lineTop(),
+ cursor.par()->params.lineBottom(),
+ cursor.par()->params.pagebreakTop(),
+ cursor.par()->params.pagebreakBottom(),
+ VSpace(VSpace::NONE), cursor.par()->params.spaceBottom(),
+ cursor.par()->params.align(),
+ cursor.par()->params.labelWidthString(), 0);
update(TEXT(bv_),
BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
} else {
beforeChange(TEXT(bv_));
if (cursor.pos() == 0) {
- if (cursor.par()->added_space_top == VSpace(VSpace::NONE)) {
+ if (cursor.par()->params.spaceTop() == VSpace(VSpace::NONE)) {
TEXT(bv_)->SetParagraph
(bv_,
- cursor.par()->line_top,
- cursor.par()->line_bottom,
- cursor.par()->pagebreak_top,
- cursor.par()->pagebreak_bottom,
- VSpace(VSpace::DEFSKIP), cursor.par()->added_space_bottom,
- cursor.par()->align,
- cursor.par()->labelwidthstring, 1);
+ cursor.par()->params.lineTop(),
+ cursor.par()->params.lineBottom(),
+ cursor.par()->params.pagebreakTop(),
+ cursor.par()->params.pagebreakBottom(),
+ VSpace(VSpace::DEFSKIP), cursor.par()->params.spaceBottom(),
+ cursor.par()->params.align(),
+ cursor.par()->params.labelWidthString(), 1);
//update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
}
}
case LFUN_PARAGRAPH_SPACING:
{
LyXParagraph * par = TEXT(bv_)->cursor.par();
- Spacing::Space cur_spacing = par->spacing.getSpace();
+ Spacing::Space cur_spacing = par->params.spacing().getSpace();
float cur_value = 1.0;
if (cur_spacing == Spacing::Other) {
- cur_value = par->spacing.getValue();
+ cur_value = par->params.spacing().getValue();
}
istringstream istr(argument.c_str());
<< argument << endl;
}
if (cur_spacing != new_spacing || cur_value != new_value) {
- par->spacing.set(new_spacing, new_value);
+ par->params.spacing(Spacing(new_spacing, new_value));
TEXT(bv_)->RedoParagraph(bv_);
update(TEXT(bv_),
BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
projects / lyx.git / blobdiff