reformatting and remove using delc

[lyx.git] / src / insets / inset.C

diff --git a/src/insets/inset.C b/src/insets/inset.C
index 19249a574e4bf9a6ad7af379ba157397b4dec113..cef7715c47761c0f089b3d46f5b1fd4b2276d108 100644 (file)
--- a/src/insets/inset.C
+++ b/src/insets/inset.C
@@ -19,66 +19,67 @@
 #include "BufferView.h"
 #include "support/lstrings.h"
 #include "Painter.h"
+#include "commandtags.h"
+#include "support/lstrings.h"
 
 using std::endl;
 
-/* Insets default methods */
+// Insets default methods
 
 bool Inset::Deletable() const
 {
-  return true;
+       return true;
 }
 
 
 bool Inset::DirectWrite() const
 {
-  return false;
+       return false;
 }
 
 
 Inset::EDITABLE Inset::Editable() const
 {
-  return NOT_EDITABLE;
-}
-
-
-bool Inset::IsTextInset() const
-{
-       return ((LyxCode() == TEXT_CODE) ||
-               (LyxCode() == ERT_CODE) ||
-               (LyxCode() == FOOT_CODE) ||
-               (LyxCode() == MARGIN_CODE));
+       return NOT_EDITABLE;
 }
 
 
 void Inset::Validate(LaTeXFeatures &) const
-{
-}
+{}
 
 
 bool Inset::AutoDelete() const
 {
-  return false;
+       return false;
 }
 
 
 void Inset::Edit(BufferView *, int, int, unsigned int)
+{}
+
+
+LyXFont const Inset::ConvertFont(LyXFont const & font) const
 {
+       return LyXFont(font);
 }
 
 
-LyXFont Inset::ConvertFont(LyXFont font)
+string const Inset::EditMessage() const 
 {
-  return font;
+       return _("Opened inset");
 }
 
 
-char const * Inset::EditMessage() const 
+LyXText * Inset::getLyXText(BufferView const * bv, bool const) const
 {
-       return _("Opened inset");
+       if (owner())
+               return owner()->getLyXText(bv, false);
+       else
+               return bv->text;
 }
 
- /* some stuff for inset locking */
+
+// some stuff for inset locking
 
 void UpdatableInset::InsetButtonPress(BufferView *, int x, int y, int button)
 {
@@ -121,72 +122,116 @@ Inset::EDITABLE UpdatableInset::Editable() const
 
 
 void UpdatableInset::ToggleInsetCursor(BufferView *)
-{
-}
+{}
 
 
-void UpdatableInset::ShowInsetCursor(BufferView *)
-{
-}
+void UpdatableInset::ShowInsetCursor(BufferView *, bool)
+{}
 
 
 void UpdatableInset::HideInsetCursor(BufferView *)
-{
-}
-
-
-void UpdatableInset::Edit(BufferView * bv, int, int, unsigned int)
-{
-    LyXFont font;
+{}
 
-    scx = 0;
 
-    mx_scx = abs((width(bv->painter(), font) - bv->workWidth()) / 2);
-}
+void UpdatableInset::Edit(BufferView *, int, int, unsigned int)
+{}
 
 
-void UpdatableInset::draw(Painter &, LyXFont const &,
-                         int /* baseline */, float & x) const
+void UpdatableInset::draw(BufferView *, LyXFont const &,
+                         int /* baseline */, float & x,
+                         bool/*cleared*/) const
 {
-    if (scx) x += float(scx);
-// ATTENTION: don't do the following here!!!
-//    top_x = int(x);
-//    top_baseline = baseline;
+       x += float(scx);
+       // ATTENTION: don't do the following here!!!
+       //    top_x = int(x);
+       //    top_baseline = baseline;
 }
 
 
 void UpdatableInset::SetFont(BufferView *, LyXFont const &, bool )
+{}
+
+
+void UpdatableInset::scroll(BufferView * bv, float s) const
 {
+       LyXFont font;
+       
+       if (!s) {
+               scx = 0;
+               return;
+       }
+
+       int const workW = bv->workWidth();
+       int const tmp_top_x = top_x - scx;
+       
+       if (tmp_top_x > 0 && 
+           (tmp_top_x + width(bv, font)) < workW)
+               return;
+       if (s > 0 && top_x > 0)
+               return;
+
+       // int mx_scx=abs((width(bv,font) - bv->workWidth())/2);
+       //int const save_scx = scx;
+    
+       scx = int(s * workW / 2);
+       // if (!display())
+       // scx += 20;
+
+       if ((tmp_top_x + scx + width(bv, font)) < (workW / 2)) {
+               scx += (workW / 2) - (tmp_top_x + scx + width(bv, font));
+       }
+       // bv->updateInset(const_cast<UpdatableInset *>(this), false);
+}
+
+void UpdatableInset::scroll(BufferView * bv, int offset) const
+{
+       if (offset > 0) {
+               if (!scx && top_x >= 20)
+                       return;
+               if ((top_x + offset) > 20)
+                       scx = 0;
+               // scx += offset - (top_x - scx + offset - 20);
+               else
+                       scx += offset;
+       } else {
+               LyXFont const font;
+               if (!scx && (top_x + width(bv, font)) < (bv->workWidth() - 20))
+                       return;
+               if ((top_x - scx + offset + width(bv, font)) < (bv->workWidth() - 20)) {
+                       scx = bv->workWidth() - width(bv, font) - top_x + scx - 20; 
+               } else {
+                       scx += offset;
+               }
+       }
+       // bv->updateInset(const_cast<UpdatableInset *>(this), false);
 }
 
 
 ///  An updatable inset could handle lyx editing commands
-#ifdef SCROLL_INSET
-UpdatableInset::RESULT
-UpdatableInset::LocalDispatch(BufferView *, 
-                             int action, string const & arg) 
-#else
 UpdatableInset::RESULT
-UpdatableInset::LocalDispatch(BufferView *, int, string const &)
-#endif
-{
-#ifdef SCROLL_INSET
-    if (action==LFUN_SCROLL_INSET)
-       {
-           float xx;
-           sscanf(arg.c_str(), "%f", &xx);     
-           scroll(xx);
-
-           return DISPATCHED;
+UpdatableInset::LocalDispatch(BufferView * bv, 
+                             kb_action action, string const & arg) 
+{
+       if (!arg.empty() && (action==LFUN_SCROLL_INSET)) {
+               if (arg.find('.') != arg.npos) {
+                       float const xx = static_cast<float>(strToDbl(arg));
+                       scroll(bv, xx);
+               } else {
+                       int const xx = strToInt(arg);
+                       scroll(bv, xx);
+               }
+               bv->updateInset(this, false);
+               
+               return DISPATCHED;
        }
-#endif
-    return UNDISPATCHED; 
+       return UNDISPATCHED; 
 }
 
 
-int UpdatableInset::getMaxWidth(Painter & pain, UpdatableInset const *) const
+int UpdatableInset::getMaxWidth(BufferView * bv, UpdatableInset const *) const
 {
-    if (owner())
-        return static_cast<UpdatableInset*>(owner())->getMaxWidth(pain, this);
-    return pain.paperWidth();
+       if (owner())
+               return static_cast<UpdatableInset*>
+                       (owner())->getMaxWidth(bv, this);
+       return bv->workWidth();
 }