Changeset 15 in flair-src for trunk/tools/FlairGCS/src/Scrollbar.cpp


Ignore:
Timestamp:
Apr 8, 2016, 3:40:57 PM (5 years ago)
Author:
Bayard Gildas
Message:

sources reformatted with flair-format-dir script

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/tools/FlairGCS/src/Scrollbar.cpp

    r10 r15  
    77#include "Scrollbar.h"
    88
    9 ScrollBar::ScrollBar(QWidget * parent):
    10     QScrollBar(parent)
    11 {
    12     init();
     9ScrollBar::ScrollBar(QWidget *parent) : QScrollBar(parent) { init(); }
     10
     11ScrollBar::ScrollBar(Qt::Orientation o, QWidget *parent)
     12    : QScrollBar(o, parent) {
     13  init();
    1314}
    1415
    15 ScrollBar::ScrollBar(Qt::Orientation o,
    16         QWidget *parent):
    17     QScrollBar(o, parent)
    18 {
    19     init();
     16ScrollBar::ScrollBar(float minBase, float maxBase, Qt::Orientation o,
     17                     QWidget *parent)
     18    : QScrollBar(o, parent) {
     19  init();
     20  setBase(minBase, maxBase);
     21  moveSlider(minBase, maxBase);
    2022}
    2123
    22 ScrollBar::ScrollBar(float minBase, float maxBase,
    23         Qt::Orientation o, QWidget *parent):
    24     QScrollBar(o, parent)
    25 {
    26     init();
    27     setBase(minBase, maxBase);
    28     moveSlider(minBase, maxBase);
     24void ScrollBar::init(void) {
     25  d_inverted = orientation() == Qt::Vertical;
     26  d_baseTicks = 1000000;
     27  d_minBase = 0.0;
     28  d_maxBase = 1.0;
     29  moveSlider(d_minBase, d_maxBase);
     30
     31  connect(this, SIGNAL(sliderMoved(int)), SLOT(catchSliderMoved(int)));
     32  connect(this, SIGNAL(valueChanged(int)), SLOT(catchValueChanged(int)));
    2933}
    3034
    31 void ScrollBar::init(void)
    32 {
    33     d_inverted = orientation() == Qt::Vertical;
    34     d_baseTicks = 1000000;
    35     d_minBase = 0.0;
    36     d_maxBase = 1.0;
    37     moveSlider(d_minBase, d_maxBase);
    38 
    39     connect(this, SIGNAL(sliderMoved(int)), SLOT(catchSliderMoved(int)));
    40     connect(this, SIGNAL(valueChanged(int)), SLOT(catchValueChanged(int)));
     35void ScrollBar::setInverted(bool inverted) {
     36  if (d_inverted != inverted) {
     37    d_inverted = inverted;
     38    moveSlider(minSliderValue(), maxSliderValue());
     39  }
    4140}
    4241
    43 void ScrollBar::setInverted(bool inverted)
    44 {
    45     if ( d_inverted != inverted )
    46     {
    47         d_inverted = inverted;
    48         moveSlider(minSliderValue(), maxSliderValue());
    49     }
     42bool ScrollBar::isInverted(void) const { return d_inverted; }
     43
     44void ScrollBar::setBase(float min, float max) {
     45  if (min != d_minBase || max != d_maxBase) {
     46    d_minBase = min;
     47    d_maxBase = max;
     48
     49    moveSlider(minSliderValue(), maxSliderValue());
     50  }
    5051}
    5152
    52 bool ScrollBar::isInverted(void) const
    53 {
    54     return d_inverted;
     53void ScrollBar::moveSlider(float min, float max) {
     54  const int sliderTicks =
     55      qRound((max - min) / (d_maxBase - d_minBase) * d_baseTicks);
     56
     57  // setRange initiates a valueChanged of the scrollbars
     58  // in some situations. So we block
     59  // and unblock the signals.
     60
     61  blockSignals(true);
     62
     63  setRange(sliderTicks / 2, d_baseTicks - sliderTicks / 2);
     64  int steps = sliderTicks / 200;
     65  if (steps <= 0)
     66    steps = 1;
     67
     68  setSingleStep(steps);
     69  setPageStep(sliderTicks);
     70
     71  int tick = mapToTick(min + (max - min) / 2);
     72  if (isInverted())
     73    tick = d_baseTicks - tick;
     74
     75  setSliderPosition(tick);
     76  blockSignals(false);
    5577}
    5678
    57 void ScrollBar::setBase(float min, float max)
    58 {
    59     if ( min != d_minBase || max != d_maxBase )
    60     {
    61         d_minBase = min;
    62         d_maxBase = max;
     79float ScrollBar::minBaseValue(void) const { return d_minBase; }
    6380
    64         moveSlider(minSliderValue(), maxSliderValue());
    65     }
     81float ScrollBar::maxBaseValue(void) const { return d_maxBase; }
     82
     83void ScrollBar::sliderRange(int value, float &min, float &max) const {
     84  if (isInverted())
     85    value = d_baseTicks - value;
     86
     87  const int visibleTicks = pageStep();
     88
     89  min = mapFromTick(value - visibleTicks / 2);
     90  max = mapFromTick(value + visibleTicks / 2);
    6691}
    6792
    68 void ScrollBar::moveSlider(float min, float max)
    69 {
    70     const int sliderTicks = qRound((max - min) /
    71         (d_maxBase - d_minBase) * d_baseTicks);
     93float ScrollBar::minSliderValue(void) const {
     94  float min, dummy;
     95  sliderRange(value(), min, dummy);
    7296
    73     // setRange initiates a valueChanged of the scrollbars
    74     // in some situations. So we block
    75     // and unblock the signals.
    76 
    77     blockSignals(true);
    78 
    79     setRange(sliderTicks / 2, d_baseTicks - sliderTicks / 2);
    80     int steps = sliderTicks / 200;
    81     if ( steps <= 0 )
    82         steps = 1;
    83 
    84     setSingleStep(steps);
    85     setPageStep(sliderTicks);
    86 
    87     int tick = mapToTick(min + (max - min) / 2);
    88     if ( isInverted() )
    89         tick = d_baseTicks - tick;
    90 
    91     setSliderPosition(tick);
    92     blockSignals(false);
     97  return min;
    9398}
    9499
    95 float ScrollBar::minBaseValue(void) const
    96 {
    97     return d_minBase;
     100float ScrollBar::maxSliderValue(void) const {
     101  float max, dummy;
     102  sliderRange(value(), dummy, max);
     103
     104  return max;
    98105}
    99106
    100 float ScrollBar::maxBaseValue(void) const
    101 {
    102     return d_maxBase;
     107int ScrollBar::mapToTick(float v) const {
     108  return (int)((v - d_minBase) / (d_maxBase - d_minBase) * d_baseTicks);
    103109}
    104110
    105 void ScrollBar::sliderRange(int value, float &min, float &max) const
    106 {
    107     if ( isInverted() )
    108         value = d_baseTicks - value;
    109 
    110     const int visibleTicks = pageStep();
    111 
    112     min = mapFromTick(value - visibleTicks / 2);
    113     max = mapFromTick(value + visibleTicks / 2);
     111float ScrollBar::mapFromTick(int tick) const {
     112  return d_minBase + (d_maxBase - d_minBase) * tick / d_baseTicks;
    114113}
    115114
    116 float ScrollBar::minSliderValue(void) const
    117 {
    118     float min, dummy;
    119     sliderRange(value(), min, dummy);
    120 
    121     return min;
     115void ScrollBar::catchValueChanged(int value) {
     116  float min, max;
     117  sliderRange(value, min, max);
     118  Q_EMIT valueChanged(orientation(), min, max);
    122119}
    123120
    124 float ScrollBar::maxSliderValue(void) const
    125 {
    126     float max, dummy;
    127     sliderRange(value(), dummy, max);
    128 
    129     return max;
     121void ScrollBar::catchSliderMoved(int value) {
     122  float min, max;
     123  sliderRange(value, min, max);
     124  Q_EMIT sliderMoved(orientation(), min, max);
    130125}
    131126
    132 int ScrollBar::mapToTick(float v) const
    133 {
    134     return (int) ( ( v - d_minBase) / (d_maxBase - d_minBase ) * d_baseTicks );
     127int ScrollBar::extent(void) const {
     128  QStyleOptionSlider opt;
     129  opt.init(this);
     130  opt.subControls = QStyle::SC_None;
     131  opt.activeSubControls = QStyle::SC_None;
     132  opt.orientation = orientation();
     133  opt.minimum = minimum();
     134  opt.maximum = maximum();
     135  opt.sliderPosition = sliderPosition();
     136  opt.sliderValue = value();
     137  opt.singleStep = singleStep();
     138  opt.pageStep = pageStep();
     139  opt.upsideDown = invertedAppearance();
     140  if (orientation() == Qt::Horizontal)
     141    opt.state |= QStyle::State_Horizontal;
     142  return style()->pixelMetric(QStyle::PM_ScrollBarExtent, &opt, this);
    135143}
    136 
    137 float ScrollBar::mapFromTick(int tick) const
    138 {
    139     return d_minBase + ( d_maxBase - d_minBase ) * tick / d_baseTicks;
    140 }
    141 
    142 void ScrollBar::catchValueChanged(int value)
    143 {
    144     float min, max;
    145     sliderRange(value, min, max);
    146     Q_EMIT valueChanged(orientation(), min, max);
    147 }
    148 
    149 void ScrollBar::catchSliderMoved(int value)
    150 {
    151     float min, max;
    152     sliderRange(value, min, max);
    153     Q_EMIT sliderMoved(orientation(), min, max);
    154 }
    155 
    156 int ScrollBar::extent(void) const
    157 {
    158     QStyleOptionSlider opt;
    159     opt.init(this);
    160     opt.subControls = QStyle::SC_None;
    161     opt.activeSubControls = QStyle::SC_None;
    162     opt.orientation = orientation();
    163     opt.minimum = minimum();
    164     opt.maximum = maximum();
    165     opt.sliderPosition = sliderPosition();
    166     opt.sliderValue = value();
    167     opt.singleStep = singleStep();
    168     opt.pageStep = pageStep();
    169     opt.upsideDown = invertedAppearance();
    170     if (orientation() == Qt::Horizontal)
    171         opt.state |= QStyle::State_Horizontal;
    172     return style()->pixelMetric(QStyle::PM_ScrollBarExtent, &opt, this);
    173 }
Note: See TracChangeset for help on using the changeset viewer.