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