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