src/frontends/gtk/GFloat.C

   1 /**
   2  * \file GFloat.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Spray
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 // Too hard to make concept checks work with this file
  14 #ifdef _GLIBCPP_CONCEPT_CHECKS
  15 #undef _GLIBCPP_CONCEPT_CHECKS
  16 #endif
  17
  18 #include "GFloat.h"
  19 #include "ControlFloat.h"
  20
  21 #include "ghelpers.h"
  22
  23 #include "insets/insetfloat.h"
  24
  25 #include "support/lstrings.h"
  26
  27 #include <libglademm.h>
  28
  29 using std::string;
  30
  31 namespace lyx {
  32
  33 using support::contains;
  34
  35 namespace frontend {
  36
  37 GFloat::GFloat(Dialog & parent)
  38         : GViewCB<ControlFloat, GViewGladeB>(parent, _("Float Settings"), false)
  39 {}
  40
  41
  42 void GFloat::doBuild()
  43 {
  44         string const gladeName = findGladeFile("float");
  45         xml_ = Gnome::Glade::Xml::create(gladeName);
  46
  47         Gtk::Button * cancelbutton;
  48         xml_->get_widget("Close", cancelbutton);
  49         setCancel(cancelbutton);
  50
  51         xml_->get_widget("Default", defaultradio_);
  52         xml_->get_widget("HereDefinitely", heredefinitelyradio_);
  53         xml_->get_widget("Alternative", alternativeradio_);
  54         xml_->get_widget("Top", topcheck_);
  55         xml_->get_widget("Bottom", bottomcheck_);
  56         xml_->get_widget("PageOfFloats", pageoffloatscheck_);
  57         xml_->get_widget("HereIfPossible", hereifpossiblecheck_);
  58         xml_->get_widget("IgnoreRules", ignorerulescheck_);
  59         xml_->get_widget("SpanColumns", spancolumnscheck_);
  60         xml_->get_widget("RotateSideways", rotatesidewayscheck_);
  61
  62         defaultradio_->signal_toggled().connect(
  63                 sigc::mem_fun(*this, &GFloat::apply));
  64         heredefinitelyradio_->signal_toggled().connect(
  65                 sigc::mem_fun(*this, &GFloat::apply));
  66         alternativeradio_->signal_toggled().connect(
  67                 sigc::mem_fun(*this, &GFloat::apply));
  68         topcheck_->signal_toggled().connect(
  69                 sigc::mem_fun(*this, &GFloat::apply));
  70         bottomcheck_->signal_toggled().connect(
  71                 sigc::mem_fun(*this, &GFloat::apply));
  72         pageoffloatscheck_->signal_toggled().connect(
  73                 sigc::mem_fun(*this, &GFloat::apply));
  74         hereifpossiblecheck_->signal_toggled().connect(
  75                 sigc::mem_fun(*this, &GFloat::apply));
  76         ignorerulescheck_->signal_toggled().connect(
  77                 sigc::mem_fun(*this, &GFloat::apply));
  78         spancolumnscheck_->signal_toggled().connect(
  79                 sigc::mem_fun(*this, &GFloat::apply));
  80         rotatesidewayscheck_->signal_toggled().connect(
  81                 sigc::mem_fun(*this, &GFloat::apply));
  82
  83         bcview().addReadOnly(defaultradio_);
  84         bcview().addReadOnly(heredefinitelyradio_);
  85         bcview().addReadOnly(alternativeradio_);
  86         bcview().addReadOnly(topcheck_);
  87         bcview().addReadOnly(bottomcheck_);
  88         bcview().addReadOnly(pageoffloatscheck_);
  89         bcview().addReadOnly(hereifpossiblecheck_);
  90         bcview().addReadOnly(ignorerulescheck_);
  91         bcview().addReadOnly(spancolumnscheck_);
  92         bcview().addReadOnly(rotatesidewayscheck_);
  93 }
  94
  95
  96 void GFloat::update()
  97 {
  98         applylock_ = true;
  99
 100         bc().refreshReadOnly();
 101
 102         string placement(controller().params().placement);
 103         bool const wide = controller().params().wide;
 104         bool const sideways = controller().params().sideways;
 105
 106         bool const here_definitely = contains(placement, 'H');
 107
 108         bool const top    = contains(placement, 't');
 109         bool const bottom = contains(placement, 'b');
 110         bool const page   = contains(placement, 'p');
 111         bool const here   = contains(placement, 'h');
 112         bool const force  = contains(placement, '!');
 113         bool const alternatives = top || bottom || page || (here && !wide);
 114
 115         if (alternatives) {
 116                 alternativeradio_->set_active(true);
 117         } else if (here_definitely) {
 118                 heredefinitelyradio_->set_active(true);
 119         } else {
 120                 defaultradio_->set_active(true);
 121         }
 122         ignorerulescheck_->set_active(force);
 123         topcheck_->set_active(top);
 124         bottomcheck_->set_active(bottom);
 125         pageoffloatscheck_->set_active(page);
 126         hereifpossiblecheck_->set_active(here);
 127         spancolumnscheck_->set_active(wide);
 128         rotatesidewayscheck_->set_active(sideways);
 129
 130         updateSensitivity();
 131
 132         applylock_ = false;
 133 }
 134
 135
 136 void GFloat::updateSensitivity()
 137 {
 138         bool const wide = spancolumnscheck_->get_active();
 139         bool const sideways = rotatesidewayscheck_->get_active();
 140         bool const sideways_possible = (controller().params().type == "figure"
 141                 || controller().params().type == "table");
 142         bool const alternatives = alternativeradio_->get_active();
 143         bool const readonly = readOnly();
 144
 145         heredefinitelyradio_->set_sensitive(!wide && !sideways && !readonly);
 146         ignorerulescheck_->set_sensitive(alternatives && !sideways && !readonly);
 147         topcheck_->set_sensitive(alternatives && !sideways && !readonly);
 148         bottomcheck_->set_sensitive(alternatives && !sideways && !readonly);
 149         pageoffloatscheck_->set_sensitive(alternatives && !sideways && !readonly);
 150         hereifpossiblecheck_->set_sensitive(alternatives && !wide && !sideways && !readonly);
 151         spancolumnscheck_->set_sensitive(!sideways && !readonly);
 152         defaultradio_->set_sensitive(!sideways && !readonly);
 153         alternativeradio_->set_sensitive(!sideways && !readonly);
 154         rotatesidewayscheck_->set_sensitive(sideways_possible && !readonly);
 155 }
 156
 157
 158 void GFloat::apply()
 159 {
 160         if (applylock_)
 161                 return;
 162
 163         updateSensitivity();
 164
 165         bool const wide = spancolumnscheck_->get_active();
 166         bool const sideways = rotatesidewayscheck_->get_active();
 167
 168         int placementmode = 0; //default
 169         if (heredefinitelyradio_->get_active())
 170                 placementmode = 1; // "Here, definitely"
 171         else if (alternativeradio_->get_active())
 172                 placementmode = 2; // "Alternative"
 173
 174         string placement;
 175         switch (placementmode) {
 176         case 2:
 177                 // "Alternative"
 178                 if (ignorerulescheck_->get_active()) {
 179                         // Ignore internal LaTeX rules
 180                         placement += '!';
 181                 }
 182                 if (topcheck_->get_active()) {
 183                         // Top of page
 184                         placement += 't';
 185                 }
 186                 if (bottomcheck_->get_active()) {
 187                         // Bottom of page
 188                         placement += 'b';
 189                 }
 190                 if (pageoffloatscheck_->get_active()) {
 191                         // Page of floats
 192                         placement += 'p';
 193                 }
 194                 // ignore if wide is selected
 195                 if (!wide && hereifpossiblecheck_->get_active()) {
 196                         // Here, if possible
 197                         placement += 'h';
 198                 }
 199                 if (placement == "!") {
 200                         // ignore placement if only force is selected.
 201                         placement.erase();
 202                 }
 203                 break;
 204
 205         case 1:
 206                 // Here, definitely
 207                 placement = "H";
 208                 break;
 209
 210         case 0:
 211                 // default, do nothing.
 212                 break;
 213         }
 214
 215         controller().params().placement = placement;
 216         controller().params().wide = wide;
 217         controller().params().sideways = sideways;
 218
 219         controller().dispatchParams();
 220 }
 221
 222 } // namespace frontend
 223 } // namespace lyx