src/insets/insetcollapsable.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *          Copyright (C) 1998 The LyX Team.
   7  *
   8  *======================================================*/
   9
  10 #include <config.h>
  11
  12 #ifdef __GNUG__
  13 #pragma implementation
  14 #endif
  15
  16 #include "insetcollapsable.h"
  17 #include "gettext.h"
  18 #include "lyxfont.h"
  19 #include "BufferView.h"
  20 #include "Painter.h"
  21 #include "support/LOstream.h"
  22
  23 using std::ostream;
  24
  25 InsetCollapsable::InsetCollapsable(Buffer * bf)
  26                 : InsetText(bf)
  27 {
  28     collapsed = true;
  29     label = "Label";
  30     autocollapse = true;
  31     autoBreakRows = true;
  32     framecolor = LColor::footnoteframe;
  33     widthOffset = 10;
  34     button_length = button_top_y = button_bottom_y = 0;
  35     setInsetName("Collapsable");
  36 }
  37
  38
  39 Inset * InsetCollapsable::Clone() const
  40 {
  41     InsetCollapsable * result = new InsetCollapsable(buffer);
  42     result->init(buffer, this);
  43
  44     result->collapsed = collapsed;
  45     return result;
  46 }
  47
  48 void InsetCollapsable::Write(ostream & os) const
  49 {
  50     os << getInsetName() << "\n\ncollapsed ";
  51     if (display())
  52         os << "false\n";
  53     else
  54         os << "true\n";
  55     WriteParagraphData(os);
  56 }
  57
  58
  59 void InsetCollapsable::Read(LyXLex & lex)
  60 {
  61     if (lex.IsOK()) {
  62         lex.next();
  63         string token = lex.GetString();
  64         if (token == "collapsed") {
  65             lex.next();
  66             collapsed = lex.GetBool();
  67         }
  68     }
  69     InsetText::Read(lex);
  70 }
  71
  72
  73 int InsetCollapsable::ascent_collapsed(Painter & pain, LyXFont const &) const
  74 {
  75     int width = 0, ascent = 0, descent = 0;
  76     pain.buttonText(0, 0, label.c_str(), labelfont, false,
  77                     width, ascent, descent);
  78     return ascent;
  79 }
  80
  81
  82 int InsetCollapsable::descent_collapsed(Painter & pain, LyXFont const &) const
  83 {
  84     int width = 0, ascent = 0, descent = 0;
  85     pain.buttonText(0, 0, label.c_str(), labelfont, false,
  86                     width, ascent, descent);
  87     return descent;
  88 }
  89
  90
  91 int InsetCollapsable::width_collapsed(Painter & pain, LyXFont const &) const
  92 {
  93     int width, ascent, descent;
  94     pain.buttonText(TEXT_TO_INSET_OFFSET, 0, label.c_str(), labelfont, false,
  95                     width, ascent, descent);
  96     return width + (2*TEXT_TO_INSET_OFFSET);
  97 }
  98
  99
 100 int InsetCollapsable::ascent(Painter & pain, LyXFont const & font) const
 101 {
 102     if (collapsed)
 103         return ascent_collapsed(pain, font);
 104     else
 105         return InsetText::ascent(pain, font) + TEXT_TO_TOP_OFFSET;
 106 }
 107
 108
 109 int InsetCollapsable::descent(Painter & pain, LyXFont const & font) const
 110 {
 111     if (collapsed)
 112         return descent_collapsed(pain, font);
 113     else
 114         return InsetText::descent(pain, font) + TEXT_TO_BOTTOM_OFFSET;
 115 }
 116
 117
 118 int InsetCollapsable::width(Painter & pain, LyXFont const & font) const
 119 {
 120     if (collapsed)
 121         return width_collapsed(pain, font);
 122
 123     return getMaxWidth(pain, this) - widthOffset + 2;
 124 }
 125
 126
 127 void InsetCollapsable::draw_collapsed(Painter & pain, LyXFont const &,
 128                                       int baseline, float & x) const
 129 {
 130     int width = 0;
 131     pain.buttonText(int(x) + TEXT_TO_INSET_OFFSET, baseline,
 132                     label.c_str(), labelfont, true, width);
 133     x += width + (2 * TEXT_TO_INSET_OFFSET);
 134 }
 135
 136
 137 void InsetCollapsable::draw(Painter & pain, LyXFont const & f,
 138                             int baseline, float & x) const
 139 {
 140     button_length = width_collapsed(pain, labelfont) + 2;
 141     button_top_y = -ascent_collapsed(pain, f);
 142     button_bottom_y = descent_collapsed(pain, f);
 143     if (collapsed) {
 144         draw_collapsed(pain, f, baseline, x);
 145         return;
 146     }
 147
 148     int top_x = int(x);
 149
 150     draw_collapsed(pain, f, baseline, x);
 151     x += 2;
 152
 153     int w =  getMaxTextWidth(pain, this);
 154     int h = ascent(pain,f) + descent(pain, f);
 155
 156     pain.rectangle(int(x), baseline - ascent(pain, f), w, h, framecolor);
 157
 158     x += 4;
 159     drawTextXOffset = int(x) - top_x;
 160     InsetText::draw(pain, f, baseline, x);
 161 }
 162
 163
 164 void InsetCollapsable::Edit(BufferView * bv, int x, int y, unsigned int button)
 165 {
 166     if (collapsed && autocollapse) {
 167         collapsed = false;
 168         UpdateLocal(bv, true);
 169         InsetText::Edit(bv, 0, 0, button);
 170     } else if (!collapsed) {
 171         InsetText::Edit(bv, x, y, button);
 172     }
 173 }
 174
 175
 176 Inset::EDITABLE InsetCollapsable::Editable() const
 177 {
 178         if (collapsed)
 179                 return IS_EDITABLE;
 180         return HIGHLY_EDITABLE;
 181 }
 182
 183
 184 void InsetCollapsable::InsetUnlock(BufferView * bv)
 185 {
 186     if (autocollapse) {
 187         collapsed = true;
 188     }
 189     InsetText::InsetUnlock(bv);
 190     UpdateLocal(bv, false);
 191 }
 192
 193
 194 void InsetCollapsable::UpdateLocal(BufferView * bv, bool flag)
 195 {
 196     InsetText::UpdateLocal(bv, flag);
 197 }
 198
 199
 200 void InsetCollapsable::InsetButtonPress(BufferView * bv,int x,int y,int button)
 201 {
 202     if (!collapsed && (x >= button_length)) {
 203         InsetText::InsetButtonPress(bv, x, y, button);
 204     }
 205 }
 206
 207
 208 void InsetCollapsable::InsetButtonRelease(BufferView * bv,
 209                                           int x, int y, int button)
 210 {
 211     if ((x >= 0)  && (x < button_length) &&
 212         (y >= button_top_y) &&  (y < button_bottom_y)) {
 213         if (collapsed) {
 214             collapsed = false;
 215             InsetText::InsetButtonRelease(bv, 0, 0, button);
 216             UpdateLocal(bv, true);
 217         } else {
 218             collapsed = true;
 219             UpdateLocal(bv, false);
 220             bv->unlockInset(this);
 221         }
 222     } else if (!collapsed && (x >= button_length) && (y >= button_top_y)) {
 223         InsetText::InsetButtonRelease(bv, x, y, button);
 224     }
 225 }
 226
 227
 228 void InsetCollapsable::InsetMotionNotify(BufferView * bv,
 229                                          int x, int y, int state)
 230 {
 231     if (x >= button_length) {
 232         InsetText::InsetMotionNotify(bv, x, y, state);
 233     }
 234 }
 235
 236
 237 int InsetCollapsable::getMaxWidth(Painter & pain,
 238                                   UpdatableInset const * inset) const
 239 {
 240     if ((this == inset) && !owner())
 241         return pain.paperWidth();
 242     if (this == inset)
 243         return static_cast<UpdatableInset*>(owner())->getMaxWidth(pain,inset);
 244     if (owner())
 245         return static_cast<UpdatableInset*>(owner())->getMaxWidth(pain,inset)-
 246                 width_collapsed(pain, labelfont) - 2 - widthOffset;
 247
 248     return pain.paperWidth()-width_collapsed(pain, labelfont)-2-widthOffset;
 249 }
 250
 251
 252 int InsetCollapsable::getMaxTextWidth(Painter & pain,
 253                                       UpdatableInset const * inset, int) const
 254 {
 255     return getMaxWidth(pain, inset) -
 256         width_collapsed(pain, labelfont) - widthOffset - 2;
 257 }