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