Merge lp:~cardinot/stellarium/MeteorShower into lp:stellarium

[Marcos Cardinot]

This branch aims to improve and sort out several bugs of the Meteor Showers plugin and the Meteor module.

* main meteor model and the MS plugin was rewritten
* better management of the active meteors (great performance improvement)
* now we have a SporadicMeteor class, which inherits from the Meteor class
* huge cleanup on the MeteorShowers plugin
* MS plugin now has 2 dilogs: one to settings and another one to search events only
* several bugs with the management of the meteor activities were found and fixed
etc etc etc

[lp:~cardinot/stellarium/MeteorShower]

7796. By Marcos Cardinot on 2015-07-30

conflicts

[gzotti (georg-zotti)]

Cannot compile with Qt5.5 and MSVC:
MSConfigDialog.cpp line 55: 'listEvents' and 'aboutTextBrowser': not an element of 'Ui_MSConfigDialog'

I commented that out for now to continue compilation, but don't know what are the replacements.

and line 135: Apparently the name ERROR causes conflicts, even if given with MeteorShowersMgr::. I have replaced with e.g. MSMERROR, then it compiles and runs nicely.

Somewhere in the config panel, can you please describe what's a real/generic/inactive radiant?
And if you have implemented a model from some paper (???) and get the annual data from somewhere, can you please add a reference?

review: Needs Fixing

[Alexander Wolf (alexwolf)]

Inconsistent behaviour in GUI: "Show buttons on toolbar" ignores settings. Where is "Save settings" button and where is Leonides? :)

And I don't see any meteors :'(

review: Needs Fixing

[lp:~cardinot/stellarium/MeteorShower]

7801. By Marcos Cardinot on 2015-07-30

fix Kinetic scrolling

7802. By Marcos Cardinot on 2015-07-30

renames the DownloadStatus from ERROR to FAILED

[Marcos Cardinot (cardinot)]

Hi Georg, thanks for your review! ;)

> Cannot compile with Qt5.5 and MSVC:
> MSConfigDialog.cpp line 55: 'listEvents' and 'aboutTextBrowser': not an
> element of 'Ui_MSConfigDialog'

fixed!

> I commented that out for now to continue compilation, but don't know what are
> the replacements.
>
> and line 135: Apparently the name ERROR causes conflicts, even if given with
> MeteorShowersMgr::. I have replaced with e.g. MSMERROR, then it compiles and
> runs nicely.

I renamed it to FAILED - could you check if it works fine now please?

> Somewhere in the config panel, can you please describe what's a
> real/generic/inactive radiant?

Yeah, I will include a description on the about tab... but I think we should rename them to something more intuitive...

Real: it means that this data comes from a real IMO catalog - confirmed meteor shower
Generic: it means that this radiant is usually active at this time of year, but it was not confirmed from IMO.
Inactive: it means that this radiant is not active at this time of year.

Maybe we should rename to...
Real -> Confirmed
Generic -> Unconfirmed

ideas?

> And if you have implemented a model from some paper (???)
no
> and get the annual
> data from somewhere, can you please add a reference?

yes, we get the data from the International Meteor Organization catalog (http://imo.net/) - I will include it on the about tab

[Marcos Cardinot (cardinot)]

Hi Alex,
thanks for your review!

> Inconsistent behaviour in GUI: "Show buttons on toolbar" ignores settings.

fixed!

> Where is "Save settings" button

Now we just save things automatically =D
Since most software have the same behavior, it's far more intuitive than forcing users to click on "save" all the time.

If a user goes to the settings dialog, set something (mainly options like: 'enable buttons', 'enable plugin at startup', colors etc) and closes Stellarium... I bet $1.000.000.000 dollars that he would expect to see their settings there again - so, why ask for save?

> and where is Leonides? :)

please, update your catalog =D

> And I don't see any meteors :'(

could you check it for a radiant with a high ZHR please? (or even set some data on the catalog, only for tests)

[lp:~cardinot/stellarium/MeteorShower]

7803. By Marcos Cardinot on 2015-07-30

fix bug when setting the buttons on toolbar

[Alexander Wolf (alexwolf)]

A fresh catalog has invalid data for Leonids.

[Alexander Wolf (alexwolf)]

Hint: current version of plugin did not supports for format of meteor shower with variable ZHR

[Marcos Cardinot (cardinot)]

> Hint: current version of plugin did not supports for format of meteor shower
> with variable ZHR

Atually it supports - I only added some checkers to see if the "variable" field is in right format, which is "int-int"

On the older catalog, LEO had a activity with something like "int-int*"
http://bazaar.launchpad.net/~stellarium/stellarium/trunk/revision/7751

For the IMO catalog, this * means that his shower may have multiple peaks - but as it's very rare (see that this was the only case on the whole catalog) - we won't accept these "*" anymore...

--

We are loading the default catalog from qrc and it seems that Qt does not clean/refresh it properly - so, to avoid problems I will start loading the default catalog from the installation dir...

For now, you could just remove the "*" from your 'showers.json' and LEO should be available again =D

[lp:~cardinot/stellarium/MeteorShower]

7804. By Marcos Cardinot on 2015-07-30

restore default showers.json from installation directory instead of qrc

[Marcos Cardinot (cardinot)]

Hi Alex,
it should be fine now!
Could you also push the 'stellarium-website' branch to the SF? (just to update the showers.json)
thanks

[lp:~cardinot/stellarium/MeteorShower]

7805. By Marcos Cardinot on 2015-07-30

oops..typo

[Alexander Wolf (alexwolf)]

>Could you also push the 'stellarium-website' branch to the SF?

Yes, but not today

I don't understand your last 2 commits. Plugins should not store data into main data directory.

[Marcos Cardinot (cardinot)]

> >Could you also push the 'stellarium-website' branch to the SF?
>
> Yes, but not today

Ok, but have in mind that if your auto-updates is enabled, the new catalog will be replaced by the old one. (it explains why LEO was invalid for you, even after a fresh build)

> I don't understand your last 2 commits. Plugins should not store data into
> main data directory.

Yeah, you're right! I reverted both commits!

The copy from qrc is working fine. As I said, I was just with my auto-updates enabled, so, after copying the right file, I was replacing it with the old catalog from the web (which is outdated with the "*" issue)... that was the reason why I've thought that the copy was not being done correctly - my bad! - **1000 facepalms to me!** =D

[lp:~cardinot/stellarium/MeteorShower]

7806. By Marcos Cardinot on 2015-07-30

reverting the last commit - loads the default showers.json from qrc

[gzotti (georg-zotti)]

> Hi Georg, thanks for your review! ;)

Hi!

Compilation with MSVC2013 works now.

> > Somewhere in the config panel, can you please describe what's a
> > real/generic/inactive radiant?
>
> Yeah, I will include a description on the about tab... but I think we should
> rename them to something more intuitive...
>
> Real: it means that this data comes from a real IMO catalog - confirmed meteor
> shower
> Generic: it means that this radiant is usually active at this time of year,
> but it was not confirmed from IMO.
> Inactive: it means that this radiant is not active at this time of year.
>
> Maybe we should rename to...
> Real -> Confirmed
> Generic -> Unconfirmed
>
> ideas?

Real->IMO confirmed
Generic -> average data

Another thing: After Searching showers in te search panel, they are sorted by name. I would prefer sort-by-date. ... Oh that works even with a table header click, good!

But if I want to sort now by ZHR (can you change the table heading to ZHR?), I am not sure how sorting works for min-max numbers? It's a minor issue, but just in case it's a simple fix, decide for min/average/max as sort value?

[lp:~cardinot/stellarium/MeteorShower]

7807. By Marcos Cardinot on 2015-07-31

search dialog - prefer sort-by-date

7808. By Marcos Cardinot on 2015-07-31

search dialog - fix bug when sorting by ZHR

ZHR is variable ? choose the max value

[Marcos Cardinot (cardinot)]

> > Hi Georg, thanks for your review! ;)
>
> Hi!
>
> Compilation with MSVC2013 works now.
>
> > > Somewhere in the config panel, can you please describe what's a
> > > real/generic/inactive radiant?
> >
> > Yeah, I will include a description on the about tab... but I think we should
> > rename them to something more intuitive...
> >
> > Real: it means that this data comes from a real IMO catalog - confirmed
> meteor
> > shower
> > Generic: it means that this radiant is usually active at this time of year,
> > but it was not confirmed from IMO.
> > Inactive: it means that this radiant is not active at this time of year.
> >
> > Maybe we should rename to...
> > Real -> Confirmed
> > Generic -> Unconfirmed
> >
> > ideas?
>
> Real->IMO confirmed
> Generic -> average data

Humm... the problem is that sometimes we (or even the user) could add a new shower, in which the data was confirmed by some other catalog - in this way, "IMO confirmed" would be too specific...

>
> Another thing: After Searching showers in te search panel, they are sorted by
> name. I would prefer sort-by-date. ... Oh that works even with a table header
> click, good!

Yeah, it's possible to sort the columns by clicking on the header =D
But I agree with you - I pushed a patch to always prefer sort-by-date...

>
> But if I want to sort now by ZHR (can you change the table heading to ZHR?),

But it's "ZHR" already - not?
http://bazaar.launchpad.net/~mcardinot/stellarium/MeteorShower/view/head:/plugins/MeteorShowers/src/gui/MSSearchDialog.cpp#L180

> I am not sure how sorting works for min-max numbers? It's a minor issue, but
> just in case it's a simple fix, decide for min/average/max as sort value?

good catch - thanks!
I believe that usually users would look for higher ZHRs, so I fixed it to always choose max...

[gzotti (georg-zotti)]

> > >
> > > Maybe we should rename to...
> > > Real -> Confirmed
> > > Generic -> Unconfirmed
> > >
> > > ideas?
> >
> > Real->IMO confirmed
> > Generic -> average data
>
> Humm... the problem is that sometimes we (or even the user) could add a new
> shower, in which the data was confirmed by some other catalog - in this way,
> "IMO confirmed" would be too specific...

Ah, OK. (I am not too familiar with the details of this plugin, sorry.)
Real -> Current data
Generic -> Average data

> > But if I want to sort now by ZHR (can you change the table heading to ZHR?),
>
> But it's "ZHR" already - not?

Ouch, translation... --- OMG - it's my own! (Apparently at that time I had seen ZR used in the German literature. But the international "ZHR" may be better also in the German version after all.)

> > I am not sure how sorting works for min-max numbers? It's a minor issue,
> but
> > just in case it's a simple fix, decide for min/average/max as sort value?
>
> good catch - thanks!
> I believe that usually users would look for higher ZHRs, so I fixed it to
> always choose max...

OK

[lp:~cardinot/stellarium/MeteorShower]

7809. By Marcos Cardinot on 2015-08-05

Merge with trunk

7810. By Marcos Cardinot on 2015-08-05

fix merge conflicts

7811. By Marcos Cardinot on 2015-08-05

cosmetic fix

7812. By Marcos Cardinot on 2015-08-05

update pot

[Marcos Cardinot (cardinot)]

> > > >
> > > > Maybe we should rename to...
> > > > Real -> Confirmed
> > > > Generic -> Unconfirmed
> > > >
> > > > ideas?
> > >
> > > Real->IMO confirmed
> > > Generic -> average data
> >
> > Humm... the problem is that sometimes we (or even the user) could add a new
> > shower, in which the data was confirmed by some other catalog - in this way,
> > "IMO confirmed" would be too specific...
>
> Ah, OK. (I am not too familiar with the details of this plugin, sorry.)
> Real -> Current data
> Generic -> Average data

I'm ok with "Generic -> Average data", but I'm not sure if "Current data" is a good one... When using the MS plugin, people might be interested to see some historical showers (very high ZHR), so, using "current" would sounds strange... =/

>
> > > But if I want to sort now by ZHR (can you change the table heading to
> ZHR?),
> >
> > But it's "ZHR" already - not?
>
> Ouch, translation... --- OMG - it's my own! (Apparently at that time I had
> seen ZR used in the German literature. But the international "ZHR" may be
> better also in the German version after all.)
>
> > > I am not sure how sorting works for min-max numbers? It's a minor issue,
> > but
> > > just in case it's a simple fix, decide for min/average/max as sort value?
> >
> > good catch - thanks!
> > I believe that usually users would look for higher ZHRs, so I fixed it to
> > always choose max...
>
> OK

[gzotti (georg-zotti)]

> > > > >
> > > > > Maybe we should rename to...
> > > > > Real -> Confirmed
> > > > > Generic -> Unconfirmed
> > > > >
> > > > > ideas?
> > > >
> > > > Real->IMO confirmed
> > > > Generic -> average data
> > >
> > > Humm... the problem is that sometimes we (or even the user) could add a
> new
> > > shower, in which the data was confirmed by some other catalog - in this
> way,
> > > "IMO confirmed" would be too specific...
> >
> > Ah, OK. (I am not too familiar with the details of this plugin, sorry.)
> > Real -> Current data
> > Generic -> Average data
>
> I'm ok with "Generic -> Average data", but I'm not sure if "Current data" is a
> good one... When using the MS plugin, people might be interested to see some
> historical showers (very high ZHR), so, using "current" would sounds
> strange... =/

Oh, I was not aware that you simulate historical showers, I had thought the update would only provide e.g. pending shower forecast (IMO) for observers. Now I have seen "generic" and details for particular years in the JSON file.

Detailed/Accurate/Particular?

[Marcos Cardinot (cardinot)]

> > > > > >
> > > > > > Maybe we should rename to...
> > > > > > Real -> Confirmed
> > > > > > Generic -> Unconfirmed
> > > > > >
> > > > > > ideas?
> > > > >
> > > > > Real->IMO confirmed
> > > > > Generic -> average data
> > > >
> > > > Humm... the problem is that sometimes we (or even the user) could add a
> > new
> > > > shower, in which the data was confirmed by some other catalog - in this
> > way,
> > > > "IMO confirmed" would be too specific...
> > >
> > > Ah, OK. (I am not too familiar with the details of this plugin, sorry.)
> > > Real -> Current data
> > > Generic -> Average data
> >
> > I'm ok with "Generic -> Average data", but I'm not sure if "Current data" is
> a
> > good one... When using the MS plugin, people might be interested to see some
> > historical showers (very high ZHR), so, using "current" would sounds
> > strange... =/
>
> Oh, I was not aware that you simulate historical showers, I had thought the
> update would only provide e.g. pending shower forecast (IMO) for observers.
> Now I have seen "generic" and details for particular years in the JSON file.

Yeah
In general, a meteor shower occur at the same period of time (annually). However, the ZHR is not always the same - also, some showers are harder to predict, in this way, the IMO ends up to confirm the details of some showers which they were able to predicted...

So, in our JSON catalog, for each meteor shower we have an array 'activity', which must have at least one "generic" data, followed by the years in which the shower will really occur (or occurred).

eg.
   "activity":
   [
   {
    "year": "generic",
    "zhr": 3,
    "start": "09.25",
    "finish": "12.06",
    "peak": "11.09"
   },
   {
    "year": "1904",
    "zhr": 20
   },
   {
    "year": "1899",
    "zhr": 100
   }

There we see that the most recent record for this shower was in '1904' - but that in general, some meteor could always come from this radiant between Oct25 and Dec06 with a very low ZHR (3).
So, "generic data" is not exactly an average from all "confirmed data" that we have on our JSON catalog...

> Detailed/Accurate/Particular?

confirmed data?

Alex, do you have any thought?

[Alexander Wolf (alexwolf)]

2015-08-06 22:34 GMT+06:00 Marcos CARDINOT <email address hidden>:

> > Detailed/Accurate/Particular?
>
> confirmed data?
>
> Alex, do you have any thought?
>

Historical data because all this ZHR has been in past

--
With best regards, Alexander

[Marcos Cardinot (cardinot)]

> 2015-08-06 22:34 GMT+06:00 Marcos CARDINOT <email address hidden>:
>
> > > Detailed/Accurate/Particular?
> >
> > confirmed data?
> >
> > Alex, do you have any thought?
> >
>
> Historical data because all this ZHR has been in past

We need something more general, since some showers would also have forecasts (eg. 2016, 2017)

>
> --
> With best regards, Alexander

[gzotti (georg-zotti)]

But what if IMO gives a short-time prediction?

I think "Generic" vs. "Concrete" or "Confirmed" data might describes this best.

[Alexander Wolf (alexwolf)]

2015-08-06 23:20 GMT+06:00 gzotti <email address hidden>:

> But what if IMO gives a short-time prediction?
>

Not only IMO gives data for meteor showers.

>
> I think "Generic" vs. "Concrete" or "Confirmed" data might describes this
> best.
>

Historical/Predicted?

--
With best regards, Alexander

[Marcos Cardinot (cardinot)]

> 2015-08-06 23:20 GMT+06:00 gzotti <email address hidden>:
>
> > But what if IMO gives a short-time prediction?
> >
>
> Not only IMO gives data for meteor showers.

Yeah, but I guess that predictions are done/published only 1 or rarely 2 years before the event...

>
> >
> > I think "Generic" vs. "Concrete" or "Confirmed" data might describes this
> > best.
> >
>
> Historical/Predicted?

I don't know if "historical" is a good one, mainly because to see it the user will have to change the sky date - as in Stellarium we simulate the Sky based on the current time sets by the user, a historical shower would always be "actual" or "predicted" at some point...

Currently we use "Real data" and "Generic data" to differentiate the showers which were confirmed and the non-confirmed ones (generic).

Georg, so your vote goes to:
"Real data" -> "Confirmed data"
"Generic data" -> "Generic data"
OR
"Real data" -> "Concrete data"
"Generic data" -> "Generic data"

?

> --
> With best regards, Alexander

[gzotti (georg-zotti)]

On Do, 6.08.2015, 19:27, Alexander Wolf wrote:
> 2015-08-06 23:20 GMT+06:00 gzotti <email address hidden>:
>
>> But what if IMO gives a short-time prediction?
>>
>
> Not only IMO gives data for meteor showers.
>

Yes, we had that before. Just that "Historical" alone is not the solution
if there is accurately predicted data, be that by IMO or by other source.

>> I think "Generic" vs. "Concrete" or "Confirmed" data might describes
>> this
>> best.
>>
>
> Historical/Predicted?

Is string length available? Then OK, and close the case?

[gzotti (georg-zotti)]

My favorite would be
"Real data" -> "Concrete data"
"Generic data" -> "Generic data"

It says we have some gemeral idea when a shower should be, or better data for the year in question, be that predicted or as post-event information (like Leonids 1966 etc). But I am happy with other solutions as well, as long as it is clear from short documentation (About..., or tooltip) what it means.

[lp:~cardinot/stellarium/MeteorShower]

7813. By Marcos Cardinot on 2015-08-06

cosmetic fix - renames from 'real data' to 'confirmed data'

7814. By Marcos Cardinot on 2015-08-07

cosmetic fix - updates the about tab

7815. By Marcos Cardinot on 2015-08-07

merge with trunk

7816. By Marcos Cardinot on 2015-08-07

cosmetic fix - removing the html tags from the translatable strings

7817. By Marcos Cardinot on 2015-08-07

oops... don't use '+' with N_()

7818. By Marcos Cardinot on 2015-08-07

update pot files

[Marcos Cardinot (cardinot)]

so, any new comment? Can I merge it?

[Alexander Wolf (alexwolf)]

Marcos, I think management of buttons should be splitted - one checkbox for main button and one checkbox for search button.

[lp:~cardinot/stellarium/MeteorShower]

7819. By Marcos Cardinot on 2015-08-07

splits the visibility management of the buttons

7820. By Marcos Cardinot on 2015-08-07

fix signal&slot connection

[Marcos Cardinot (cardinot)]

> Marcos, I think management of buttons should be splitted - one checkbox for
> main button and one checkbox for search button.

Yeah, good catch - thanks ;)

done! =D

[Alexander Wolf (alexwolf)]

review: Approve

[gzotti (georg-zotti)]

I think it's fine!

review: Approve

=== modified file 'plugins/MeteorShowers/CMakeLists.txt'
--- plugins/MeteorShowers/CMakeLists.txt	2015-04-11 13:31:54 +0000
+++ plugins/MeteorShowers/CMakeLists.txt	2015-08-07 05:13:12 +0000
@@ -1,6 +1,6 @@
-SET(METEORSHOWERS_MAJOR "1")
+SET(METEORSHOWERS_MAJOR "2")
 SET(METEORSHOWERS_MINOR "0")
-SET(METEORSHOWERS_PATCH "1")
+SET(METEORSHOWERS_PATCH "0")
 SET(METEORSHOWERS_VERSION "${METEORSHOWERS_MAJOR}.${METEORSHOWERS_MINOR}.${METEORSHOWERS_PATCH}")
 
 IF(APPLE)

=== modified file 'plugins/MeteorShowers/resources/MeteorShower.qrc'
--- plugins/MeteorShowers/resources/MeteorShower.qrc	2015-04-22 02:34:10 +0000
+++ plugins/MeteorShowers/resources/MeteorShower.qrc	2015-08-07 05:13:12 +0000
@@ -4,5 +4,7 @@
         <file>radiant.png</file>
         <file>btMS-off.png</file>
         <file>btMS-on.png</file>
+        <file>btMS-search-on.png</file>
+        <file>btMS-search-off.png</file>
     </qresource>
 </RCC>

=== added file 'plugins/MeteorShowers/resources/btMS-search-off.png'
Binary files plugins/MeteorShowers/resources/btMS-search-off.png	1970-01-01 00:00:00 +0000 and plugins/MeteorShowers/resources/btMS-search-off.png	2015-08-07 05:13:12 +0000 differ
=== added file 'plugins/MeteorShowers/resources/btMS-search-on.png'
Binary files plugins/MeteorShowers/resources/btMS-search-on.png	1970-01-01 00:00:00 +0000 and plugins/MeteorShowers/resources/btMS-search-on.png	2015-08-07 05:13:12 +0000 differ
=== modified file 'plugins/MeteorShowers/src/CMakeLists.txt'
--- plugins/MeteorShowers/src/CMakeLists.txt	2014-03-10 13:17:28 +0000
+++ plugins/MeteorShowers/src/CMakeLists.txt	2015-08-07 05:13:12 +0000
@@ -12,14 +12,20 @@
     MeteorShower.cpp
     MeteorShowers.hpp
     MeteorShowers.cpp
-    MeteorStream.hpp
-    MeteorStream.cpp
-    gui/MeteorShowerDialog.hpp
-    gui/MeteorShowerDialog.cpp
+    MeteorShowersMgr.hpp
+    MeteorShowersMgr.cpp
+    MeteorObj.hpp
+    MeteorObj.cpp
+    gui/MSConfigDialog.hpp
+    gui/MSConfigDialog.cpp
+    gui/MSSearchDialog.hpp
+    gui/MSSearchDialog.cpp
+    translations.h
 )
 
 SET(MeteorShowersDialog_UIS
-    gui/meteorShowerDialog.ui
+    gui/MSConfigDialog.ui
+    gui/MSSearchDialog.ui
 )
 
 QT5_WRAP_UI(MeteorShowersDialog_UIS_H ${MeteorShowersDialog_UIS})

=== added file 'plugins/MeteorShowers/src/MeteorObj.cpp'
--- plugins/MeteorShowers/src/MeteorObj.cpp	1970-01-01 00:00:00 +0000
+++ plugins/MeteorShowers/src/MeteorObj.cpp	2015-08-07 05:13:12 +0000
@@ -0,0 +1,86 @@
+/*
+ * Stellarium: Meteor Showers Plug-in
+ * Copyright (C) 2013-2015 Marcos Cardinot
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+ */
+
+
+#include "MeteorObj.hpp"
+
+MeteorObj::MeteorObj(const StelCore* core, int speed, const float& radiantAlpha, const float& radiantDelta,
+		     const float& pidx, QList<Meteor::colorPair> colors, const StelTextureSP& bolideTexture)
+	: Meteor(core, bolideTexture)
+{
+	// if speed is zero, use a random value
+	if (!speed)
+	{
+		speed = 11 + (double)qrand() / ((double)RAND_MAX + 1) * 61;  // abs range 11-72 km/s
+	}
+
+	// determine the meteor color
+	if (colors.isEmpty()) {
+		colors.push_back(Meteor::colorPair("white", 100));
+	} else {
+		// handle cases when the total intensity is less than 100
+		int totalIntensity = 0;
+		int indexWhite = -1;
+		for (int i=0; i < colors.size(); ++i) {
+			totalIntensity += colors.at(i).second;
+			if (colors.at(i).first == "white") {
+				indexWhite = i;
+			}
+		}
+
+		int increaseWhite = 0;
+		if (totalIntensity > 100) {
+			qWarning() << "MeteorShowers plugin (showers.json): Total intensity must be less than 100";
+			colors.clear();
+			colors.push_back(Meteor::colorPair("white", 100));
+		} else {
+			increaseWhite = 100 - totalIntensity;
+		}
+
+		if (increaseWhite > 0) {
+			if (indexWhite == -1) {
+				colors.push_back(Meteor::colorPair("white", increaseWhite));
+			} else {
+				colors[indexWhite].second = increaseWhite;
+			}
+		}
+	}
+
+	// building meteor model
+	init(radiantAlpha, radiantDelta, speed, colors);
+
+	if (!isAlive())
+	{
+		return;
+	}
+
+	// implements the population index
+	float oneMag = -0.2; // negative, working in different scale ( 0 to 1 - where 1 is brighter)
+	if (pidx) // is not zero
+	{
+		if (qrand()%100 < 100.f/pidx) // probability
+		{
+			setAbsMag(absMag() + oneMag);  // (m+1)
+		}
+	}
+}
+
+MeteorObj::~MeteorObj()
+{
+}

=== added file 'plugins/MeteorShowers/src/MeteorObj.hpp'
--- plugins/MeteorShowers/src/MeteorObj.hpp	1970-01-01 00:00:00 +0000
+++ plugins/MeteorShowers/src/MeteorObj.hpp	2015-08-07 05:13:12 +0000
@@ -0,0 +1,46 @@
+/*
+ * Stellarium: Meteor Showers Plug-in
+ * Copyright (C) 2013-2015 Marcos Cardinot
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+ */
+
+#ifndef _METEOROBJ_HPP_
+#define _METEOROBJ_HPP_
+
+#include "Meteor.hpp"
+#include "StelCore.hpp"
+
+//! @class MeteorObj
+//! Models a single meteor.
+//! @author Marcos Cardinot <[e-mail]>
+//! @ingroup meteorShowers
+class MeteorObj : public Meteor
+{
+public:
+	//! Create a Meteor object.
+	//! @param core StelCore instance.
+	//! @param speed Meteor speed in km/s.
+	//! @param radiantAlpha The radiant alpha in rad.
+	//! @param radiantDelta The radiant delta in rad.
+	//! @param pidx Population index.
+	//! @param colors Meteor color.
+	//! @param bolideTexture Bolide texture.
+	MeteorObj(const StelCore*, int speed, const float& radiantAlpha, const float& radiantDelta,
+		  const float& pidx, QList<Meteor::colorPair> colors, const StelTextureSP& bolideTexture);
+	virtual ~MeteorObj();
+};
+
+#endif // _METEOROBJ_HPP_

=== modified file 'plugins/MeteorShowers/src/MeteorShower.cpp'
--- plugins/MeteorShowers/src/MeteorShower.cpp	2015-08-03 13:17:06 +0000
+++ plugins/MeteorShowers/src/MeteorShower.cpp	2015-08-07 05:13:12 +0000
@@ -1,7 +1,6 @@
 /*
  * Stellarium: Meteor Showers Plug-in
- * Copyright (C) 2013 Marcos Cardinot
- * Copyright (C) 2011 Alexander Wolf
+ * Copyright (C) 2013-2015 Marcos Cardinot
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -18,60 +17,145 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
+#include <QtMath>
+
+#include "LandscapeMgr.hpp"
 #include "MeteorShower.hpp"
 #include "MeteorShowers.hpp"
+#include "SporadicMeteorMgr.hpp"
 #include "StelApp.hpp"
 #include "StelCore.hpp"
 #include "StelModuleMgr.hpp"
+#include "StelObjectMgr.hpp"
 #include "StelTexture.hpp"
 #include "StelUtils.hpp"
 
-StelTextureSP MeteorShower::radiantTexture;
-bool MeteorShower::showLabels = true;
-bool MeteorShower::radiantMarkerEnabled = true;
-bool MeteorShower::showActiveRadiantsOnly = true;
-
-MeteorShower::MeteorShower(const QVariantMap& map)
-	: initialized(false)
-	, active(false)
-	, speed(0)
-	, rAlphaPeak(0)
-	, rDeltaPeak(0)
-	, driftAlpha(0)
-	, driftDelta(0)
-	, pidx(0)
-	, radiantAlpha(0)
-	, radiantDelta(0)
-	, zhr(0)
-	, status(0)
+MeteorShower::MeteorShower(MeteorShowersMgr* mgr, const QVariantMap& map)
+	: m_mgr(mgr)
+	, m_status(INVALID)
+	, m_speed(0)
+	, m_rAlphaPeak(0)
+	, m_rDeltaPeak(0)
+	, m_driftAlpha(0)
+	, m_driftDelta(0)
+	, m_pidx(0)
+	, m_radiantAlpha(0)
+	, m_radiantDelta(0)
 {
 	// return initialized if the mandatory fields are not present
-	if(!map.contains("showerID"))
+	if(!map.contains("showerID") || !map.contains("activity")
+		|| !map.contains("radiantAlpha") || !map.contains("radiantDelta"))
+	{
+		qWarning() << "MeteorShower: INVALID meteor shower!" << map.value("showerID").toString();
+		qWarning() << "MeteorShower: Please, check your 'showers.json' catalog!";
 		return;
-
-	showerID = map.value("showerID").toString();
-	designation  = map.value("designation").toString();
-	speed = map.value("speed").toInt();
-	rAlphaPeak = radiantAlpha = StelUtils::getDecAngle(map.value("radiantAlpha").toString());
-	rDeltaPeak = radiantDelta = StelUtils::getDecAngle(map.value("radiantDelta").toString());
-	driftAlpha = StelUtils::getDecAngle(map.value("driftAlpha").toString());
-	driftDelta = StelUtils::getDecAngle(map.value("driftDelta").toString());
-	parentObj = map.value("parentObj").toString();
-	pidx = map.value("pidx").toFloat();
-
-	if(map.contains("activity"))
-	{
-		foreach(const QVariant &ms, map.value("activity").toList())
-		{
-			QVariantMap activityMap = ms.toMap();
-			activityData d;
-			d.year = activityMap.value("year").toString();
-			d.zhr = activityMap.value("zhr").toInt();
-			d.variable = activityMap.value("variable").toString();
-			d.peak = activityMap.value("peak").toString();
-			d.start = activityMap.value("start").toString();
-			d.finish = activityMap.value("finish").toString();
-			activity.append(d);
+	}
+
+	m_showerID = map.value("showerID").toString();
+	m_designation  = map.value("designation").toString();
+	m_speed = map.value("speed").toInt();
+	m_radiantAlpha = StelUtils::getDecAngle(map.value("radiantAlpha").toString());
+	m_radiantDelta = StelUtils::getDecAngle(map.value("radiantDelta").toString());
+	m_parentObj = map.value("parentObj").toString();
+	m_pidx = map.value("pidx").toFloat();
+
+	// the catalog (IMO) will give us the drift for a five-day interval from peak
+	m_driftAlpha = StelUtils::getDecAngle(map.value("driftAlpha").toString()) / 5.f;
+	m_driftDelta = StelUtils::getDecAngle(map.value("driftDelta").toString()) / 5.f;
+
+	m_rAlphaPeak = m_radiantAlpha;
+	m_rDeltaPeak = m_radiantDelta;
+
+	int genericYear = 1000;
+
+	// build the activity list
+	QList<QVariant> activities = map.value("activity").toList();
+	foreach(const QVariant &ms, activities)
+	{
+		QVariantMap activityMap = ms.toMap();
+		Activity d;
+		d.zhr = activityMap.value("zhr").toInt();
+
+		//
+		// 'variable'field
+		//
+		QStringList variable = activityMap.value("variable").toString().split("-");
+		if (d.zhr == -1) // is variable
+		{
+			bool ok = variable.size() == 2;
+			for (int i=0; i < 2 && ok; i++)
+			{
+				d.variable.append(variable.at(i).toInt(&ok));
+			}
+
+			if (!ok)
+			{
+				qWarning() << "MeteorShower: INVALID data for " << m_showerID;
+				qWarning() << "MeteorShower: Please, check your 'showers.json' catalog!";
+				return;
+			}
+		}
+
+		//
+		// 'start', 'finish' and 'peak' fields
+		//
+		d.year = activityMap.value("year").toInt();
+		QString year = QString::number(d.year == 0 ? genericYear : d.year);
+
+		QString start = activityMap.value("start").toString();
+		start = start.isEmpty() ? "" : start + " " + year;
+		d.start = QDate::fromString(start, "MM.dd yyyy");
+
+		QString finish = activityMap.value("finish").toString();
+		finish = finish.isEmpty() ? "" : finish + " " + year;
+		d.finish = QDate::fromString(finish, "MM.dd yyyy");
+
+		QString peak = activityMap.value("peak").toString();
+		peak = peak.isEmpty() ? "" : peak + " " + year;
+		d.peak = QDate::fromString(peak, "MM.dd yyyy");
+
+		if (d.start.isValid() && d.finish.isValid() && d.peak.isValid())
+		{
+			// Fix the 'finish' year! Handling cases when the shower starts on
+			// the current year and ends on the next year!
+			if(d.start.operator >(d.finish))
+			{
+				d.finish = d.finish.addYears(1);
+			}
+			// Fix the 'peak' year
+			if(d.start.operator >(d.peak))
+			{
+				d.peak = d.peak.addYears(1);
+			}
+		}
+
+		m_activities.append(d);
+	}
+
+	// filling null values of the activity list with generic data
+	const Activity& g = m_activities.at(0);
+	const int activitiesSize = m_activities.size();
+	for (int i = 1; i < activitiesSize; ++i)
+	{
+		Activity a = m_activities.at(i);
+		if (a.zhr == 0)
+		{
+			a.zhr = g.zhr;
+			a.variable = g.variable;
+		}
+
+		int aux = a.year - genericYear;
+		a.start = a.start.isValid() ? a.start : g.start.addYears(aux);
+		a.finish = a.finish.isValid() ? a.finish : g.finish.addYears(aux);
+		a.peak = a.peak.isValid() ? a.peak : g.peak.addYears(aux);
+		m_activities.replace(i, a);
+
+		if (!a.start.isValid() || !a.finish.isValid() || !a.peak.isValid())
+		{
+			qWarning() << "MeteorShower: INVALID data for "
+				   << m_showerID << "Unable to read some dates!";
+			qWarning() << "MeteorShower: Please, check your 'showers.json' catalog!";
+			return;
 		}
 	}
 
@@ -82,258 +166,345 @@
 			QVariantMap colorMap = ms.toMap();
 			QString color = colorMap.value("color").toString();
 			int intensity = colorMap.value("intensity").toInt();
-			colors.append(colorPair(color, intensity));
+			m_colors.append(Meteor::colorPair(color, intensity));
 		}
 	}
 
-	updateCurrentData(getSkyQDateTime());
-	// ensures that all objects will be drawn once
-	// that's to avoid crashes by trying select a nonexistent object
-	StelPainter painter(StelApp::getInstance().getCore()->getProjection(StelCore::FrameJ2000));
-	draw(painter);
+	m_status = UNDEFINED;
 
 	qsrand(QDateTime::currentMSecsSinceEpoch());
-
-	initialized = true;
 }
 
 MeteorShower::~MeteorShower()
 {
-	//
-}
-
-QVariantMap MeteorShower::getMap(void)
-{
-	QVariantMap map;
-	map["showerID"] = showerID;
-	map["designation"] = designation;
-	map["speed"] = speed;
-	map["radiantAlpha"] = rAlphaPeak;
-	map["radiantDelta"] = rDeltaPeak;
-	map["driftAlpha"] = driftAlpha;
-	map["driftDelta"] = driftDelta;
-	map["parentObj"] = parentObj;
-	map["pidx"] = pidx;
-
-	QVariantList activityList;
-	foreach(const activityData &p, activity)
-	{
-		QVariantMap activityMap;
-		activityMap["year"] = p.year;
-		activityMap["zhr"] = p.zhr;
-		activityMap["variable"] = p.variable;
-		activityMap["start"] = p.start;
-		activityMap["finish"] = p.finish;
-		activityMap["peak"] = p.peak;
-		activityList << activityMap;
-	}
-	map["activity"] = activityList;
-
-	QVariantList colorList;
-	foreach(const colorPair &c, colors)
-	{
-		QVariantMap colorMap;
-		colorMap["color"] = c.first;
-		colorMap["intensity"] = c.second;
-		colorList << colorMap;
-	}
-	map["colors"] = colorList;
-
-	return map;
-}
-
-float MeteorShower::getSelectPriority(const StelCore*) const
-{
-	return -4.0;
-}
-
-QString MeteorShower::getDesignation() const
-{
-	if (showerID.toInt()) // if showerID is a number
-	{
-		return "";
-	}
-	return showerID;
-}
-
-QString MeteorShower::getDateFromJSON(QString jsondate) const
-{
-	QStringList parsedDate = jsondate.split(".");
-
-	return QString("%1 %2").arg(parsedDate.at(1).toInt()).arg(getMonthName(parsedDate.at(0).toInt()));
-}
-
-QString MeteorShower::getDayFromJSON(QString jsondate) const
-{
-	QStringList parsedDate = jsondate.split(".");
-
-	return QString("%1").arg(parsedDate.at(1).toInt());
-}
-
-int MeteorShower::getMonthFromJSON(QString jsondate) const
-{
-	QStringList parsedDate = jsondate.split(".");
-
-	return parsedDate.at(0).toInt();
-}
-
-QString MeteorShower::getMonthNameFromJSON(QString jsondate) const
-{
-	QStringList parsedDate = jsondate.split(".");
-
-	return QString("%1").arg(getMonthName(parsedDate.at(0).toInt()));
-}
-
-QString MeteorShower::getMonthName(int number) const
-{
-	QStringList monthList;
-	monthList.append(N_("January"));
-	monthList.append(N_("February"));
-	monthList.append(N_("March"));
-	monthList.append(N_("April"));
-	monthList.append(N_("May"));
-	monthList.append(N_("June"));
-	monthList.append(N_("July"));
-	monthList.append(N_("August"));
-	monthList.append(N_("September"));
-	monthList.append(N_("October"));
-	monthList.append(N_("November"));
-	monthList.append(N_("December"));
-
-	return q_(monthList.at(number-1));
-}
-
-QDateTime MeteorShower::getSkyQDateTime() const
-{
-	StelCore* core = StelApp::getInstance().getCore();
-	//get the current sky date (zone time)
-	double JD = core->getJD();
-	return StelUtils::jdToQDateTime(JD+ StelUtils::getGMTShiftFromQT(JD)/24);
-}
-
-void MeteorShower::updateCurrentData(QDateTime skyDate)
-{
-	//Check if we have real data for the current sky year
-	int index = searchRealData(skyDate.toString("yyyy"));
-
-	/**************************
-	 *ZHR info
-	 **************************/
-	zhr = activity[index].zhr == 0 ? activity[0].zhr : activity[index].zhr;
-
-	if (zhr == -1)
-		variable = activity[index].variable.isEmpty() ? activity[0].variable : activity[index].variable;
-	else
-		variable = "";
-
-	/***************************
-	 *Dates - start/finish/peak
-	 ***************************/
-	QString dateStart = activity[index].start.isEmpty() ? activity[0].start : activity[index].start;
-	QString dateFinish = activity[index].finish.isEmpty() ? activity[0].finish : activity[index].finish;
-	QString datePeak = activity[index].peak.isEmpty() ? activity[0].peak : activity[index].peak;
-	QString yearBase = activity[index].year == "generic" ? skyDate.toString("yyyy") : activity[index].year;
-	QString yearS, yearF;
-
-	int monthStart = getMonthFromJSON(dateStart);
-	int monthFinish = getMonthFromJSON(dateFinish);
-
-	if(monthStart > monthFinish)
-	{
-		if(monthStart == skyDate.toString("MM").toInt())
-		{
-			yearS = yearBase;
-			yearF = QString("%1").arg(yearBase.toInt() + 1);
-		}
-		else
-		{
-			yearS = QString("%1").arg(yearBase.toInt() - 1);
-			yearF = yearBase;
-		}
-	}
-	else
-	{
-		yearS = yearF = yearBase;
-	}
-
-	start = QDateTime::fromString(dateStart + " " + yearS, "MM.dd yyyy");
-	finish = QDateTime::fromString(dateFinish + " " + yearF, "MM.dd yyyy");
-	peak = QDateTime::fromString(datePeak + " " + yearS, "MM.dd yyyy");
-
-	if (peak.operator <(start) || peak.operator >(finish))
-		peak = QDateTime::fromString(datePeak + " " + yearF, "MM.dd yyyy");
-
-	/***************************
-	 *Activity - is active?
-	 ***************************/
-	if(skyDate.operator >=(start) && skyDate.operator <=(finish))
-	{
-		if(index)
-			status = ACTIVE_REAL; // real data
-		else
-			status = ACTIVE_GENERIC; // generic data
-	}
-	else
-	{
-		status = INACTIVE; // isn't active
-	}
-	active = (status != INACTIVE) || !showActiveRadiantsOnly;
-
-	/**************************
-	 *Radiant drift
-	 *************************/
-	radiantAlpha = rAlphaPeak;
-	radiantDelta = rDeltaPeak;
-
-	if (status != INACTIVE)
-	{
-		double time = (StelUtils::qDateTimeToJd(skyDate) - StelUtils::qDateTimeToJd(peak))*24;
-		radiantAlpha += (driftAlpha/120)*time;
-		radiantDelta += (driftDelta/120)*time;
-	}
-}
-
-int MeteorShower::searchRealData(QString yyyy) const
-{
-	int index = -1;
-	foreach(const activityData &p, activity)
-	{
-		index++;
-		if(p.year == yyyy)
-			return index;
-	}
-
-	return 0;
-}
-
-float MeteorShower::getSolarLongitude(QDateTime QDT) const
+	qDeleteAll(m_activeMeteors);
+	m_activeMeteors.clear();
+}
+
+bool MeteorShower::enabled() const
+{
+	if (m_status == INVALID)
+	{
+		return false;
+	}
+	else if (m_status == UNDEFINED)
+	{
+		return true;
+	}
+	else if (m_mgr->getActiveRadiantOnly())
+	{
+		return m_status == ACTIVE_GENERIC || m_status == ACTIVE_CONFIRMED;
+	}
+	else
+	{
+		return true;
+	}
+}
+
+void MeteorShower::update(StelCore* core, double deltaTime)
+{
+	if (m_status == INVALID)
+	{
+		return;
+	}
+
+	// gets the current UTC date
+	double currentJD = core->getJD();
+	QDate currentDate = QDate::fromJulianDay(currentJD);
+
+	// updating status and activity
+	bool found = false;
+	m_status = INACTIVE;
+	m_activity = hasConfirmedShower(currentDate, found);
+	if (found)
+	{
+		m_status = ACTIVE_CONFIRMED;
+	}
+	else
+	{
+		m_activity = hasGenericShower(currentDate, found);
+		if (found)
+		{
+			m_status = ACTIVE_GENERIC;
+		}
+	}
+
+	// will be displayed?
+	if (!enabled())
+	{
+		return;
+	}
+
+	// fix the radiant position (considering drift)
+	m_radiantAlpha = m_rAlphaPeak;
+	m_radiantDelta = m_rDeltaPeak;
+	if (m_status != INACTIVE)
+	{
+		double daysToPeak = currentJD - m_activity.peak.toJulianDay();
+		m_radiantAlpha += m_driftAlpha * daysToPeak;
+		m_radiantDelta += m_driftDelta * daysToPeak;
+	}
+
+	// step through and update all active meteors
+	foreach (MeteorObj* m, m_activeMeteors)
+	{
+		if (!m->update(deltaTime))
+		{
+			m_activeMeteors.removeOne(m);
+		}
+	}
+
+	// going forward or backward ?
+	// don't create new meteors
+	if(!core->getRealTimeSpeed())
+	{
+		return;
+	}
+
+	// calculates a ZHR for the current date
+	int currentZHR = calculateZHR(currentJD);
+	if (currentZHR < 1)
+	{
+		return;
+	}
+
+	// average meteors per frame
+	float mpf = currentZHR * deltaTime / 3600.f;
+
+	// maximum amount of meteors for the current frame
+	int maxMpf = qRound(mpf);
+	maxMpf = maxMpf < 1 ? 1 : maxMpf;
+
+	float rate = mpf / (float) maxMpf;
+	for (int i = 0; i < maxMpf; ++i)
+	{
+		float prob = (float) qrand() / (float) RAND_MAX;
+		if (prob < rate)
+		{
+			MeteorObj *m = new MeteorObj(core, m_speed, m_radiantAlpha, m_radiantDelta,
+						     m_pidx, m_colors, m_mgr->getBolideTexture());
+			m_activeMeteors.append(m);
+		}
+	}
+}
+
+void MeteorShower::draw(StelCore* core)
+{
+	if (!enabled())
+	{
+		return;
+	}
+	drawRadiant(core);
+	drawMeteors(core);
+}
+
+void MeteorShower::drawRadiant(StelCore *core)
+{
+	StelPainter painter(core->getProjection(StelCore::FrameJ2000));
+
+	Vec3d XY;
+	StelUtils::spheToRect(m_radiantAlpha, m_radiantDelta, m_position);
+	painter.getProjector()->project(m_position, XY);
+
+	glEnable(GL_TEXTURE_2D);
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+
+	Vec3f rgb;
+	float alpha = 0.85f + ((float) qrand() / (float) RAND_MAX) / 10.f;
+	switch(m_status)
+	{
+		case ACTIVE_CONFIRMED: //Active, confirmed data
+			rgb = m_mgr->getColorARC();
+			break;
+		case ACTIVE_GENERIC: //Active, generic data
+			rgb = m_mgr->getColorARG();
+			break;
+		default: //Inactive
+			rgb = m_mgr->getColorIR();
+	}
+	rgb /= 255.f;
+	painter.setColor(rgb[0], rgb[1], rgb[2], alpha);
+
+	Vec3d win;
+	if (m_mgr->getEnableMarker() && painter.getProjector()->projectCheck(m_position, win))
+	{
+		m_mgr->getRadiantTexture()->bind();
+		painter.drawSprite2dMode(XY[0], XY[1], 45);
+
+		if (m_mgr->getEnableLabels())
+		{
+			painter.setFont(m_mgr->getFont());
+			float size = getAngularSize(NULL)*M_PI/180.*painter.getProjector()->getPixelPerRadAtCenter();
+			float shift = 8.f + size/1.8f;
+			painter.drawText(XY[0]+shift, XY[1]+shift, getNameI18n(), 0, 0, 0, false);
+		}
+	}
+}
+
+void MeteorShower::drawMeteors(StelCore *core)
+{
+	if (!core->getSkyDrawer()->getFlagHasAtmosphere())
+	{
+		return;
+	}
+
+	LandscapeMgr* landmgr = GETSTELMODULE(LandscapeMgr);
+	if (landmgr->getFlagAtmosphere() && landmgr->getLuminance() > 5.f)
+	{
+		return;
+	}
+
+	// step through and draw all active meteors
+	StelPainter painter(core->getProjection(StelCore::FrameAltAz));
+	foreach (MeteorObj* m, m_activeMeteors)
+	{
+		m->draw(core, painter);
+	}
+}
+
+MeteorShower::Activity MeteorShower::hasGenericShower(QDate date, bool &found) const
+{
+	int year = date.year();
+	Activity g = m_activities.at(0);
+	bool peakOnStart = g.peak.year() == g.start.year(); // 'peak' and 'start' on the same year ?
+
+	//Fix the 'generic years'!
+	// Handling cases when the shower starts on the current year and
+	// ends on the next year; or when it started on the last year...
+	if (g.start.year() != g.finish.year()) // edge case?
+	{
+		// trying the current year with the next year
+		g.start.setDate(year, g.start.month(), g.start.day());
+		g.finish.setDate(year + 1, g.finish.month(), g.finish.day());
+		found = date.operator >=(g.start) && date.operator <=(g.finish);
+
+		if (!found)
+		{
+			// trying the last year with the current year
+			g.start.setDate(year - 1, g.start.month(), g.start.day());
+			g.finish.setDate(year, g.finish.month(), g.finish.day());
+			found = date.operator >=(g.start) && date.operator <=(g.finish);
+		}
+	}
+	else
+	{
+		g.start.setDate(year, g.start.month(), g.start.day());
+		g.finish.setDate(year, g.finish.month(), g.finish.day());
+		found = date.operator >=(g.start) && date.operator <=(g.finish);
+	}
+
+	if (found)
+	{
+		g.year = g.start.year();
+		g.peak.setDate(peakOnStart ? g.start.year() : g.finish.year(),
+			       g.peak.month(),
+			       g.peak.day());
+		return g;
+	}
+	return Activity();
+}
+
+MeteorShower::Activity MeteorShower::hasConfirmedShower(QDate date, bool& found) const
+{
+	const int activitiesSize = m_activities.size();
+	for (int i = 1; i < activitiesSize; ++i)
+	{
+		const Activity& a = m_activities.at(i);
+		if (date.operator >=(a.start) && date.operator <=(a.finish))
+		{
+			found = true;
+			return a;
+		}
+	}
+	return Activity();
+}
+
+int MeteorShower::calculateZHR(const double& currentJD)
+{
+	double startJD = m_activity.start.toJulianDay();
+	double finishJD = m_activity.finish.toJulianDay();
+	double peakJD = m_activity.peak.toJulianDay();
+
+	float sd; //standard deviation
+	if (currentJD >= startJD && currentJD < peakJD) //left side of gaussian
+	{
+		sd = (peakJD - startJD) / 2.f;
+	}
+	else
+	{
+		sd = (finishJD - peakJD) / 2.f;
+	}
+
+	float maxZHR = m_activity.zhr == -1 ? m_activity.variable.at(1) : m_activity.zhr;
+	float minZHR = m_activity.zhr == -1 ? m_activity.variable.at(0) : 0;
+
+	float gaussian = maxZHR * qExp( - qPow(currentJD - peakJD, 2) / (sd * sd) ) + minZHR;
+
+	return qRound(gaussian);
+}
+
+QString MeteorShower::getSolarLongitude(QDate date) const
 {
 	//The number of days (positive or negative) since Greenwich noon,
 	//Terrestrial Time, on 1 January 2000 (J2000.0)
-	double n = StelUtils::qDateTimeToJd(QDT) - 2451545.0;
+	double n = date.toJulianDay() - 2451545.0;
 
 	//The mean longitude of the Sun, corrected for the aberration of light
-	float slong = (280.460 + 0.9856474*n) / 360;
-	slong = (slong - (int) slong) * 360 - 1;
-
-	return slong;
+	float l = 280.460 + 0.9856474 * n;
+
+	// put it in the range 0 to 360 degrees
+	l /= 360.f;
+	l = (l - (int) l) * 360.f - 1.f;
+
+	return QString::number(l, 'f', 2);
+}
+
+QString MeteorShower::getDesignation() const
+{
+	if (m_showerID.toInt()) // if showerID is a number
+	{
+		return "";
+	}
+	return m_showerID;
+}
+
+Vec3f MeteorShower::getInfoColor(void) const
+{
+	return StelApp::getInstance().getVisionModeNight() ? Vec3f(0.6, 0.0, 0.0) : Vec3f(1.0, 1.0, 1.0);
 }
 
 QString MeteorShower::getInfoString(const StelCore* core, const InfoStringGroup& flags) const
 {
+	if (!enabled())
+	{
+		GETSTELMODULE(StelObjectMgr)->unSelect();
+		return "";
+	}
+
 	QString str;
 	QTextStream oss(&str);
 
-	QString mstdata = q_("generic data");
-	if(status == ACTIVE_REAL)
-		mstdata = q_("real data");
+	QString mstdata;
+	if (m_status == ACTIVE_GENERIC)
+	{
+		mstdata = q_("generic data");
+	}
+	else if (m_status == ACTIVE_CONFIRMED)
+	{
+		mstdata = q_("confirmed data");
+	}
+	else if (m_status == INACTIVE)
+	{
+		mstdata = q_("inactive");
+	}
 
 	if(flags&Name)
 	{
 		oss << "<h2>" << getNameI18n();
-		if (!showerID.toInt())
+		if (!m_showerID.toInt())
 		{
-			oss << " (" << showerID  <<")</h2>";
+			oss << " (" << m_showerID  <<")</h2>";
 		}
 		else
 		{
@@ -353,59 +524,64 @@
 	{
 		oss << QString("%1: %2/%3")
 			.arg(q_("Radiant drift (per day)"))
-			.arg(StelUtils::radToHmsStr(driftAlpha/5))
-			.arg(StelUtils::radToDmsStr(driftDelta/5));
-		oss << "<br />";
-
-		if (speed>0)
-		{
-			oss << q_("Geocentric meteoric velocity: %1 km/s").arg(speed) << "<br />";
-		}
-
-		if(pidx>0)
-		{
-			oss << q_("The population index: %1").arg(pidx) << "<br />";
-		}
-
-		if(!parentObj.isEmpty())
-		{
-			oss << q_("Parent body: %1").arg(q_(parentObj)) << "<br />";
-		}
-
-		if(start.toString("M") == finish.toString("M"))
-		{
-			oss << QString("%1: %2 - %3 %4")
-			       .arg(q_("Active"))
-			       .arg(start.toString("d"))
-			       .arg(finish.toString("d"))
-			       .arg(start.toString("MMMM"));
-		}
-		else
-		{
-			oss << QString("%1: %2 - %3")
-			       .arg(q_("Activity"))
-			       .arg(start.toString("d MMMM"))
-			       .arg(finish.toString("d MMMM"));
-		}
-		oss << "<br />";
-		oss << q_("Maximum: %1").arg(peak.toString("d MMMM"));
-
-		QString slong = QString::number( MeteorShower::getSolarLongitude(peak), 'f', 2 );
-		oss << QString(" (%1 %2&deg;)").arg(q_("Solar longitude is")).arg(slong);
-		oss << "<br />";
-
-		if(zhr>0)
-		{
-			oss << QString("ZHR<sub>max</sub>: %1").arg(zhr) << "<br />";
-		}
-		else
-		{
-			oss << QString("ZHR<sub>max</sub>: %1").arg(q_("variable"));
-			if(!variable.isEmpty())
-			{
-				oss << "; " << variable;
-			}
-			oss << "<br />";
+			.arg(StelUtils::radToHmsStr(m_driftAlpha))
+			.arg(StelUtils::radToDmsStr(m_driftDelta));
+		oss << "<br />";
+
+		if (m_speed > 0)
+		{
+			oss << q_("Geocentric meteoric velocity: %1 km/s").arg(m_speed) << "<br />";
+		}
+
+		if(m_pidx > 0)
+		{
+			oss << q_("The population index: %1").arg(m_pidx) << "<br />";
+		}
+
+		if(!m_parentObj.isEmpty())
+		{
+			oss << q_("Parent body: %1").arg(q_(m_parentObj)) << "<br />";
+		}
+
+		// activity info
+		if (m_status != INACTIVE)
+		{
+			if(m_activity.start.month() == m_activity.finish.month())
+			{
+				oss << QString("%1: %2 - %3 %4")
+				       .arg(q_("Active"))
+				       .arg(m_activity.start.day())
+				       .arg(m_activity.finish.day())
+				       .arg(m_activity.start.toString("MMMM"));
+			}
+			else
+			{
+				oss << QString("%1: %2 - %3")
+				       .arg(q_("Activity"))
+				       .arg(m_activity.start.toString("d MMMM"))
+				       .arg(m_activity.finish.toString("d MMMM"));
+			}
+			oss << "<br />";
+			oss << q_("Maximum: %1").arg(m_activity.peak.toString("d MMMM"));
+
+			oss << QString(" (%1 %2&deg;)").arg(q_("Solar longitude"))
+			       .arg(getSolarLongitude(m_activity.peak));
+			oss << "<br />";
+
+			if(m_activity.zhr > 0)
+			{
+				oss << QString("ZHR<sub>max</sub>: %1").arg(m_activity.zhr) << "<br />";
+			}
+			else
+			{
+				oss << QString("ZHR<sub>max</sub>: %1").arg(q_("variable"));
+				if(m_activity.variable.size() == 2)
+				{
+					oss << QString("; %1-%2").arg(m_activity.variable.at(0))
+					       .arg(m_activity.variable.at(1));
+				}
+				oss << "<br />";
+			}
 		}
 	}
 
@@ -413,58 +589,3 @@
 
 	return str;
 }
-
-Vec3f MeteorShower::getInfoColor(void) const
-{
-	return StelApp::getInstance().getVisionModeNight() ? Vec3f(0.6, 0.0, 0.0) : Vec3f(1.0, 1.0, 1.0);
-}
-
-double MeteorShower::getAngularSize(const StelCore*) const
-{
-	return 0.001;
-}
-
-void MeteorShower::update(double deltaTime)
-{
-	labelsFader.update((int)(deltaTime*1000));
-	updateCurrentData(getSkyQDateTime());
-}
-
-void MeteorShower::draw(StelPainter &painter)
-{
-	StelUtils::spheToRect(radiantAlpha, radiantDelta, XYZ);
-	painter.getProjector()->project(XYZ, XY);
-
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-
-	qreal r, g, b;
-	float alpha = 0.85f + ((double) qrand() / (RAND_MAX))/10;
-	switch(status)
-	{
-		case ACTIVE_REAL: //Active, real data
-			GETSTELMODULE(MeteorShowers)->getColorARR().getRgbF(&r,&g,&b);
-			break;
-		case ACTIVE_GENERIC: //Active, generic data
-			GETSTELMODULE(MeteorShowers)->getColorARG().getRgbF(&r,&g,&b);
-			break;
-		default: //Inactive
-			GETSTELMODULE(MeteorShowers)->getColorIR().getRgbF(&r,&g,&b);
-	}
-
-	painter.setColor(r, g, b, alpha);
-
-	Vec3d win;
-	if (MeteorShower::radiantMarkerEnabled && painter.getProjector()->projectCheck(XYZ, win))
-	{
-		MeteorShower::radiantTexture->bind();
-		painter.drawSprite2dMode(XY[0], XY[1], 45);
-
-		if (MeteorShower::showLabels)
-		{
-			float size = getAngularSize(NULL)*M_PI/180.*painter.getProjector()->getPixelPerRadAtCenter();
-			float shift = 8.f + size/1.8f;
-			painter.drawText(XY[0]+shift, XY[1]+shift, getNameI18n(), 0, 0, 0, false);
-		}
-	}
-}

=== modified file 'plugins/MeteorShowers/src/MeteorShower.hpp'
--- plugins/MeteorShowers/src/MeteorShower.hpp	2015-05-30 19:56:47 +0000
+++ plugins/MeteorShowers/src/MeteorShower.hpp	2015-08-07 05:13:12 +0000
@@ -1,7 +1,6 @@
 /*
  * Stellarium: Meteor Showers Plug-in
- * Copyright (C) 2013 Marcos Cardinot
- * Copyright (C) 2011 Alexander Wolf
+ * Copyright (C) 2013-2015 Marcos Cardinot
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -21,8 +20,8 @@
 #ifndef _METEORSHOWER_HPP_
 #define _METEORSHOWER_HPP_
 
-#include <QDateTime>
-
+#include "MeteorObj.hpp"
+#include "MeteorShowersMgr.hpp"
 #include "StelFader.hpp"
 #include "StelObject.hpp"
 #include "StelPainter.hpp"
@@ -37,160 +36,122 @@
 
 class MeteorShower : public StelObject
 {
-	friend class MeteorShowers;
-
 public:
-	enum RadiantStatus {
-		INACTIVE,        // inactive radiant.
-		ACTIVE_REAL,     // active radiant - real data.
-		ACTIVE_GENERIC   // active radiant - generic data.
+	//! @enum Meteor Shower status.
+	enum Status {
+		INVALID,          // not initialized properly
+		UNDEFINED,        // it's loaded but with 'activity' undefined
+		INACTIVE,         // inactive radiant
+		ACTIVE_CONFIRMED, // active radiant - confirmed data
+		ACTIVE_GENERIC    // active radiant - generic data
 	};
 
-	//! @param id The official ID designation for a meteor shower, e.g. "LYR"
-	MeteorShower(const QVariantMap& map);
+	//! @struct Activity
+	typedef struct
+	{
+		int year;                  //! The catalog year (0 for generic)
+		int zhr;                   //! The ZHR on peak
+		QList<int> variable;       //! The ZHR range when it's variable
+		QDate start;               //! Initial date of activity
+		QDate finish;              //! Last date of activity
+		QDate peak;                //! Peak activity
+	} Activity;
+
+	//! Constructor
+	//! @param map QVariantMap containing all the data about a Meteor Shower.
+	MeteorShower(MeteorShowersMgr* mgr, const QVariantMap& map);
+
+	//! Destructor
 	~MeteorShower();
 
-	//! Get a QVariantMap which describes the meteor shower. Could be used to
-	//! create a duplicate.
-	QVariantMap getMap(void);
-
-	virtual QString getType(void) const
-	{
-		return "MeteorShower";
-	}
-	virtual float getSelectPriority(const StelCore* core) const;
-
-	//! Get an HTML string to describe the object
-	//! @param core A pointer to the core
-	//! @flags a set of flags with information types to include.
+	//! Update
+	//! @param deltaTime the time increment in seconds since the last call.
+	void update(StelCore *core, double deltaTime);
+
+	//! Draw
+	void draw(StelCore *core);
+
+	//! Checks if we have generic data for a given date
+	//! @param date QDate
+	//! @return Activity
+	Activity hasGenericShower(QDate date, bool &found) const;
+
+	//! Checks if we have confirmed data for a given date
+	//! @param date QDate
+	//! @return Activity
+	Activity hasConfirmedShower(QDate date, bool &found) const;
+
+	//! Checks if this meteor shower is being displayed or not
+	//! @return true if it's being displayed
+	bool enabled() const;
+
+	//! Gets the meteor shower id
+	//! //! @return designation
+	QString getDesignation() const;
+
+	//! Gets the current meteor shower status
+	//! @return status
+	Status getStatus() { return m_status; }
+
+	//! Gets the peak
+	//! @return peak
+	QDate getPeak() { return m_activity.peak; }
+
+	//! Gets the current ZHR
+	//! @return ZHR
+	int getZHR() { return m_activity.zhr; }
+
+	//
+	// Methods defined in StelObject class
+	//
 	virtual QString getInfoString(const StelCore* core, const InfoStringGroup& flags) const;
+	virtual QString getType(void) const { return "MeteorShower"; }
+	virtual QString getEnglishName(void) const { return m_designation.trimmed(); }
+	virtual QString getNameI18n(void) const	{ return q_(m_designation.trimmed()); }
+	virtual Vec3d getJ2000EquatorialPos(const StelCore*) const { return m_position; }
+	virtual float getSelectPriority(const StelCore* core) const { return -4.0; }
 	virtual Vec3f getInfoColor(void) const;
-	virtual Vec3d getJ2000EquatorialPos(const StelCore*) const
-	{
-		return XYZ;
-	}
-	virtual double getAngularSize(const StelCore* core) const;
-	virtual QString getNameI18n(void) const
-	{
-		return q_(designation.trimmed());
-	}
-	virtual QString getEnglishName(void) const
-	{
-		return designation.trimmed();
-	}
-	QString getDesignation(void) const;
-	void update(double deltaTime);
-	static bool showLabels;
-
-	//! Get current activity status of MS
-	//! @return 0:inactive 1:activeRealData 2:activeGenericData
-	int getStatus()
-	{
-		return status;
-	}
-
-	//! Get peak
-	//! @return peak
-	QDateTime getPeak()
-	{
-		return peak;
-	}
-
-	//! Get zhr
-	//! @return ZHR
-	int getZHR()
-	{
-		return zhr;
-	}
-
-	//! <colorName, intensity>
-	typedef QPair<QString, int> colorPair;
+	virtual double getAngularSize(const StelCore* core) const { return 0.001; }
 
 private:
-	Vec3d XYZ;                      //! Cartesian equatorial position
-	Vec3d XY;                       //! Store temporary 2D position
-
-	static StelTextureSP radiantTexture;
-	static bool radiantMarkerEnabled;
-	static bool showActiveRadiantsOnly;
-
-	LinearFader labelsFader;
-
-	typedef struct
-	{
-		QString year;		   //! Value of year for actual data
-		int zhr;		   //! ZHR of shower
-		QString variable;	   //! value of variable for ZHR
-		QString start;		   //! First day for activity
-		QString finish;		   //! Latest day for activity
-		QString peak;		   //! Day with maximum for activity
-	} activityData;
-
-	bool initialized;
-	bool active;
-	QString showerID;		//! The ID of the meteor shower
-	QString designation;            //! The designation of the meteor shower
-	QList<activityData> activity;	//! List of activity
-	int speed;                      //! Speed of meteors
-	float rAlphaPeak;               //! R.A. for radiant of meteor shower on the peak day
-	float rDeltaPeak;               //! Dec. for radiant of meteor shower on the peak day
-	float driftAlpha;		//! Drift of R.A.
-	float driftDelta;		//! Drift of Dec.
-	QString parentObj;		//! Parent object for meteor shower
-	float pidx;			//! The population index
-	QList<colorPair> colors;	//! <colorName, 0-100>
+	MeteorShowersMgr* m_mgr;           //! MeteorShowersMgr instance
+	Status m_status;                   //! Meteor shower status
+
+	// data from catalog
+	QString m_showerID;                //! The ID of the meteor shower
+	QString m_designation;             //! The designation of the meteor shower
+	QList<Activity> m_activities;      //! Activity list
+	int m_speed;                       //! Speed of meteors
+	float m_rAlphaPeak;                //! R.A. for radiant of meteor shower on the peak day
+	float m_rDeltaPeak;                //! Dec. for radiant of meteor shower on the peak day
+	float m_driftAlpha;                //! Drift of R.A. for each day from peak
+	float m_driftDelta;                //! Drift of Dec. for each day from peak
+	QString m_parentObj;               //! Parent object for meteor shower
+	float m_pidx;                      //! The population index
+	QList<Meteor::colorPair> m_colors; //! <colorName, 0-100>
 
 	//current information
-	double radiantAlpha;            //! Current R.A. for radiant of meteor shower
-	double radiantDelta;            //! Current Dec. for radiant of meteor shower
-	int zhr;			//! ZHR of shower
-	QString variable;		//! value of variable for ZHR
-	QDateTime start;		//! First day for activity
-	QDateTime finish;		//! Latest day for activity
-	QDateTime peak;			//! Day with maximum for activity
-
-	int status;		        //! Check if the radiant is active for the current sky date
-					//! 0=inactive; 1=realData 2=genericData
-
-	void draw(StelPainter &painter);
-
-	//! Get a date string from JSON file and parse it for display in info corner
-	//! @param jsondate A string from JSON file
-	QString getDateFromJSON(QString jsondate) const;
-
-	//! Get a day from JSON file and parse it for display in info corner
-	//! @param jsondate A string from JSON file
-	QString getDayFromJSON(QString jsondate) const;
-
-	//! Get a month string from JSON file and parse it for display in info corner
-	//! @param jsondate A string from JSON file
-	int getMonthFromJSON(QString jsondate) const;
-
-	//! Get a month string from JSON file and parse it for display in info corner
-	//! @param jsondate A string from JSON file
-	QString getMonthNameFromJSON(QString jsondate) const;
-
-	//! Get a month name from month number
-	//! @param jsondate A string from JSON file
-	QString getMonthName(int number) const;
-
-	//! Get the current sky QDateTime
-	//! @return Current QDateTime of sky
-	QDateTime getSkyQDateTime() const;
-
-	//! Update value of current information(zhr, variable, stat, finish and peak)
-	//! @param current sky QDateTime
-	void updateCurrentData(QDateTime skyDate);
-
-	//! Check if the JSON file has real data to a given year
-	//! @param yyyy year to check
-	//! @return index of the year or 0 to generic data
-	int searchRealData(QString yyyy) const;
-
-	//! Get the solar longitude for a specified date
-	//! @param QDT QDateTime
+	Vec3d m_position;                  //! Cartesian equatorial position
+	double m_radiantAlpha;             //! Current R.A. for radiant of meteor shower
+	double m_radiantDelta;             //! Current Dec. for radiant of meteor shower
+	Activity m_activity;               //! Current activity
+
+	QList<MeteorObj*> m_activeMeteors; //! List with all the active meteors
+
+	//! Draws the radiant
+	void drawRadiant(StelCore* core);
+
+	//! Draws all active meteors
+	void drawMeteors(StelCore* core);
+
+	//! Calculates the ZHR using normal distribution
+	//! @param current julian day
+	int calculateZHR(const double& currentJD);
+
+	//! Gets the solar longitude for a specified date
+	//! @param date QDate
 	//! @return solar longitude in degree
-	float getSolarLongitude(QDateTime QDT) const;
+	QString getSolarLongitude(QDate date) const;
 };
 
 #endif /*_METEORSHOWER_HPP_*/

=== modified file 'plugins/MeteorShowers/src/MeteorShowers.cpp'
--- plugins/MeteorShowers/src/MeteorShowers.cpp	2015-08-03 13:17:06 +0000
+++ plugins/MeteorShowers/src/MeteorShowers.cpp	2015-08-07 05:13:12 +0000
@@ -1,7 +1,6 @@
 /*
  * Stellarium: Meteor Showers Plug-in
- * Copyright (C) 2013 Marcos Cardinot
- * Copyright (C) 2011 Alexander Wolf
+ * Copyright (C) 2013-2015 Marcos Cardinot
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -18,679 +17,172 @@
  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
  */
 
-#include <QDir>
-#include <QNetworkReply>
-#include <QSettings>
-#include <QTimer>
+#include <QtMath>
 
-#include "LabelMgr.hpp"
-#include "LandscapeMgr.hpp"
-#include "MeteorMgr.hpp"
-#include "MeteorShowerDialog.hpp"
 #include "MeteorShowers.hpp"
-#include "Planet.hpp"
 #include "StelApp.hpp"
-#include "StelCore.hpp"
-#include "StelFileMgr.hpp"
-#include "StelGui.hpp"
-#include "StelGuiItems.hpp"
-#include "StelJsonParser.hpp"
 #include "StelModuleMgr.hpp"
 #include "StelObjectMgr.hpp"
-#include "StelProgressController.hpp"
 #include "StelTextureMgr.hpp"
-
-#define CATALOG_FORMAT_VERSION 1 /* Version of format of catalog */
-
-const double MeteorShowers::zhrToWsr = MeteorMgr::zhrToWsr;
-
-/*
- This method is the one called automatically by the StelModuleMgr just
- after loading the dynamic library
-*/
-StelModule* MeteorShowersStelPluginInterface::getStelModule() const
-{
-	return new MeteorShowers();
-}
-
-StelPluginInfo MeteorShowersStelPluginInterface::getPluginInfo() const
-{
-	// Allow to load the resources when used as a static plugin
-	Q_INIT_RESOURCE(MeteorShower);
-
-	StelPluginInfo info;
-	info.id = "MeteorShowers";
-	info.displayedName = N_("Meteor Showers");
-	info.authors = "Marcos Cardinot";
-	info.contact = "[e-mail]";
-	info.description = N_("This plugin displays meteor showers and a marker"
-			      " for each active and inactive radiant, showing"
-			      " real information about its activity.");
-	info.version = METEORSHOWERS_PLUGIN_VERSION;
-	return info;
-}
-
-/*
- Constructor
-*/
-MeteorShowers::MeteorShowers()
-	: flagShowMS(false)
-	, flagShowMSButton(true)
-	, OnIcon(NULL)
-	, OffIcon(NULL)
-	, GlowIcon(NULL)
-	, toolbarButton(NULL)
-	, updateState(CompleteNoUpdates)
-	, downloadMgr(NULL)
-	, progressBar(NULL)
-	, updateTimer(0)
-	, messageTimer(0)
-	, updatesEnabled(false)
-	, updateFrequencyHours(0)
-	, enableAtStartup(false)
-	, flagShowARG(true)
-	, flagShowARR(true)
-	, flagShowIR(true)
-{
-	setObjectName("MeteorShowers");
-	configDialog = new MeteorShowerDialog();
-	conf = StelApp::getInstance().getSettings();
-	qsrand(QDateTime::currentMSecsSinceEpoch());
-}
-
-/*
- Destructor
-*/
+#include "StelUtils.hpp"
+
+MeteorShowers::MeteorShowers(MeteorShowersMgr* mgr)
+	: m_mgr(mgr)
+{
+	GETSTELMODULE(StelObjectMgr)->registerStelObjectMgr(this);
+}
+
 MeteorShowers::~MeteorShowers()
 {
-	delete configDialog;
-
-	if (GlowIcon)
-	{
-		delete GlowIcon;
-	}
-
-	if (OnIcon)
-	{
-		delete OnIcon;
-	}
-
-	if (OffIcon)
-	{
-		delete OffIcon;
-	}
-
-	active.clear();
-	activeInfo.clear();
-}
-
-/*
- Reimplementation of the getCallOrder method
-*/
-double MeteorShowers::getCallOrder(StelModuleActionName actionName) const
-{
-	if (actionName == StelModule::ActionDraw)
-	{
-		return GETSTELMODULE(MeteorMgr)->getCallOrder(actionName)+10.;
-	}
-
-	return 0;
-}
-
-void MeteorShowers::init()
-{
-	upgradeConfigIni();
-
-	try
-	{
-		StelFileMgr::makeSureDirExistsAndIsWritable(StelFileMgr::getUserDir()+"/modules/MeteorShowers");
-
-		// If no settings in the main config file, create with defaults
-		if (!conf->childGroups().contains("MeteorShowers"))
-		{
-			qDebug() << "MeteorShowers: no MeteorShower section exists in main config file - creating with defaults";
-			restoreDefaultConfigIni();
-		}
-
-		// populate settings from main config file.
-		readSettingsFromConfig();
-
-		showersJsonPath = StelFileMgr::findFile("modules/MeteorShowers", (StelFileMgr::Flags)(StelFileMgr::Directory|StelFileMgr::Writable)) + "/showers.json";
-
-		texPointer = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/pointeur5.png");
-		MeteorShower::radiantTexture = StelApp::getInstance().getTextureManager().createTexture(":/MeteorShowers/radiant.png");
-
-		// key bindings and other actions
-		QString msGroup = N_("Meteor Showers");
-		addAction("actionShow_MeteorShower", msGroup, N_("Show meteor showers"), "msVisible", "Ctrl+Alt+M");
-		addAction("actionShow_radiant_Labels", msGroup, N_("Radiant labels"), "labelsVisible", "Shift+M");
-		addAction("actionShow_MeteorShower_ConfigDialog", msGroup, N_("Meteor Shower configuration window"), configDialog, "visible", "Ctrl+Shift+M");
-
-		GlowIcon = new QPixmap(":/graphicGui/glow32x32.png");
-		OnIcon = new QPixmap(":/MeteorShowers/btMS-on.png");
-		OffIcon = new QPixmap(":/MeteorShowers/btMS-off.png");
-
-		setFlagShowMSButton(flagShowMSButton);
-		setFlagShowMS(getEnableAtStartup());
-	}
-	catch(std::runtime_error &e)
-	{
-		qWarning() << "MeteorShowers: init error:" << e.what();
-		return;
-	}
-
-	// A timer for hiding alert messages
-	messageTimer = new QTimer(this);
-	messageTimer->setSingleShot(true);   // recurring check for update
-	messageTimer->setInterval(9000);      // 6 seconds should be enough time
-	messageTimer->stop();
-	connect(messageTimer, SIGNAL(timeout()), this, SLOT(messageTimeout()));
-
-	// If the json file does not already exist, create it from the resource in the QT resource
-	if (!QFileInfo(showersJsonPath).exists())
-	{
-		qDebug() << "MeteorShowers: showers.json does not exist - copying default file to" << QDir::toNativeSeparators(showersJsonPath);
-		restoreDefaultJsonFile();
-	}
-	// Validate JSON format and data
-	if (!checkJsonFileFormat() || getJsonFileFormatVersion()<CATALOG_FORMAT_VERSION)
-	{
-		displayMessage(q_("The old showers.json file is no longer compatible - using default file"), "#bb0000");
-		restoreDefaultJsonFile();
-	}
-
-	qDebug() << "MeteorShowers: loading catalog file:" << QDir::toNativeSeparators(showersJsonPath);
-
-	// create meteor Showers according to content os Showers.json file
-	readJsonFile();
-
-	// Set up download manager and the update schedule
-	downloadMgr = new QNetworkAccessManager(this);
-	connect(downloadMgr, SIGNAL(finished(QNetworkReply*)), this, SLOT(updateDownloadComplete(QNetworkReply*)));
-	updateState = CompleteNoUpdates;
-	updateTimer = new QTimer(this);
-	updateTimer->setSingleShot(false);   // recurring check for update
-	updateTimer->setInterval(13000);     // check once every 13 seconds to see if it is time for an update
-	connect(updateTimer, SIGNAL(timeout()), this, SLOT(checkForUpdate()));
-	updateTimer->start();
-
-	// skyDate startup
-	// GZ JDfix for 0.14 I am not sure how skyDate is used. It used to be set to JDE, so again:
-	skyDate = StelUtils::jdToQDateTime(StelApp::getInstance().getCore()->getJDE());
-
-	GETSTELMODULE(StelObjectMgr)->registerStelObjectMgr(this);
-}
-
-void MeteorShowers::deinit()
-{
-	MeteorShower::radiantTexture.clear();
-	texPointer.clear();
-}
-
-void MeteorShowers::upgradeConfigIni(void)
-{
-	// Upgrade settings for MeteorShower plugin
-	if (conf->contains("MeteorShowers/flag_show_ms"))
-	{
-		bool b = conf->value("MeteorShowers/flag_show_ms", false).toBool();
-		if (!conf->contains("MeteorShowers/enable_at_startup"))
-			conf->setValue("MeteorShowers/enable_at_startup", b);
-		conf->remove("MeteorShowers/flag_show_ms");
-	}
-}
-
-void MeteorShowers::setFlagShowMS(bool b)
-{
-	if (toolbarButton != NULL)
-	{
-		toolbarButton->setChecked(b);
-	}
-
-	flagShowMS=b;
-}
-
-// Define whether the button toggling meteor showers should be visible
-void MeteorShowers::setFlagShowMSButton(bool b)
-{
-	StelGui* gui = dynamic_cast<StelGui*>(StelApp::getInstance().getGui());
-	if (gui != NULL)
-	{
-		if (b)
-		{
-			if (toolbarButton == NULL)
-			{
-				// Create the MeteorShowers button
-				toolbarButton = new StelButton(NULL, *OnIcon, *OffIcon, *GlowIcon, "actionShow_MeteorShower");
-			}
-			gui->getButtonBar()->addButton(toolbarButton, "065-pluginsGroup");
-		}
-		else
-		{
-			gui->getButtonBar()->hideButton("actionShow_MeteorShower");
-		}
-		flagShowMSButton = b;
-	}
-}
-
-bool MeteorShowers::changedSkyDate(StelCore* core)
-{
-	double JD = core->getJD();
-	skyDate = StelUtils::jdToQDateTime(JD+StelUtils::getGMTShiftFromQT(JD)/24);
-	if (skyDate.toString("MM.dd.yyyy") != lastSkyDate.toString("MM.dd.yyyy"))  //if the sky date changed
-	{
-		return true;
-	}
-	else
-	{
-		return false;
+	m_meteorShowers.clear();
+}
+
+void MeteorShowers::update(StelCore* core, double deltaTime)
+{
+	foreach (const MeteorShowerP& ms, m_meteorShowers)
+	{
+		ms->update(core, deltaTime);
 	}
 }
 
 void MeteorShowers::draw(StelCore* core)
 {
-	if (!getFlagShowMS())
+	foreach (const MeteorShowerP& ms, m_meteorShowers)
+	{
+		ms->draw(core);
+	}
+
+	if (GETSTELMODULE(StelObjectMgr)->getFlagSelectedObjectPointer())
+	{
+		drawPointer(core);
+	}
+}
+
+void MeteorShowers::drawPointer(StelCore* core)
+{
+	const QList<StelObjectP> newSelected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("MeteorShower");
+	if (newSelected.empty())
 	{
 		return;
 	}
 
+	const StelObjectP obj = newSelected[0];
+	Vec3d pos = obj->getJ2000EquatorialPos(core);
+
+	// Compute 2D pos and return if outside screen
+	Vec3d screenpos;
 	StelPainter painter(core->getProjection(StelCore::FrameJ2000));
-	drawMarker(core, painter);
-
-	if (GETSTELMODULE(StelObjectMgr)->getFlagSelectedObjectPointer())
+	if (!painter.getProjector()->project(pos, screenpos))
 	{
-		drawPointer(core, painter);
+		return;
 	}
 
-	painter.setProjector(core->getProjection(StelCore::FrameAltAz));
-	drawStream(core, painter);
-}
-
-void MeteorShowers::drawMarker(StelCore* core, StelPainter& painter)
-{
-	Q_UNUSED(core);
-	painter.setFont(labelFont);
-
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	const Vec3f& c(obj->getInfoColor());
+	painter.setColor(c[0],c[1],c[2]);
+	m_mgr->getPointerTexture()->bind();
+	painter.enableTexture2d(true);
 	glEnable(GL_BLEND);
-	glEnable(GL_TEXTURE_2D);
-
-	foreach (const MeteorShowerP& ms, mShowers)
-	{
-		ms->updateCurrentData(skyDate);
-
-		if (ms && ms->initialized && ms->active)
-		{
-			ms->draw(painter);
-		}
-	}
-	glDisable(GL_TEXTURE_2D);
-}
-
-void MeteorShowers::drawPointer(StelCore* core, StelPainter& painter)
-{
-	const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000);
-
-	const QList<StelObjectP> newSelected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("MeteorShower");
-	if (!newSelected.empty())
-	{
-		const StelObjectP obj = newSelected[0];
-		Vec3d pos=obj->getJ2000EquatorialPos(core);
-
-		Vec3d screenpos;
-		// Compute 2D pos and return if outside screen
-		if (!painter.getProjector()->project(pos, screenpos))
-		{
-			return;
-		}
-
-		const Vec3f& c(obj->getInfoColor());
-		painter.setColor(c[0],c[1],c[2]);
-		texPointer->bind();
-		painter.enableTexture2d(true);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
-
-		float size = obj->getAngularSize(core)*M_PI/180.*prj->getPixelPerRadAtCenter();
-		size+=20.f + 10.f*std::sin(2.f * StelApp::getInstance().getTotalRunTime());
-
-		painter.drawSprite2dMode(screenpos[0]-size/2, screenpos[1]-size/2, 10.f, 90);
-		painter.drawSprite2dMode(screenpos[0]-size/2, screenpos[1]+size/2, 10.f, 0);
-		painter.drawSprite2dMode(screenpos[0]+size/2, screenpos[1]+size/2, 10.f, -90);
-		painter.drawSprite2dMode(screenpos[0]+size/2, screenpos[1]-size/2, 10.f, -180);
-		painter.setColor(1,1,1,0);
-	}
-}
-
-void MeteorShowers::drawStream(StelCore* core, StelPainter& painter)
-{
-	if (!core->getSkyDrawer()->getFlagHasAtmosphere())
-	{
-		return;
-	}
-
-	LandscapeMgr* landmgr = GETSTELMODULE(LandscapeMgr);
-	if (landmgr->getFlagAtmosphere() && landmgr->getLuminance()>5)
-	{
-		return;
-	}
-
-	int index = 0;
-	if (active.size() > 0)
-	{
-		foreach (const activeData &a, activeInfo)
-		{
-			Q_UNUSED(a);
-			// step through and draw all active meteors
-			std::vector<MeteorStream*>::iterator iter;
-			for (iter = active[index].begin(); iter != active[index].end(); ++iter)
-			{
-				(*iter)->draw(core, painter);
-			}
-			index++;
-		}
-	}
-}
-
-int MeteorShowers::calculateZHR(int zhr, QString variable, QDateTime start, QDateTime finish, QDateTime peak)
-{
-	/***************************************
-	 * Get ZHR ranges
-	 ***************************************/
-	int highZHR;
-	int lowZHR;
-	//bool multPeak = false; //multiple peaks
-	if (zhr != -1)  //isn't variable
-	{
-		highZHR = zhr;
-		lowZHR = 0;
-	}
-	else
-	{
-		QStringList varZHR = variable.split("-");
-		lowZHR = varZHR.at(0).toInt();
-		if (varZHR.at(1).contains("*"))
-		{
-			//multPeak = true;
-			highZHR = varZHR[1].replace("*", "").toInt();
-		}
-		else
-		{
-			highZHR = varZHR.at(1).toInt();
-		}
-	}
-
-	/***************************************
-	 * Convert time intervals
-	 ***************************************/
-	double startJD = StelUtils::qDateTimeToJd(start);
-	double finishJD = StelUtils::qDateTimeToJd(finish);
-	double peakJD = StelUtils::qDateTimeToJd(peak);
-	double currentJD = StelUtils::qDateTimeToJd(skyDate);
-
-	/***************************************
-	 * Gaussian distribution
-	 ***************************************/
-	double sd; //standard deviation
-	if (currentJD >= startJD && currentJD < peakJD) //left side of gaussian
-		sd = (peakJD - startJD)/2;
-	else
-		sd = (finishJD - peakJD)/2;
-
-	double gaussian = highZHR * std::exp( - std::pow(currentJD - peakJD, 2) / (sd*sd) ) + lowZHR;
-
-	return (int) ((int) ((gaussian - (int) gaussian) * 10) >= 5 ? gaussian+1 : gaussian);
-}
-
-void MeteorShowers::updateActiveInfo(void)
-{
-	foreach (const MeteorShowerP& ms, mShowers)
-	{
-		if (ms && ms->initialized)
-		{
-			//if the meteor shower is active, get data
-			if (ms->getStatus())
-			{
-				//First, check if there is already data about the constellation in "activeInfo"
-				//The var "index" will be updated to show the correct place do put the new information
-				int index = 0;
-				foreach(const activeData &a, activeInfo)
-				{
-					if (a.showerID == ms->showerID)  //exists
-						break;
-					index++;
-				}
-
-				if (activeInfo.size() < index + 1) //new?, put in the end
-				{
-					activeData newData;
-					newData.showerID = ms->showerID;
-					newData.speed = ms->speed;
-					newData.radiantAlpha = ms->radiantAlpha;
-					newData.radiantDelta = ms->radiantDelta;
-					newData.pidx = ms->pidx;
-					newData.zhr = ms->zhr;
-					newData.variable = ms->variable;
-					newData.start = ms->start;
-					newData.finish = ms->finish;
-					newData.peak = ms->peak;
-					newData.status = ms->status;
-					newData.colors = ms->colors;
-					activeInfo.append(newData);
-				}
-				else //just overwrites
-				{
-					activeInfo[index].zhr = ms->zhr;
-					activeInfo[index].variable = ms->variable;
-					activeInfo[index].start = ms->start;
-					activeInfo[index].finish = ms->finish;
-					activeInfo[index].peak = ms->peak;
-					activeInfo[index].status = ms->status;
-				}
-			}
-		}
-	}
-	lastSkyDate = skyDate;
-}
-
-void MeteorShowers::update(double deltaTime)
-{
-	if (!getFlagShowMS())
-	{
-		return;
-	}
-
-	StelCore* core = StelApp::getInstance().getCore();
-
-	double tspeed = core->getTimeRate()*86400;  // sky seconds per actual second
-	if (!tspeed) { // is paused?
-		return; // freeze meteors at the current position
-	}
-
-	deltaTime*=1000;
-	// if stellarium has been suspended, don't create huge number of meteors to
-	// make up for lost time!
-	if (deltaTime > 500)
-	{
-		deltaTime = 500;
-	}
-
-	QList<activeData> old_activeInfo;
-
-	//check if the sky date changed
-	if (changedSkyDate(core))
-	{
-		// clear data of all MS active
-		old_activeInfo = activeInfo;
-		activeInfo.clear();
-
-		// Is GUI visible and the year changed? refresh ranges
-		if (configDialog->visible() && lastSkyDate.toString("yyyy") != skyDate.toString("yyyy"))
-			configDialog->refreshRangeDates();
-	}
-
-	// fill `activeInfo` with all current active meteor showers
-	updateActiveInfo();
-	// counting index of `active`
-	int index = 0;
-	// something changed? check if we have some MS to remove from `active`
-	if (!old_activeInfo.isEmpty())
-	{
-		for (int i=0; i<old_activeInfo.size(); i++)
-		{
-			bool found = false;
-			for (int j=0; j<activeInfo.size(); j++)
-			{
-				if (old_activeInfo[i].showerID == activeInfo[j].showerID)
-				{
-					found = true;
-					break;
-				}
-			}
-			if (!found)
-			{
-				active.erase(active.begin().operator +(index));
-				index--;
-			}
-			index++;
-		}
-	}
-
-	std::vector<std::vector<MeteorStream*> >::iterator iterOut;
-	std::vector<MeteorStream*>::iterator iterIn;
-	index = 0;
-	if (active.size() > 0)
-	{
-		// step through and update all active meteors
-		for (iterOut = active.begin(); iterOut != active.end(); ++iterOut)
-		{
-			for (iterIn = active[index].begin(); iterIn != active[index].end(); ++iterIn)
-			{
-				if (!(*iterIn)->update(deltaTime))
-				{
-					delete *iterIn;
-					iterIn = active[index].erase(iterIn);
-					iterIn--;
-				}
-			}
-			if (active[index].empty())
-			{
-				iterOut = active.erase(iterOut);
-				iterOut--;
-				index--;
-			}
-			index++;
-		}
-	}
-
-	index = 0;
-	foreach (const activeData &current, activeInfo)
-	{
-		std::vector<MeteorStream*> aux;
-		if (active.empty() || active.size() < (unsigned) activeInfo.size())
-		{
-			if(tspeed<0 || fabs(tspeed)>1.)
-			{
-				activeInfo.removeAt(index);
-				continue; // don't create new meteors
-			}
-			active.push_back(aux);
-		}
-
-		int ZHR = calculateZHR(current.zhr,
-				       current.variable,
-				       current.start,
-				       current.finish,
-				       current.peak);
-
-		// determine average meteors per frame needing to be created
-		int mpf = (int)((double)ZHR*zhrToWsr*deltaTime/1000.0 + 0.5);
-		if (mpf<1)
-		{
-			mpf = 1;
-		}
-
-		for (int i=0; i<mpf; ++i)
-		{
-			// start new meteor based on ZHR time probability
-			double prob = ((double)qrand())/RAND_MAX;
-			if (ZHR>0 && prob<((double)ZHR*zhrToWsr*deltaTime/1000.0/(double)mpf))
-			{
-				MeteorStream *m = new MeteorStream(core,
-								   current.speed,
-								   current.radiantAlpha,
-								   current.radiantDelta,
-								   current.pidx,
-								   current.colors);
-				active[index].push_back(m);
-			}
-		}
-		index++;
-	}
-}
-
-QList<MeteorShowerP> MeteorShowers::searchEvents(QDate dateFrom, QDate dateTo) const
-{
-	QList<MeteorShowerP> result;
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode
+
+	float size = obj->getAngularSize(core) * M_PI / 180. * painter.getProjector()->getPixelPerRadAtCenter();
+	size += 20.f + 10.f * qSin(2.f * StelApp::getInstance().getTotalRunTime());
+
+	painter.drawSprite2dMode(screenpos[0]-size/2, screenpos[1]-size/2, 10.f, 90);
+	painter.drawSprite2dMode(screenpos[0]-size/2, screenpos[1]+size/2, 10.f, 0);
+	painter.drawSprite2dMode(screenpos[0]+size/2, screenpos[1]+size/2, 10.f, -90);
+	painter.drawSprite2dMode(screenpos[0]+size/2, screenpos[1]-size/2, 10.f, -180);
+	painter.setColor(1, 1, 1, 0);
+}
+
+void MeteorShowers::loadMeteorShowers(const QVariantMap& map)
+{
+	m_meteorShowers.clear();
+	foreach(QString msKey, map.keys())
+	{
+		QVariantMap msData = map.value(msKey).toMap();
+		msData["showerID"] = msKey;
+
+		MeteorShowerP ms(new MeteorShower(m_mgr, msData));
+		if (ms->getStatus() != MeteorShower::INVALID)
+		{
+			m_meteorShowers.append(ms);
+		}
+	}
+}
+
+QList<MeteorShowers::SearchResult> MeteorShowers::searchEvents(QDate dateFrom, QDate dateTo) const
+{
+	QList<SearchResult> result;
+	bool found;
 	QDate date;
-
-	foreach(const MeteorShowerP& ms, mShowers)
+	MeteorShower::Activity a;
+	SearchResult r;
+	foreach(const MeteorShowerP& ms, m_meteorShowers)
 	{
 		date = dateFrom;
 		while(date.operator <=(dateTo))
 		{
-			ms->updateCurrentData((QDateTime) date);
-			if (ms->initialized && ms->status)
-			{
-				result.append(ms);
+			found = false;
+			a = ms->hasConfirmedShower(date, found);
+			if (!found)
+			{
+				a = ms->hasGenericShower(date, found);
+			}
+
+			if (found)
+			{
+				r.name = ms->getNameI18n();
+				r.peak = a.peak;
+				r.type = a.year > 0 ? q_("Confirmed") : q_("Generic");
+				r.zhr = a.zhr == -1
+				      ? QString("%1-%2").arg(a.variable.at(0)).arg(a.variable.at(1))
+				      : QString::number(a.zhr);
+				result.append(r);
 				break;
 			}
 			date = date.addDays(1);
 		}
 	}
-
 	return result;
 }
 
 QList<StelObjectP> MeteorShowers::searchAround(const Vec3d& av, double limitFov, const StelCore*) const
 {
 	QList<StelObjectP> result;
-
-	if (!getFlagShowMS() || !getFlagRadiant())
+	if (!m_mgr->getEnablePlugin())
 	{
 		return result;
 	}
 
 	Vec3d v(av);
 	v.normalize();
-	double cosLimFov = cos(limitFov * M_PI/180.);
+	double cosLimFov = qCos(limitFov * M_PI/180.);
 	Vec3d equPos;
-
-	foreach(const MeteorShowerP& ms, mShowers)
+	foreach(const MeteorShowerP& ms, m_meteorShowers)
 	{
-		if (ms->initialized && ms->active)
+		if (ms->enabled())
 		{
-			equPos = ms->XYZ;
+			equPos = ms->getJ2000EquatorialPos(NULL);
 			equPos.normalize();
-			if (equPos[0]*v[0] + equPos[1]*v[1] + equPos[2]*v[2]>=cosLimFov)
+			if (equPos[0]*v[0] + equPos[1]*v[1] + equPos[2]*v[2] >= cosLimFov)
 			{
 				result.append(qSharedPointerCast<StelObject>(ms));
 			}
 		}
 	}
-
 	return result;
 }
 
 StelObjectP MeteorShowers::searchByName(const QString& englishName) const
 {
-	if (!getFlagShowMS() || !getFlagRadiant())
+	if (!m_mgr->getEnablePlugin())
 	{
 		return NULL;
 	}
 
-	foreach(const MeteorShowerP& ms, mShowers)
+	foreach(const MeteorShowerP& ms, m_meteorShowers)
 	{
-		if (ms->initialized)
+		if (ms->enabled())
 		{
 			bool sameEngName = ms->getEnglishName().toUpper() == englishName.toUpper();
 			bool desigIsEngName = ms->getDesignation().toUpper() == englishName.toUpper();
@@ -701,20 +193,19 @@
 			}
 		}
 	}
-
 	return NULL;
 }
 
 StelObjectP MeteorShowers::searchByNameI18n(const QString& nameI18n) const
 {
-	if (!getFlagShowMS() || !getFlagRadiant())
+	if (!m_mgr->getEnablePlugin())
 	{
 		return NULL;
 	}
 
-	foreach(const MeteorShowerP& ms, mShowers)
+	foreach(const MeteorShowerP& ms, m_meteorShowers)
 	{
-		if (ms->initialized)
+		if (ms->enabled())
 		{
 			if (ms->getNameI18n().toUpper() == nameI18n.toUpper())
 			{
@@ -722,52 +213,44 @@
 			}
 		}
 	}
-
 	return NULL;
 }
 
 QStringList MeteorShowers::listMatchingObjectsI18n(const QString& objPrefix, int maxNbItem, bool useStartOfWords) const
 {
 	QStringList result;
-	if (!getFlagShowMS() || !getFlagRadiant())
-	{
-		return result;
-	}
-
-	if (maxNbItem==0)
+	if (!m_mgr->getEnablePlugin() || maxNbItem == 0)
 	{
 		return result;
 	}
 
 	QString sn;
-	bool find;
-
-	foreach(const MeteorShowerP& ms, mShowers)
+	bool found = false;
+	foreach(const MeteorShowerP& ms, m_meteorShowers)
 	{
-		if (ms->initialized && ms->active)
+		if (ms->enabled())
 		{
 			sn = ms->getNameI18n();
-			find = false;
 			if (useStartOfWords)
 			{
-				if (sn.toUpper().left(objPrefix.length()) == objPrefix.toUpper())
-					find = true;
+				found = sn.toUpper().left(objPrefix.length()) == objPrefix.toUpper();
 			}
 			else
 			{
-				if (sn.contains(objPrefix, Qt::CaseInsensitive))
-					find = true;
-			}
-			if (find)
-				result << sn;
+				found = sn.contains(objPrefix, Qt::CaseInsensitive);
+			}
+
+			if (found)
+			{
+				result.append(sn);
+			}
 		}
 	}
 
 	result.sort();
-
-	if (result.size()>maxNbItem)
+	if (result.size() > maxNbItem)
 	{
-		result.erase(result.begin()+maxNbItem, result.end());
+		result.erase(result.begin() + maxNbItem, result.end());
 	}
 
 	return result;
@@ -776,642 +259,76 @@
 QStringList MeteorShowers::listMatchingObjects(const QString& objPrefix, int maxNbItem, bool useStartOfWords) const
 {
 	QStringList result;
-	if (!getFlagShowMS() || !getFlagRadiant())
-	{
-		return result;
-	}
-
-	if (maxNbItem==0)
+	if (!m_mgr->getEnablePlugin() || maxNbItem == 0)
 	{
 		return result;
 	}
 
 	QString sn;
-	bool find;
-	foreach(const MeteorShowerP& ms, mShowers)
+	bool found = false;
+	foreach(const MeteorShowerP& ms, m_meteorShowers)
 	{
-		if (ms->initialized && ms->active)
+		if (ms->enabled())
 		{
 			sn = ms->getEnglishName();
-			find = false;
 			if (useStartOfWords)
 			{
-				if (objPrefix.toUpper()==sn.toUpper().left(objPrefix.length()))
-					find = true;
+				found = objPrefix.toUpper()==sn.toUpper().left(objPrefix.length());
 			}
 			else
 			{
-				if (sn.contains(objPrefix, Qt::CaseInsensitive))
-					find = true;
+				found = sn.contains(objPrefix, Qt::CaseInsensitive);
 			}
-			if (find)
+			if (found)
 			{
-				result << sn;
+				result.append(sn);
 			}
 
 			sn = ms->getDesignation();
-			find = false;
 			if (useStartOfWords)
 			{
-				if (objPrefix.toUpper()==sn.toUpper().left(objPrefix.length()))
-					find = true;
+				found = objPrefix.toUpper()==sn.toUpper().left(objPrefix.length());
 			}
 			else
 			{
-				if (sn.contains(objPrefix, Qt::CaseInsensitive))
-					find = true;
+				found = sn.contains(objPrefix, Qt::CaseInsensitive);
 			}
-			if (find)
+			if (found)
 			{
-				result << sn;
+				result.append(sn);
 			}
 		}
 	}
 
 	result.sort();
-	if (result.size()>maxNbItem)
-		result.erase(result.begin()+maxNbItem, result.end());
-
+	if (result.size() > maxNbItem)
+	{
+		result.erase(result.begin() + maxNbItem, result.end());
+	}
 	return result;
 }
 
 QStringList MeteorShowers::listAllObjects(bool inEnglish) const
 {
 	QStringList result;
+	if (!m_mgr->getEnablePlugin())
+	{
+		return result;
+	}
+
 	if (inEnglish)
 	{
-		foreach(const MeteorShowerP& ms, mShowers)
+		foreach(const MeteorShowerP& ms, m_meteorShowers)
 		{
-			result << ms->getEnglishName();
+			result.append(ms->getEnglishName());
 		}
 	}
 	else
 	{
-		foreach(const MeteorShowerP& ms, mShowers)
+		foreach(const MeteorShowerP& ms, m_meteorShowers)
 		{
-			result << ms->getNameI18n();
+			result.append(ms->getNameI18n());
 		}
 	}
 	return result;
 }
-
-bool MeteorShowers::configureGui(bool show)
-{
-	if (show)
-	{
-		configDialog->setVisible(true);
-	}
-
-	return true;
-}
-
-QVariantMap MeteorShowers::loadShowersMap(QString path)
-{
-	if (path.isEmpty())
-	{
-		path = showersJsonPath;
-	}
-
-	QVariantMap map;
-	QFile jsonFile(path);
-	if (!jsonFile.open(QIODevice::ReadOnly))
-	{
-		qWarning() << "MeteorShowers: cannot open" << path;
-	}
-	else
-	{
-		map = StelJsonParser::parse(jsonFile.readAll()).toMap();
-		jsonFile.close();
-	}
-	return map;
-}
-
-void MeteorShowers::readJsonFile(void)
-{
-	setShowersMap(loadShowersMap());
-}
-
-void MeteorShowers::setShowersMap(const QVariantMap& map)
-{
-	mShowers.clear();
-	QVariantMap msMap = map.value("showers").toMap();
-	foreach(QString msKey, msMap.keys())
-	{
-		QVariantMap msData = msMap.value(msKey).toMap();
-		msData["showerID"] = msKey;
-
-		MeteorShowerP ms(new MeteorShower(msData));
-		if (ms->initialized)
-		{
-			mShowers.append(ms);
-		}
-	}
-}
-
-void MeteorShowers::restoreDefaults(void)
-{
-	restoreDefaultConfigIni();
-	restoreDefaultJsonFile();
-	readJsonFile();
-	readSettingsFromConfig();
-}
-
-void MeteorShowers::restoreDefaultConfigIni(void)
-{
-	conf->beginGroup("MeteorShowers");
-
-	// delete all existing MeteorShower settings...
-	conf->remove("");
-
-	conf->setValue("enable_at_startup", true);
-	conf->setValue("updates_enabled", true);
-	conf->setValue("url", "http://stellarium.org/json/showers.json");
-	conf->setValue("update_frequency_hours", 100);
-	conf->setValue("flag_show_ms_button", true);
-	conf->setValue("flag_show_radiants", true);
-	conf->setValue("flag_active_radiants", true);
-
-	conf->setValue("colorARG", "0, 255, 240");
-	conf->setValue("colorARR", "255, 240, 0");
-	conf->setValue("colorIR", "255, 255, 255");
-
-	conf->setValue("show_radiant_labels", true);
-
-	conf->endGroup();
-}
-
-void MeteorShowers::restoreDefaultJsonFile(void)
-{
-	if (QFileInfo(showersJsonPath).exists())
-	{
-		backupJsonFile(true);
-	}
-
-	QFile src(":/MeteorShowers/showers.json");
-	if (!src.copy(showersJsonPath))
-	{
-		qWarning() << "MeteorShowers: cannot copy JSON resource to" << showersJsonPath;
-	}
-	else
-	{
-		qDebug() << "MeteorShowers: copied default showers.json to" << showersJsonPath;
-		// The resource is read only, and the new file inherits this...  make sure the new file
-		// is writable by the Stellarium process so that updates can be done.
-		QFile dest(showersJsonPath);
-		dest.setPermissions(dest.permissions() | QFile::WriteOwner);
-
-		// Make sure that in the case where an online update has previously been done, but
-		// the json file has been manually removed, that an update is schreduled in a timely
-		// manner
-		conf->remove("MeteorShowers/last_update");
-		lastUpdate = QDateTime::fromString("2013-12-31T12:00:00", Qt::ISODate);
-	}
-}
-
-bool MeteorShowers::backupJsonFile(bool deleteOriginal)
-{
-	QFile old(showersJsonPath);
-	if (!old.exists())
-	{
-		qWarning() << "MeteorShowers: no file to backup";
-		return false;
-	}
-
-	QString backupPath = showersJsonPath + ".old";
-	if (QFileInfo(backupPath).exists())
-	{
-		QFile(backupPath).remove();
-	}
-
-	if (old.copy(backupPath))
-	{
-		if (deleteOriginal)
-		{
-			if (!old.remove())
-			{
-				qWarning() << "MeteorShowers: WARNING - could not remove old showers.json file";
-				return false;
-			}
-		}
-	}
-	else
-	{
-		qWarning() << "MeteorShowers: WARNING - failed to copy showers.json to showers.json.old";
-		return false;
-	}
-
-	return true;
-}
-
-int MeteorShowers::getJsonFileFormatVersion(void)
-{
-	int jsonVersion = -1;
-	QFile showersJsonFile(showersJsonPath);
-	if (!showersJsonFile.open(QIODevice::ReadOnly))
-	{
-		qWarning() << "MeteorShowers: cannot open" << QDir::toNativeSeparators(showersJsonPath);
-		return jsonVersion;
-	}
-
-	QVariantMap map;
-	map = StelJsonParser::parse(&showersJsonFile).toMap();
-	if (map.contains("version"))
-	{
-		jsonVersion = map.value("version").toInt();
-	}
-
-	showersJsonFile.close();
-	qDebug() << "MeteorShowers: version of the format of the catalog:" << jsonVersion;
-	return jsonVersion;
-}
-
-bool MeteorShowers::checkJsonFileFormat()
-{
-	QFile showersJsonFile(showersJsonPath);
-	if (!showersJsonFile.open(QIODevice::ReadOnly))
-	{
-		qWarning() << "MeteorShowers: cannot open" << QDir::toNativeSeparators(showersJsonPath);
-		return false;
-	}
-	
-	QVariantMap map;
-	try
-	{
-		map = StelJsonParser::parse(&showersJsonFile).toMap();
-		showersJsonFile.close();
-	}
-	catch(std::runtime_error& e)
-	{
-		qDebug() << "MeteorShowers: file format is wrong! Error:" << e.what();
-		return false;
-	}
-	
-	return true;
-}
-
-void MeteorShowers::readSettingsFromConfig(void)
-{
-	conf->beginGroup("MeteorShowers");
-
-	updateUrl = conf->value("url", "http://stellarium.org/json/showers.json").toString();
-	updateFrequencyHours = conf->value("update_frequency_hours", 720).toInt();
-	lastUpdate = QDateTime::fromString(conf->value("last_update", "2013-12-10T12:00:00").toString(), Qt::ISODate);
-	updatesEnabled = conf->value("updates_enabled", true).toBool();
-	enableAtStartup = conf->value("enable_at_startup", true).toBool();
-	flagShowMSButton = conf->value("flag_show_ms_button", true).toBool();
-	setFlagRadiant(conf->value("flag_show_radiants", true).toBool());
-	setFlagActiveRadiant(conf->value("flag_active_radiants", true).toBool());
-
-	Vec3f color;
-	color = StelUtils::strToVec3f(conf->value("colorARG", "0, 255, 240").toString());
-	colorARG = QColor(color[0],color[1],color[2]);
-	color = StelUtils::strToVec3f(conf->value("colorARR", "255, 240, 0").toString());
-	colorARR = QColor(color[0],color[1],color[2]);
-	color = StelUtils::strToVec3f(conf->value("colorIR", "255, 255, 255").toString());
-	colorIR = QColor(color[0],color[1],color[2]);
-
-	MeteorShower::showLabels = conf->value("show_radiant_labels", true).toBool();
-	labelFont.setPixelSize(conf->value("font_size", 13).toInt());
-
-	conf->endGroup();
-}
-
-void MeteorShowers::saveSettingsToConfig(void)
-{
-	conf->beginGroup("MeteorShowers");
-
-	conf->setValue("url", updateUrl);
-	conf->setValue("update_frequency_hours", updateFrequencyHours);
-	conf->setValue("updates_enabled", updatesEnabled);
-	conf->setValue("enable_at_startup", enableAtStartup);
-	conf->setValue("flag_show_ms_button", flagShowMSButton);
-	conf->setValue("flag_show_radiants", getFlagRadiant());
-	conf->setValue("flag_active_radiants", getFlagActiveRadiant());
-
-	int r,g,b;
-	colorARG.getRgb(&r,&g,&b);
-	conf->setValue("colorARG", QString("%1, %2, %3").arg(r).arg(g).arg(b));
-	colorARR.getRgb(&r,&g,&b);
-	conf->setValue("colorARR", QString("%1, %2, %3").arg(r).arg(g).arg(b));
-	colorIR.getRgb(&r,&g,&b);
-	conf->setValue("colorIR", QString("%1, %2, %3").arg(r).arg(g).arg(b));
-
-	conf->setValue("show_radiant_labels", MeteorShower::showLabels);
-	conf->setValue("font_size", labelFont.pixelSize());
-
-	conf->endGroup();
-}
-
-int MeteorShowers::getSecondsToUpdate(void)
-{
-	QDateTime nextUpdate = lastUpdate.addSecs(updateFrequencyHours * 3600);
-	return QDateTime::currentDateTime().secsTo(nextUpdate);
-}
-
-void MeteorShowers::checkForUpdate(void)
-{
-	if (updatesEnabled && lastUpdate.addSecs(updateFrequencyHours * 3600) <= QDateTime::currentDateTime())
-	{
-		updateJSON();
-	}
-}
-
-void MeteorShowers::updateJSON(void)
-{
-	if (updateState == MeteorShowers::Updating)
-	{
-		qWarning() << "MeteorShowers: already updating...  will not start again current update is complete.";
-		return;
-	}
-	else
-	{
-		qDebug() << "MeteorShowers: starting update...";
-	}
-
-	lastUpdate = QDateTime::currentDateTime();
-	conf->setValue("MeteorShowers/last_update", lastUpdate.toString(Qt::ISODate));
-
-	emit(jsonUpdateComplete());
-
-	updateState = MeteorShowers::Updating;
-
-	emit(updateStateChanged(updateState));
-	updateFile.clear();
-
-	if (progressBar == NULL)
-	{
-		progressBar = StelApp::getInstance().addProgressBar();
-	}
-
-	progressBar->setValue(0);
-	progressBar->setRange(0, 100);
-	progressBar->setFormat("Update meteor showers");
-
-	QNetworkRequest request;
-	request.setUrl(QUrl(updateUrl));
-	request.setRawHeader("User-Agent", QString("Mozilla/5.0 (Stellarium Meteor Showers Plugin %1; http://stellarium.org/)").arg(METEORSHOWERS_PLUGIN_VERSION).toUtf8());
-	downloadMgr->get(request);
-
-	updateState = MeteorShowers::CompleteUpdates;
-	emit(updateStateChanged(updateState));
-	emit(jsonUpdateComplete());
-}
-
-void MeteorShowers::updateDownloadComplete(QNetworkReply* reply)
-{
-	// check the download worked, and save the data to file if this is the case.
-	if (reply->error() != QNetworkReply::NoError)
-	{
-		qWarning() << "MeteorShowers: FAILED to download" << reply->url() << " Error:" << reply->errorString();
-	}
-	else
-	{
-		// download completed successfully.
-		QString jsonFilePath = StelFileMgr::findFile("modules/MeteorShowers", StelFileMgr::Flags(StelFileMgr::Writable|StelFileMgr::Directory)) + "/showers.json";
-		if (jsonFilePath.isEmpty())
-		{
-			qWarning() << "MeteorShowers: cannot write JSON data to file";
-		}
-		else
-		{
-			QFile jsonFile(jsonFilePath);
-			if (jsonFile.exists())
-			{
-				jsonFile.remove();
-			}
-
-			if (jsonFile.open(QIODevice::WriteOnly | QIODevice::Text))
-			{
-				jsonFile.write(reply->readAll());
-				jsonFile.close();
-			}
-		}
-	}
-
-	if (progressBar)
-	{
-		progressBar->setValue(100);
-		StelApp::getInstance().removeProgressBar(progressBar);
-		progressBar = NULL;
-	}
-
-	readJsonFile();
-}
-
-void MeteorShowers::displayMessage(const QString& message, const QString hexColor)
-{
-	messageIDs << GETSTELMODULE(LabelMgr)->labelScreen(message, 30, 30 + (20*messageIDs.count()), true, 16, hexColor);
-	messageTimer->start();
-}
-
-void MeteorShowers::messageTimeout(void)
-{
-	foreach(int i, messageIDs)
-	{
-		GETSTELMODULE(LabelMgr)->deleteLabel(i);
-	}
-}
-
-bool MeteorShowers::getFlagLabels()
-{
-	return MeteorShower::showLabels;
-}
-
-void MeteorShowers::setFlagLabels(bool b)
-{
-	if (MeteorShower::showLabels != b)
-		MeteorShower::showLabels = b;
-}
-
-void MeteorShowers::setLabelFontSize(int size)
-{
-	if (labelFont.pixelSize() != size)
-		labelFont.setPixelSize(size);
-}
-
-bool MeteorShowers::getFlagShowMS(void) const
-{
-	if (StelApp::getInstance().getCore()->getCurrentPlanet().data()->getEnglishName()!="Earth")
-		return false;
-	else
-		return flagShowMS;
-}
-
-void MeteorShowers::translations()
-{
-#if 0
-	// Meteor showers
-	// TRANSLATORS: Name of meteor shower
-	N_("Quadrantids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Lyrids");
-	// TRANSLATORS: Name of meteor shower
-	N_("α-Centaurids");
-	// TRANSLATORS: Name of meteor shower
-	N_("γ-Normids");
-	// TRANSLATORS: Name of meteor shower
-	N_("η-Aquariids");
-	// TRANSLATORS: Name of meteor shower
-	N_("June Bootids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Piscis Austrinids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Southern δ-Aquariids");
-	// TRANSLATORS: Name of meteor shower
-	N_("α-Capricornids");
-	// TRANSLATORS: Name of meteor shower
-	N_("α-Aurigids");
-	// TRANSLATORS: Name of meteor shower
-	N_("September ε-Perseids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Draconids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Leonids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Phoenicids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Puppid-Velids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Ursids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Perseids");
-	// TRANSLATORS: Name of meteor shower
-	N_("δ-Leonids");
-	// TRANSLATORS: Name of meteor shower
-	N_("π-Puppids");
-	// TRANSLATORS: Name of meteor shower
-	N_("June Lyrids");
-	// TRANSLATORS: Name of meteor shower
-	N_("κ-Cygnids");
-	// TRANSLATORS: Name of meteor shower
-	N_("ε-Lyrids");
-	// TRANSLATORS: Name of meteor shower
-	N_("δ-Aurigids");
-	// TRANSLATORS: Name of meteor shower
-	N_("ε-Geminids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Southern Taurids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Northern Taurids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Monocerotids");
-	// TRANSLATORS: Name of meteor shower
-	N_("α-Monocerotids");
-	// TRANSLATORS: Name of meteor shower
-	N_("σ-Hydrids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Geminids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Leonis Minorids");
-	// TRANSLATORS: Name of meteor shower
-	N_("December Leonis Minorids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Comae Berenicids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Orionids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Andromedids");
-	// TRANSLATORS: Name of meteor shower
-	N_("η-Lyrids");
-	// TRANSLATORS: Name of meteor shower
-	N_("α-Scorpiids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Ophiuchids");
-	// TRANSLATORS: Name of meteor shower
-	N_("θ-Ophiuchids");
-	// TRANSLATORS: Name of meteor shower
-	N_("κ-Serpentids");
-	// TRANSLATORS: Name of meteor shower
-	N_("θ-Centaurids");
-	// TRANSLATORS: Name of meteor shower
-	N_("ω-Cetids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Southern ω-Scorpiids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Northern ω-Scorpiids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Arietids");
-	// TRANSLATORS: Name of meteor shower
-	N_("π-Cetids");
-	// TRANSLATORS: Name of meteor shower
-	N_("δ-Cancrids");
-	// TRANSLATORS: Name of meteor shower
-	N_("τ-Herculids");
-	// TRANSLATORS: Name of meteor shower
-	N_("ρ-Geminids");
-	// TRANSLATORS: Name of meteor shower
-	N_("η-Carinids");
-	// TRANSLATORS: Name of meteor shower
-	N_("η-Craterids");
-	// TRANSLATORS: Name of meteor shower
-	N_("π-Virginids");
-	// TRANSLATORS: Name of meteor shower
-	N_("θ-Virginids");
-	// TRANSLATORS: Name of meteor shower
-	N_("May Librids");
-	// TRANSLATORS: Name of meteor shower
-	N_("June Scutids");
-	// TRANSLATORS: Name of meteor shower
-	N_("α-Pisces Australids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Southern ι-Aquariids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Northern ι-Aquariids");
-	// TRANSLATORS: Name of meteor shower
-	N_("γ-Aquariids");
-	// TRANSLATORS: Name of meteor shower
-	N_("Autumn Arietids");
-	// TRANSLATORS: Name of meteor shower
-	N_("χ-Orionids");
-
-	// List of parent objects for meteor showers
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 1P/Halley");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 7P/Pons-Winnecke");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 55P/Tempel-Tuttle");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 96P/Machholz");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 109P/Swift-Tuttle");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet Thatcher (1861 I)");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 26P/Grigg-Skjellerup");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 21P/Giacobini-Zinner");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 169P/NEAT");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 289P/Blanpain");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 8P/Tuttle");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 3D/Biela");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet C/1917 F1 (Mellish)");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet C/1964 N1 (Ikeya)");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet Schwassmann-Wachmann 3");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Minor planet 2003 EH1 and Comet C/1490 Y1");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Minor planet (4450) Pan");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Minor planet 2008 ED69");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Comet 2P/Encke");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Minor planet 2004 TG10");
-	// TRANSLATORS: Name of parent object for meteor shower
-	N_("Minor planet (3200) Phaethon");
-
-	/* For copy/paste:
-	// TRANSLATORS: Name of meteor shower
-	N_("");
-	*/
-
-#endif
-}

=== modified file 'plugins/MeteorShowers/src/MeteorShowers.hpp'
--- plugins/MeteorShowers/src/MeteorShowers.hpp	2015-05-31 09:35:00 +0000
+++ plugins/MeteorShowers/src/MeteorShowers.hpp	2015-08-07 05:13:12 +0000
@@ -1,7 +1,6 @@
 /*
  * Stellarium: Meteor Showers Plug-in
- * Copyright (C) 2013 Marcos Cardinot
- * Copyright (C) 2011 Alexander Wolf
+ * Copyright (C) 2013-2015 Marcos Cardinot
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -21,397 +20,70 @@
 #ifndef METEORSHOWERS_HPP_
 #define METEORSHOWERS_HPP_
 
-#include <QColor>
-
 #include "MeteorShower.hpp"
-#include "MeteorStream.hpp"
-#include "StelObjectModule.hpp"
-
-class MeteorShowerDialog;
-class QNetworkAccessManager;
-class QNetworkReply;
-class StelButton;
+#include "MeteorShowersMgr.hpp"
 
 typedef QSharedPointer<MeteorShower> MeteorShowerP;
 
-/*! @defgroup meteorShowers Meteor Showers Plug-in
-@{
-The %Meteor Showers plugin displays meteor showers and a marker for each
-active and inactive radiant, showing real information about its activity.
-
-<b>Configuration</b>
-
-The plug-ins' configuration data is stored in Stellarium's main configuration
-file (section [MeteorShowers]).
-
-@}
-*/
-
 //! @class MeteorShowers
-//! Main class of the %Meteor Showers plugin.
-//! @author Marcos Cardinot
+//! This class manages a collection of MeteorShower objects.
+//! It inherits from MeteorShowersMgr and is basically used to
+//! reimplement the methods defined in the StelObjectModule class.
+//! @author Marcos Cardinot <[e-mail]>
 //! @ingroup meteorShowers
-class MeteorShowers : public StelObjectModule
+class MeteorShowers : public MeteorShowersMgr
 {
 	Q_OBJECT
-	Q_PROPERTY(bool msVisible READ getFlagShowMS WRITE setFlagShowMS)
-	Q_PROPERTY(bool labelsVisible READ getFlagLabels WRITE setFlagLabels)
 public:
-	//! @enum UpdateState
-	//! Used for keeping track of the download/update status
-	enum UpdateState
+	//! @struct SearchResult
+	typedef struct
 	{
-		Updating,             //!< Update in progress
-		CompleteNoUpdates,    //!< Update completed, there we no updates
-		CompleteUpdates,      //!< Update completed, there were updates
-		DownloadError,        //!< Error during download phase
-		OtherError            //!< Other error
-	};
-
-	MeteorShowers();
+		QString name;
+		QString zhr;
+		QString type;
+		QDate peak;
+	} SearchResult;
+
+	//! Constructor
+	MeteorShowers(MeteorShowersMgr *mgr);
+
+	//! Destructor
 	virtual ~MeteorShowers();
 
-	///////////////////////////////////////////////////////////////////////////
-	// Methods defined in the StelModule class
-	virtual void init();
-	//! called before the plug-in is un-loaded.
-	//! Useful for stopping processes, unloading textures, etc.
-	virtual void deinit();
-	virtual void update(double deltaTime);
-	virtual void draw(StelCore* core);
-	virtual void drawMarker(StelCore* core, StelPainter& painter);
-	virtual void drawPointer(StelCore* core, StelPainter& painter);
-	virtual void drawStream(StelCore* core, StelPainter& painter);
-	virtual double getCallOrder(StelModuleActionName actionName) const;
-
-	///////////////////////////////////////////////////////////////////////////
-	// Methods defined in StelObjectManager class
-	//! Used to get a list of objects which are near to some position.
-	//! @param v a vector representing the position in th sky around which to search for nebulae.
-	//! @param limitFov the field of view around the position v in which to search for satellites.
-	//! @param core the StelCore to use for computations.
-	//! @return an list containing the satellites located inside the limitFov circle around position v.
+	//! Update
+	//! @param deltaTime the time increment in seconds since the last call.
+	void update(StelCore *core, double deltaTime);
+
+	//! Draw
+	void draw(StelCore* core);
+
+	//! Loads all meteor showers contained in a QVariantMap.
+	//! @param map
+	void loadMeteorShowers(const QVariantMap& map);
+
+	//! Find all meteor_shower events in a given date interval
+	//! @param dateFrom
+	//! @param dateTo
+	//! @return list
+	QList<SearchResult> searchEvents(QDate dateFrom, QDate dateTo) const;
+
+	//
+	// Methods defined in StelObjectModule class
+	//
 	virtual QList<StelObjectP> searchAround(const Vec3d& v, double limitFov, const StelCore* core) const;
-
-	//! Return the matching satellite object's pointer if exists or NULL.
-	//! @param nameI18n The case in-sensistive satellite name
 	virtual StelObjectP searchByNameI18n(const QString& nameI18n) const;
-
-	//! Return the matching satellite if exists or NULL.
-	//! @param name The case in-sensistive standard program name
 	virtual StelObjectP searchByName(const QString& name) const;
-
-	//! Find and return the list of at most maxNbItem objects auto-completing the passed object I18n name.
-	//! @param objPrefix the case insensitive first letters of the searched object
-	//! @param maxNbItem the maximum number of returned object names
-	//! @return a list of matching object name by order of relevance, or an empty list if nothing match
 	virtual QStringList listMatchingObjectsI18n(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false) const;
 	virtual QStringList listMatchingObjects(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false) const;
 	virtual QStringList listAllObjects(bool inEnglish) const;
-	virtual QStringList listAllObjectsByType(const QString& objType, bool inEnglish) const { Q_UNUSED(objType) Q_UNUSED(inEnglish) return QStringList(); }
-	virtual QString getName() const
-	{
-		return "Meteor Showers";
-	}
-
-	//! get a ms object by identifier
-	MeteorShowerP getByID(const QString& id);
-
-	//! Implment this to tell the main Stellarium GUI that there is a GUI element to configure this
-	//! plugin.
-	virtual bool configureGui(bool show=true);
-
-	//! Set up the plugin with default values.  This means clearing out the MeteorShower section in the
-	//! main config.ini (if one already exists), and populating it with default values.  It also
-	//! creates the default showers.json file from the resource embedded in the plugin lib/dll file.
-	void restoreDefaults(void);
-
-	//! Read (or re-read) settings from the main config file.  This will be called from init and also
-	//! when restoring defaults (i.e. from the configuration dialog / restore defaults button).
-	void readSettingsFromConfig(void);
-
-	//! Save the settings to the main configuration file.
-	void saveSettingsToConfig(void);
-
-	//! get whether or not the plugin will try to update TLE data from the internet
-	//! @return true if updates are set to be done, false otherwise
-	bool getUpdatesEnabled(void)
-	{
-		return updatesEnabled;
-	}
-	//! set whether or not the plugin will try to update TLE data from the internet
-	//! @param b if true, updates will be enabled, else they will be disabled
-	void setUpdatesEnabled(bool b)
-	{
-		updatesEnabled=b;
-	}
-
-	//! get the date and time the TLE elements were updated
-	QDateTime getLastUpdate(void)
-	{
-		return lastUpdate;
-	}
-
-	//! get the update frequency in hours
-	int getUpdateFrequencyHours(void)
-	{
-		return updateFrequencyHours;
-	}
-	void setUpdateFrequencyHours(int hours)
-	{
-		updateFrequencyHours = hours;
-	}
-
-	//! get the number of seconds till the next update
-	int getSecondsToUpdate(void);
-
-	//! Get the current updateState
-	UpdateState getUpdateState(void)
-	{
-		return updateState;
-	}
-
-	//! Get current color of active radiant based  in generic data
-	QColor getColorARG()
-	{
-		return colorARG;
-	}
-	void setColorARG(QColor color)
-	{
-		colorARG = color;
-	}
-
-	//! Get current color of active radiant based  in real data
-	QColor getColorARR()
-	{
-		return colorARR;
-	}
-	void setColorARR(QColor color)
-	{
-		colorARR = color;
-	}
-
-	//! Get current inactive radiant color
-	QColor getColorIR()
-	{
-		return colorIR;
-	}
-	void setColorIR(QColor color)
-	{
-		colorIR = color;
-	}
-
-	//! get the label font size.
-	//! @return the pixel size of the font
-	int getLabelFontSize()
-	{
-		return labelFont.pixelSize();
-	}
-
-	//! Get status of labels
-	//! @return false: hidden
-	bool getFlagLabels();
-
-	//! Get current sky date.
-	//! @return current sky date
-	QDateTime getSkyDate()
-	{
-		return skyDate;
-	}
-
-	//! Find all meteor_shower events in a given date interval
-	//! @param dateFrom
-	//! @param dateTo
-	//! @return meteor_shower list
-	QList<MeteorShowerP> searchEvents(QDate dateFrom, QDate dateTo) const;
-
-signals:
-	//! @param state the new update state.
-	void updateStateChanged(MeteorShowers::UpdateState state);
-
-	//! emitted after a JSON update has run.
-	void jsonUpdateComplete(void);
-
-public slots:
-	//! Download JSON from web recources described in the module section of the
-	//! module.ini file and update the local JSON file.
-	void updateJSON(void);
-
-	void setFlagShowMS(bool b);
-	bool getFlagShowMS(void) const;
-
-	//! Display a message. This is used for plugin-specific warnings and such
-	void displayMessage(const QString& message, const QString hexColor="#999999");
-	void messageTimeout(void);
-
-	//! Define whether the button toggling meteor showers should be visible
-	void setFlagShowMSButton(bool b);
-	bool getFlagShowMSButton(void) { return flagShowMSButton; }
-
-	//! set the label font size.
-	//! @param size the pixel size of the font
-	void setLabelFontSize(int size);
-
-	//! Set whether text labels should be displayed next to radiant.
-	//! @param false: hidden
-	void setFlagLabels(bool b);
-
-	bool getFlagActiveRadiant(void)
-	{
-		return MeteorShower::showActiveRadiantsOnly;
-	}
-	void setFlagActiveRadiant(bool b)
-	{
-		MeteorShower::showActiveRadiantsOnly=b;
-	}
-
-	bool getEnableAtStartup(void) {return enableAtStartup;}
-	void setEnableAtStartup(bool b)	{enableAtStartup=b;}
-
-	bool getFlagRadiant(void) const { return MeteorShower::radiantMarkerEnabled; }
-	void setFlagRadiant(bool b) { MeteorShower::radiantMarkerEnabled=b; }
+	virtual QString getName() const { return "Meteor Showers"; }
 
 private:
-	// Upgrade config.ini: rename old key settings to new
-	void upgradeConfigIni(void);
-
-	//! Check if the sky date was changed
-	//! @param core
-	//! @return if changed, return true
-	bool changedSkyDate(StelCore* core);
-
-	//! Calculate value of ZHR using normal distribution
-	//! @param zhr
-	//! @param variable
-	//! @param start
-	//! @param finish
-	//! @param peak
-	int calculateZHR(int zhr, QString variable, QDateTime start, QDateTime finish, QDateTime peak);
-
-	//! Update the list with information about active meteors
-	//! @param core
-	void updateActiveInfo(void);
-
-	//! Set up the plugin with default values.
-	void restoreDefaultConfigIni(void);
-
-	//! replace the json file with the default from the compiled-in resource
-	void restoreDefaultJsonFile(void);
-
-	//! read the json file and create the meteor Showers.
-	void readJsonFile(void);
-
-	//! Creates a backup of the showers.json file called showers.json.old
-	//! @param deleteOriginal if true, the original file is removed, else not
-	//! @return true on OK, false on failure
-	bool backupJsonFile(bool deleteOriginal=false);
-
-	//! Get the version from the "version of format" value in the showers.json file
-	//! @return version, e.g. "1"
-	int getJsonFileFormatVersion(void);
-	
-	//! Check format of the catalog of meteor showers
-	//! @return valid boolean, e.g. "true"
-	bool checkJsonFileFormat(void);
-
-	//! Parse JSON file and load showers to map
-	QVariantMap loadShowersMap(QString path=QString());
-
-	//! Set items for list of struct from data map
-	void setShowersMap(const QVariantMap& map);
-
-	//! A fake method for strings marked for translation.
-	//! Use it instead of translations.h for N_() strings, except perhaps for
-	//! keyboard action descriptions. (It's better for them to be in a single
-	//! place.)
-	static void translations();
-
-	//! Font used for displaying our text
-	QFont labelFont;
-
-	QString showersJsonPath;
-
-	StelTextureSP texPointer;
-	QList<MeteorShowerP> mShowers;
-
-	// GUI
-	MeteorShowerDialog* configDialog;
-	bool flagShowMS;
-	bool flagShowMSButton;	
-	QPixmap* OnIcon;
-	QPixmap* OffIcon;
-	QPixmap* GlowIcon;
-	StelButton* toolbarButton;
-	QColor colorARR;			//color of active radiant based on real data
-	QColor colorARG;			//color of active radiant based on generic data
-	QColor colorIR;			//color of inactive radiant
-
-	// variables and functions for the updater
-	UpdateState updateState;
-	QNetworkAccessManager* downloadMgr;
-	QString updateUrl;
-	QString updateFile;
-	class StelProgressController* progressBar;
-	QTimer* updateTimer;
-	QTimer* messageTimer;
-	QList<int> messageIDs;
-	bool updatesEnabled;
-	QDateTime lastUpdate;
-	int updateFrequencyHours;
-	bool enableAtStartup;
-
-	QSettings* conf;
-
-	//MS
-	std::vector<std::vector<MeteorStream*> > active;		// Matrix containing all active meteors
-	static const double zhrToWsr;  // factor to convert from zhr to whole earth per second rate
-
-	bool flagShowARG;  //! Show marker of active radiant based on generic data
-	bool flagShowARR;  //! Show marker of active radiant based on generic data
-	bool flagShowIR;   //! Show marker of inactive radiant
-
-	typedef struct
-	{
-		QString showerID;		//! The ID of the meteor shower
-		QDateTime start;		//! First day for activity
-		QDateTime finish;		//! Latest day for activity
-		QDateTime peak;			//! Day with maximum for activity
-		int status;			//! 0:inactive 1:activeRealData 2:activeGenericData
-		int zhr;			//! ZHR of shower
-		QString variable;		//! value of variable for ZHR
-		int speed;			//! Speed of meteors
-		float radiantAlpha;		//! R.A. for radiant of meteor shower
-		float radiantDelta;		//! Dec. for radiant of meteor shower
-		float pidx;			//! Population index
-		QList<MeteorShower::colorPair> colors;	//! Population index
-	} activeData;
-
-	QList<activeData> activeInfo;	//! List of active meteors
-	QDateTime skyDate;              //! Current sky date
-	QDateTime lastSkyDate;          //! Last sky date
-
-private slots:
-	//! check to see if an update is required.  This is called periodically by a timer
-	//! if the last update was longer than updateFrequencyHours ago then the update is
-	//! done.
-	void checkForUpdate(void);
-	void updateDownloadComplete(QNetworkReply* reply);
-};
-
-
-//#include "fixx11h.h"
-#include <QObject>
-#include "StelPluginInterface.hpp"
-
-//! This class is used by Qt to manage a plug-in interface
-class MeteorShowersStelPluginInterface : public QObject, public StelPluginInterface
-{
-	Q_OBJECT
-	Q_PLUGIN_METADATA(IID StelPluginInterface_iid)
-	Q_INTERFACES(StelPluginInterface)
-public:
-	virtual StelModule* getStelModule() const;
-	virtual StelPluginInfo getPluginInfo() const;
+	MeteorShowersMgr* m_mgr;
+	QList<MeteorShowerP> m_meteorShowers;
+
+	//! Draw pointer
+	void drawPointer(StelCore* core);
 };
 
 #endif /*METEORSHOWERS_HPP_*/

=== added file 'plugins/MeteorShowers/src/MeteorShowersMgr.cpp'
--- plugins/MeteorShowers/src/MeteorShowersMgr.cpp	1970-01-01 00:00:00 +0000
+++ plugins/MeteorShowers/src/MeteorShowersMgr.cpp	2015-08-07 05:13:12 +0000
@@ -0,0 +1,611 @@
+/*
+ * Stellarium: Meteor Showers Plug-in
+ * Copyright (C) 2013-2015 Marcos Cardinot
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+ */
+
+#include <QDir>
+#include <QJsonDocument>
+#include <QSettings>
+#include <QTimer>
+
+#include "LabelMgr.hpp"
+#include "MSConfigDialog.hpp"
+#include "MSSearchDialog.hpp"
+#include "MeteorShowersMgr.hpp"
+#include "Planet.hpp"
+#include "StelActionMgr.hpp"
+#include "StelApp.hpp"
+#include "StelFileMgr.hpp"
+#include "StelGui.hpp"
+#include "StelModuleMgr.hpp"
+#include "StelProgressController.hpp"
+#include "StelTextureMgr.hpp"
+#include "StelUtils.hpp"
+#include "SporadicMeteorMgr.hpp"
+
+MeteorShowersMgr::MeteorShowersMgr()
+	: m_meteorShowers(NULL)
+	, m_configDialog(NULL)
+	, m_searchDialog(NULL)
+	, m_conf(StelApp::getInstance().getSettings())
+	, m_onEarth(false)
+	, m_enablePlugin(false)
+	, m_activeRadiantOnly(false)
+	, m_enableAtStartup(true)
+	, m_enableLabels(true)
+	, m_enableMarker(true)
+	, m_showEnableButton(true)
+	, m_showSearchButton(true)
+	, m_messageTimer(NULL)
+	, m_enableAutoUpdates(true)
+	, m_updateFrequencyHours(0)
+	, m_statusOfLastUpdate(OUTDATED)
+	, m_downloadMgr(NULL)
+	, m_progressBar(NULL)
+{
+	setObjectName("MeteorShowers");
+	qsrand(QDateTime::currentMSecsSinceEpoch());
+}
+
+MeteorShowersMgr::~MeteorShowersMgr()
+{
+	delete m_configDialog;
+	delete m_searchDialog;
+	delete m_downloadMgr;
+}
+
+void MeteorShowersMgr::init()
+{
+	loadTextures();
+
+	m_meteorShowers = new MeteorShowers(this);
+	m_configDialog = new MSConfigDialog(this);
+	m_searchDialog = new MSSearchDialog(this);
+
+	createActions();
+	loadConfig();
+
+	// timer to hide the alert messages
+	m_messageTimer = new QTimer(this);
+	m_messageTimer->setSingleShot(true);
+	m_messageTimer->setInterval(9000);
+	m_messageTimer->stop();
+	connect(m_messageTimer, SIGNAL(timeout()), this, SLOT(messageTimeout()));
+
+	// MeteorShowers directory
+	QString userDir = StelFileMgr::getUserDir() + "/modules/MeteorShowers";
+	StelFileMgr::makeSureDirExistsAndIsWritable(userDir);
+
+	// Loads the JSON catalog
+	m_catalogPath = userDir + "/showers.json";
+	if (!loadCatalog(m_catalogPath))
+	{
+		displayMessage(q_("The current catalog of Meteor Showers is invalid!"), "#bb0000");
+		restoreDefaultCatalog(m_catalogPath);
+	}
+
+	// Sets up the download manager
+	m_downloadMgr = new QNetworkAccessManager(this);
+	connect(m_downloadMgr, SIGNAL(finished(QNetworkReply*)), this, SLOT(updateFinished(QNetworkReply*)));
+
+	// every 5 min, check if it's time to update
+	QTimer* updateTimer = new QTimer(this);
+	updateTimer->setInterval(300000);
+	connect(updateTimer, SIGNAL(timeout()), this, SLOT(checkForUpdates()));
+	updateTimer->start();
+	checkForUpdates();
+
+	// always check if we are on Earth
+	StelCore* core = StelApp::getInstance().getCore();
+	m_onEarth = core->getCurrentPlanet().data()->getEnglishName() == "Earth";
+	connect(core, SIGNAL(locationChanged(StelLocation)),
+		this, SLOT(locationChanged(StelLocation)));
+
+	// enable at startup?
+	setEnablePlugin(getEnableAtStartup());
+}
+
+void MeteorShowersMgr::deinit()
+{
+	m_bolideTexture.clear();
+	m_radiantTexture.clear();
+	m_pointerTexture.clear();
+}
+
+double MeteorShowersMgr::getCallOrder(StelModuleActionName actionName) const
+{
+	if (actionName == StelModule::ActionDraw)
+	{
+		return GETSTELMODULE(SporadicMeteorMgr)->getCallOrder(actionName) + 10.;
+	}
+	return 0.;
+}
+
+bool MeteorShowersMgr::configureGui(bool show)
+{
+	if (show)
+	{
+		m_configDialog->setVisible(show);
+	}
+	return true;
+}
+
+void MeteorShowersMgr::createActions()
+{
+	QString msGroup = N_("Meteor Showers");
+	addAction("actionShow_MeteorShowers",               msGroup, N_("Toggle meteor showers"), this,           "enablePlugin", "Ctrl+Alt+M");
+	addAction("actionShow_MeteorShowers_labels",        msGroup, N_("Toggle radiant labels"), this,           "enableLabels", "Shift+M");
+	addAction("actionShow_MeteorShowers_config_dialog", msGroup, N_("Show settings dialog"),  m_configDialog, "visible",      "Ctrl+Shift+M");
+	addAction("actionShow_MeteorShowers_search_dialog", msGroup, N_("Show search dialog"),    m_searchDialog, "visible",      "Ctrl+Shift+S");
+}
+
+void MeteorShowersMgr::loadConfig()
+{
+	setActiveRadiantOnly(m_conf->value(MS_CONFIG_PREFIX + "/flag_active_radiant_only", true).toBool());
+	setShowEnableButton(m_conf->value(MS_CONFIG_PREFIX + "/show_enable_button", true).toBool());
+	setShowSearchButton(m_conf->value(MS_CONFIG_PREFIX + "/show_search_button", true).toBool());
+	setColorARG(StelUtils::strToVec3f(m_conf->value(MS_CONFIG_PREFIX + "/colorARG", "0,255,240").toString()));
+	setColorARC(StelUtils::strToVec3f(m_conf->value(MS_CONFIG_PREFIX + "/colorARC", "255,240,0").toString()));
+	setColorIR(StelUtils::strToVec3f(m_conf->value(MS_CONFIG_PREFIX + "/colorIR", "255,255,255").toString()));
+	setEnableAtStartup(m_conf->value(MS_CONFIG_PREFIX + "/enable_at_startup", true).toBool());
+	setFontSize(m_conf->value(MS_CONFIG_PREFIX + "/font_size", 13).toInt());
+	setEnableLabels(m_conf->value(MS_CONFIG_PREFIX + "/flag_radiant_labels", true).toBool());
+	setEnableMarker(m_conf->value(MS_CONFIG_PREFIX + "/flag_radiant_marker", true).toBool());
+	setUpdateFrequencyHours(m_conf->value(MS_CONFIG_PREFIX + "/update_frequency_hours", 720).toInt());
+	setEnableAutoUpdates(m_conf->value(MS_CONFIG_PREFIX + "/automatic_updates_enabled", true).toBool());
+	setUrl(m_conf->value(MS_CONFIG_PREFIX + "/url", "http://stellarium.org/json/showers.json").toString());
+	setLastUpdate(m_conf->value(MS_CONFIG_PREFIX + "/last_update", "2015-07-01T00:00:00").toDateTime());
+	setStatusOfLastUpdate(m_conf->value(MS_CONFIG_PREFIX + "/last_update_status", 0).toInt());
+}
+
+void MeteorShowersMgr::loadTextures()
+{
+	m_bolideTexture = StelApp::getInstance().getTextureManager().createTextureThread(
+				StelFileMgr::getInstallationDir() + "/textures/cometComa.png",
+				StelTexture::StelTextureParams(true, GL_LINEAR, GL_CLAMP_TO_EDGE));
+
+	m_pointerTexture = StelApp::getInstance().getTextureManager().createTexture(
+				StelFileMgr::getInstallationDir() + "/textures/pointeur5.png");
+
+	m_radiantTexture = StelApp::getInstance().getTextureManager().createTexture(
+				":/MeteorShowers/radiant.png");
+}
+
+bool MeteorShowersMgr::loadCatalog(const QString& jsonPath)
+{
+	qDebug() << "MeteorShowersMgr: Loading catalog file:"
+		 << QDir::toNativeSeparators(jsonPath);
+
+	QFile jsonFile(jsonPath);
+	if (!jsonFile.exists())
+	{
+		restoreDefaultCatalog(jsonPath);
+	}
+
+	if (!jsonFile.open(QIODevice::ReadOnly))
+	{
+		qWarning() << "MeteorShowersMgr: Cannot to open the catalog file!";
+		return false;
+	}
+
+	QJsonObject json(QJsonDocument::fromJson(jsonFile.readAll()).object());
+	jsonFile.close();
+
+	if (json["shortName"].toString() != "meteor showers data"
+		|| json["version"].toInt() != MS_CATALOG_VERSION)
+	{
+		qWarning()  << "MeteorShowersMgr: The current catalog is not compatible!";
+		return false;
+	}
+
+	QVariantMap map = json["showers"].toObject().toVariantMap();
+	m_meteorShowers->loadMeteorShowers(map);
+
+	return true;
+}
+
+void MeteorShowersMgr::restoreDefaultSettings()
+{
+	qDebug() << "MeteorShowersMgr: Restoring default settings";
+	m_conf->beginGroup(MS_CONFIG_PREFIX);
+	m_conf->remove("");
+	m_conf->endGroup();
+	loadConfig();
+	restoreDefaultCatalog(m_catalogPath);
+	m_configDialog->init();
+}
+
+bool MeteorShowersMgr::restoreDefaultCatalog(const QString& destination)
+{
+	qDebug() << "MeteorShowersMgr: Trying to restore the default catalog to"
+		 << QDir::toNativeSeparators(destination);
+
+	QFile d(destination);
+	if (d.exists() && !d.remove())
+	{
+		qWarning() << "MeteorShowersMgr: Cannot remove the current catalog file!";
+		return false;
+	}
+
+	QFile defaultJson(":/MeteorShowers/showers.json");
+	if (!defaultJson.copy(destination))
+	{
+		qWarning() << "MeteorShowersMgr: Cannot copy the default catalog!";
+		return false;
+	}
+
+	// The resource is read only, and the new file inherits this... make sure the
+	// new file is writable by the Stellarium process so that updates can be done.
+	QFile dest(destination);
+	dest.setPermissions(dest.permissions() | QFile::WriteOwner);
+
+	setLastUpdate(QDateTime::fromString("2015-07-01T00:00:00"));
+
+	qDebug() << "MeteorShowersMgr: The default catalog was copied!";
+	displayMessage(q_("Using the default Meteor Showers catalog."), "#bb0000");
+
+	return true;
+}
+
+void MeteorShowersMgr::update(double deltaTime)
+{
+	if (!m_enablePlugin || !m_onEarth)
+	{
+		return;
+	}
+
+	StelCore* core = StelApp::getInstance().getCore();
+
+	// is paused?
+	// freeze meteors at the current position
+	if (!core->getTimeRate()) {
+		return;
+	}
+
+	// is GUI visible? refresh dates
+	if (m_searchDialog->visible())
+	{
+		m_searchDialog->refreshRangeDates();
+	}
+
+	m_meteorShowers->update(core, deltaTime);
+}
+
+void MeteorShowersMgr::draw(StelCore* core)
+{
+	if (m_enablePlugin && m_onEarth)
+	{
+		m_meteorShowers->draw(core);
+	}
+}
+
+void MeteorShowersMgr::repaint()
+{
+	update(1.0);
+	draw(StelApp::getInstance().getCore());
+}
+
+void MeteorShowersMgr::checkForUpdates()
+{
+	if (m_enableAutoUpdates && m_lastUpdate.addSecs(m_updateFrequencyHours * 3600.) <= QDateTime::currentDateTime())
+	{
+		updateCatalog();
+	}
+}
+
+void MeteorShowersMgr::updateCatalog()
+{
+	if (m_statusOfLastUpdate == UPDATING)
+	{
+		qWarning() << "MeteorShowersMgr: The catalog is being updated already!";
+		return;
+	}
+
+	qDebug() << "MeteorShowersMgr: Starting to update the catalog...";
+	setStatusOfLastUpdate(UPDATING);
+
+	setLastUpdate(QDateTime::currentDateTime());
+
+	m_progressBar = StelApp::getInstance().addProgressBar();
+	m_progressBar->setValue(0);
+	m_progressBar->setRange(0, 100);
+	m_progressBar->setFormat("Meteor Showers Catalog");
+
+	QNetworkRequest request;
+	request.setUrl(QUrl(m_url));
+	request.setRawHeader("User-Agent", QString("Mozilla/5.0 (Stellarium Meteor Showers Plugin %1; http://stellarium.org/)").arg(METEORSHOWERS_PLUGIN_VERSION).toUtf8());
+	m_downloadMgr->get(request);
+}
+
+void MeteorShowersMgr::updateFinished(QNetworkReply* reply)
+{
+	if (m_progressBar)
+	{
+		m_progressBar->setValue(100);
+		StelApp::getInstance().removeProgressBar(m_progressBar);
+		m_progressBar = NULL;
+	}
+
+	if (reply->error() != QNetworkReply::NoError)
+	{
+		qWarning() << "MeteorShowersMgr: Failed to download!" << reply->url();
+		qWarning() << "MeteorShowersMgr: Error " << reply->errorString();
+		setStatusOfLastUpdate(FAILED);
+		return;
+	}
+
+	QString tempPath(m_catalogPath + "_new.json");
+	QFile newCatalog(tempPath);
+	newCatalog.remove(); // always overwrites
+	if (!newCatalog.open(QIODevice::ReadWrite | QIODevice::Text))
+	{
+		qWarning() << "MeteorShowersMgr: Cannot write the downloaded catalog!";
+		setStatusOfLastUpdate(FAILED);
+		return;
+	}
+
+	newCatalog.write(reply->readAll());
+	newCatalog.close();
+
+	if (!loadCatalog(tempPath))
+	{
+		setStatusOfLastUpdate(FAILED);
+		return;
+	}
+
+	QFile(m_catalogPath).remove();
+	newCatalog.rename(tempPath.remove("_new.json"));
+
+	qDebug() << "MeteorShowersMgr: The catalog was updated!";
+	setStatusOfLastUpdate(UPDATED);
+}
+
+void MeteorShowersMgr::setEnablePlugin(const bool& b)
+{
+	// we should never change the 'm_enablePlugin' member directly!
+	// as it's a button on the toolbar, it must be sync with its StelAction
+	StelActionMgr* actionMgr = StelApp::getInstance().getStelActionManager();
+	StelAction* action = actionMgr->findAction("actionShow_MeteorShowers");
+	action->setChecked(b);
+}
+
+void MeteorShowersMgr::setActiveRadiantOnly(const bool& b)
+{
+	m_activeRadiantOnly = b;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/flag_active_radiant_only", b);
+}
+
+void MeteorShowersMgr::setShowEnableButton(const bool& show)
+{
+	try
+	{
+		StelGui* gui = dynamic_cast<StelGui*>(StelApp::getInstance().getGui());
+		if (!gui)
+		{
+			return;
+		}
+
+		if (show)
+		{
+			StelButton* enablePlugin = new StelButton(NULL,
+								  QPixmap(":/MeteorShowers/btMS-on.png"),
+								  QPixmap(":/MeteorShowers/btMS-off.png"),
+								  QPixmap(":/graphicGui/glow32x32.png"),
+								  "actionShow_MeteorShowers");
+			gui->getButtonBar()->addButton(enablePlugin, "065-pluginsGroup");
+		}
+		else
+		{
+			gui->getButtonBar()->hideButton("actionShow_MeteorShowers");
+		}
+	}
+	catch (std::runtime_error& e)
+	{
+		qWarning() << "MeteorShowersMgr : unable to create toolbar buttons for MeteorShowers plugin!"
+			   << e.what();
+	}
+	m_showEnableButton = show;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/show_enable_button", show);
+}
+
+void MeteorShowersMgr::setShowSearchButton(const bool& show)
+{
+	try
+	{
+		StelGui* gui = dynamic_cast<StelGui*>(StelApp::getInstance().getGui());
+		if (!gui)
+		{
+			return;
+		}
+
+		if (show)
+		{
+			StelButton* searchMS = new StelButton(NULL,
+							      QPixmap(":/MeteorShowers/btMS-search-on.png"),
+							      QPixmap(":/MeteorShowers/btMS-search-off.png"),
+							      QPixmap(":/graphicGui/glow32x32.png"),
+							      "actionShow_MeteorShowers_search_dialog");
+			gui->getButtonBar()->addButton(searchMS, "065-pluginsGroup");
+		}
+		else
+		{
+			gui->getButtonBar()->hideButton("actionShow_MeteorShowers_search_dialog");
+		}
+	}
+	catch (std::runtime_error& e)
+	{
+		qWarning() << "MeteorShowersMgr : unable to create toolbar buttons for MeteorShowers plugin!"
+			   << e.what();
+	}
+	m_showSearchButton = show;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/show_search_button", show);
+}
+
+void MeteorShowersMgr::setColorARG(const Vec3f& rgb)
+{
+	m_colorARG = rgb;
+	QString rgbStr = QString("%1,%2,%3").arg(rgb[0]).arg(rgb[1]).arg(rgb[2]);
+	m_conf->setValue(MS_CONFIG_PREFIX + "/colorARG", rgbStr);
+}
+
+void MeteorShowersMgr::setColorARC(const Vec3f& rgb)
+{
+	m_colorARC = rgb;
+	QString rgbStr = QString("%1,%2,%3").arg(rgb[0]).arg(rgb[1]).arg(rgb[2]);
+	m_conf->setValue(MS_CONFIG_PREFIX + "/colorARC", rgbStr);
+}
+
+void MeteorShowersMgr::setColorIR(const Vec3f& rgb)
+{
+	m_colorIR = rgb;
+	QString rgbStr = QString("%1,%2,%3").arg(rgb[0]).arg(rgb[1]).arg(rgb[2]);
+	m_conf->setValue(MS_CONFIG_PREFIX + "/colorIR", rgbStr);
+}
+
+void MeteorShowersMgr::setEnableAtStartup(const bool& b)
+{
+	m_enableAtStartup = b;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/enable_at_startup", b);
+}
+
+void MeteorShowersMgr::setFontSize(int pixelSize)
+{
+	pixelSize = pixelSize < 1 ? 13 : pixelSize;
+	m_font.setPixelSize(pixelSize);
+	m_conf->setValue(MS_CONFIG_PREFIX + "/font_size", pixelSize);
+}
+
+void MeteorShowersMgr::setEnableLabels(const bool& b)
+{
+	m_enableLabels = b;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/flag_radiant_labels", b);
+}
+
+void MeteorShowersMgr::setEnableMarker(const bool& b)
+{
+	m_enableMarker = b;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/flag_radiant_marker", b);
+}
+
+void MeteorShowersMgr::setUpdateFrequencyHours(const int& hours)
+{
+	m_updateFrequencyHours = hours;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/update_frequency_hours", hours);
+}
+
+void MeteorShowersMgr::setEnableAutoUpdates(const bool& b)
+{
+	m_enableAutoUpdates = b;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/automatic_updates_enabled", b);
+}
+
+void MeteorShowersMgr::setUrl(const QString& url)
+{
+	m_url = url;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/url", url);
+}
+
+void MeteorShowersMgr::setLastUpdate(const QDateTime &datetime)
+{
+	m_lastUpdate = datetime;
+	m_conf->setValue(MS_CONFIG_PREFIX + "/last_update", m_lastUpdate.toString(Qt::ISODate));
+}
+
+void MeteorShowersMgr::setStatusOfLastUpdate(const int &downloadStatus)
+{
+	m_statusOfLastUpdate = (DownloadStatus) downloadStatus;
+	if (m_statusOfLastUpdate != UPDATING)
+	{
+		m_conf->setValue(MS_CONFIG_PREFIX + "/last_update_status", downloadStatus);
+	}
+	emit(downloadStatusChanged(m_statusOfLastUpdate));
+}
+
+QDateTime MeteorShowersMgr::getNextUpdate()
+{
+	return m_lastUpdate.addSecs(m_updateFrequencyHours * 3600);
+}
+
+void MeteorShowersMgr::displayMessage(const QString& message, const QString hexColor)
+{
+	m_messageIDs << GETSTELMODULE(LabelMgr)->labelScreen(message, 30, 30 + (20 * m_messageIDs.count()), true, 16, hexColor);
+	m_messageTimer->start();
+}
+
+void MeteorShowersMgr::messageTimeout()
+{
+	foreach(int i, m_messageIDs)
+	{
+		GETSTELMODULE(LabelMgr)->deleteLabel(i);
+	}
+}
+
+void MeteorShowersMgr::locationChanged(StelLocation location)
+{
+	m_onEarth = location.planetName == "Earth";
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+StelModule* MeteorShowersStelPluginInterface::getStelModule() const
+{
+	return new MeteorShowersMgr();
+}
+
+StelPluginInfo MeteorShowersStelPluginInterface::getPluginInfo() const
+{
+	// Allow to load the resources when used as a static plugin
+	Q_INIT_RESOURCE(MeteorShower);
+
+	StelPluginInfo info;
+	info.id = "MeteorShowers";
+	info.displayedName = N_("Meteor Showers");
+	info.authors = "Marcos Cardinot";
+	info.contact = "[e-mail]";
+	info.description =
+	"<p>"
+		N_("This plugin enables you to simulate periodic meteor showers and "
+		   "to display a marker for each active and inactive radiant.")
+	"</p>"
+		N_("By a single click on the radiant's marker, you can see all the "
+		   "details about its position and activity. Most data used on this "
+		   "plugin comes from the oficial <a href=\"http://imo.net\">International "
+		   "Meteor Organization</a> catalog.")
+	"</p>"
+		N_("It has three types of markers:")
+		"<ul>"
+			"<li>"
+				"<b>" N_("Confirmed:") "</b> "
+				N_("the radiant is active and its data was confirmed."
+				" Thus, this is a historical (really occurred in the past) or predicted"
+				" meteor shower.")
+			"</li>"
+			"<li>"
+				"<b>" N_("Generic:") "</b> "
+				N_("the radiant is active, but its data was not confirmed."
+				" It means that this can occur on real life, but that we do not have real"
+				" data about its activity for the current sky year.")
+			"</li>"
+			"<li>"
+				"<b>" N_("Inactive:") "</b> "
+				N_("the radiant is inactive for the current sky date.")
+			"</li>"
+		"</ul>"
+	"</p>";
+	info.version = METEORSHOWERS_PLUGIN_VERSION;
+	return info;
+}

=== added file 'plugins/MeteorShowers/src/MeteorShowersMgr.hpp'
--- plugins/MeteorShowers/src/MeteorShowersMgr.hpp	1970-01-01 00:00:00 +0000
+++ plugins/MeteorShowers/src/MeteorShowersMgr.hpp	2015-08-07 05:13:12 +0000
@@ -0,0 +1,288 @@
+/*
+ * Stellarium: Meteor Showers Plug-in
+ * Copyright (C) 2013-2015 Marcos Cardinot
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+ */
+
+#ifndef METEORSHOWERSMGR_HPP_
+#define METEORSHOWERSMGR_HPP_
+
+#include <QNetworkReply>
+
+#include "StelGuiItems.hpp"
+#include "StelObjectModule.hpp"
+
+#define MS_CATALOG_VERSION 1
+#define MS_CONFIG_PREFIX QString("MeteorShowers")
+
+class MeteorShowers;
+class MSConfigDialog;
+class MSSearchDialog;
+
+/*! @defgroup meteorShowers Meteor Showers Plug-in
+@{
+The %Meteor Showers plugin displays meteor showers and a marker for each
+active and inactive radiant, showing real information about its activity.
+
+<b>Configuration</b>
+
+The plug-ins' configuration data is stored in Stellarium's main configuration
+file (section [MeteorShowers]).
+
+@}
+*/
+
+//! @class MeteorShowersMgr
+//! Main class of the %Meteor Showers plugin, inherits from StelObjectModule.
+//! @author Marcos Cardinot <[e-mail]>
+//! @ingroup meteorShowers
+class MeteorShowersMgr : public StelObjectModule
+{
+	Q_OBJECT
+	Q_PROPERTY(bool enablePlugin READ getEnablePlugin WRITE actionEnablePlugin)
+	Q_PROPERTY(bool enableLabels READ getEnableLabels WRITE setEnableLabels)
+
+public:
+	//! @enum DownloadStatus
+	enum DownloadStatus {
+		OUTDATED,
+		UPDATING,
+		UPDATED,
+		FAILED
+	};
+
+	//! Constructor.
+	MeteorShowersMgr();
+
+	//! Destructor.
+	virtual ~MeteorShowersMgr();
+
+	//! Restore default catalog.
+	bool restoreDefaultCatalog(const QString& destination);
+
+	//! Gets the bolide texture.
+	//! @return texture
+	StelTextureSP getBolideTexture() { return m_bolideTexture; }
+
+	//! Gets the pointer texture.
+	//! @return texture
+	StelTextureSP getPointerTexture() { return m_pointerTexture; }
+
+	//! Gets the radiant texture
+	//! @return texture
+	StelTextureSP getRadiantTexture() { return m_radiantTexture; }
+
+	//! Gets the MeteorShowers instance
+	//! @return MeteorShowers instance
+	MeteorShowers* getMeteorShowers() { return m_meteorShowers; }
+
+	//! Enable/disable the meteor showers plugin.
+	void setEnablePlugin(const bool& b);
+	bool getEnablePlugin() { return m_enablePlugin; }
+
+	//! True if user wants to see the active radiants only.
+	bool getActiveRadiantOnly() { return m_activeRadiantOnly; }
+
+	//! Get the status of the enable button on the toolbar.
+	//! @return true if it's visible
+	bool getShowEnableButton() { return m_showEnableButton; }
+
+	//! Get the status of the search button on the toolbar.
+	//! @return true if it's visible
+	bool getShowSearchButton() { return m_showSearchButton; }
+
+	//! Set the color of the active radiant based on generic data.
+	void setColorARG(const Vec3f& rgb);
+	Vec3f getColorARG() { return m_colorARG; }
+
+	//! Set the color of the active radiant based on confirmed data.
+	void setColorARC(const Vec3f& rgb);
+	Vec3f getColorARC() { return m_colorARC; }
+
+	//! Set the color of the inactive radiant.
+	void setColorIR(const Vec3f& rgb);
+	Vec3f getColorIR() { return m_colorIR; }
+
+	//! True if the plugin is enabled at Stellarium startup.
+	bool getEnableAtStartup() { return m_enableAtStartup; }
+
+	//! Set the font size (used on radiant labels).
+	int getFontSize() { return m_font.pixelSize(); }
+
+	//! Get the font.
+	QFont getFont() { return m_font; }
+
+	//! Enable/disable radiant labels
+	bool getEnableLabels() { return m_enableLabels; }
+
+	//! Enable/disable radiant marker.
+	bool getEnableMarker() { return m_enableMarker; }
+
+	//! Gets the update frequency in hours.
+	int getUpdateFrequencyHours() { return m_updateFrequencyHours; }
+
+	//! Enable/disable catalog updates from the internet.
+	bool getEnableAutoUpdates() { return m_enableAutoUpdates; }
+
+	//! Set the URL for downloading the meteor showers catalog.
+	void setUrl(const QString& url);
+	QString getUrl() { return m_url; }
+
+	//! Set the date and time of last update.
+	void setLastUpdate(const QDateTime& datetime);
+	QDateTime getLastUpdate() { return m_lastUpdate; }
+
+	//! Set the status of the last update
+	void setStatusOfLastUpdate(const int &downloadStatus);
+	DownloadStatus getStatusOfLastUpdate() { return m_statusOfLastUpdate; }
+
+	//! Gets the date of the next update.
+	QDateTime getNextUpdate();
+
+	//! It's useful to force the update() and draw().
+	void repaint();
+
+	//
+	// Methods defined in the StelModule class
+	//
+	virtual void init();
+	virtual void deinit();
+	virtual void update(double deltaTime);
+	virtual void draw(StelCore* core);
+	virtual double getCallOrder(StelModuleActionName actionName) const;
+	virtual bool configureGui(bool show=true);
+
+	//
+	// Methods defined in StelObjectModule class
+	//
+	virtual QList<StelObjectP> searchAround(const Vec3d& v, double limitFov, const StelCore* core) const { return QList<StelObjectP>();}
+	virtual StelObjectP searchByNameI18n(const QString& nameI18n) const { return StelObjectP();}
+	virtual StelObjectP searchByName(const QString& name) const { return StelObjectP();}
+	virtual QStringList listMatchingObjectsI18n(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false) const { return QStringList();}
+	virtual QStringList listMatchingObjects(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false) const { return QStringList();}
+	virtual QStringList listAllObjects(bool inEnglish) const { return QStringList();}
+	virtual QStringList listAllObjectsByType(const QString& objType, bool inEnglish) const { Q_UNUSED(objType) Q_UNUSED(inEnglish) return QStringList(); }
+	virtual QString getName() const { return QString();}
+
+signals:
+	void downloadStatusChanged(DownloadStatus);
+
+public slots:
+	//! Enable the meteor showers plugin at Stellarium startup.
+	void setEnableAtStartup(const bool& b);
+
+	//! Show/hide the button that enable/disable the meteor showers plugin.
+	void setShowEnableButton(const bool& show);
+
+	//! Show/hide the button that opens the search dialog.
+	void setShowSearchButton(const bool& show);
+
+	//! Enable/disable radiant marker.
+	void setEnableMarker(const bool& b);
+
+	//! True if user wants to see the active radiants only.
+	void setActiveRadiantOnly(const bool& b);
+
+	//! Enable/disable radiant labels
+	void setEnableLabels(const bool& b);
+
+	//! Set the font size (used on radiant labels).
+	void setFontSize(int pixelSize);
+
+	//! Set the update frequency in hours.
+	void setUpdateFrequencyHours(const int& hours);
+
+	//! Enable/disable automatic catalog updates from the internet.
+	void setEnableAutoUpdates(const bool& b);
+
+	//! Download the Meteor Showers catalog from the Internet.
+	void updateCatalog();
+
+	//! Restore default settings.
+	void restoreDefaultSettings();
+
+	//! Display a message. This is used for plugin-specific warnings and such
+	void displayMessage(const QString& message, const QString hexColor="#999999");
+	void messageTimeout();
+
+private slots:
+	void checkForUpdates();
+	void updateFinished(QNetworkReply* reply);
+	void locationChanged(StelLocation location);
+
+private:
+	MeteorShowers* m_meteorShowers;
+	MSConfigDialog* m_configDialog;
+	MSSearchDialog* m_searchDialog;
+
+	QFont m_font;
+	QSettings* m_conf;
+	QString m_catalogPath;
+
+	bool m_onEarth;
+	bool m_enablePlugin;
+	bool m_activeRadiantOnly;
+	bool m_enableAtStartup;
+	bool m_enableLabels;
+	bool m_enableMarker;
+	bool m_showEnableButton;
+	bool m_showSearchButton;
+
+	Vec3f m_colorARG;        //! color of active radiant based on generic data
+	Vec3f m_colorARC;        //! color of active radiant based on confirmed data
+	Vec3f m_colorIR;         //! color of inactive radiant
+
+	QTimer* m_messageTimer;
+	QList<int> m_messageIDs;
+
+	StelTextureSP m_bolideTexture;  //! Meteor bolide texture
+	StelTextureSP m_pointerTexture; //! Pointer texture
+	StelTextureSP m_radiantTexture; //! Radiant texture
+
+	bool m_isUpdating;
+	bool m_enableAutoUpdates;
+	int m_updateFrequencyHours;
+	QString m_url;
+	QDateTime m_lastUpdate;
+	DownloadStatus m_statusOfLastUpdate;
+	QNetworkAccessManager* m_downloadMgr;
+	class StelProgressController* m_progressBar;
+
+	void createActions();
+	void loadConfig();
+	void loadTextures();
+	bool loadCatalog(const QString& jsonPath);
+
+	//! Enable/disable the Meteor Showers plugin.
+	//! It'll be triggered by a StelAction! So, it should NOT be called directly!
+	void actionEnablePlugin(const bool& b) { m_enablePlugin = b; }
+};
+
+#include <QObject>
+#include "StelPluginInterface.hpp"
+
+//! This class is used by Qt to manage a plug-in interface
+class MeteorShowersStelPluginInterface : public QObject, public StelPluginInterface
+{
+	Q_OBJECT
+	Q_PLUGIN_METADATA(IID StelPluginInterface_iid)
+	Q_INTERFACES(StelPluginInterface)
+public:
+	virtual StelModule* getStelModule() const;
+	virtual StelPluginInfo getPluginInfo() const;
+};
+
+#endif /*METEORSHOWERSMGR_HPP_*/

=== removed file 'plugins/MeteorShowers/src/MeteorStream.cpp'
--- plugins/MeteorShowers/src/MeteorStream.cpp	2015-03-22 09:33:56 +0000
+++ plugins/MeteorShowers/src/MeteorStream.cpp	1970-01-01 00:00:00 +0000
@@ -1,128 +0,0 @@
-/*
- * Stellarium: Meteor Showers Plug-in
- * Copyright (C) 2013 Marcos Cardinot
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
- */
-
-#include "MeteorShowers.hpp"
-#include "MeteorStream.hpp"
-
-MeteorStream::MeteorStream(const StelCore* core,
-			   int speed,
-			   float radiantAlpha,
-			   float radiantDelta,
-			   float pidx,
-			   QList<MeteorShower::colorPair> colors)
-	: m_speed(speed)
-	, m_segments(10)
-{
-	qsrand (QDateTime::currentMSecsSinceEpoch());
-	// if speed is zero, use a random value
-	if (!speed)
-	{
-		m_speed = 11+(double)qrand()/((double)RAND_MAX+1)*61;  // abs range 11-72 km/s
-	}
-
-	// view matrix of meteor model
-	m_viewMatrix = Mat4d::zrotation(radiantAlpha) * Mat4d::yrotation(M_PI_2 - radiantDelta);
-
-	// building meteor model
-	m_alive = Meteor::initMeteorModel(core, m_segments, m_viewMatrix, meteor);
-	if (!m_alive)
-	{
-		return;
-	}
-
-	// implements the population index
-	float oneMag = -0.2; // negative, working in different scale ( 0 to 1 - where 1 is brighter)
-	if (pidx) // is not zero
-	{
-		if (qrand()%100 < 100.f/pidx) // probability
-		{
-			meteor.mag += oneMag;  // (m+1)
-		}
-	}
-
-	// determine the meteor color
-	if (colors.isEmpty()) {
-		colors.push_back(MeteorShower::colorPair("white", 100));
-	} else {
-		// handle cases when the total intensity is less than 100
-		int totalIntensity = 0;
-		int indexWhite = -1;
-		for (int i=0; i<colors.size(); i++) {
-			totalIntensity += colors.at(i).second;
-			if (colors.at(i).first == "white") {
-				indexWhite = i;
-			}
-		}
-
-		int increaseWhite = 0;
-		if (totalIntensity > 100) {
-			qDebug() << "MeteorShowers plugin (showers.json): Total intensity must be less than 100";
-			colors.clear();
-			colors.push_back(MeteorShower::colorPair("white", 100));
-		} else {
-			increaseWhite = 100 - totalIntensity;
-		}
-
-		if (increaseWhite > 0) {
-			if (indexWhite == -1) {
-				colors.push_back(MeteorShower::colorPair("white", increaseWhite));
-			} else {
-				colors[indexWhite].second = increaseWhite;
-			}
-		}
-	}
-
-	// building lineColorArray and trainColorArray
-	Meteor::buildColorArrays(m_segments, colors, m_lineColorArray, m_trainColorArray);
-}
-
-MeteorStream::~MeteorStream()
-{
-}
-
-// returns true if alive
-bool MeteorStream::update(double deltaTime)
-{
-	if (!m_alive)
-	{
-		return false;
-	}
-
-	m_alive = Meteor::updateMeteorModel(deltaTime, m_speed, meteor);
-
-	return m_alive;
-}
-
-// returns true if visible
-// Assumes that we are in local frame
-void MeteorStream::draw(const StelCore* core, StelPainter& sPainter)
-{
-	if (!m_alive)
-	{
-		return;
-	}
-
-	float thickness, bolideSize;
-	Meteor::calculateThickness(core, thickness, bolideSize);
-
-	Meteor::drawTrain(core, sPainter, meteor, m_viewMatrix, thickness,
-			  m_segments, m_lineColorArray, m_trainColorArray);
-
-	Meteor::drawBolide(core, sPainter, meteor, m_viewMatrix, bolideSize);
-}

=== removed file 'plugins/MeteorShowers/src/MeteorStream.hpp'
--- plugins/MeteorShowers/src/MeteorStream.hpp	2015-05-30 19:56:47 +0000
+++ plugins/MeteorShowers/src/MeteorStream.hpp	1970-01-01 00:00:00 +0000
@@ -1,71 +0,0 @@
-/*
- * Stellarium: Meteor Showers Plug-in
- * Copyright (C) 2013 Marcos Cardinot
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
- */
-
-#ifndef _METEORSTREAM_HPP_
-#define _METEORSTREAM_HPP_
-
-#include "Meteor.hpp"
-#include "VecMath.hpp"
-
-class StelCore;
-class StelPainter;
-
-//! @class MeteorStream
-//! Models a single meteor.
-//! Control of the meteor rate is performed in the MeteorShowers class.  Once
-//! created, a meteor object only lasts for some amount of time, and then
-//! "dies", after which, the update() member returns false.
-//! @ingroup meteorShowers
-class MeteorStream
-{
-public:
-	//! Create a Meteor object.
-	//! @param the speed of the meteor in km/s.
-	//! @param rAlpha the radiant alpha in rad
-	//! @param rDelta the radiant delta in rad
-	//! @param pidx population index
-	MeteorStream(const StelCore*,
-		     int speed,
-		     float radiantAlpha,
-		     float radiantDelta,
-		     float pidx,
-		     QList<MeteorShower::colorPair> colors);
-
-	virtual ~MeteorStream();
-
-	//! Updates the position of the meteor, and expires it if necessary.
-	//! @return true of the meteor is still alive, else false.
-	bool update(double deltaTime);
-
-	//! Draws the meteor.
-	void draw(const StelCore* core, StelPainter& sPainter);
-
-private:
-	bool m_alive;             //! Indicate if the meteor it still visible
-
-	float m_speed;              //! Velocity of meteor in km/s
-	Mat4d m_viewMatrix;         //! View Matrix
-	Meteor::MeteorModel meteor; //! Parameters of meteor model
-
-	QList<Vec4f> m_trainColorArray;
-	QList<Vec4f> m_lineColorArray;
-	int m_segments;                 //! Number of segments along the train
-};
-
-#endif // _METEORSTREAM_HPP_

=== added file 'plugins/MeteorShowers/src/gui/MSConfigDialog.cpp'
--- plugins/MeteorShowers/src/gui/MSConfigDialog.cpp	1970-01-01 00:00:00 +0000
+++ plugins/MeteorShowers/src/gui/MSConfigDialog.cpp	2015-08-07 05:13:12 +0000
@@ -0,0 +1,313 @@
+/*
+ * Stellarium: Meteor Showers Plug-in
+ * Copyright (C) 2013-2015 Marcos Cardinot
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+*/
+
+#include <QColorDialog>
+
+#include "MSConfigDialog.hpp"
+#include "StelApp.hpp"
+#include "StelGui.hpp"
+#include "ui_MSConfigDialog.h"
+
+MSConfigDialog::MSConfigDialog(MeteorShowersMgr* mgr)
+	: m_mgr(mgr)
+	, m_ui(new Ui_MSConfigDialog)
+{
+}
+
+MSConfigDialog::~MSConfigDialog()
+{
+	delete m_ui;
+}
+
+void MSConfigDialog::retranslate()
+{
+	if (dialog)
+	{
+		m_ui->retranslateUi(dialog);
+		setAboutHtml();
+	}
+}
+
+void MSConfigDialog::createDialogContent()
+{
+	m_ui->setupUi(dialog);
+	m_ui->tabs->setCurrentIndex(0);
+
+#ifdef Q_OS_WIN
+	// Kinetic scrolling for tablet pc and pc
+	QList<QWidget *> addscroll;
+	addscroll << m_ui->about;
+	installKineticScrolling(addscroll);
+#endif
+
+	connect(&StelApp::getInstance(), SIGNAL(languageChanged()), this, SLOT(retranslate()));
+	connect(m_ui->closeStelWindow, SIGNAL(clicked()), this, SLOT(close()));
+	connect(m_ui->bRestoreDefaults, SIGNAL(clicked()), m_mgr, SLOT(restoreDefaultSettings()));
+
+	// General tab
+	connect(m_ui->enableAtStartUp, SIGNAL(clicked(bool)), m_mgr, SLOT(setEnableAtStartup(bool)));
+	connect(m_ui->showEnableButton, SIGNAL(clicked(bool)), m_mgr, SLOT(setShowEnableButton(bool)));
+	connect(m_ui->showSearchButton, SIGNAL(clicked(bool)), m_mgr, SLOT(setShowSearchButton(bool)));
+
+	// Radiant tab
+	connect(m_ui->enableMarker, SIGNAL(clicked(bool)), m_mgr, SLOT(setEnableMarker(bool)));
+	connect(m_ui->activeRadiantsOnly, SIGNAL(clicked(bool)), m_mgr, SLOT(setActiveRadiantOnly(bool)));
+	connect(m_ui->enableLabels, SIGNAL(clicked(bool)), m_mgr, SLOT(setEnableLabels(bool)));
+	connect(m_ui->fontSize, SIGNAL(valueChanged(int)), m_mgr, SLOT(setFontSize(int)));
+
+	connect(m_ui->setColorARG, SIGNAL(clicked()), this, SLOT(setColorARG()));
+	connect(m_ui->setColorARC, SIGNAL(clicked()), this, SLOT(setColorARC()));
+	connect(m_ui->setColorIR, SIGNAL(clicked()), this, SLOT(setColorIR()));
+
+	// Update tab
+	connect(m_ui->enableUpdates, SIGNAL(clicked(bool)), m_mgr, SLOT(setEnableAutoUpdates(bool)));
+	connect(m_ui->updateFrequency, SIGNAL(valueChanged(int)), m_mgr, SLOT(setUpdateFrequencyHours(int)));
+	connect(m_ui->bUpdate, SIGNAL(clicked()), m_mgr, SLOT(updateCatalog()));
+
+	connect(m_ui->enableUpdates, SIGNAL(clicked()), this, SLOT(refreshUpdateTab()));
+	connect(m_ui->updateFrequency, SIGNAL(valueChanged(int)), this, SLOT(refreshUpdateTab()));
+	connect(m_ui->bUpdate, SIGNAL(clicked()), this, SLOT(refreshUpdateTab()));
+	connect(m_mgr, SIGNAL(downloadStatusChanged(DownloadStatus)), this, SLOT(refreshUpdateTab()));
+
+	// About tab
+	setAboutHtml();
+	StelGui* gui = dynamic_cast<StelGui*>(StelApp::getInstance().getGui());
+	if (gui)
+	{
+		m_ui->about->document()->setDefaultStyleSheet(QString(gui->getStelStyle().htmlStyleSheet));
+	}
+
+	init();
+}
+
+void MSConfigDialog::init()
+{
+	// General tab
+	m_ui->enableAtStartUp->setChecked(m_mgr->getEnableAtStartup());
+	m_ui->showEnableButton->setChecked(m_mgr->getShowEnableButton());
+	m_ui->showSearchButton->setChecked(m_mgr->getShowSearchButton());
+
+	// Radiant tab
+	m_ui->enableMarker->setChecked(m_mgr->getEnableMarker());
+	m_ui->activeRadiantsOnly->setChecked(m_mgr->getActiveRadiantOnly());
+	m_ui->enableLabels->setChecked(m_mgr->getEnableLabels());
+	m_ui->fontSize->setValue(m_mgr->getFontSize());
+	refreshMarkersColor();
+
+	// Update tab
+	refreshUpdateTab();
+}
+
+void MSConfigDialog::refreshUpdateTab()
+{
+	m_ui->enableUpdates->setChecked(m_mgr->getEnableAutoUpdates());
+	m_ui->updateFrequency->setValue(m_mgr->getUpdateFrequencyHours());
+	m_ui->nextUpdate->setDateTime(m_mgr->getNextUpdate());
+
+	m_ui->lastUpdate->setDateTime(m_mgr->getLastUpdate());
+	m_ui->bUpdate->setEnabled(true);
+
+	QString msg;
+	MeteorShowersMgr::DownloadStatus s = m_mgr->getStatusOfLastUpdate();
+	if (s == MeteorShowersMgr::UPDATING)
+	{
+		msg = q_("Updating...");
+		m_ui->bUpdate->setEnabled(false);
+	}
+	else if (s == MeteorShowersMgr::UPDATED)
+	{
+		msg = q_("Successfully updated!");
+	}
+	else if (s == MeteorShowersMgr::FAILED)
+	{
+		msg = q_("Failed!");
+	}
+	else
+	{
+		msg = q_("Outdated!");
+	}
+	m_ui->status->setText(msg);
+}
+
+void MSConfigDialog::refreshMarkersColor()
+{
+	Vec3f c = m_mgr->getColorARG();
+	QColor color(c[0], c[1], c[2]);
+	m_ui->setColorARG->setStyleSheet("background-color:" + color.name() + ";");
+
+	c = m_mgr->getColorARC();
+	color = QColor(c[0], c[1], c[2]);
+	m_ui->setColorARC->setStyleSheet("background-color:" + color.name() + ";");
+
+	c = m_mgr->getColorIR();
+	color = QColor(c[0], c[1], c[2]);
+	m_ui->setColorIR->setStyleSheet("background-color:" + color.name() + ";");
+}
+
+void MSConfigDialog::setColorARG()
+{
+	Vec3f c = m_mgr->getColorARG();
+	QColor color(c[0], c[1], c[2]);
+	color = QColorDialog::getColor(color);
+	if (color.isValid())
+	{
+		m_ui->setColorARG->setStyleSheet("background-color:" + color.name() + ";");
+		m_mgr->setColorARG(Vec3f(color.red(), color.green(), color.blue()));
+	}
+}
+
+void MSConfigDialog::setColorARC()
+{
+	Vec3f c = m_mgr->getColorARC();
+	QColor color(c[0], c[1], c[2]);
+	color = QColorDialog::getColor(color);
+	if (color.isValid())
+	{
+		m_ui->setColorARC->setStyleSheet("background-color:" + color.name() + ";");
+		m_mgr->setColorARC(Vec3f(color.red(), color.green(), color.blue()));
+	}
+}
+
+void MSConfigDialog::setColorIR()
+{
+	Vec3f c = m_mgr->getColorIR();
+	QColor color(c[0], c[1], c[2]);
+	color = QColorDialog::getColor(color);
+	if (color.isValid())
+	{
+		m_ui->setColorIR->setStyleSheet("background-color:" + color.name() + ";");
+		m_mgr->setColorIR(Vec3f(color.red(), color.green(), color.blue()));
+	}
+}
+
+void MSConfigDialog::setAboutHtml()
+{
+	QString html = "<html><head></head><body>"
+	"<h2>" + q_("Meteor Showers Plug-in") + "</h2>"
+	"<table width=\"90%\">"
+		"<tr width=\"30%\">"
+			"<td><strong>" + q_("Version") + ":</strong></td>"
+			"<td>" + METEORSHOWERS_PLUGIN_VERSION + "</td>"
+		"</tr>"
+		"<tr>"
+			"<td><strong>" + q_("Author") + ":</strong></td>"
+			"<td>Marcos Cardinot &lt;[e-mail]&gt;</td>"
+		"</tr>"
+	"</table>"
+	"<p>"
+		+ q_(""
+		     "This plugin enables you to simulate periodic meteor showers and "
+		     "to display a marker for each active and inactive radiant."
+		     "") +
+	"</p>"
+		+ q_(""
+		     "By a single click on the radiant's marker, you can see all the "
+		     "details about its position and activity. Most data used on this "
+		     "plugin comes from the oficial <a href=\"http://imo.net\">International "
+		     "Meteor Organization</a> catalog."
+		     "") +
+	"</p>"
+		+ q_("It has three types of markers:") +
+		"<ul>"
+			"<li>"
+				"<b>" + q_("Confirmed:") + "</b> " +
+				q_("the radiant is active and its data was confirmed."
+				" Thus, this is a historical (really occurred in the past) or predicted"
+				" meteor shower.") +
+			"</li>"
+			"<li>"
+				"<b>" + q_("Generic:") + "</b> " +
+				q_("the radiant is active, but its data was not confirmed."
+				" It means that this can occur on real life, but that we do not have real"
+				" data about its activity for the current sky year.") +
+			"</li>"
+			"<li>"
+				"<b>" + q_("Inactive:") + "</b> " +
+				q_("the radiant is inactive for the current sky date.") +
+			"</li>"
+		"</ul>"
+	"</p>"
+	"<h3>" + q_("Terms") + "</h3>"
+	"<p><b>" + q_("Meteor shower") + "</b>"
+		"<br />" +
+		q_("A meteor shower is a celestial event in which a number of meteors are observed to "
+		"radiate, or originate, from one point in the night sky. These meteors are caused by "
+		"streams of cosmic debris called meteoroids entering Earth's atmosphere at extremely "
+		"high speeds on parallel trajectories. Most meteors are smaller than a grain of sand, "
+		"so almost all of them disintegrate and never hit the Earth's surface. Intense or "
+		"unusual meteor showers are known as meteor outbursts and meteor storms, which may "
+		"produce greater than 1,000 meteors an hour.") +
+	"</p>"
+	"<p><b>" + q_("Radiant") + "</b>"
+		"<br />" +
+		q_("The radiant or apparent radiant of a meteor shower is the point in the sky, from "
+		   "which (to a planetary observer) meteors appear to originate. The Perseids, for "
+		   "example, are meteors which appear to come from a point within the constellation "
+		   "of Perseus.") +
+	"</p>"
+	"<p>" +
+		q_("An observer might see such a meteor anywhere in the sky but the direction of motion, "
+		   "when traced back, will point to the radiant. A meteor that does not point back to the "
+		   "known radiant for a given shower is known as a sporadic and is not considered part of "
+		   "that shower.") +
+	"</p>"
+	"<p>" + q_("Many showers have a radiant point that changes position during the interval when it "
+		   "appears. For example, the radiant point for the Delta Aurigids drifts by more than a "
+		   "degree per night.") +
+	"</p>"
+	"<p><b>" + q_("Zenithal Hourly Rate (ZHR)") + "</b>"
+		"<br />" +
+		q_("In astronomy, the Zenithal Hourly Rate (ZHR) of a meteor shower is the number of meteors "
+		   "a single observer would see in one hour under a clear, dark sky (limiting apparent "
+		   "magnitude of 6.5) if the radiant of the shower were at the zenith. The rate that can "
+		   "effectively be seen is nearly always lower and decreases the closer the radiant is to "
+		   "the horizon.") +
+	"</p>"
+	"<p><b>" + q_("Population index") + "</b>"
+		"<br />" +
+		q_("The population index indicates the magnitude distribution of the meteor showers. The "
+		   "values below 2.5 correspond to distributions where bright meteors are more frequent "
+		   "than average, while values above 3.0 mean that the share of faint meteors is larger "
+		   "than usual.") +
+	"</p>"
+	"<h3>" + q_("Notes") + "</h3>"
+	"<p>" + q_("This plugin was initially created as a project of the ESA Summer of Code in Space 2013.") + "</p>"
+	"<h3>" + q_("Info") + "</h3>"
+	"<p>" + q_("Info about meteor showers you can get here:") + "</p>"
+	"<ul>"
+	// TRANSLATORS: The numbers contain the opening and closing tag of an HTML link
+	"<li>" + QString(q_("%1Meteor shower%2 - article in Wikipedia").arg("<a href=\"https://en.wikipedia.org/wiki/Meteor_Showers\">")).arg("</a>") + "</li>"
+	// TRANSLATORS: The numbers contain the opening and closing tag of an HTML link
+	"<li>" + QString(q_("%1International Meteor Organization%2").arg("<a href=\"http://www.imo.net/\">")).arg("</a>") + "</li>"
+	"</ul>"
+	"<h3>" + q_("Links") + "</h3>"
+	"<p>" + QString(q_("Support is provided via the Launchpad website. Be sure to put \"%1\" in the subject when posting.")).arg("Meteor Showers Plugin") + "</p>"
+	"<ul>"
+	// TRANSLATORS: The numbers contain the opening and closing tag of an HTML link
+	"<li>" + QString(q_("If you have a question, you can %1get an answer here%2").arg("<a href=\"https://answers.launchpad.net/stellarium\">")).arg("</a>") + "</li>"
+	// TRANSLATORS: The numbers contain the opening and closing tag of an HTML link
+	"<li>" + QString(q_("Bug reports can be made %1here%2.")).arg("<a href=\"https://bugs.launchpad.net/stellarium\">").arg("</a>") + "</li>"
+	// TRANSLATORS: The numbers contain the opening and closing tag of an HTML link
+	"<li>" + q_("If you would like to make a feature request, you can create a bug report, and set the severity to \"wishlist\".") + "</li>"
+	// TRANSLATORS: The numbers contain the opening and closing tag of an HTML link
+	"<li>" + q_("If you want to read full information about the plugin, its history and format of the catalog you can %1get info here%2.").arg("<a href=\"http://stellarium.org/wiki/index.php/Meteor_Showers_plugin\">").arg("</a>") + "</li>"
+	"</ul></body></html>";
+
+	m_ui->about->setHtml(html);
+}

=== added file 'plugins/MeteorShowers/src/gui/MSConfigDialog.hpp'
--- plugins/MeteorShowers/src/gui/MSConfigDialog.hpp	1970-01-01 00:00:00 +0000
+++ plugins/MeteorShowers/src/gui/MSConfigDialog.hpp	2015-08-07 05:13:12 +0000
@@ -0,0 +1,76 @@
+/*
+ * Stellarium: Meteor Showers Plug-in
+ * Copyright (C) 2013-2015 Marcos Cardinot
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
+*/
+ 
+#ifndef _MSCONFIGDIALOG_HPP_
+#define _MSCONFIGDIALOG_HPP_
+
+#include "MeteorShowers.hpp"
+#include "StelDialog.hpp"
+
+class Ui_MSConfigDialog;
+
+//! @class MSConfigDialog
+//! Configuration window.
+//! @author Marcos Cardinot <[e-mail]>
+//! @ingroup meteorShowers
+class MSConfigDialog : public StelDialog
+{
+	Q_OBJECT
+
+public:
+	//! Constructor
+	MSConfigDialog(MeteorShowersMgr *mgr);
+
+	//! Destructor
+	~MSConfigDialog();
+
+	//! Initializes the components based on the current settings
+	void init();
+
+protected:
+	//! Initializes the dialog and connect the signals/slots
+	void createDialogContent();
+
+public slots:
+	void retranslate();
+
+private slots:
+	//! Refresh details about the last update
+	void refreshUpdateTab();
+
+	//! Refresh the color of all markers
+	void refreshMarkersColor();
+
+	//! Sets the color of the active radiant based on confirmed data.
+	void setColorARC();
+
+	//! Sets the color of the active radiant based on generic data.
+	void setColorARG();
+
+	//! Sets the color of the inactive radiant.
+	void setColorIR();
+
+private:
+	MeteorShowersMgr* m_mgr;
+	Ui_MSConfigDialog* m_ui;
+
+	void setAboutHtml();
+};
+
+#endif // _MSCONFIGDIALOG_HPP_

=== added file 'plugins/MeteorShowers/src/gui/MSConfigDialog.ui'
--- plugins/MeteorShowers/src/gui/MSConfigDialog.ui	1970-01-01 00:00:00 +0000
+++ plugins/MeteorShowers/src/gui/MSConfigDialog.ui	2015-08-07 05:13:12 +0000
@@ -0,0 +1,657 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MSConfigDialog</class>
+ <widget class="QWidget" name="MSConfigDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>530</width>
+    <height>404</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Meteor Showers Configuration</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <property name="spacing">
+    <number>0</number>
+   </property>
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>