← Back to branch summary

~ubuntu-branches/ubuntu/wily/qgis/wily

« back to all changes in this revision

Viewing changes to src/gui/qgsmapoverviewcanvas.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Johan Van de Wauw
  • Date: 2010-07-11 20:23:24 UTC
  • mfrom: (3.1.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100711202324-5ktghxa7hracohmr
Tags: 1.4.0+12730-3ubuntu1
https://launchpad.net/bugs/540941
* Merge from Debian unstable (LP: #540941).
* Fix compilation issues with QT 4.7
* Add build-depends on libqt4-webkit-dev 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/qgsmapoverviewcanvas.cpp
15
15
 *   (at your option) any later version.                                   *
16
16
 *                                                                         *
17
17
 ***************************************************************************/
18
 
/* $Id: qgsmapoverviewcanvas.cpp 6550 2007-02-08 06:44:42Z telwertowski $ */
 
18
/* $Id$ */
19
19
 
20
20
#include "qgsmapcanvas.h"
21
 
#include "qgsmaprender.h"
 
21
#include "qgsmaprenderer.h"
22
22
#include "qgsmapoverviewcanvas.h"
23
23
#include "qgsmaptopixel.h"
24
24
 
26
26
#include <QPaintEvent>
27
27
#include <QResizeEvent>
28
28
#include <QMouseEvent>
 
29
#include "qgslogger.h"
 
30
#include <limits.h>
29
31
 
30
32
//! widget that serves as rectangle showing current extent in overview
31
33
class QgsPanningWidget : public QWidget
32
34
{
33
 
public:
34
 
  QgsPanningWidget(QWidget* parent)
35
 
  : QWidget(parent, "panningWidget")
36
 
  {
37
 
    setMinimumSize(5,5);
38
 
    setBackgroundMode(Qt::NoBackground);
39
 
  }
40
 
 
41
 
  void resizeEvent(QResizeEvent* r)
42
 
  {
43
 
    QSize s = r->size();
44
 
    QRegion reg(0,0, s.width(), s.height());
45
 
    QRegion reg2(2,2, s.width()-4, s.height()-4);
46
 
    QRegion reg3 = reg.subtract(reg2);
47
 
    setMask(reg3);
48
 
  }
49
 
 
50
 
 
51
 
  void paintEvent(QPaintEvent* pe)
52
 
  {
53
 
    QRect r(QPoint(0,0), size());
54
 
    QPainter p;
55
 
    p.begin(this);
56
 
    p.setPen(Qt::red);
57
 
    p.setBrush(Qt::red);
58
 
    p.drawRect(r);
59
 
    p.end();
60
 
  }
 
35
  public:
 
36
    QgsPanningWidget( QWidget* parent )
 
37
        : QWidget( parent )
 
38
    {
 
39
      setObjectName( "panningWidget" );
 
40
      setMinimumSize( 5, 5 );
 
41
      setAttribute( Qt::WA_NoSystemBackground );
 
42
    }
 
43
 
 
44
    void resizeEvent( QResizeEvent* r )
 
45
    {
 
46
      QSize s = r->size();
 
47
      QRegion reg( 0, 0, s.width(), s.height() );
 
48
      QRegion reg2( 2, 2, s.width() - 4, s.height() - 4 );
 
49
      QRegion reg3 = reg.subtract( reg2 );
 
50
      setMask( reg3 );
 
51
    }
 
52
 
 
53
 
 
54
    void paintEvent( QPaintEvent* pe )
 
55
    {
 
56
      QRect r( QPoint( 0, 0 ), size() );
 
57
      QPainter p;
 
58
      p.begin( this );
 
59
      p.setPen( Qt::red );
 
60
      p.setBrush( Qt::red );
 
61
      p.drawRect( r );
 
62
      p.end();
 
63
    }
61
64
 
62
65
};
63
66
 
64
67
 
65
68
 
66
 
QgsMapOverviewCanvas::QgsMapOverviewCanvas(QWidget * parent, QgsMapCanvas* mapCanvas)
67
 
  : QWidget(parent), mMapCanvas(mapCanvas)
 
69
QgsMapOverviewCanvas::QgsMapOverviewCanvas( QWidget * parent, QgsMapCanvas* mapCanvas )
 
70
    : QWidget( parent ), mMapCanvas( mapCanvas )
68
71
{
69
 
  setObjectName("theOverviewCanvas");
70
 
  mPanningWidget = new QgsPanningWidget(this);
71
 
  
72
 
  mMapRender = new QgsMapRender;
73
 
  mMapRender->setOverview();
74
 
  
75
 
  setbgColor(palette().window().color());
 
72
  setObjectName( "theOverviewCanvas" );
 
73
  mPanningWidget = new QgsPanningWidget( this );
 
74
 
 
75
  mMapRenderer = new QgsMapRenderer;
 
76
  mMapRenderer->enableOverviewMode();
 
77
 
 
78
  setBackgroundColor( palette().window().color() );
76
79
}
77
80
 
78
81
QgsMapOverviewCanvas::~QgsMapOverviewCanvas()
79
82
{
80
 
  delete mMapRender;
 
83
  delete mMapRenderer;
81
84
}
82
85
 
83
 
void QgsMapOverviewCanvas::resizeEvent(QResizeEvent* e)
 
86
void QgsMapOverviewCanvas::resizeEvent( QResizeEvent* e )
84
87
{
85
 
  mPixmap = QPixmap(e->size());
86
 
  mMapRender->setOutputSize(e->size(), mPixmap.logicalDpiX());
 
88
  mPixmap = QPixmap( e->size() );
 
89
  mMapRenderer->setOutputSize( e->size(), mPixmap.logicalDpiX() );
87
90
  refresh();
88
91
}
89
92
 
90
93
 
91
 
void QgsMapOverviewCanvas::reflectChangedExtent()
 
94
void QgsMapOverviewCanvas::drawExtentRect()
92
95
{
93
 
  const QgsRect& extent = mMapCanvas->extent();
94
 
  
 
96
  const QgsRectangle& extent = mMapCanvas->extent();
 
97
 
95
98
  // show only when valid extent is set
96
 
  if (extent.isEmpty())
 
99
  if ( extent.isEmpty() )
97
100
  {
98
 
#ifdef QGISDEBUG
99
 
    std::cout << "panning: empty extent" << std::endl;
100
 
#endif
101
101
    mPanningWidget->hide();
102
102
    return;
103
103
  }
104
 
  
105
 
  QgsMapToPixel* cXf = mMapRender->coordXForm();
106
 
  QgsPoint ll(extent.xMin(), extent.yMin());
107
 
  QgsPoint ur(extent.xMax(), extent.yMax());
108
 
  if(cXf)
 
104
 
 
105
  const QgsMapToPixel* cXf = mMapRenderer->coordinateTransform();
 
106
  QgsPoint ll( extent.xMinimum(), extent.yMinimum() );
 
107
  QgsPoint ur( extent.xMaximum(), extent.yMaximum() );
 
108
  if ( cXf )
109
109
  {
110
110
    // transform the points before drawing
111
 
    cXf->transform(&ll);
112
 
    cXf->transform(&ur);
 
111
    cXf->transform( &ll );
 
112
    cXf->transform( &ur );
113
113
  }
114
 
  /*  
115
 
  // test whether panning widget should be drawn  
 
114
 
 
115
#if 0
 
116
  // test whether panning widget should be drawn
116
117
  bool show = false;
117
 
  if (ur.x() >= 0 && ur.x() < width())  show = true;
118
 
  if (ll.x() >= 0 && ll.x() < width())  show = true;
119
 
  if (ur.y() >= 0 && ur.y() < height()) show = true;
120
 
  if (ll.y() >= 0 && ll.y() < height()) show = true;
121
 
  if (!show)
 
118
  if ( ur.x() >= 0 && ur.x() < width() )  show = true;
 
119
  if ( ll.x() >= 0 && ll.x() < width() )  show = true;
 
120
  if ( ur.y() >= 0 && ur.y() < height() ) show = true;
 
121
  if ( ll.y() >= 0 && ll.y() < height() ) show = true;
 
122
  if ( !show )
122
123
  {
123
 
#ifdef QGISDEBUG
124
 
    std::cout << "panning: extent out of overview area" << std::endl;
125
 
#endif
 
124
    QgsDebugMsg( "panning: extent out of overview area" );
126
125
    mPanningWidget->hide();
127
126
    return;
128
 
}*/
129
 
  
 
127
  }
 
128
#endif
 
129
 
130
130
  // round values
131
 
  int x1 = static_cast<int>(ur.x()+0.5), x2 = static_cast<int>(ll.x()+0.5);
132
 
  int y1 = static_cast<int>(ur.y()+0.5), y2 = static_cast<int>(ll.y()+0.5);
133
 
  
134
 
  if (x1 > x2)
135
 
    std::swap(x1, x2);  
136
 
  if (y1 > y2)
137
 
    std::swap(y1, y2);
138
 
  
 
131
  int x1 = static_cast<int>( ur.x() + 0.5 ), x2 = static_cast<int>( ll.x() + 0.5 );
 
132
  int y1 = static_cast<int>( ur.y() + 0.5 ), y2 = static_cast<int>( ll.y() + 0.5 );
 
133
 
 
134
  if ( x1 > x2 )
 
135
    std::swap( x1, x2 );
 
136
  if ( y1 > y2 )
 
137
    std::swap( y1, y2 );
 
138
 
139
139
#ifdef Q_WS_MAC
140
140
  // setGeometry (Qt 4.2) is causing Mac window corruption (decorations
141
141
  // are drawn at odd locations) if both coords are at limit. This may
142
142
  // have something to do with Qt calculating dimensions as x2 - x1 + 1.
143
143
  // (INT_MAX - INT_MIN + 1 is UINT_MAX + 1)
144
 
  if (x1 == INT_MIN && x2 == INT_MAX) x1 += 1;  // x2 -= 1 works too
145
 
  if (y1 == INT_MIN && y2 == INT_MAX) y1 += 1;
146
 
#endif
147
 
 
148
 
  QRect r(x1, y1, x2-x1+1, y2-y1+1);
149
 
  
150
 
#ifdef QGISDEBUG
151
 
  std::cout << "panning: extent to widget: [" << x1 << "," << y1 <<
152
 
                "] [" << r.width() << "x" << r.height() << "]" << std::endl;
153
 
#endif
154
 
    
155
 
  mPanningWidget->setGeometry(r);
156
 
  mPanningWidget->show(); // show if hidden 
 
144
  if ( x1 == INT_MIN && x2 == INT_MAX ) x1 += 1;  // x2 -= 1 works too
 
145
  if ( y1 == INT_MIN && y2 == INT_MAX ) y1 += 1;
 
146
#endif
 
147
 
 
148
  QRect r( x1, y1, x2 - x1 + 1, y2 - y1 + 1 );
 
149
 
 
150
  // allow for 5 pixel minimum widget size
 
151
  if ( r.width() < 5 && x1 > INT_MIN + 2 ) // make sure no underflow occurs (2 is largest adjustment)
 
152
  {
 
153
    r.setX( r.x() - (( 5 - r.width() ) / 2 ) );  // adjust x  by 1/2 the difference of calculated and min. width
 
154
    r.setWidth( 5 );
 
155
  }
 
156
  if ( r.height() < 5 && y1 > INT_MIN + 2 )
 
157
  {
 
158
    r.setY( r.y() - (( 5 - r.height() ) / 2 ) );  // adjust y
 
159
    r.setHeight( 5 );
 
160
  }
 
161
 
 
162
  QgsDebugMsg( QString( "panning: extent to widget: [%1,%2] [%3x%4]" ).arg( x1 ).arg( y1 ).arg( r.width() ).arg( r.height() ) );
 
163
 
 
164
  mPanningWidget->setGeometry( r );
 
165
  mPanningWidget->show(); // show if hidden
157
166
}
158
167
 
159
168
 
160
 
void QgsMapOverviewCanvas::mousePressEvent(QMouseEvent * e)
 
169
void QgsMapOverviewCanvas::mousePressEvent( QMouseEvent * e )
161
170
{
162
171
//  if (mPanningWidget->isHidden())
163
172
//    return;
164
173
 
165
174
  // set offset in panning widget if inside it
166
175
  // for better experience with panning :)
167
 
  if (mPanningWidget->geometry().contains(e->pos()))
 
176
  if ( mPanningWidget->geometry().contains( e->pos() ) )
168
177
  {
169
178
    mPanningCursorOffset = e->pos() - mPanningWidget->pos();
170
179
  }
172
181
  {
173
182
    // use center of the panning widget if outside
174
183
    QSize s = mPanningWidget->size();
175
 
    mPanningCursorOffset = QPoint(s.width()/2, s.height()/2);
 
184
    mPanningCursorOffset = QPoint( s.width() / 2, s.height() / 2 );
176
185
  }
177
 
  updatePanningWidget(e->pos());
 
186
  updatePanningWidget( e->pos() );
178
187
}
179
188
 
180
189
 
181
 
void QgsMapOverviewCanvas::mouseReleaseEvent(QMouseEvent * e)
 
190
void QgsMapOverviewCanvas::mouseReleaseEvent( QMouseEvent * e )
182
191
{
183
192
//  if (mPanningWidget->isHidden())
184
193
//    return;
185
194
 
186
 
  if ((e->state() && Qt::LeftButton) == Qt::LeftButton)
 
195
  if ( e->button() == Qt::LeftButton )
187
196
  {
188
197
    // set new extent
189
 
    QgsMapToPixel* cXf = mMapRender->coordXForm();
 
198
    const QgsMapToPixel* cXf = mMapRenderer->coordinateTransform();
190
199
    QRect rect = mPanningWidget->geometry();
191
 
    
192
 
    QgsPoint center = cXf->toMapCoordinates(rect.center());
193
 
    QgsRect oldExtent = mMapCanvas->extent();
194
 
    QgsRect ext;
195
 
    ext.setXmin(center.x() - oldExtent.width()/2);
196
 
    ext.setXmax(center.x() + oldExtent.width()/2);
197
 
    ext.setYmin(center.y() - oldExtent.height()/2);
198
 
    ext.setYmax(center.y() + oldExtent.height()/2);
199
 
    
200
 
#ifdef QGISDEBUG
201
 
  std::cout << "panning: new position: [" << rect.left() << "," << rect.top() <<
202
 
                "] [" << rect.width() << "x" << rect.height() << "]" << std::endl;
203
 
#endif
204
 
 
205
 
    mMapCanvas->setExtent(ext);
 
200
 
 
201
    QgsPoint center = cXf->toMapCoordinates( rect.center() );
 
202
    QgsRectangle oldExtent = mMapCanvas->extent();
 
203
    QgsRectangle ext;
 
204
    ext.setXMinimum( center.x() - oldExtent.width() / 2 );
 
205
    ext.setXMaximum( center.x() + oldExtent.width() / 2 );
 
206
    ext.setYMinimum( center.y() - oldExtent.height() / 2 );
 
207
    ext.setYMaximum( center.y() + oldExtent.height() / 2 );
 
208
 
 
209
    QgsDebugMsg( QString( "panning: new position: [%1,%2] [%3x%4]" ).arg( rect.left() ).arg( rect.top() ).arg( rect.width() ).arg( rect.height() ) );
 
210
 
 
211
    mMapCanvas->setExtent( ext );
206
212
    mMapCanvas->refresh();
207
213
  }
208
214
}
209
215
 
210
216
 
211
 
void QgsMapOverviewCanvas::mouseMoveEvent(QMouseEvent * e)
 
217
void QgsMapOverviewCanvas::mouseMoveEvent( QMouseEvent * e )
212
218
{
213
219
  // move with panning widget if tracking cursor
214
 
  if ((e->state() && Qt::LeftButton) == Qt::LeftButton)
 
220
  if (( e->buttons() & Qt::LeftButton ) == Qt::LeftButton )
215
221
  {
216
 
    updatePanningWidget(e->pos());
 
222
    updatePanningWidget( e->pos() );
217
223
  }
218
224
}
219
225
 
220
226
 
221
 
void QgsMapOverviewCanvas::updatePanningWidget(const QPoint& pos)
 
227
void QgsMapOverviewCanvas::updatePanningWidget( const QPoint& pos )
222
228
{
223
229
//  if (mPanningWidget->isHidden())
224
230
//    return;
225
231
  QSize size = mPanningWidget->size();
226
 
  mPanningWidget->move(pos.x() - mPanningCursorOffset.x(), pos.y() - mPanningCursorOffset.y());
 
232
  mPanningWidget->move( pos.x() - mPanningCursorOffset.x(), pos.y() - mPanningCursorOffset.y() );
227
233
}
228
234
 
229
235
 
230
 
void QgsMapOverviewCanvas::paintEvent(QPaintEvent * pe)
 
236
void QgsMapOverviewCanvas::paintEvent( QPaintEvent * pe )
231
237
{
232
 
  QPainter paint(this);
233
 
  paint.drawPixmap(pe->rect().topLeft(), mPixmap, pe->rect());
 
238
  QPainter paint( this );
 
239
  paint.drawPixmap( pe->rect().topLeft(), mPixmap, pe->rect() );
234
240
}
235
241
 
236
242
 
237
243
void QgsMapOverviewCanvas::refresh()
238
244
{
239
 
  mPixmap.fill(mBgColor); //palette().color(backgroundRole());
 
245
  if ( mPixmap.isNull() )
 
246
    return;
 
247
 
 
248
  mPixmap.fill( mBgColor ); //palette().color(backgroundRole());
240
249
 
241
250
  QPainter painter;
242
 
  painter.begin(&mPixmap);
243
 
  
 
251
  painter.begin( &mPixmap );
 
252
 
244
253
  // antialiasing
245
 
  if (mAntiAliasing)
246
 
    painter.setRenderHint(QPainter::Antialiasing);
247
 
  
 
254
  if ( mAntiAliasing )
 
255
    painter.setRenderHint( QPainter::Antialiasing );
 
256
 
248
257
  // render image
249
 
  mMapRender->setExtent(mMapCanvas->fullExtent());
250
 
  mMapRender->render(&painter);
251
 
  
 
258
  mMapRenderer->render( &painter );
 
259
 
252
260
  painter.end();
253
 
  
 
261
 
254
262
  // schedule repaint
255
263
  update();
256
 
  
 
264
 
257
265
  // update panning widget
258
 
  reflectChangedExtent();
 
266
  drawExtentRect();
259
267
}
260
268
 
261
269
 
262
 
void QgsMapOverviewCanvas::setbgColor(const QColor& color)
 
270
void QgsMapOverviewCanvas::setBackgroundColor( const QColor& color )
263
271
{
264
272
  mBgColor = color;
265
 
  
 
273
 
266
274
  // set erase color
267
275
  QPalette palette;
268
 
  palette.setColor(backgroundRole(), color);
269
 
  setPalette(palette);
270
 
}
271
 
 
272
 
void QgsMapOverviewCanvas::setLayerSet(std::deque<QString>& layerSet)
273
 
{
274
 
  QgsMapLayerSet& layers = mMapRender->layers();
275
 
  layers.setLayerSet(layerSet);
276
 
}
277
 
 
278
 
void QgsMapOverviewCanvas::updateFullExtent()
279
 
{
280
 
  mMapRender->layers().updateFullExtent();
 
276
  palette.setColor( backgroundRole(), color );
 
277
  setPalette( palette );
 
278
}
 
279
 
 
280
void QgsMapOverviewCanvas::setLayerSet( const QStringList& layerSet )
 
281
{
 
282
  mMapRenderer->setLayerSet( layerSet );
 
283
}
 
284
 
 
285
void QgsMapOverviewCanvas::updateFullExtent( const QgsRectangle& rect )
 
286
{
 
287
  mMapRenderer->setExtent( rect );
 
288
  drawExtentRect();
 
289
}
 
290
 
 
291
void QgsMapOverviewCanvas::hasCrsTransformEnabled( bool flag )
 
292
{
 
293
  mMapRenderer->setProjectionsEnabled( flag );
 
294
}
 
295
 
 
296
void QgsMapOverviewCanvas::destinationSrsChanged()
 
297
{
 
298
  const QgsCoordinateReferenceSystem& srs = mMapCanvas->mapRenderer()->destinationSrs();
 
299
  mMapRenderer->setDestinationSrs( srs );
 
300
}
 
301
 
 
302
QStringList& QgsMapOverviewCanvas::layerSet()
 
303
{
 
304
  return mMapRenderer->layerSet();
281
305
}