← Back to branch summary

~ubuntu-branches/ubuntu/quantal/qgis/quantal

« back to all changes in this revision

Viewing changes to src/qgscomposermap.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Steve Halasz
  • Date: 2005-11-05 16:04:45 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20051105160445-l0g4isz5bc9yehet
Tags: 0.7.4-1
http://bugs.debian.org/248649
* New upstream release
* Build GRASS support in qgis-plugin-grass package (Closes: #248649)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/qgscomposermap.cpp
 
1
/***************************************************************************
 
2
                         qgscomposermap.cpp
 
3
                             -------------------
 
4
    begin                : January 2005
 
5
    copyright            : (C) 2005 by Radim Blazek
 
6
    email                : blazek@itc.it
 
7
 ***************************************************************************/
 
8
 
 
9
/***************************************************************************
 
10
 *                                                                         *
 
11
 *   This program is free software; you can redistribute it and/or modify  *
 
12
 *   it under the terms of the GNU General Public License as published by  *
 
13
 *   the Free Software Foundation; either version 2 of the License, or     *
 
14
 *   (at your option) any later version.                                   *
 
15
 *                                                                         *
 
16
 ***************************************************************************/
 
17
#include <math.h>
 
18
#include <iostream>
 
19
 
 
20
#include <qwidget.h>
 
21
#include <qrect.h>
 
22
#include <qcombobox.h>
 
23
#include <qdom.h>
 
24
#include <qcanvas.h>
 
25
#include <qpainter.h>
 
26
#include <qstring.h>
 
27
#include <qpixmap.h>
 
28
#include <qimage.h>
 
29
#include <qlineedit.h>
 
30
#include <qpointarray.h>
 
31
#include <qlabel.h>
 
32
#include <qcheckbox.h>
 
33
 
 
34
#include "qgis.h"
 
35
#include "qgsproject.h"
 
36
#include "qgsrect.h"
 
37
#include "qgsmaptopixel.h"
 
38
#include "qgsmapcanvas.h"
 
39
#include "qgsmaplayer.h"
 
40
#include "qgsvectorlayer.h"
 
41
#include "qgscomposition.h"
 
42
#include "qgscomposermap.h"
 
43
 
 
44
QgsComposerMap::QgsComposerMap ( QgsComposition *composition, int id, int x, int y, int width, int height )
 
45
    : QCanvasRectangle(x,y,width,height,0)
 
46
{
 
47
    mComposition = composition;
 
48
    mId = id;
 
49
    mMapCanvas = mComposition->mapCanvas();
 
50
    mName = QString(tr("Map %1").arg(mId));
 
51
 
 
52
    init();
 
53
    recalculate();
 
54
 
 
55
    // Add to canvas
 
56
    setCanvas(mComposition->canvas());
 
57
    QCanvasRectangle::show();
 
58
 
 
59
    writeSettings();
 
60
}
 
61
 
 
62
QgsComposerMap::QgsComposerMap ( QgsComposition *composition, int id )
 
63
    : QCanvasRectangle(0,0,10,10,0)
 
64
{
 
65
    mComposition = composition;
 
66
    mId = id;
 
67
    mMapCanvas = mComposition->mapCanvas();
 
68
    mName = QString(tr("Map %1").arg(mId));
 
69
 
 
70
    init();
 
71
    readSettings();
 
72
    recalculate();
 
73
 
 
74
    // Add to canvas
 
75
    setCanvas(mComposition->canvas());
 
76
    QCanvasRectangle::show();
 
77
}
 
78
 
 
79
void QgsComposerMap::init ()
 
80
{
 
81
    mNumCachedLayers = 0;
 
82
    mSelected = false;
 
83
    mUserExtent = mMapCanvas->extent();
 
84
    mDrawing = false;
 
85
 
 
86
    // Cache
 
87
    mCacheUpdated = false;
 
88
 
 
89
    // Calculate
 
90
    mCalculateComboBox->insertItem( tr("Extent (calculate scale)"), Scale );
 
91
    mCalculateComboBox->insertItem( tr("Scale (calculate extent)"), Extent );
 
92
    mCalculate = Scale;
 
93
 
 
94
    setPlotStyle ( QgsComposition::Preview );
 
95
    
 
96
    // Preview style
 
97
    mPreviewMode = Cache;
 
98
    mPreviewModeComboBox->insertItem ( "Cache", Cache );
 
99
    mPreviewModeComboBox->insertItem ( "Render", Render );
 
100
    mPreviewModeComboBox->insertItem ( "Rectangle", Rectangle );
 
101
    mPreviewModeComboBox->setCurrentItem ( Cache );
 
102
 
 
103
    mWidthScale = 1.0 / mComposition->scale();
 
104
    mSymbolScale = 1.0;
 
105
    mFontScale = 1.0;
 
106
 
 
107
    mFrame = true;
 
108
 
 
109
    QCanvasRectangle::setZ(20);
 
110
    setActive(true);
 
111
 
 
112
    connect ( mMapCanvas, SIGNAL(addedLayer(QgsMapLayer *)), this, SLOT(mapCanvasChanged()) );
 
113
    connect ( mMapCanvas, SIGNAL(removedLayer(QString)), this, SLOT(mapCanvasChanged()) );
 
114
    connect ( mMapCanvas, SIGNAL(removedAll()), this, SLOT(mapCanvasChanged()) );
 
115
}
 
116
 
 
117
QgsComposerMap::~QgsComposerMap()
 
118
{
 
119
     std::cerr << "QgsComposerMap::~QgsComposerMap" << std::endl;
 
120
}
 
121
 
 
122
void QgsComposerMap::draw ( QPainter *painter, QgsRect *extent, QgsMapToPixel *transform, QPaintDevice *device )
 
123
{
 
124
    mMapCanvas->freeze(true);  // necessary ?
 
125
    int nlayers = mMapCanvas->layerCount();
 
126
 
 
127
    for ( int i = 0; i < nlayers; i++ ) {
 
128
      QgsMapLayer *layer = mMapCanvas->getZpos(i);
 
129
 
 
130
      if ( !layer->visible() ) continue;
 
131
 
 
132
      if ( layer->type() == QgsMapLayer::VECTOR ) {
 
133
          QgsVectorLayer *vector = dynamic_cast <QgsVectorLayer*> (layer);
 
134
 
 
135
          double widthScale = mWidthScale * mComposition->scale();
 
136
          if ( plotStyle() == QgsComposition::Preview && mPreviewMode == Render ) {
 
137
        widthScale *= mComposition->viewScale();
 
138
          }
 
139
          double symbolScale = mSymbolScale * mComposition->scale();
 
140
          vector->draw( painter, extent, transform, device, widthScale, symbolScale, 0 );
 
141
 
 
142
      } else { 
 
143
          // raster
 
144
          if ( plotStyle() == QgsComposition::Print || plotStyle() == QgsComposition::Postscript ) {
 
145
              // we have to rescale the raster to get requested resolution
 
146
              
 
147
              // calculate relation between composition point size and requested resolution (in mm)
 
148
              double multip = (1. / mComposition->scale()) / (25.4 / mComposition->resolution()) ;
 
149
              
 
150
              double sc = mExtent.width() / (multip*QCanvasRectangle::width());
 
151
              
 
152
              QgsMapToPixel trans ( sc, multip*QCanvasRectangle::height(), mExtent.yMin(), mExtent.xMin() );
 
153
              
 
154
              painter->save();
 
155
              painter->scale( 1./multip, 1./multip);
 
156
 
 
157
              layer->draw( painter, extent, &trans, device );
 
158
              
 
159
              painter->restore();
 
160
          } 
 
161
          else 
 
162
          {
 
163
              layer->draw( painter, extent, transform, device );
 
164
          }
 
165
      }
 
166
    }
 
167
    
 
168
    // Draw vector labels
 
169
    for ( int i = 0; i < nlayers; i++ ) {
 
170
      QgsMapLayer *layer = mMapCanvas->getZpos(i);
 
171
        
 
172
      if ( !layer->visible() ) continue;
 
173
      
 
174
      if ( layer->type() == QgsMapLayer::VECTOR ) {
 
175
          QgsVectorLayer *vector = dynamic_cast <QgsVectorLayer*> (layer);
 
176
 
 
177
          if ( vector->labelOn() ) {
 
178
              double fontScale = 25.4 * mFontScale * mComposition->scale() / 72;
 
179
              if ( plotStyle() == QgsComposition::Postscript ) {
 
180
                  fontScale = QgsComposition::psFontScaleFactor() * 72.0 / mComposition->resolution();
 
181
              }
 
182
              vector->drawLabels (  painter, extent, transform, device, fontScale );
 
183
          }
 
184
 
 
185
      }
 
186
    }
 
187
    
 
188
    mMapCanvas->freeze(false);
 
189
}
 
190
 
 
191
void QgsComposerMap::setUserExtent ( QgsRect const & rect )
 
192
{
 
193
    mUserExtent = rect;
 
194
    recalculate();
 
195
    
 
196
    QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
197
    QCanvasRectangle::update();
 
198
    QCanvasRectangle::canvas()->update();
 
199
}
 
200
 
 
201
void QgsComposerMap::cache ( void )
 
202
{
 
203
    // Create preview on some reasonable size. It was slow with cca 1500x1500 points on 2x1.5GHz 
 
204
    // Note: The resolution should also respect the line widths, it means that 
 
205
    //       1 pixel in cache should have ia similar size as 1 pixel in canvas
 
206
    //       but it can result in big cache -> limit
 
207
 
 
208
    int w = QCanvasRectangle::width() < 1000 ? QCanvasRectangle::width() : 1000;
 
209
    int h = (int) ( mExtent.height() * w / mExtent.width() );
 
210
    // It can happen that extent is not initialised well -> check 
 
211
    if ( h < 1 || h > 10000 ) h = w; 
 
212
    
 
213
    std::cout << "extent = " << mExtent.width() <<  " x " << mExtent.height() << std::endl;
 
214
    std::cout << "cache = " << w <<  " x " << h << std::endl;
 
215
 
 
216
    mCacheExtent = QgsRect ( mExtent );
 
217
    double scale = mExtent.width() / w;
 
218
    mCacheExtent.setXmax ( mCacheExtent.xMin() + w * scale );
 
219
    mCacheExtent.setYmax ( mCacheExtent.yMin() + h * scale );
 
220
      
 
221
    mCachePixmap.resize( w, h );
 
222
 
 
223
    // WARNING: ymax in QgsMapToPixel is device height!!!
 
224
    QgsMapToPixel transform(scale, h, mCacheExtent.yMin(), mCacheExtent.xMin() );
 
225
 
 
226
    std::cout << "transform = " << transform.showParameters().local8Bit() << std::endl;
 
227
    
 
228
    mCachePixmap.fill(QColor(255,255,255));
 
229
 
 
230
    QPainter p(&mCachePixmap);
 
231
    
 
232
    draw( &p, &mCacheExtent, &transform, &mCachePixmap );
 
233
    p.end();
 
234
 
 
235
    mNumCachedLayers = mMapCanvas->layerCount();
 
236
    mCacheUpdated = true;
 
237
}
 
238
 
 
239
void QgsComposerMap::draw ( QPainter & painter )
 
240
{
 
241
    if ( mDrawing ) return; 
 
242
    mDrawing = true;
 
243
 
 
244
    std::cout << "draw mPlotStyle = " << plotStyle() 
 
245
        << " mPreviewMode = " << mPreviewMode << std::endl;
 
246
    
 
247
    if ( plotStyle() == QgsComposition::Preview &&  mPreviewMode == Cache ) { // Draw from cache
 
248
        std::cout << "use cache" << std::endl;
 
249
 
 
250
  if ( !mCacheUpdated || mMapCanvas->layerCount() != mNumCachedLayers ) {
 
251
      cache();
 
252
  }
 
253
  
 
254
  // Scale so that the cache fills the map rectangle
 
255
  double scale = 1.0 * QCanvasRectangle::width() / mCachePixmap.width();
 
256
  
 
257
  
 
258
  painter.save();
 
259
 
 
260
  painter.translate ( QCanvasRectangle::x(), QCanvasRectangle::y() );
 
261
  painter.scale(scale,scale);
 
262
  std::cout << "scale = " << scale << std::endl;
 
263
        std::cout << "translate: " << QCanvasRectangle::x() << ", " << QCanvasRectangle::y() << std::endl;
 
264
  // Note: drawing only a visible part of the pixmap doesn't make it much faster
 
265
  painter.drawPixmap(0,0, mCachePixmap);
 
266
 
 
267
  painter.restore();
 
268
 
 
269
    } else if ( (plotStyle() == QgsComposition::Preview && mPreviewMode == Render) || 
 
270
           plotStyle() == QgsComposition::Print ||
 
271
       plotStyle() == QgsComposition::Postscript ) 
 
272
    {
 
273
        std::cout << "render" << std::endl;
 
274
  
 
275
      double scale = mExtent.width() / QCanvasRectangle::width();
 
276
      QgsMapToPixel transform(scale, QCanvasRectangle::height(), mExtent.yMin(), mExtent.xMin() );
 
277
      
 
278
      painter.save();
 
279
      painter.translate ( QCanvasRectangle::x(), QCanvasRectangle::y() );
 
280
         
 
281
      // Note: CoordDevice doesn't work well
 
282
      painter.setClipRect ( 0, 0, QCanvasRectangle::width(), QCanvasRectangle::height(), QPainter::CoordPainter );
 
283
      
 
284
      draw( &painter, &mExtent, &transform, painter.device() );
 
285
      painter.restore();
 
286
    } 
 
287
 
 
288
    // Draw frame around
 
289
    if ( mFrame ) {
 
290
      painter.setPen( QPen(QColor(0,0,0), 1) );
 
291
      painter.setBrush( Qt::NoBrush );
 
292
            painter.save();
 
293
      painter.translate ( QCanvasRectangle::x(), QCanvasRectangle::y() );
 
294
      painter.drawRect ( 0, 0, QCanvasRectangle::width()+1, QCanvasRectangle::height()+1 ); // is it right?
 
295
        painter.restore();
 
296
    }
 
297
 
 
298
    // Show selected / Highlight
 
299
    if ( mSelected && plotStyle() == QgsComposition::Preview ) {
 
300
  painter.setPen( mComposition->selectionPen() );
 
301
  painter.setBrush( mComposition->selectionBrush() );
 
302
  int x = (int) QCanvasRectangle::x();
 
303
  int y = (int) QCanvasRectangle::y();
 
304
  int s = mComposition->selectionBoxSize();
 
305
 
 
306
  painter.drawRect ( x, y, s, s );
 
307
  x += QCanvasRectangle::width();
 
308
  painter.drawRect ( x-s, y, s, s );
 
309
  y += QCanvasRectangle::height();
 
310
  painter.drawRect ( x-s, y-s, s, s );
 
311
  x -= QCanvasRectangle::width();
 
312
  painter.drawRect ( x, y-s, s, s );
 
313
    }
 
314
    
 
315
    mDrawing = false;
 
316
}
 
317
 
 
318
void QgsComposerMap::sizeChanged ( void ) 
 
319
{
 
320
    int w, h;
 
321
    w = mComposition->fromMM ( mWidthLineEdit->text().toDouble() );
 
322
    h = mComposition->fromMM ( mHeightLineEdit->text().toDouble() );
 
323
 
 
324
    QCanvasRectangle::setSize ( w, h);
 
325
    recalculate();
 
326
 
 
327
    QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
328
    QCanvasRectangle::update();
 
329
    QCanvasRectangle::canvas()->update();
 
330
    
 
331
    writeSettings();
 
332
}
 
333
 
 
334
void QgsComposerMap::calculateChanged ( void ) 
 
335
{
 
336
    mCalculate = mCalculateComboBox->currentItem();
 
337
    
 
338
    if ( mCalculate == Scale ) { // return to extent defined by user
 
339
  recalculate();
 
340
 
 
341
  mCacheUpdated = false;
 
342
  //QCanvasRectangle::canvas()->setAllChanged(); // must be setAllChanged(), not sure why
 
343
      QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
344
  QCanvasRectangle::canvas()->update();
 
345
    
 
346
  mComposition->emitMapChanged ( mId );
 
347
    }
 
348
    setOptions();
 
349
    writeSettings();
 
350
}
 
351
 
 
352
double QgsComposerMap::scaleFromUserScale ( double us ) 
 
353
{
 
354
    double s;
 
355
    
 
356
    switch ( QgsProject::instance()->mapUnits() ) {
 
357
  case QGis::METERS :
 
358
      s = 1000. * mComposition->scale() / us;
 
359
      break;
 
360
  case QGis::FEET :
 
361
      s = 304.8 * mComposition->scale() / us;
 
362
      break;
 
363
  case QGis::DEGREES :
 
364
      s = mComposition->scale() / us;
 
365
      break;
 
366
    }
 
367
    return s;
 
368
}
 
369
 
 
370
double QgsComposerMap::userScaleFromScale ( double s )
 
371
{ 
 
372
    double us;
 
373
    
 
374
    switch ( QgsProject::instance()->mapUnits() ) {
 
375
  case QGis::METERS :
 
376
      us = 1000. * mComposition->scale() / s; 
 
377
      break;
 
378
  case QGis::FEET :
 
379
      us = 304.8 * mComposition->scale() / s; 
 
380
      break;
 
381
  case QGis::DEGREES :
 
382
      us = mComposition->scale() / s;
 
383
      break;
 
384
    }
 
385
    
 
386
    return us;
 
387
}
 
388
 
 
389
void QgsComposerMap::mapScaleChanged ( void ) 
 
390
{
 
391
    std::cout << "QgsComposerMap::mapScaleChanged" << std::endl;
 
392
 
 
393
    mCalculate = mCalculateComboBox->currentItem();
 
394
 
 
395
    mUserScale = mScaleLineEdit->text().toDouble();
 
396
 
 
397
    mScale = scaleFromUserScale ( mUserScale );
 
398
 
 
399
    recalculate();
 
400
 
 
401
    mCacheUpdated = false;
 
402
    QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
403
    QCanvasRectangle::update();
 
404
    QCanvasRectangle::canvas()->update();
 
405
    
 
406
    writeSettings();
 
407
    mComposition->emitMapChanged ( mId );
 
408
}
 
409
 
 
410
void QgsComposerMap::scaleChanged ( void ) 
 
411
{
 
412
    mWidthScale = mWidthScaleLineEdit->text().toDouble();
 
413
    mSymbolScale = mSymbolScaleLineEdit->text().toDouble();
 
414
    mFontScale = mFontScaleLineEdit->text().toDouble();
 
415
 
 
416
    mCacheUpdated = false;
 
417
    QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
418
    QCanvasRectangle::update();
 
419
    QCanvasRectangle::canvas()->update();
 
420
    
 
421
    writeSettings();
 
422
    mComposition->emitMapChanged ( mId );
 
423
}
 
424
 
 
425
void QgsComposerMap::mapCanvasChanged ( void ) 
 
426
{
 
427
    std::cout << "QgsComposerMap::canvasChanged" << std::endl;
 
428
 
 
429
    mCacheUpdated = false;
 
430
    QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
431
}
 
432
 
 
433
void QgsComposerMap::previewModeChanged ( int i )
 
434
{
 
435
    mPreviewMode = (PreviewMode) i;
 
436
    writeSettings();
 
437
}
 
438
 
 
439
void QgsComposerMap::recalculate ( void ) 
 
440
{
 
441
    std::cout << "QgsComposerMap::recalculate mCalculate = " << mCalculate << std::endl;
 
442
 
 
443
    if ( mCalculate == Scale ) 
 
444
    {
 
445
  // Calculate scale from extent and rectangle
 
446
  double xscale = QCanvasRectangle::width() / mUserExtent.width();
 
447
  double yscale = QCanvasRectangle::height() / mUserExtent.height();
 
448
 
 
449
  mExtent = mUserExtent;
 
450
 
 
451
  if ( xscale < yscale ) {
 
452
      mScale = xscale;
 
453
      // extend y
 
454
      double d = ( 1. * QCanvasRectangle::height() / mScale - mUserExtent.height() ) / 2 ;
 
455
      mExtent.setYmin ( mUserExtent.yMin() - d );
 
456
      mExtent.setYmax ( mUserExtent.yMax() + d );
 
457
  } else {
 
458
      mScale = yscale;
 
459
      // extend x
 
460
      double d = ( 1.* QCanvasRectangle::width() / mScale - mUserExtent.width() ) / 2 ;
 
461
      mExtent.setXmin ( mUserExtent.xMin() - d );
 
462
      mExtent.setXmax ( mUserExtent.xMax() + d );
 
463
  }
 
464
 
 
465
  mUserScale = userScaleFromScale ( mScale );
 
466
    } 
 
467
    else
 
468
    {
 
469
  // Calculate extent
 
470
  double xc = ( mUserExtent.xMax() + mUserExtent.xMin() ) / 2;
 
471
  double yc = ( mUserExtent.yMax() + mUserExtent.yMin() ) / 2;
 
472
    
 
473
  double width = QCanvasRectangle::width() / mScale;
 
474
  double height = QCanvasRectangle::height() / mScale;
 
475
  
 
476
  mExtent.setXmin ( xc - width/2  );
 
477
  mExtent.setXmax ( xc + width/2  );
 
478
  mExtent.setYmin ( yc - height/2  );
 
479
  mExtent.setYmax ( yc + height/2  );
 
480
 
 
481
    }
 
482
 
 
483
    std::cout << "mUserExtent = " << mUserExtent.stringRep().local8Bit() << std::endl;
 
484
    std::cout << "mScale = " << mScale << std::endl;
 
485
    std::cout << "mExtent = " << mExtent.stringRep().local8Bit() << std::endl;
 
486
 
 
487
    setOptions();
 
488
    mCacheUpdated = false;
 
489
}
 
490
 
 
491
void QgsComposerMap::frameChanged ( )
 
492
{
 
493
    mFrame = mFrameCheckBox->isChecked();
 
494
 
 
495
    QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
496
    QCanvasRectangle::update();
 
497
    QCanvasRectangle::canvas()->update();
 
498
 
 
499
    writeSettings();
 
500
}
 
501
 
 
502
 
 
503
void QgsComposerMap::setOptions ( void )
 
504
{ 
 
505
    std::cout << "QgsComposerMap::setOptions" << std::endl;
 
506
    
 
507
    mNameLabel->setText ( mName );
 
508
    
 
509
    mCalculateComboBox->setCurrentItem( mCalculate );
 
510
    
 
511
    mWidthLineEdit->setText ( QString("%1").arg( mComposition->toMM(QCanvasRectangle::width()), 0,'g') );
 
512
    mHeightLineEdit->setText ( QString("%1").arg( mComposition->toMM(QCanvasRectangle::height()),0,'g') );
 
513
    
 
514
    // Scale
 
515
    switch ( QgsProject::instance()->mapUnits() ) {
 
516
  case QGis::METERS :
 
517
  case QGis::FEET :
 
518
            mScaleLineEdit->setText ( QString("%1").arg((int)mUserScale) );
 
519
      break;
 
520
  case QGis::DEGREES :
 
521
            mScaleLineEdit->setText ( QString("%1").arg(mUserScale,0,'f') );
 
522
      break;
 
523
    }
 
524
    if ( mCalculate == Scale ) {
 
525
  mScaleLineEdit->setEnabled(false);  
 
526
    } else {
 
527
  mScaleLineEdit->setEnabled(true); 
 
528
    }
 
529
    
 
530
    mWidthScaleLineEdit->setText ( QString("%1").arg(mWidthScale,0,'g',2) );
 
531
    mSymbolScaleLineEdit->setText ( QString("%1").arg(mSymbolScale,0,'g',2) );
 
532
    mFontScaleLineEdit->setText ( QString("%1").arg(mFontScale,0,'g',2) );
 
533
 
 
534
    mFrameCheckBox->setChecked ( mFrame );
 
535
    
 
536
    mPreviewModeComboBox->setCurrentItem( mPreviewMode );
 
537
}
 
538
 
 
539
void QgsComposerMap::setCurrentExtent ( void )
 
540
{ 
 
541
    mUserExtent = mMapCanvas->extent();
 
542
    recalculate();
 
543
    QCanvasRectangle::canvas()->setChanged( QCanvasRectangle::boundingRect() );
 
544
    QCanvasRectangle::update();
 
545
    QCanvasRectangle::canvas()->update();
 
546
    setOptions();
 
547
    writeSettings();
 
548
    mComposition->emitMapChanged ( mId );
 
549
}
 
550
 
 
551
void QgsComposerMap::setSelected (  bool s ) 
 
552
{
 
553
    mSelected = s;
 
554
    QCanvasRectangle::update(); // show highlight
 
555
}    
 
556
 
 
557
bool QgsComposerMap::selected( void )
 
558
{
 
559
    return mSelected;
 
560
}
 
561
 
 
562
void QgsComposerMap::setCacheUpdated ( bool u ) 
 
563
{
 
564
    mCacheUpdated = u;
 
565
}    
 
566
 
 
567
double QgsComposerMap::scale ( void ) { return mScale; }
 
568
 
 
569
QWidget *QgsComposerMap::options ( void )
 
570
{
 
571
    setOptions ();
 
572
    return ( dynamic_cast <QWidget *> (this) );
 
573
}
 
574
 
 
575
QString QgsComposerMap::name ( void ) 
 
576
{
 
577
    return mName;
 
578
}
 
579
 
 
580
double QgsComposerMap::widthScale (void ) { return mWidthScale ; }
 
581
double QgsComposerMap::symbolScale (void ) { return mSymbolScale ; }
 
582
double QgsComposerMap::fontScale (void ) { return mFontScale ; }
 
583
 
 
584
bool QgsComposerMap::writeSettings ( void )  
 
585
{
 
586
    QString path;
 
587
    path.sprintf("/composition_%d/map_%d/", mComposition->id(), mId ); 
 
588
    QgsProject::instance()->writeEntry( "Compositions", path+"x", mComposition->toMM((int)QCanvasRectangle::x()) );
 
589
    QgsProject::instance()->writeEntry( "Compositions", path+"y", mComposition->toMM((int)QCanvasRectangle::y()) );
 
590
    QgsProject::instance()->writeEntry( "Compositions", path+"width", mComposition->toMM(QCanvasRectangle::width()) );
 
591
    QgsProject::instance()->writeEntry( "Compositions", path+"height", mComposition->toMM(QCanvasRectangle::height()) );
 
592
 
 
593
    if ( mCalculate == Scale ) {
 
594
        QgsProject::instance()->writeEntry( "Compositions", path+"calculate", QString("scale") );
 
595
    } else {
 
596
        QgsProject::instance()->writeEntry( "Compositions", path+"calculate", QString("extent") );
 
597
    }
 
598
    
 
599
    QgsProject::instance()->writeEntry( "Compositions", path+"north", mUserExtent.yMax() );
 
600
    QgsProject::instance()->writeEntry( "Compositions", path+"south", mUserExtent.yMin() );
 
601
    QgsProject::instance()->writeEntry( "Compositions", path+"east", mUserExtent.xMax() );
 
602
    QgsProject::instance()->writeEntry( "Compositions", path+"west", mUserExtent.xMin() );
 
603
 
 
604
    QgsProject::instance()->writeEntry( "Compositions", path+"scale", mUserScale );
 
605
 
 
606
    QgsProject::instance()->writeEntry( "Compositions", path+"widthscale", mWidthScale );
 
607
    QgsProject::instance()->writeEntry( "Compositions", path+"symbolscale", mSymbolScale );
 
608
    QgsProject::instance()->writeEntry( "Compositions", path+"fontscale", mFontScale );
 
609
 
 
610
    QgsProject::instance()->writeEntry( "Compositions", path+"frame", mFrame );
 
611
 
 
612
    QgsProject::instance()->writeEntry( "Compositions", path+"previewmode", mPreviewMode );
 
613
 
 
614
    return true; 
 
615
}
 
616
 
 
617
bool QgsComposerMap::readSettings ( void )
 
618
{
 
619
    bool ok;
 
620
    QString path;
 
621
    path.sprintf("/composition_%d/map_%d/", mComposition->id(), mId );
 
622
 
 
623
    
 
624
    QCanvasRectangle::setX( mComposition->fromMM(QgsProject::instance()->readDoubleEntry( "Compositions", path+"x", 0, &ok)) );
 
625
    QCanvasRectangle::setY( mComposition->fromMM(QgsProject::instance()->readDoubleEntry( "Compositions", path+"y", 0, &ok)) );
 
626
    int w = mComposition->fromMM(QgsProject::instance()->readDoubleEntry( "Compositions", path+"width", 100, &ok)) ;
 
627
    int h = mComposition->fromMM(QgsProject::instance()->readDoubleEntry( "Compositions", path+"height", 100, &ok)) ;
 
628
    QCanvasRectangle::setSize(w,h);
 
629
 
 
630
    QString calculate = QgsProject::instance()->readEntry("Compositions", path+"calculate", "scale", &ok);
 
631
    if ( calculate == "extent" ) {
 
632
        mCalculate = Extent;
 
633
    } else {
 
634
        mCalculate = Scale;
 
635
    }
 
636
 
 
637
    mUserExtent.setYmax ( QgsProject::instance()->readDoubleEntry( "Compositions", path+"north", 100, &ok) );
 
638
    mUserExtent.setYmin ( QgsProject::instance()->readDoubleEntry( "Compositions", path+"south", 0, &ok) );
 
639
    mUserExtent.setXmax ( QgsProject::instance()->readDoubleEntry( "Compositions", path+"east", 100, &ok) );
 
640
    mUserExtent.setXmin ( QgsProject::instance()->readDoubleEntry( "Compositions", path+"west", 0, &ok) );
 
641
 
 
642
    mUserScale =  QgsProject::instance()->readDoubleEntry( "Compositions", path+"scale", 1000., &ok);
 
643
    mScale = scaleFromUserScale ( mUserScale );
 
644
 
 
645
    mWidthScale = QgsProject::instance()->readDoubleEntry("Compositions", path+"widthscale", 1., &ok);
 
646
    mSymbolScale = QgsProject::instance()->readDoubleEntry("Compositions", path+"symbolscale", 1., &ok);
 
647
    mFontScale = QgsProject::instance()->readDoubleEntry("Compositions", path+"fontscale", 1., &ok);
 
648
    
 
649
    mFrame = QgsProject::instance()->readBoolEntry("Compositions", path+"frame", true, &ok);
 
650
    
 
651
    mPreviewMode = (PreviewMode) QgsProject::instance()->readNumEntry("Compositions", path+"previewmode", Cache, &ok);
 
652
    
 
653
    recalculate();
 
654
 
 
655
    return true;
 
656
}
 
657
 
 
658
bool QgsComposerMap::removeSettings ( void )
 
659
{
 
660
    QString path;
 
661
    path.sprintf("/composition_%d/map_%d", mComposition->id(), mId );
 
662
    return QgsProject::instance()->removeEntry ( "Compositions", path );
 
663
}
 
664
    
 
665
bool QgsComposerMap::writeXML( QDomNode & node, QDomDocument & document, bool temp )
 
666
{
 
667
    return true;
 
668
}
 
669
 
 
670
bool QgsComposerMap::readXML( QDomNode & node )
 
671
{
 
672
    return true;
 
673
}