From: Lars Gullik Bjønnes Date: Wed, 12 Apr 2000 15:11:29 +0000 (+0000) Subject: two new files X-Git-Tag: 1.6.10~22301 X-Git-Url: https://git.lyx.org/gitweb/?a=commitdiff_plain;h=ce363ba1012d517db9fd8a2a688ded914f347e04;p=features.git two new files git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@652 a592a061-630c-0410-9148-cb99ea01b6c8 --- diff --git a/src/bufferview_funcs.C b/src/bufferview_funcs.C new file mode 100644 index 0000000000..e3f9f0a734 --- /dev/null +++ b/src/bufferview_funcs.C @@ -0,0 +1,315 @@ +#include + +#include "bufferview_funcs.h" +#include "LyXView.h" +#include "BufferView.h" +#include "lyxparagraph.h" +#include "lyxfont.h" +#include "lyx_gui_misc.h" +#include "lyxtext.h" +#include "minibuffer.h" +#include "buffer.h" +#include "support/lstrings.h" +#include "lyx_cb.h" +#include "layout_forms.h" + +extern FD_form_paragraph * fd_form_paragraph; +extern FD_form_character * fd_form_character; + + +static +void SetXtermCursor(Window win) +{ + static Cursor cursor; + static bool cursor_undefined = true; + if (cursor_undefined){ + cursor = XCreateFontCursor(fl_display, XC_xterm); + XFlush(fl_display); + cursor_undefined = false; + } + XDefineCursor(fl_display, win, cursor); + XFlush(fl_display); +} + + +void Foot(BufferView * bv) +{ + if (!bv->available()) + return; + + bv->owner()->getMiniBuffer() + ->Set(_("Inserting Footnote...")); + bv->hideCursor(); + bv->update(-2); + bv->text->InsertFootnoteEnvironment(LyXParagraph::FOOTNOTE); + bv->update(1); +} + + +void Emph(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setEmph(LyXFont::TOGGLE); + ToggleAndShow(bv, font); +} + + +void Bold(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setSeries(LyXFont::BOLD_SERIES); + ToggleAndShow(bv, font); +} + + +void Noun(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setNoun(LyXFont::TOGGLE); + ToggleAndShow(bv, font); +} + + +void Margin(BufferView * bv) +{ + if (bv->available()) { + bv->owner()->getMiniBuffer()->Set(_("Inserting margin note...")); + bv->hideCursor(); + bv->update(-2); + bv->text->InsertFootnoteEnvironment(LyXParagraph::MARGIN); + bv->update(1); + } +} + + +void Lang(BufferView * bv, string const & l) +{ + LyXFont font(LyXFont::ALL_IGNORE); + Languages::iterator lit = languages.find(l); + if (lit != languages.end()) { + font.setLanguage(&(*lit).second); + ToggleAndShow(bv, font); + } else + WriteAlert(_("Error! unknown language"),l); +} + + +void Melt(BufferView * bv) +{ + if (!bv->available()) return; + + bv->owner()->getMiniBuffer()->Set(_("Melt")); + bv->hideCursor(); + bv->beforeChange(); + bv->update(-2); + bv->text->MeltFootnoteEnvironment(); + bv->update(1); +} + + +void Tex(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setLatex (LyXFont::TOGGLE); + ToggleAndShow(bv, font); +} + + +// Change environment depth. +// if decInc >= 0, increment depth +// if decInc < 0, decrement depth +void changeDepth(BufferView * bv, int decInc) +{ + if (!bv->available()) return; + + bv->hideCursor(); + bv->update(-2); + if (decInc >= 0) + bv->text->IncDepth(); + else + bv->text->DecDepth(); + bv->update(1); + bv->owner()->getMiniBuffer() + ->Set(_("Changed environment depth" + " (in possible range, maybe not)")); +} + + +void Free(BufferView * bv) +{ + ToggleAndShow(bv, UserFreeFont()); +} + + +// How should this actually work? Should it prohibit input in all BufferViews, +// or just in the current one? If "just the current one", then it should be +// placed in BufferView. If "all BufferViews" then LyXGUI (I think) should +// run "ProhibitInput" on all LyXViews which will run prohibitInput on all +// BufferViews. Or is it perhaps just the (input in) BufferViews in the +// current LyxView that should be prohibited (Lgb) (This applies to +// "AllowInput" as well.) +void ProhibitInput(BufferView * bv) +{ + bv->hideCursor(); + + static Cursor cursor; + static bool cursor_undefined = true; + + if (cursor_undefined){ + cursor = XCreateFontCursor(fl_display, XC_watch); + XFlush(fl_display); + cursor_undefined = false; + } + + /* set the cursor to the watch for all forms and the canvas */ + XDefineCursor(fl_display, bv->owner()->getForm()->window, + cursor); + if (fd_form_paragraph->form_paragraph->visible) + XDefineCursor(fl_display, + fd_form_paragraph->form_paragraph->window, + cursor); + if (fd_form_character->form_character->visible) + XDefineCursor(fl_display, + fd_form_character->form_character->window, + cursor); + + XFlush(fl_display); + fl_deactivate_all_forms(); +} + + +void AllowInput(BufferView * bv) +{ + /* reset the cursor from the watch for all forms and the canvas */ + + XUndefineCursor(fl_display, bv->owner()->getForm()->window); + if (fd_form_paragraph->form_paragraph->visible) + XUndefineCursor(fl_display, + fd_form_paragraph->form_paragraph->window); + if (fd_form_character->form_character->visible) + XUndefineCursor(fl_display, + fd_form_character->form_character->window); + + // What to do about this? (Lgb) + if (bv->belowMouse()) + SetXtermCursor(bv->owner()->getForm()->window); + + XFlush(fl_display); + fl_activate_all_forms(); +} + + +void Code(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good + ToggleAndShow(bv, font); +} + + +void Sans(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setFamily(LyXFont::SANS_FAMILY); + ToggleAndShow(bv, font); +} + + +void Roman(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setFamily(LyXFont::ROMAN_FAMILY); + ToggleAndShow(bv, font); +} + + +void StyleReset(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_INHERIT, ignore_language); + ToggleAndShow(bv, font); +} + + +void Underline(BufferView * bv) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setUnderbar(LyXFont::TOGGLE); + ToggleAndShow(bv, font); +} + + +void FontSize(BufferView * bv, string const & size) +{ + LyXFont font(LyXFont::ALL_IGNORE); + font.setGUISize(size); + ToggleAndShow(bv, font); +} + + +/* -------> Returns the current font and depth by printing a message. In the + * future perhaps we could try to implement a callback to the button-bar. + * That is, `light' the bold button when the font is currently bold, etc. + */ +string CurrentState(BufferView * bv) +{ + string state; + if (bv->available()) { + // I think we should only show changes from the default + // font. (Asger) + Buffer * buffer = bv->buffer(); + LyXFont font = bv->text->real_current_font; + LyXFont defaultfont = textclasslist.TextClass(buffer-> + params.textclass).defaultfont(); + font.reduce(defaultfont); + state = _("Font: ") + font.stateText(); + // The paragraph depth + int depth = bv->text->GetDepth(); + if (depth > 0) + state += string(_(", Depth: ")) + tostr(depth); + // The paragraph spacing, but only if different from + // buffer spacing. + if (!bv->text->cursor.par->spacing.isDefault()) { + Spacing::Space cur_space = + bv->text->cursor.par->spacing.getSpace(); + state += _(", Spacing: "); + switch (cur_space) { + case Spacing::Single: + state += _("Single"); + break; + case Spacing::Onehalf: + state += _("Onehalf"); + break; + case Spacing::Double: + state += _("Double"); + break; + case Spacing::Other: + state += _("Other ("); + state += tostr(bv->text->cursor.par->spacing.getValue()); + state += ")"; + break; + case Spacing::Default: + // should never happen, do nothing + break; + } + } + } + return state; +} + + +// candidate for move to BufferView +/* -------> Does the actual toggle job of the XxxCB() calls above. + * Also shows the current font state. + */ +void ToggleAndShow(BufferView * bv, LyXFont const & font) +{ + if (bv->available()) { + bv->hideCursor(); + bv->update(-2); + if (bv->the_locking_inset) + bv->the_locking_inset->SetFont(bv, font, toggleall); + else + bv->text->ToggleFree(font, toggleall); + bv->update(1); + } +} diff --git a/src/bufferview_funcs.h b/src/bufferview_funcs.h new file mode 100644 index 0000000000..ada69da5ea --- /dev/null +++ b/src/bufferview_funcs.h @@ -0,0 +1,54 @@ +// -*- C++ -*- +#ifndef BUFFERVIEW_FUNCS_H +#define BUFFERVIEW_FUNCS_H + +#include "LString.h" + +class BufferView; +class LyXFont; + +/// +extern void Foot(BufferView *); +/// +extern void Emph(BufferView *); +/// +extern void Bold(BufferView *); +/// +extern void Noun(BufferView *); +/// +extern void Margin(BufferView *); +/// +extern void Figure(); +/// +extern void Table(); +/// +extern void Lang(BufferView *, string const &); +/// +extern void Melt(BufferView *); +/// +extern void Tex(BufferView *); +/// +extern void changeDepth(BufferView *, int); +/// +extern void Free(BufferView *); +/// +extern void ProhibitInput(BufferView *); +/// +extern void AllowInput(BufferView *); +/// +extern void Code(BufferView *); +/// +extern void Sans(BufferView *); +/// +extern void Roman(BufferView *); +/// +extern void StyleReset(BufferView *); +/// +extern void Underline(BufferView *); +/// +extern void FontSize(BufferView *, string const &); +/// +extern string CurrentState(BufferView *); +/// +extern void ToggleAndShow(BufferView *, LyXFont const &); +#endif