Changeset 2065


Ignore:
Timestamp:
04/01/10 11:28:04 (8 years ago)
Author:
pgiraud
Message:

prepare git local commit before svn commit

Location:
core/trunk/geoext
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • core/trunk/geoext/examples/print-extent.js

    r1956 r2065  
    2727    });
    2828
     29    var printExtent = new GeoExt.plugins.PrintExtent({
     30        printProvider: printProvider
     31    });
     32
    2933    // The map we want to print, with the PrintExtent added as item.
    3034    mapPanel = new GeoExt.MapPanel({
     
    3640        center: [146.56, -41.56],
    3741        zoom: 6,
    38         plugins: [
    39             new GeoExt.plugins.PrintExtent({
    40                 printProvider: printProvider
    41             })
    42         ],
     42        plugins: [printExtent],
    4343        bbar: [{
    4444            text: "Create PDF",
     
    4949        }]
    5050    });
     51    printExtent.addPage();
    5152});
  • core/trunk/geoext/lib/GeoExt/plugins/PrintExtent.js

    r1972 r2065  
    3535 *      });
    3636 *
     37 *      printExtent.addPage();
     38 *
    3739 *      // print the map
    3840 *      printExtent.print();
     
    4749 *  :class:`GeoExt.MapPanel`.
    4850 */
    49 
    50 GeoExt.plugins.PrintExtent = function(config) {
    51     config = config || {};
    52 
    53     Ext.apply(this, config);
    54     this.initialConfig = config;
    55 
    56     if(!this.pages) {
    57         this.pages = [new GeoExt.data.PrintPage({
    58             printProvider: this.printProvider
    59         })];
    60     }
    61 
    62     if(!this.printProvider) {
    63         this.printProvider = this.pages[0].printProvider;
    64     }
    65 };
    66 
    67 GeoExt.plugins.PrintExtent.prototype = {
     51GeoExt.plugins.PrintExtent = Ext.extend(Ext.util.Observable, {
    6852
    6953    /** private: initialConfig
     
    123107    page: null,
    124108
     109    /** private: method[constructor]
     110     *  Private constructor override.
     111     */
     112    constructor: function(config) {
     113        config = config || {};
     114
     115        Ext.apply(this, config);
     116        this.initialConfig = config;
     117
     118        if(!this.printProvider) {
     119            this.printProvider = this.pages[0].printProvider;
     120        }
     121
     122        if(!this.pages) {
     123            this.pages = [];
     124        }
     125       
     126        this.addEvents(
     127            /** api: events[selectpage]
     128             *  Triggered when a page has been selected using the control
     129             * 
     130             *  Listener arguments:
     131             *  * printPage - :class:`GeoExt.data.PrintPage` this printPage
     132             */
     133            "selectpage"
     134        );
     135
     136        GeoExt.plugins.PrintExtent.superclass.constructor.apply(this, arguments);
     137    },
     138
    125139    /** api: method[print]
    126140     *  :param options: ``Object`` Options to send to the PrintProvider's
     
    141155        this.map = mapPanel.map;
    142156        mapPanel.on("destroy", this.onMapPanelDestroy, this);
     157
     158        if (!this.layer) {
     159            this.layer = new OpenLayers.Layer.Vector(null, {
     160                displayInLayerSwitcher: false
     161            });
     162        }
     163        this.createControl();
     164
     165        for(var i=0, len=this.pages.length; i<len; ++i) {
     166            this.addPage(this.pages[i]);
     167        }
    143168        this.setUp();
     169    },
     170
     171    /** api: method[addPage]
     172     *  Adds a page to the list of pages that this plugin controls.
     173     *  :param page: :class:`GeoExt.data.PrintPage` The page to add
     174     *       to this plugin. If not provided, a page that fits the current
     175     *       extent is created.
     176     *  :return: page :class:``GeoExt.data.PrintPage``
     177     */
     178    addPage: function(page) {
     179        page = page || new GeoExt.data.PrintPage({
     180            printProvider: this.printProvider
     181        });
     182        if(this.pages.indexOf(page) === -1) {
     183            this.pages.push(page);
     184        }
     185        this.layer.addFeatures([page.feature]);
     186        page.on("change", this.onPageChange, this);
     187
     188        this.page = page;
     189        var map = this.map;
     190        if(map.getCenter()) {
     191            this.fitPage();
     192        } else {
     193            map.events.register("moveend", this, function() {
     194                map.events.unregister("moveend", this, arguments.callee);
     195                this.fitPage();
     196            });
     197        }
     198        return page;
     199    },
     200
     201    /** api: method[removePage]
     202     *  Removes a page from the list of pages that this plugin controls.
     203     *  :param page: :class:`GeoExt.data.PrintPage` The page to remove
     204     *       from this plugin.
     205     */
     206    removePage: function(page) {
     207        this.pages.remove(page);
     208        if (page.feature.layer) {
     209            this.layer.removeFeatures([page.feature]);
     210        }
     211        page.un("change", this.onPageChange, this);
     212    },
     213   
     214    /** api: method[selectPage]
     215     *  Selects the given page (ie. calls the setFeature on the
     216     *      modify feature control)
     217     *  :param page: :class:`GeoExt.data.PrintPage` The page to select
     218     */
     219    selectPage: function(page) {
     220        this.control.active && this.control.setFeature(page.feature);
     221        // FIXME raise the feature up so that it is on top
    144222    },
    145223
     
    150228     */
    151229    setUp: function() {
    152         this.initLayer();
    153 
    154         this.initControl();
     230        this.map.addLayer(this.layer);
    155231        this.map.addControl(this.control);
    156232        this.control.activate();
    157233
    158234        this.printProvider.on("layoutchange", this.updateBox, this);
    159 
    160         if(!this.initialConfig.pages) {
    161             this.page = this.pages[0];
    162             var map = this.map;
    163             if(map.getCenter()) {
    164                 this.fitPage();
    165             } else {
    166                 map.events.register("moveend", this, function() {
    167                     map.events.unregister("moveend", this, arguments.callee);
    168                     this.fitPage();
    169                 });
    170             }
    171         }
    172235    },
    173236
     
    196259
    197260        var layer = this.layer;
    198         if(layer && layer.events) {
    199             for(var i=0, len=this.pages.length; i<len; ++i) {
    200                 var page = this.pages[i];
    201                 page.un("change", this.onPageChange, this);
    202                 layer.removeFeatures([page.feature]);
    203             }
    204         }
    205261
    206262        if(!this.initialConfig.layer &&
     
    214270     */
    215271    onMapPanelDestroy: function() {
     272
     273        var map = this.map;
     274
     275        for(var len = this.pages.length - 1, i = len; i>=0; i--) {
     276            this.removePage(this.pages[i]);
     277        }
     278
    216279        this.tearDown();
    217 
    218         var map = this.map;
    219280
    220281        var control = this.control;
     
    236297        this.map = null;
    237298    },
    238 
    239     /** private: method[initLayer]
    240      */
    241     initLayer: function() {
    242         if(!this.layer) {
    243             this.layer = new OpenLayers.Layer.Vector(null, {
    244                 displayInLayerSwitcher: false
    245             });
    246         }
    247         for(var i=0, len=this.pages.length; i<len; ++i) {
    248             var page = this.pages[i];
    249             this.layer.addFeatures([page.feature]);
    250             page.on("change", this.onPageChange, this);
    251         }
    252         if(!this.layer.map) {
    253             this.map.addLayer(this.layer);
    254         }
    255     },
    256    
    257     /** private: method[initControl]
    258      */
    259     initControl: function() {
    260         var pages = this.pages;
    261 
    262         if(!this.control) {
    263             this.control = new OpenLayers.Control.TransformFeature(this.layer, {
    264                 preserveAspectRatio: true,
    265                 eventListeners: {
    266                     "beforesetfeature": function(e) {
    267                         for(var i=0, len=this.pages.length; i<len; ++i) {
    268                             if(this.pages[i].feature === e.feature) {
    269                                 this.page = this.pages[i];
    270                                 e.object.rotation = -this.pages[i].rotation;
    271                                 break;
    272                             }
     299   
     300    /** private: method[createControl]
     301     */
     302    createControl: function() {
     303        this.control = new OpenLayers.Control.TransformFeature(this.layer, {
     304            preserveAspectRatio: true,
     305            eventListeners: {
     306                "beforesetfeature": function(e) {
     307                    for(var i=0, len=this.pages.length; i<len; ++i) {
     308                        if(this.pages[i].feature === e.feature) {
     309                            this.page = this.pages[i];
     310                            e.object.rotation = -this.pages[i].rotation;
     311                            break;
    273312                        }
    274                     },
    275                     "beforetransform": function(e) {
    276                         this._updating = true;
    277                         var page = this.page;
    278                         if(e.rotation) {
    279                             if(this.printProvider.layout.get("rotation")) {
    280                                 page.setRotation(-e.object.rotation);
    281                             } else {
    282                                 e.object.setFeature(page.feature);
    283                             }
    284                         } else if(e.center) {
    285                             page.setCenter(OpenLayers.LonLat.fromString(
    286                                 e.center.toShortString()
    287                             ));
     313                    }
     314                },
     315                "setfeature": function(e) {
     316                    for(var i=0, len=this.pages.length; i<len; ++i) {
     317                        if(this.pages[i].feature === e.feature) {
     318                            this.fireEvent("selectpage", this.pages[i]);
     319                            break;
     320                        }
     321                    }
     322                },
     323                "beforetransform": function(e) {
     324                    this._updating = true;
     325                    var page = this.page;
     326                    if(e.rotation) {
     327                        if(this.printProvider.layout.get("rotation")) {
     328                            page.setRotation(-e.object.rotation);
    288329                        } else {
    289                             page.fit(e.object.box);
    290                             var minScale = this.printProvider.scales.getAt(0);
    291                             var maxScale = this.printProvider.scales.getAt(
    292                                 this.printProvider.scales.getCount() - 1);
    293                             var boxBounds = e.object.box.geometry.getBounds();
    294                             var pageBounds = page.feature.geometry.getBounds();
    295                             var tooLarge = page.scale === minScale &&
    296                                 boxBounds.containsBounds(pageBounds);
    297                             var tooSmall = page.scale === maxScale &&
    298                                 pageBounds.containsBounds(boxBounds);
    299                             if(tooLarge === true || tooSmall === true) {
    300                                 this.updateBox();
    301                             }
     330                            e.object.setFeature(page.feature);
    302331                        }
    303                         delete this._updating;
    304                         return false;
    305                     },
    306                     "transformcomplete": this.updateBox,
    307                     scope: this
    308                 }
    309             });
    310         }
     332                    } else if(e.center) {
     333                        page.setCenter(OpenLayers.LonLat.fromString(
     334                            e.center.toShortString()
     335                        ));
     336                    } else {
     337                        page.fit(e.object.box);
     338                        var minScale = this.printProvider.scales.getAt(0);
     339                        var maxScale = this.printProvider.scales.getAt(
     340                            this.printProvider.scales.getCount() - 1);
     341                        var boxBounds = e.object.box.geometry.getBounds();
     342                        var pageBounds = page.feature.geometry.getBounds();
     343                        var tooLarge = page.scale === minScale &&
     344                            boxBounds.containsBounds(pageBounds);
     345                        var tooSmall = page.scale === maxScale &&
     346                            pageBounds.containsBounds(boxBounds);
     347                        if(tooLarge === true || tooSmall === true) {
     348                            this.updateBox();
     349                        }
     350                    }
     351                    delete this._updating;
     352                    return false;
     353                },
     354                "transformcomplete": this.updateBox,
     355                scope: this
     356            }
     357        });
    311358    },
    312359
     
    326373    updateBox: function() {
    327374        var page = this.page;
    328         this.control.setFeature(page.feature, {rotation: -page.rotation});
     375        this.control.active &&
     376            this.control.setFeature(page.feature, {rotation: -page.rotation});
    329377    },
    330378
     
    334382    onPageChange: function(page, mods) {
    335383        if(!this._updating) {
    336             this.control.setFeature(page.feature, {rotation: -page.rotation});
     384            this.control.active &&
     385                this.control.setFeature(page.feature, {rotation: -page.rotation});
    337386        }
    338387    }
    339 };
     388});
    340389
    341390/** api: ptype = gx_printextent */
  • core/trunk/geoext/tests/lib/GeoExt/plugins/PrintExtent.html

    r2019 r2065  
    1111       
    1212        function test_ctor(t) {
    13             t.plan(2);
     13            t.plan(1);
    1414
    1515            var printProvider = new GeoExt.data.PrintProvider({
     
    2323            t.ok(printExtent.printProvider === printProvider,
    2424                 "ctor sets printProvider in the instance");
    25             t.ok(printExtent.pages[0] instanceof GeoExt.data.PrintPage,
    26                  "ctor creates a PrintPage");
    2725        }
    2826       
     
    104102                plugins: [printExtent]
    105103            });
     104            printExtent.addPage();
    106105
    107106            t.ok(printExtent.pages[0].center.equals(mapPanel.map.getCenter()),
     
    118117
    119118        function test_tearDown(t) {
    120             t.plan(3);
     119            t.plan(2);
    121120 
    122121            var printExtent = new GeoExt.plugins.PrintExtent({
     
    145144            t.eq(mapPanel.map.controls.length, 0,
    146145                 "control was removed.");
    147             t.eq(printExtent.pages[0].feature.layer, null,
    148                  "feature was removed from the layer.")
    149 
    150             mapPanel.destroy();
    151         }
     146
     147            mapPanel.destroy();
     148        }
     149
     150        function test_addPage(t) {
     151
     152            t.plan(2);
     153
     154            var printExtent = new GeoExt.plugins.PrintExtent({
     155                printProvider: new GeoExt.data.PrintProvider({
     156                    capabilities: printCapabilities
     157                })
     158            });
     159
     160            var mapPanel = new GeoExt.MapPanel({
     161                renderTo: "mappanel",
     162                width: 256,
     163                height: 256,
     164                map: {controls: []},
     165                layers: [
     166                    new OpenLayers.Layer("layer", {isBaseLayer: true})
     167                ],
     168                center: [146.56, -41.56],
     169                zoom: 7,
     170                plugins: [printExtent]
     171            });
     172
     173            var page = printExtent.addPage();
     174
     175            t.ok(printExtent.pages[printExtent.pages.length - 1] == page,
     176                "addPage correctly creates and add a new page when none given ");
     177
     178            var p = {
     179                feature: new OpenLayers.Feature(),
     180                on: function() {},
     181                un: function() {},
     182                fit: function() {}
     183            };
     184            var page2 = printExtent.addPage(p);
     185            t.ok(printExtent.pages[printExtent.pages.length - 1] == page2,
     186                "addPage corectly add a page");
     187
     188            mapPanel.destroy();
     189        }
     190
     191        function test_removePage(t) {
     192
     193            t.plan(1);
     194
     195            var page = {
     196                feature: new OpenLayers.Feature(),
     197                 on: function() {},
     198                 un: function() {},
     199                 fit: function() {}
     200            };
     201
     202            var printExtent = new GeoExt.plugins.PrintExtent({
     203                printProvider: new GeoExt.data.PrintProvider({
     204                    capabilities: printCapabilities
     205                }),
     206                pages: [page]
     207            });
     208
     209            var mapPanel = new GeoExt.MapPanel({
     210                renderTo: "mappanel",
     211                width: 256,
     212                height: 256,
     213                map: {controls: []},
     214                layers: [
     215                    new OpenLayers.Layer("layer", {isBaseLayer: true})
     216                ],
     217                center: [146.56, -41.56],
     218                zoom: 7,
     219                plugins: [printExtent]
     220            });
     221
     222            printExtent.removePage(page);
     223
     224            t.eq(printExtent.pages.length, 0,
     225                "page is correctly removed");
     226            mapPanel.destroy();
     227        }
     228
    152229    </script>
    153230  <body>
Note: See TracChangeset for help on using the changeset viewer.