[visualization-api] Introducing Frozen Google Charts

['Daniel LaLiberte' via Google Visualization API]

*Introducing Frozen Google Charts*

When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.

Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.

To load a frozen version, you must make some small changes in how you load
the Google Charts packages. For example, here is the usual way of loading
the stable version and drawing a chart:

<script type="text/javascript"

src="https://www.google.com/jsapi"></script>

<script type="text/javascript">

google.load('visualization', '1', {packages: ['corechart']});

google.setOnLoadCallback(drawChart);

</script>

You'll need to change your code to be like this (changes highlighted in
bold):

<script type="text/javascript"

src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>

<script type="text/javascript">

*google.charts.load(**'41'**,* {packages: ['corechart']});

*google.charts.setOnLoadCallback*(drawChart);
</script>


Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we push
out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.


When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.

1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.

We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.

Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Lokesh Setia]

Hi Daniel,

I see the following error on loading frozen charts over https:

Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure stylesheet 'http://www.gstatic.com/charts/41/css/util/util.css'.
This request has been blocked; the content must be served over HTTPS.

Seems like loader.js is linking to the http version of this file directly:
http://www.gstatic.com/charts/41/css/util/util.css

Let me know how this can be resolved.

thanks,
Lokesh

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Thanks for your report, Lokesh. We should have a fix for this in about an
hour.

Post by Lokesh Setia
Hi Daniel,
Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure stylesheet 'http://www.gstatic.com/charts/41/css/util/util.css'.
This request has been blocked; the content must be served over HTTPS.
http://www.gstatic.com/charts/41/css/util/util.css
Let me know how this can be resolved.
thanks,
Lokesh

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Jace Grantham]

Hey Daniel,

Getting this error loading on https. Trying to use the static version of
the DataTable.

Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure script
'http://www.gstatic.com/charts/41/js/jsapi_compiled_datatable_module.js'.
This request has been blocked; the content must be served over HTTPS.

Thanks and best,
Jace

Post by 'Daniel LaLiberte' via Google Visualization API
Thanks for your report, Lokesh. We should have a fix for this in about an
hour.

Post by Lokesh Setia
Hi Daniel,
Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure stylesheet 'http://www.gstatic.com/charts/41/css/util/util.css'.
This request has been blocked; the content must be served over HTTPS.
Seems like loader.js is linking to the http version of this file
directly: http://www.gstatic.com/charts/41/css/util/util.css
Let me know how this can be resolved.
thanks,
Lokesh

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Jace,

Try again. It might work for you now that I have fixed it and the cache of
the old version has timed out.

Post by Jace Grantham
Hey Daniel,
Getting this error loading on https. Trying to use the static version of
the DataTable.
Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure script '
http://www.gstatic.com/charts/41/js/jsapi_compiled_datatable_module.js'.
This request has been blocked; the content must be served over HTTPS.
Thanks and best,
Jace

Post by 'Daniel LaLiberte' via Google Visualization API
Thanks for your report, Lokesh. We should have a fix for this in about
an hour.

Post by Lokesh Setia
Hi Daniel,
Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure stylesheet 'http://www.gstatic.com/charts/41/css/util/util.css'.
This request has been blocked; the content must be served over HTTPS.
Seems like loader.js is linking to the http version of this file
directly: http://www.gstatic.com/charts/41/css/util/util.css
Let me know how this can be resolved.
thanks,
Lokesh

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/06353400-66cb-42fc-a081-821b2167e5a9%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/06353400-66cb-42fc-a081-821b2167e5a9%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Jace Grantham]

Working great now. Thanks for the quick response and fix Daniel! Much
appreciated.

Best,

Jace

Post by 'Daniel LaLiberte' via Google Visualization API
Jace,
Try again. It might work for you now that I have fixed it and the cache of
the old version has timed out.

Post by Jace Grantham
Hey Daniel,
Getting this error loading on https. Trying to use the static version of
the DataTable.
Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure script '
http://www.gstatic.com/charts/41/js/jsapi_compiled_datatable_module.js'.
This request has been blocked; the content must be served over HTTPS.
Thanks and best,
Jace

Post by 'Daniel LaLiberte' via Google Visualization API
Thanks for your report, Lokesh. We should have a fix for this in about
an hour.

Post by Lokesh Setia
Hi Daniel,
Mixed Content: The page at <url> was loaded over HTTPS, but requested
an insecure stylesheet '
http://www.gstatic.com/charts/41/css/util/util.css'. This request has
been blocked; the content must be served over HTTPS.
Seems like loader.js is linking to the http version of this file
directly: http://www.gstatic.com/charts/41/css/util/util.css
Let me know how this can be resolved.
thanks,
Lokesh

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/06353400-66cb-42fc-a081-821b2167e5a9%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/06353400-66cb-42fc-a081-821b2167e5a9%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Lokesh Setia]

Thanks Daniel, you rock!

On Tue, Aug 18, 2015 at 6:52 PM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Thanks for your report, Lokesh. We should have a fix for this in about an
hour.

Post by Lokesh Setia
Hi Daniel,
Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure stylesheet 'http://www.gstatic.com/charts/41/css/util/util.css'.
This request has been blocked; the content must be served over HTTPS.
Seems like loader.js is linking to the http version of this file
directly: http://www.gstatic.com/charts/41/css/util/util.css
Let me know how this can be resolved.
thanks,
Lokesh

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNY4z7yHQyJZB1eTz8fPhuY1wMmNQZDR65J5iFiXicbfA%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNY4z7yHQyJZB1eTz8fPhuY1wMmNQZDR65J5iFiXicbfA%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

['Daniel LaLiberte' via Google Visualization API]

We just discovered a problem with the frozen version 41 involving css for a
few features, including Table charts, if you have paging, and dashboard
controls. The styles will generally be wrong or missing entirely.

We should have a fix for this within a day.

Post by Lokesh Setia
Thanks Daniel, you rock!
On Tue, Aug 18, 2015 at 6:52 PM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Thanks for your report, Lokesh. We should have a fix for this in about
an hour.

Post by Lokesh Setia
Hi Daniel,
Mixed Content: The page at <url> was loaded over HTTPS, but requested an
insecure stylesheet 'http://www.gstatic.com/charts/41/css/util/util.css'.
This request has been blocked; the content must be served over HTTPS.
Seems like loader.js is linking to the http version of this file
directly: http://www.gstatic.com/charts/41/css/util/util.css
Let me know how this can be resolved.
thanks,
Lokesh

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/9a18b293-6519-4363-b8d2-bb69474f88d5%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNY4z7yHQyJZB1eTz8fPhuY1wMmNQZDR65J5iFiXicbfA%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNY4z7yHQyJZB1eTz8fPhuY1wMmNQZDR65J5iFiXicbfA%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CANbbOpa3n79jHO0w1HN5pAu-zFU7RPpMfa0MvsQt2EayZt2RdQ%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CANbbOpa3n79jHO0w1HN5pAu-zFU7RPpMfa0MvsQt2EayZt2RdQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Daniel Buttery]

Hi Daniel.

I've seen a number of posters both here and in GitHub experiencing issues
this morning related to version '1' being referenced. Changing this to
'1.0' has been a fix.

However I've had both a reply to your previous thread and a new thread
aimed at helping with this issues deleted. Could you at least please post a
sticky regarding '1' v '1.0'? As it stands if people follow the sample code
on the Google Charts site, they will reference v1 and have issues.

Cheers,

Dan

['Daniel LaLiberte' via Google Visualization API]

Changing "1" to "1.0" will only be a "fix" until we push 1.1 to 1.0 this
coming Monday. This is what we have always done when a candidate release
becomes the next production release.

I see a couple of your messages are being held up as potential spam. Not
sure why that would be. I'll approve.

On Tue, Aug 18, 2015 at 8:10 AM, Daniel Buttery <

Post by Daniel Buttery
Hi Daniel.
I've seen a number of posters both here and in GitHub experiencing issues
this morning related to version '1' being referenced. Changing this to
'1.0' has been a fix.
However I've had both a reply to your previous thread and a new thread
aimed at helping with this issues deleted. Could you at least please post a
sticky regarding '1' v '1.0'? As it stands if people follow the sample code
on the Google Charts site, they will reference v1 and have issues.
Cheers,
Dan
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/96c80aae-8974-4365-a03a-14af71016eb1%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/96c80aae-8974-4365-a03a-14af71016eb1%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Patrick Beaudan]

Does the *google.charts.load(**'41'**,* {packages: ['corechart']}); work
for all packages? It seems to not work for me for a gauge chart for
instance code below:

google.load("visualization", "1.0", {packages:["gauge"]});
google.setOnLoadCallback(drawChart); function drawChart() { $.ajax({ url:
"charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Daniel Buttery]

This isn't tested but from what I understand you would need to modify your

Post by Patrick Beaudan
Does the *google.charts.load(**'41'**,* {packages: ['corechart']}); work
for all packages? It seems to not work for me for a gauge chart for
google.charts.load("41", {packages:["corechart, gauge"]}); google.charts.setOnLoadCallback(drawChart);
"charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Patrick Beaudan]

Thanks very much Daniel. I tire that and other variations on that theme,
but can't make it work in one instance on our site (home page at
www.beladv.com should have this gauge, but it does not come up.

Strangely I use the same function to create this gauge on other pages of
my site, and the gauge comes up fine.

I have similar issues with some line charts. The same line chart functions
work on parts of the site, but no longer work on other parts. If anyone
else is having similar issues I'd appreciate a pointer. I'll research this
more and post a fix when I find what the problem was.

Post by Daniel Buttery
This isn't tested but from what I understand you would need to modify your

Post by Patrick Beaudan
Does the *google.charts.load(**'41'**,* {packages: ['corechart']});
work for all packages? It seems to not work for me for a gauge chart for
google.charts.load("41", {packages:["corechart, gauge"]}); google.charts.setOnLoadCallback(drawChart);
"charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Patrick,

In the JavaScript console, I see you are getting the error message:
"Uncaught Error: google.charts.load() cannot be called more than once."

As it says, the current implementation of google.charts.load() can't be
called more than one time in a page, so you'll have to arrange that all
packages you'll need are loaded in the one call, and then don't call it
again. We'll fix that in a future version, but for now, it is a limitation
you'll have to live with.

Post by Patrick Beaudan
Thanks very much Daniel. I tire that and other variations on that theme,
but can't make it work in one instance on our site (home page at
www.beladv.com should have this gauge, but it does not come up.
Strangely I use the same function to create this gauge on other pages of
my site, and the gauge comes up fine.
I have similar issues with some line charts. The same line chart functions
work on parts of the site, but no longer work on other parts. If anyone
else is having similar issues I'd appreciate a pointer. I'll research this
more and post a fix when I find what the problem was.

Post by Daniel Buttery
This isn't tested but from what I understand you would need to modify

Post by Patrick Beaudan
Does the *google.charts.load(**'41'**,* {packages: ['corechart']});
work for all packages? It seems to not work for me for a gauge chart for
google.charts.load("41", {packages:["corechart, gauge"]}); google.charts.setOnLoadCallback(drawChart);
"charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--

You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Patrick Beaudan]

Daniel, thanks very much for taking a look. What would be the way to call
all at once for bar charts, bubble charts, line charts? Can I have a call
to the frozen library and the current library on the same page (that seems
to work but only partially)?

All seems to work as before on some pages (for instance see
http://www.beladv.com/strategySummary.php?strategy=AllWeatherUltra_BA),
where the charts are called using the following script on the page:

<script type="text/javascript" src="https://www.google.com/jsapi"></script>

<script type="text/javascript"
src="charts/portfolioAnalyzer/call_rollingQuarterly.php"></script>
<script type="text/javascript"
src="charts/portfolioAnalyzer/call_quarterlyZscore.php"></script>

etc ...
But on some other pages I'm getting "draw()" errors and tried to
incorporate your frozen version with only partial success like so on our
homepage (www.beladv.com)

<script type="text/javascript"
src="https://www.gstatic.com/charts/loader.js"></script>
<!-- Google charts: Load AJAX API -->
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<!-- Google charts: Load AJAX API -->
<script type="text/javascript" src="//
ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
<script type="text/javascript" src="js/script.js"></script>
<script type="text/javascript"
src="charts/homePage/call_subAssetAlloc.php"></script>
<script type="text/javascript"
src="charts/homePage/call_NAVgrowth.php"></script>
<script type="text/javascript"
src="charts/homePage/call_riskReturnGauge_small.php"></script> <!-- map of
drawdowns vs returns -->

To generate the charts we call individual functions for each chart, and
each function has a call to load, for instance for the last in the list
above the function is:

google.charts.load("41", {packages:["gauge"]});
google.charts.setOnLoadCallback(drawChart);
// google.load("visualization", "1.0", {packages:["gauge"]});
// google.setOnLoadCallback(drawChart);

function drawChart() {
$.ajax({
url: "charts/chart_handler.php?chart=risk_return_gauge",
dataType:"json",
success: function (jsonData) {
// var data = new
google.visualization.arrayToDataTable(jsonData); // Create our data table
out of JSON data loaded from server.
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
width: 150, height: 150,
yellowFrom: 75, yellowTo: 100,
greenFrom: 25, greenTo: 75,
minorTicks: 5
};

var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options);
}
});
}

while for the chart above that (call_NAVgrowth) the function (which still
works) is:

google.load('visualization', '1.0', {'packages':['corechart']}); //
Load the Visualization API and the piechart package.
google.setOnLoadCallback(drawChart); // Set a callback to run when the
Google Visualization API is loaded.

// Callback that creates and populates a data table, instantiates the
chart, passes in the data and draws it.
function drawChart() {
var jsonData = $.ajax({
url: "charts/chart_handler.php?chart=chart_NAVgrowth",
dataType:"json",
success: function (jsonData) {
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.

var options = {
'lineWidth': 1,
'legend': {position: 'top'},
'backgroundColor':'#f8f8ea', // same color as background box
'width':850,
'height':200,
'hAxis': {textStyle: {fontSize:10, color:'black',
bold:'true'}, viewWindowMode: 'maximized', gridlines: {count:-1} },
'vAxis': {textStyle: {fontSize:10, color:'black'},
logScale: 'true', gridlines: {count:-1} },
'fontName':'Trebuchet MS'
};

var chart = new
google.visualization.LineChart(document.getElementById('chart_NAVgrowth'));
// Instantiate chart
chart.draw(data, options); // draw chart, passing in some
options.
}
});
}


Any idea based on these why the current google chart version would not
work? We'd rather change the charts to keep current than use frozen
versions. However if easy to use the frozen library, how would we change
the call to load corechart, Gauges etc all at once?

Finally in your chart library, the calls to data tables seem to all be
something like
var data = new google.visualization.arrayToDataTable(jsonData);


while they used to be simply
var data = new google.visualization.DataTable(jsonData);

Any reason to use .arrayToDataTable versus .DataTable in these examples?

Thanks very much for your help!





On Wed, Aug 19, 2015 at 8:55 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Patrick,
"Uncaught Error: google.charts.load() cannot be called more than once."
As it says, the current implementation of google.charts.load() can't be
called more than one time in a page, so you'll have to arrange that all
packages you'll need are loaded in the one call, and then don't call it
again. We'll fix that in a future version, but for now, it is a limitation
you'll have to live with.

Post by Patrick Beaudan
Thanks very much Daniel. I tire that and other variations on that theme,
but can't make it work in one instance on our site (home page at
www.beladv.com should have this gauge, but it does not come up.
Strangely I use the same function to create this gauge on other pages of
my site, and the gauge comes up fine.
I have similar issues with some line charts. The same line chart
functions work on parts of the site, but no longer work on other parts. If
anyone else is having similar issues I'd appreciate a pointer. I'll
research this more and post a fix when I find what the problem was.

Post by Daniel Buttery
This isn't tested but from what I understand you would need to modify

Post by Patrick Beaudan
Does the *google.charts.load(**'41'**,* {packages: ['corechart']});
work for all packages? It seems to not work for me for a gauge chart for
google.charts.load("41", {packages:["corechart, gauge"]}); google
.charts.setOnLoadCallback(drawChart); function drawChart() { $.ajax({
url: "charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--

You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Best Regards,
Patrick Beaudan
[phone]

['Daniel LaLiberte' via Google Visualization API]

Patrick,

Mixing google.load() and google.charts.load() in the same page is bound to
cause problems. I wouldn't recommend even trying it.

The packages property is an array, so just list all the packages you need.
e.g. packages: ['corechart', 'gauge'].

Post by Patrick Beaudan
Daniel, thanks very much for taking a look. What would be the way to call
all at once for bar charts, bubble charts, line charts? Can I have a call
to the frozen library and the current library on the same page (that seems
to work but only partially)?
All seems to work as before on some pages (for instance see
http://www.beladv.com/strategySummary.php?strategy=AllWeatherUltra_BA),
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<script type="text/javascript"
src="charts/portfolioAnalyzer/call_rollingQuarterly.php"></script>
<script type="text/javascript"
src="charts/portfolioAnalyzer/call_quarterlyZscore.php"></script>
etc ...
But on some other pages I'm getting "draw()" errors and tried to
incorporate your frozen version with only partial success like so on our
homepage (www.beladv.com)
<script type="text/javascript" src="
Load AJAX API -->
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<!-- Google charts: Load AJAX API -->
<script type="text/javascript" src="//
ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
<script type="text/javascript" src="js/script.js"></script>
<script type="text/javascript"
src="charts/homePage/call_subAssetAlloc.php"></script>
<script type="text/javascript"
src="charts/homePage/call_NAVgrowth.php"></script>
<script type="text/javascript"
src="charts/homePage/call_riskReturnGauge_small.php"></script> <!-- map of
drawdowns vs returns -->
To generate the charts we call individual functions for each chart, and
each function has a call to load, for instance for the last in the list
google.charts.load("41", {packages:["gauge"]});
google.charts.setOnLoadCallback(drawChart);
// google.load("visualization", "1.0", {packages:["gauge"]});
// google.setOnLoadCallback(drawChart);
function drawChart() {
$.ajax({
url: "charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) {
// var data = new
google.visualization.arrayToDataTable(jsonData); // Create our data
table out of JSON data loaded from server.
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
width: 150, height: 150,
yellowFrom: 75, yellowTo: 100,
greenFrom: 25, greenTo: 75,
minorTicks: 5
};
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options);
}
});
}
while for the chart above that (call_NAVgrowth) the function (which still
google.load('visualization', '1.0', {'packages':['corechart']}); //
Load the Visualization API and the piechart package.
google.setOnLoadCallback(drawChart); // Set a callback to run when
the Google Visualization API is loaded.
// Callback that creates and populates a data table, instantiates the
chart, passes in the data and draws it.
function drawChart() {
var jsonData = $.ajax({
url: "charts/chart_handler.php?chart=chart_NAVgrowth",
dataType:"json",
success: function (jsonData) {
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
'lineWidth': 1,
'legend': {position: 'top'},
'backgroundColor':'#f8f8ea', // same color as background box
'width':850,
'height':200,
'hAxis': {textStyle: {fontSize:10, color:'black',
bold:'true'}, viewWindowMode: 'maximized', gridlines: {count:-1} },
'vAxis': {textStyle: {fontSize:10, color:'black'},
logScale: 'true', gridlines: {count:-1} },
'fontName':'Trebuchet MS'
};
var chart = new
google.visualization.LineChart(document.getElementById('chart_NAVgrowth'));
// Instantiate chart
chart.draw(data, options); // draw chart, passing in some
options.
}
});
}
Any idea based on these why the current google chart version would not
work? We'd rather change the charts to keep current than use frozen
versions. However if easy to use the frozen library, how would we change
the call to load corechart, Gauges etc all at once?
Finally in your chart library, the calls to data tables seem to all be
something like
var data = new google.visualization.arrayToDataTable(jsonData);
while they used to be simply
var data = new google.visualization.DataTable(jsonData);
Any reason to use .arrayToDataTable versus .DataTable in these examples?
Thanks very much for your help!
On Wed, Aug 19, 2015 at 8:55 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Patrick,
"Uncaught Error: google.charts.load() cannot be called more than once."
As it says, the current implementation of google.charts.load() can't be
called more than one time in a page, so you'll have to arrange that all
packages you'll need are loaded in the one call, and then don't call it
again. We'll fix that in a future version, but for now, it is a limitation
you'll have to live with.

Post by Patrick Beaudan
Thanks very much Daniel. I tire that and other variations on that theme,
but can't make it work in one instance on our site (home page at
www.beladv.com should have this gauge, but it does not come up.
Strangely I use the same function to create this gauge on other pages
of my site, and the gauge comes up fine.
I have similar issues with some line charts. The same line chart
functions work on parts of the site, but no longer work on other parts. If
anyone else is having similar issues I'd appreciate a pointer. I'll
research this more and post a fix when I find what the problem was.

Post by Daniel Buttery
This isn't tested but from what I understand you would need to modify

Post by Patrick Beaudan
Does the *google.charts.load(**'41'**,* {packages: ['corechart']});
work for all packages? It seems to not work for me for a gauge chart for
google.charts.load("41", {packages:["corechart, gauge"]}); google
.charts.setOnLoadCallback(drawChart); function drawChart() { $.ajax({
url: "charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how
you load the Google Charts packages. For example, here is the usual
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help
us if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--

You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Best Regards,
Patrick Beaudan
[phone]
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CACmakz_Ugskj0G%3D%2BN%3DrY4pH6a-iVR2qkncTrV2YXFk%2BT5Z4%2Bmw%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CACmakz_Ugskj0G%3D%2BN%3DrY4pH6a-iVR2qkncTrV2YXFk%2BT5Z4%2Bmw%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

['Daniel LaLiberte' via Google Visualization API]

I should qualify that a bit. Mixing google.load('visualization', ...) and
google.charts.load() on the same page will cause problems because they are
both trying to load code into the same symbols, google.visualization and
google.charts. However, you could reasonably load (with google.load())
other libraries other than 'visualization'.

Post by 'Daniel LaLiberte' via Google Visualization API
Patrick,
Mixing google.load() and google.charts.load() in the same page is bound to
cause problems. I wouldn't recommend even trying it.
The packages property is an array, so just list all the packages you need.
e.g. packages: ['corechart', 'gauge'].

Post by Patrick Beaudan
Daniel, thanks very much for taking a look. What would be the way to call
all at once for bar charts, bubble charts, line charts? Can I have a call
to the frozen library and the current library on the same page (that seems
to work but only partially)?
All seems to work as before on some pages (for instance see
http://www.beladv.com/strategySummary.php?strategy=AllWeatherUltra_BA),
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<script type="text/javascript"
src="charts/portfolioAnalyzer/call_rollingQuarterly.php"></script>
<script type="text/javascript"
src="charts/portfolioAnalyzer/call_quarterlyZscore.php"></script>
etc ...
But on some other pages I'm getting "draw()" errors and tried to
incorporate your frozen version with only partial success like so on our
homepage (www.beladv.com)
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script> <!-- Google
charts: Load AJAX API -->
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<!-- Google charts: Load AJAX API -->
<script type="text/javascript" src="//
ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
<script type="text/javascript" src="js/script.js"></script>
<script type="text/javascript"
src="charts/homePage/call_subAssetAlloc.php"></script>
<script type="text/javascript"
src="charts/homePage/call_NAVgrowth.php"></script>
<script type="text/javascript"
src="charts/homePage/call_riskReturnGauge_small.php"></script> <!-- map of
drawdowns vs returns -->
To generate the charts we call individual functions for each chart, and
each function has a call to load, for instance for the last in the list
google.charts.load("41", {packages:["gauge"]});
google.charts.setOnLoadCallback(drawChart);
// google.load("visualization", "1.0", {packages:["gauge"]});
// google.setOnLoadCallback(drawChart);
function drawChart() {
$.ajax({
url: "charts/chart_handler.php?chart=risk_return_gauge", dataType:"json",
success: function (jsonData) {
// var data = new
google.visualization.arrayToDataTable(jsonData); // Create our data
table out of JSON data loaded from server.
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
width: 150, height: 150,
yellowFrom: 75, yellowTo: 100,
greenFrom: 25, greenTo: 75,
minorTicks: 5
};
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options);
}
});
}
while for the chart above that (call_NAVgrowth) the function (which still
google.load('visualization', '1.0', {'packages':['corechart']}); //
Load the Visualization API and the piechart package.
google.setOnLoadCallback(drawChart); // Set a callback to run when
the Google Visualization API is loaded.
// Callback that creates and populates a data table, instantiates the
chart, passes in the data and draws it.
function drawChart() {
var jsonData = $.ajax({
url: "charts/chart_handler.php?chart=chart_NAVgrowth",
dataType:"json",
success: function (jsonData) {
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
'lineWidth': 1,
'legend': {position: 'top'},
'backgroundColor':'#f8f8ea', // same color as background box
'width':850,
'height':200,
'hAxis': {textStyle: {fontSize:10, color:'black',
bold:'true'}, viewWindowMode: 'maximized', gridlines: {count:-1} },
'vAxis': {textStyle: {fontSize:10, color:'black'},
logScale: 'true', gridlines: {count:-1} },
'fontName':'Trebuchet MS'
};
var chart = new
google.visualization.LineChart(document.getElementById('chart_NAVgrowth'));
// Instantiate chart
chart.draw(data, options); // draw chart, passing in some
options.
}
});
}
Any idea based on these why the current google chart version would not
work? We'd rather change the charts to keep current than use frozen
versions. However if easy to use the frozen library, how would we change
the call to load corechart, Gauges etc all at once?
Finally in your chart library, the calls to data tables seem to all be
something like
var data = new google.visualization.arrayToDataTable(jsonData);
while they used to be simply
var data = new google.visualization.DataTable(jsonData);
Any reason to use .arrayToDataTable versus .DataTable in these examples?
Thanks very much for your help!
On Wed, Aug 19, 2015 at 8:55 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Patrick,
"Uncaught Error: google.charts.load() cannot be called more than once."
As it says, the current implementation of google.charts.load() can't be
called more than one time in a page, so you'll have to arrange that all
packages you'll need are loaded in the one call, and then don't call it
again. We'll fix that in a future version, but for now, it is a limitation
you'll have to live with.

Post by Patrick Beaudan
Thanks very much Daniel. I tire that and other variations on that
theme, but can't make it work in one instance on our site (home page at
www.beladv.com should have this gauge, but it does not come up.
Strangely I use the same function to create this gauge on other pages
of my site, and the gauge comes up fine.
I have similar issues with some line charts. The same line chart
functions work on parts of the site, but no longer work on other parts. If
anyone else is having similar issues I'd appreciate a pointer. I'll
research this more and post a fix when I find what the problem was.

Post by Daniel Buttery
This isn't tested but from what I understand you would need to modify

Post by Patrick Beaudan
Does the *google.charts.load(**'41'**,* {packages: ['corechart']});
work for all packages? It seems to not work for me for a gauge chart for
google.charts.load("41", {packages:["corechart, gauge"]}); google
.charts.setOnLoadCallback(drawChart); function drawChart() {
$.ajax({ url: "charts/chart_handler.php?chart=risk_return_gauge",
dataType:"json", success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how
you load the Google Charts packages. For example, here is the
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not
include the ‘visualization’ parameter, and the version number is a
string. Only version ‘41’ is supported at this time, which corresponds to
the current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help
us if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--

You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Best Regards,
Patrick Beaudan
[phone]
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CACmakz_Ugskj0G%3D%2BN%3DrY4pH6a-iVR2qkncTrV2YXFk%2BT5Z4%2Bmw%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CACmakz_Ugskj0G%3D%2BN%3DrY4pH6a-iVR2qkncTrV2YXFk%2BT5Z4%2Bmw%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Patrick Beaudan]

Daniel, thanks very much for your attention. It now all works, with the
current chart library. What I did is put in the call to multiple chart
types in each of my javascript functions calling the charts eg below. This
way the first of these functions on each page calls all the necessary
packages that become available to all other function calls. The reason that
my charts were working on some pages and not on others seemed to have been
the order in which "gauge" and 'corechart" where called. If gauge was
called first, I got the gauges but no line or bar charts, and if corechart
was called first it was the reverse. by calling all packages in all
functions, the order no longer matters.

Thanks!

google.load("visualization", "1.0", {packages:["gauge, corechart"]});

google.setOnLoadCallback(drawChart);
function drawChart() {
$.ajax({
url: "/charts/chart_handler.php?chart=risk_return_gauge",
dataType:"json",
success: function (jsonData) {
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
width: 150, height: 150,
yellowFrom: 75, yellowTo: 100,
greenFrom: 25, greenTo: 75,
minorTicks: 5
};

var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge'));
chart.draw(data, options);
}
});
}

On Wed, Aug 19, 2015 at 10:19 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
I should qualify that a bit. Mixing google.load('visualization', ...) and
google.charts.load() on the same page will cause problems because they are
both trying to load code into the same symbols, google.visualization and
google.charts. However, you could reasonably load (with google.load())
other libraries other than 'visualization'.

Post by 'Daniel LaLiberte' via Google Visualization API
Patrick,
Mixing google.load() and google.charts.load() in the same page is bound
to cause problems. I wouldn't recommend even trying it.
The packages property is an array, so just list all the packages you
need. e.g. packages: ['corechart', 'gauge'].

Post by Patrick Beaudan
Daniel, thanks very much for taking a look. What would be the way to
call all at once for bar charts, bubble charts, line charts? Can I have a
call to the frozen library and the current library on the same page (that
seems to work but only partially)?
All seems to work as before on some pages (for instance see
http://www.beladv.com/strategySummary.php?strategy=AllWeatherUltra_BA),
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<script type="text/javascript"
src="charts/portfolioAnalyzer/call_rollingQuarterly.php"></script>
<script type="text/javascript"
src="charts/portfolioAnalyzer/call_quarterlyZscore.php"></script>
etc ...
But on some other pages I'm getting "draw()" errors and tried to
incorporate your frozen version with only partial success like so on our
homepage (www.beladv.com)
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script> <!-- Google
charts: Load AJAX API -->
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<!-- Google charts: Load AJAX API -->
<script type="text/javascript" src="//
ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
<script type="text/javascript" src="js/script.js"></script>
<script type="text/javascript"
src="charts/homePage/call_subAssetAlloc.php"></script>
<script type="text/javascript"
src="charts/homePage/call_NAVgrowth.php"></script>
<script type="text/javascript"
src="charts/homePage/call_riskReturnGauge_small.php"></script> <!-- map of
drawdowns vs returns -->
To generate the charts we call individual functions for each chart, and
each function has a call to load, for instance for the last in the list
google.charts.load("41", {packages:["gauge"]});
google.charts.setOnLoadCallback(drawChart);
// google.load("visualization", "1.0", {packages:["gauge"]});
// google.setOnLoadCallback(drawChart);
function drawChart() {
$.ajax({
url: "charts/chart_handler.php?chart=risk_return_gauge",
dataType:"json",
success: function (jsonData) {
// var data = new
google.visualization.arrayToDataTable(jsonData); // Create our data
table out of JSON data loaded from server.
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
width: 150, height: 150,
yellowFrom: 75, yellowTo: 100,
greenFrom: 25, greenTo: 75,
minorTicks: 5
};
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options);
}
});
}
while for the chart above that (call_NAVgrowth) the function (which
google.load('visualization', '1.0', {'packages':['corechart']}); //
Load the Visualization API and the piechart package.
google.setOnLoadCallback(drawChart); // Set a callback to run when
the Google Visualization API is loaded.
// Callback that creates and populates a data table, instantiates the
chart, passes in the data and draws it.
function drawChart() {
var jsonData = $.ajax({
url: "charts/chart_handler.php?chart=chart_NAVgrowth",
dataType:"json",
success: function (jsonData) {
var data = new google.visualization.DataTable(jsonData); //
Create our data table out of JSON data loaded from server.
var options = {
'lineWidth': 1,
'legend': {position: 'top'},
'backgroundColor':'#f8f8ea', // same color as background box
'width':850,
'height':200,
'hAxis': {textStyle: {fontSize:10, color:'black',
bold:'true'}, viewWindowMode: 'maximized', gridlines: {count:-1} },
'vAxis': {textStyle: {fontSize:10, color:'black'},
logScale: 'true', gridlines: {count:-1} },
'fontName':'Trebuchet MS'
};
var chart = new
google.visualization.LineChart(document.getElementById('chart_NAVgrowth'));
// Instantiate chart
chart.draw(data, options); // draw chart, passing in some
options.
}
});
}
Any idea based on these why the current google chart version would not
work? We'd rather change the charts to keep current than use frozen
versions. However if easy to use the frozen library, how would we change
the call to load corechart, Gauges etc all at once?
Finally in your chart library, the calls to data tables seem to all be
something like
var data = new google.visualization.arrayToDataTable(jsonData);
while they used to be simply
var data = new google.visualization.DataTable(jsonData);
Any reason to use .arrayToDataTable versus .DataTable in these examples?
Thanks very much for your help!
On Wed, Aug 19, 2015 at 8:55 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Patrick,
"Uncaught Error: google.charts.load() cannot be called more than once."
As it says, the current implementation of google.charts.load() can't be
called more than one time in a page, so you'll have to arrange that all
packages you'll need are loaded in the one call, and then don't call it
again. We'll fix that in a future version, but for now, it is a limitation
you'll have to live with.

Post by Patrick Beaudan
Thanks very much Daniel. I tire that and other variations on that
theme, but can't make it work in one instance on our site (home page at
www.beladv.com should have this gauge, but it does not come up.
Strangely I use the same function to create this gauge on other pages
of my site, and the gauge comes up fine.
I have similar issues with some line charts. The same line chart
functions work on parts of the site, but no longer work on other parts. If
anyone else is having similar issues I'd appreciate a pointer. I'll
research this more and post a fix when I find what the problem was.

Post by Daniel Buttery
This isn't tested but from what I understand you would need to modify

Post by Patrick Beaudan
Does the *google.charts.load(**'41'**,* {packages: ['corechart']});
work for all packages? It seems to not work for me for a gauge chart for
google.charts.load("41", {packages:["corechart, gauge"]}); google
.charts.setOnLoadCallback(drawChart); function drawChart() {
$.ajax({ url: "charts/chart_handler.php?chart=risk_return_gauge",
dataType:"json", success: function (jsonData) { var data = new
google.visualization.DataTable(jsonData); // Create our data table out of
JSON data loaded from server. var options = { width: 150, height: 150,
yellowFrom: 75, yellowTo: 100, greenFrom: 25, greenTo: 75, minorTicks: 5 };
var chart = new
google.visualization.Gauge(document.getElementById('chart_riskReturnGauge_small'));
chart.draw(data, options); } }); }

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how
you load the Google Charts packages. For example, here is the
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not
include the ‘visualization’ parameter, and the version number is a
string. Only version ‘41’ is supported at this time, which corresponds to
the current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load
all the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help
us if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--

You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/d56187d6-accb-40bd-a038-19ce7b3532ff%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058
Ridge Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNw%2Bewp9VgoJ2mpkHRtfzQw3iKd9U6ecscaMGJ8u6jB2Q%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Best Regards,
Patrick Beaudan
[phone]
--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CACmakz_Ugskj0G%3D%2BN%3DrY4pH6a-iVR2qkncTrV2YXFk%2BT5Z4%2Bmw%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CACmakz_Ugskj0G%3D%2BN%3DrY4pH6a-iVR2qkncTrV2YXFk%2BT5Z4%2Bmw%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNk0K3FE9CApUxYeppMQUDT%2BHM2Y%3D-NXO-H9hdKY1TskQ%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNk0K3FE9CApUxYeppMQUDT%2BHM2Y%3D-NXO-H9hdKY1TskQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Best Regards,
Patrick Beaudan
[phone]

[Mark]

Hi,

I'm getting the following:

Uncaught Error: Module: 'visualization' with version: '41' not found!

var error = new Error("Module: 'visualization' with version: '41' not
found!");
error.toString = function() { return this.message; }
throw error;

['Daniel LaLiberte' via Google Visualization API]

Mark,

It sounds like you are still using google.load(). If you are trying to use
the frozen version, you need to change that too google.charts.load(), and
follow the rest of the instructions as well.

Post by Mark
Hi,
Uncaught Error: Module: 'visualization' with version: '41' not found!
var error = new Error("Module: 'visualization' with version: '41' not
found!");
error.toString = function() { return this.message; }
throw error;
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8f474e03-adf1-48d8-a606-a23f45e36c44%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8f474e03-adf1-48d8-a606-a23f45e36c44%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Mark]

Works! Thanks Daniel!

[Kevin Crawley]

We're having some trouble using the new loader in PhantomJS. It appears the
loader will not execute, and it's not giving any feedback/errors.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Kevin,

If you are using PhantomJS outside of a web page, that would explain why
the new loader is having a problem. It currently assumes it can load using
the same scheme (http or https) as the page itself. This is similar to the
problem Thomas Schwab reported regarding charts in email.

Post by Kevin Crawley
We're having some trouble using the new loader in PhantomJS. It appears
the loader will not execute, and it's not giving any feedback/errors.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Kevin Crawley]

We're actually loading the page from a web server and PhantomJS has outside
network access. I managed to get the PhantomJS remote debugger going and
got some feedback from the loader.

TypeError: 'undefined' is not an object (evaluating 'a[L]') [loader.js:60]


'loadGoogleVisLibrary': function() {
var deferred = Q.defer();

google.charts.load("visualization", "1", {
packages: ['corechart', 'table', 'gauge']
});

google.charts.setOnLoadCallback(function() {
console.log('this will never happen');
});

setTimeout(function() {
console('logically, google.load callback should have happened by now');
}, 1500);

return deferred.promise;
},

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
If you are using PhantomJS outside of a web page, that would explain why
the new loader is having a problem. It currently assumes it can load using
the same scheme (http or https) as the page itself. This is similar to the
problem Thomas Schwab reported regarding charts in email.

Post by Kevin Crawley
We're having some trouble using the new loader in PhantomJS. It appears
the loader will not execute, and it's not giving any feedback/errors.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Kevin Crawley]

@Daniel

Do you have any feedback regarding this issue. We are unable to deploy the
frozen loader until it will work in PhantomJS. The file *is *being loaded
from a web server; so I believe the problem we're experiencing is unrelated
to the issue Thomas was having.

Regards
-Kevin

Post by Kevin Crawley
We're actually loading the page from a web server and PhantomJS has
outside network access. I managed to get the PhantomJS remote debugger
going and got some feedback from the loader.
TypeError: 'undefined' is not an object (evaluating 'a[L]') [loader.js:60]
'loadGoogleVisLibrary': function() {
var deferred = Q.defer();
google.charts.load("visualization", "1", {
packages: ['corechart', 'table', 'gauge']
});
google.charts.setOnLoadCallback(function() {
console.log('this will never happen');
});
setTimeout(function() {
console('logically, google.load callback should have happened by now');
}, 1500);
return deferred.promise;
},

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
If you are using PhantomJS outside of a web page, that would explain why
the new loader is having a problem. It currently assumes it can load using
the same scheme (http or https) as the page itself. This is similar to the
problem Thomas Schwab reported regarding charts in email.

Post by Kevin Crawley
We're having some trouble using the new loader in PhantomJS. It appears
the loader will not execute, and it's not giving any feedback/errors.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Kevin,

I believe I fixed the problem of loading pages with schemes other than http
or https, so loading via PhantomJS might work now.

Post by Kevin Crawley
@Daniel
Do you have any feedback regarding this issue. We are unable to deploy the
frozen loader until it will work in PhantomJS. The file *is *being loaded
from a web server; so I believe the problem we're experiencing is unrelated
to the issue Thomas was having.
Regards
-Kevin

Post by Kevin Crawley
We're actually loading the page from a web server and PhantomJS has
outside network access. I managed to get the PhantomJS remote debugger
going and got some feedback from the loader.
TypeError: 'undefined' is not an object (evaluating 'a[L]') [loader.js:60
]
'loadGoogleVisLibrary': function() {
var deferred = Q.defer();
google.charts.load("visualization", "1", {
packages: ['corechart', 'table', 'gauge']
});
google.charts.setOnLoadCallback(function() {
console.log('this will never happen');
});
setTimeout(function() {
console('logically, google.load callback should have happened by now');
}, 1500);
return deferred.promise;
},

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
If you are using PhantomJS outside of a web page, that would explain why
the new loader is having a problem. It currently assumes it can load using
the same scheme (http or https) as the page itself. This is similar to the
problem Thomas Schwab reported regarding charts in email.

Post by Kevin Crawley
We're having some trouble using the new loader in PhantomJS. It appears
the loader will not execute, and it's not giving any feedback/errors.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--

You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2648a667-e857-4116-a04d-4472ee883de8%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2648a667-e857-4116-a04d-4472ee883de8%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Kevin Crawley]

Still having the same issue, loader.js fails at line 60. As noted, we're
loading a page from our live servers with PhantomJS, so the protocol it's
using should be http/https. I haven't tried Phantom 2.0, but 1.9.8 is not
working.

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
I believe I fixed the problem of loading pages with schemes other than
http or https, so loading via PhantomJS might work now.

Post by Kevin Crawley
@Daniel
Do you have any feedback regarding this issue. We are unable to deploy
the frozen loader until it will work in PhantomJS. The file *is *being
loaded from a web server; so I believe the problem we're experiencing is
unrelated to the issue Thomas was having.
Regards
-Kevin

Post by Kevin Crawley
We're actually loading the page from a web server and PhantomJS has
outside network access. I managed to get the PhantomJS remote debugger
going and got some feedback from the loader.
60]
'loadGoogleVisLibrary': function() {
var deferred = Q.defer();
google.charts.load("visualization", "1", {
packages: ['corechart', 'table', 'gauge']
});
google.charts.setOnLoadCallback(function() {
console.log('this will never happen');
});
setTimeout(function() {
console('logically, google.load callback should have happened by now');
}, 1500);
return deferred.promise;
},

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
If you are using PhantomJS outside of a web page, that would explain
why the new loader is having a problem. It currently assumes it can load
using the same scheme (http or https) as the page itself. This is similar
to the problem Thomas Schwab reported regarding charts in email.

Post by Kevin Crawley
We're having some trouble using the new loader in PhantomJS. It
appears the loader will not execute, and it's not giving any
feedback/errors.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2bcf2637-da51-4513-a61c-6209d2f7a432%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--

You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2648a667-e857-4116-a04d-4472ee883de8%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2648a667-e857-4116-a04d-4472ee883de8%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Thomas]

The frozen version works if the chart html file is hosted on a web server.

However, if a user opens the same chart html file from a local directory,
loader cannot load util.css.
Chrome > F12 shows:


<Loading Image...>



The loader fails.
This behavior of frozen version (41) differs from behavior of “maintained
version” (1).
A chart html file may be hosted but not mailed.
=> Would be great if frozen version would behave like maintained version
(for http and https).

['Daniel LaLiberte' via Google Visualization API]

Thomas, thanks for your report. I see that the reason this fails is that
the loader is attempting to load using the same scheme as the page, which
would be fine for web pages, but we should use the same scheme as the
loader itself was loaded with. I should be able to fix this in a couple
hours.

Post by Thomas
The frozen version works if the chart html file is hosted on a web server.
However, if a user opens the same chart html file from a local directory,
loader cannot load util.css.
<https://lh3.googleusercontent.com/-NWvm5WC1984/Vdr9zEPsRRI/AAAAAAAAAAk/eHD9h0ybL30/s1600/1.png>
The loader fails.
This behavior of frozen version (41) differs from behavior of “maintained
version” (1).
A chart html file may be hosted but not mailed.
=> Would be great if frozen version would behave like maintained version
(for http and https).
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/0bb62d14-0927-44d4-b9f9-2492d530cc98%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/0bb62d14-0927-44d4-b9f9-2492d530cc98%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas]

Works ... thank you! Thomas

[Thomas]

Hi Daniel
I guess tooltip.css does have the "scheme problem", too. (There may be
additional files.)
Regards, Thomas

['Daniel LaLiberte' via Google Visualization API]

Hi Thomas,

The tooltip.css file has a worse problem in that it is being loaded from
the wrong place entirely. I'll have a fix for that as soon as I can get it
in. Perhaps today.

Post by Lokesh Setia
Hi Daniel
I guess tooltip.css does have the "scheme problem", too. (There may be
additional files.)
Regards, Thomas
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/4d917679-2cef-48f6-b5c8-f379e299265d%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/4d917679-2cef-48f6-b5c8-f379e299265d%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas]

Okay. Thx. Sometimes, some labels overlap. This might be the result of
missing files, a "chain reaction".




<Loading Image...>

['Daniel LaLiberte' via Google Visualization API]

Thomas,

The missing tooltip.css problem should be fixed now.

Not sure how you are seeing the overlap of the axis title and tick labels.
Can you give us a link, or create a jsfiddle to demonstrate it? Thanks.

Post by Thomas
Okay. Thx. Sometimes, some labels overlap. This might be the result of
missing files, a "chain reaction".
<https://lh3.googleusercontent.com/-C8ejAsmX-a8/VersByLSD-I/AAAAAAAAAA4/HLNDp7K0e7Y/s1600/ol.jpg>
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/440705f0-feeb-43c6-949b-f43014499997%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/440705f0-feeb-43c6-949b-f43014499997%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas]

Okay, thank you.

Chrome loads tooltip.css!


Chrome shows a second reference to a file called tooltip.css, now.
Chrome cannot resolve this second reference (> Open chart html file from
local directory > F12 > Tab “Network”).

Furthermore, if a browser loads the chart resources using http, it loads
some files using http, others files using https.
Would be great if browsers could use http respectively tls all the way down.


(If the reference changes will not solve the “overlap problem” => a very
special case!, then I will try to prepare a fiddle, later.)

['Daniel LaLiberte' via Google Visualization API]

Thomas,

Yes, the extra attempt to load tooltip.css from the wrong place will
remain, since it is hard-coded into the frozen version rather than being
part of the loader configuration. This will be fixed in version 43.

Post by Thomas
Okay, thank you.
Chrome loads tooltip.css!
Chrome shows a second reference to a file called tooltip.css, now.
Chrome cannot resolve this second reference (> Open chart html file from
local directory > F12 > Tab “Network”).
Furthermore, if a browser loads the chart resources using http, it loads
some files using http, others files using https.
Would be great if browsers could use http respectively tls all the way down.
(If the reference changes will not solve the “overlap problem” => a very
special case!, then I will try to prepare a fiddle, later.)
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/33b40443-d265-427a-ae0c-e5a76aa13cc3%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/33b40443-d265-427a-ae0c-e5a76aa13cc3%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas]

hi

*https*

works, thx.
*http*
would be an asset. some html pages have to use http throughout (e.g.,

taking account of additional 3rd party libraries).

*tooltip.css*
thx for the info. when will google "freeze" 43 (provide a frozen version)?
2015? 2016? an exact

answer is not necessary, of course.

*"overlap problem"*
if the stable version draws a line chart while style.display of div is
'none' (initially), the line chart will be *okay*.
if the frozen version draws a line chart while style.display of div is
'none' (initially), the line chart will be *NOT okay*: the
vertical labels overlap (a picture is in this thread, above).
approach (subject to tests): use style.visibility rather than
style.display.
*besides, another question*
Is it in order to call setOnLoadCallback several times and draw several
charts?

['Daniel LaLiberte' via Google Visualization API]

Thomas,

I believe that pages fetched via http can load resources via https without
concern, but not the other way around. In other words, loading secure
resources in an insecure page is OK, but loading insecure resources in a
secure page would compromise the security of the page. If the Google Charts
internal use of https causes problems for anyone, I'm sure we'll hear about
it.

Version 43 will be frozen sometime before version 44 is released, but more
likely, soon after version 43 is released to production which could be in
about 1 month. We hope to start the v43 release cycle this week.

Regarding the problem with setting the container style.display to 'none',
this will continue to be a problem since Google Charts doesn't know how big
your text labels are when you draw a chart unless the chart is being
displayed, even if it is invisible (via style.visibility).

You should be able to call setOnLoadCallback multiple times, at least with
the google.charts.setOnLoadCallback. The answer is less clear with
google.setOnLoadCallback.

Post by Thomas
hi
*https*

works, thx.
*http*
would be an asset. some html pages have to use http throughout (e.g.,

taking account of additional 3rd party libraries).

*tooltip.css*
thx for the info. when will google "freeze" 43 (provide a frozen
version)? 2015? 2016? an exact

answer is not necessary, of course.

*"overlap problem"*
if the stable version draws a line chart while style.display of div is
'none' (initially), the line chart will be *okay*.
if the frozen version draws a line chart while style.display of div is
'none' (initially), the line chart will be *NOT okay*: the
vertical labels overlap (a picture is in this thread, above).
approach (subject to tests): use style.visibility rather than
style.display.
*besides, another question*
Is it in order to call setOnLoadCallback several times and draw several
charts?
--

You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/b41e7e50-ad3b-4d7b-87b5-2fc0aac2a020%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/b41e7e50-ad3b-4d7b-87b5-2fc0aac2a020%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas]

thanks a lot!

but it is okay to use *only* style.visibility, right?

['Daniel LaLiberte' via Google Visualization API]

Yes, using style.visibility = 'hidden' does everything the same as
'visible' except it's just not visible. So text measuring works OK.

Post by Thomas
thanks a lot!
but it is okay to use *only* style.visibility, right?
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/92b62d42-7d6e-488c-95bc-2ef7cc46d140%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/92b62d42-7d6e-488c-95bc-2ef7cc46d140%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

['Daniel LaLiberte' via Google Visualization API]

Google Charts version 42 can now be loaded via the frozen code loader.
Just replace "41" with "42" in your google.charts.load() call to get that
version.

In upcoming releases, we expect to make the "frozen" version available even
sooner after the public release of the "stable" version. In fact, we will
probably make the next version available even before starting the normal
release cycle, thus allowing people to use our very latest development
version and help us test it out that much sooner. Watch for upcoming
announcements about that.

Post by 'Daniel LaLiberte' via Google Visualization API
Yes, using style.visibility = 'hidden' does everything the same as
'visible' except it's just not visible. So text measuring works OK.

Post by Thomas
thanks a lot!
but it is okay to use *only* style.visibility, right?
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/92b62d42-7d6e-488c-95bc-2ef7cc46d140%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/92b62d42-7d6e-488c-95bc-2ef7cc46d140%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Paul Benson]

We are using dynamic chart creation, so I can not specify
"google.charts.setOnLoadCallback(drawTable);" so javascript is failing when
I try to reference google.visualization.DateTable, or anything else using
google.visualization....

I am using the google.charts.load() as well as the other changes
highlighted above.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Hi Paul,

I don't understand why you can't call
google.charts.setOnLoadCallback(drawTable) when you want the drawTable
function to be called (once the Google Charts code has been loaded). How
is this different from when you would use google.load() and
google.setOnLoadCallback()?

Post by Paul Benson
We are using dynamic chart creation, so I can not specify
"google.charts.setOnLoadCallback(drawTable);" so javascript is failing when
I try to reference google.visualization.DateTable, or anything else using
google.visualization....
I am using the google.charts.load() as well as the other changes
highlighted above.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/de90d1cf-ec12-4f4f-a963-ca1ed450c212%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/de90d1cf-ec12-4f4f-a963-ca1ed450c212%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Paul Benson]

Daniel, I might be doing something wrong, but in the mean time here is my
issue.


In this example, I set up using jfiddle to show how it used to work. If I
have 4 rows, it will show 4 rows with a normal row height.
https://jsfiddle.net/zftetxa3/

With the latest version it will fit the rows to the chart height, which
gives it an odd look
https://jsfiddle.net/5ed4oeLe/

Post by 'Daniel LaLiberte' via Google Visualization API
Hi Paul,
I don't understand why you can't call
google.charts.setOnLoadCallback(drawTable) when you want the drawTable
function to be called (once the Google Charts code has been loaded). How
is this different from when you would use google.load() and
google.setOnLoadCallback()?

Post by Paul Benson
We are using dynamic chart creation, so I can not specify
"google.charts.setOnLoadCallback(drawTable);" so javascript is failing when
I try to reference google.visualization.DateTable, or anything else using
google.visualization....
I am using the google.charts.load() as well as the other changes
highlighted above.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/de90d1cf-ec12-4f4f-a963-ca1ed450c212%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/de90d1cf-ec12-4f4f-a963-ca1ed450c212%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

The frozen version (in your first jsfiddle) appears to be loading find
then. We can deal with your issues with the table chart in the other
thread.

Post by Paul Benson
Daniel, I might be doing something wrong, but in the mean time here is my
issue.
In this example, I set up using jfiddle to show how it used to work. If I
have 4 rows, it will show 4 rows with a normal row height.
https://jsfiddle.net/zftetxa3/
With the latest version it will fit the rows to the chart height, which
gives it an odd look
https://jsfiddle.net/5ed4oeLe/

Post by 'Daniel LaLiberte' via Google Visualization API
Hi Paul,
I don't understand why you can't call
google.charts.setOnLoadCallback(drawTable) when you want the drawTable
function to be called (once the Google Charts code has been loaded). How
is this different from when you would use google.load() and
google.setOnLoadCallback()?

Post by Paul Benson
We are using dynamic chart creation, so I can not specify
"google.charts.setOnLoadCallback(drawTable);" so javascript is failing when
I try to reference google.visualization.DateTable, or anything else using
google.visualization....
I am using the google.charts.load() as well as the other changes
highlighted above.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/de90d1cf-ec12-4f4f-a963-ca1ed450c212%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/de90d1cf-ec12-4f4f-a963-ca1ed450c212%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/1d719ce6-594c-4cad-a1b3-f4307df0cf0b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/1d719ce6-594c-4cad-a1b3-f4307df0cf0b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Henry Harrison]

Hi Daniel

Is there any timeline for a resolution on point 1 of using the frozen
versions?
1. You can only call google.charts.load() one time. You can instead list
all the packages that you'll need in one call, so there is usually no need
to make separate calls.

Regards
Henry

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Post by Lokesh Setia
Hi Daniel
Is there any timeline for a resolution on point 1 of using the frozen
versions?
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.

No resolution yet. It's been a lower priority since there is an easy
workaround for most applications. I'm curious why you need it.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Henry Harrison]

Legacy application that we haven't had the time to rewrite yet. We have multiple charts on the same page with different functions that we use on callback. Definite room for improvement but the ability to use google.charts.load more than once was a simple workaround for us.

Date: Thu, 27 Aug 2015 08:28:32 -0400
Subject: Re: [visualization-api] Re: Introducing Frozen Google Charts
From: google-visualization-***@googlegroups.com
To: google-visualization-***@googlegroups.com

On Thu, Aug 27, 2015 at 8:15 AM, Henry Harrison <***@gmail.com> wrote:
Hi Daniel
Is there any timeline for a resolution on point 1 of using the frozen versions? 1. You can only call google.charts.load() one time. You can instead list all the packages that you'll need in one call, so there is usually no need to make separate calls.

No resolution yet. It's been a lower priority since there is an easy workaround for most applications. I'm curious why you need it.
--
Daniel LaLiberte - 978-394-1058
***@Google.com 5CC, Cambridge ***@GMail.com 9 Juniper Ridge Road, Acton MA
--
You received this message because you are subscribed to a topic in the Google Groups "Google Visualization API" group.

To unsubscribe from this topic, visit https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe.

To unsubscribe from this group and all its topics, send an email to google-visualization-api+***@googlegroups.com.

To post to this group, send email to google-visualization-***@googlegroups.com.

Visit this group at http://groups.google.com/group/google-visualization-api.

To view this discussion on the web visit https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMJRkRir0s1apYf5uKnkD_ay_UEiqvA1Nv%2BJCZvSeePfg%40mail.gmail.com.

For more options, visit https://groups.google.com/d/optout.

['Daniel LaLiberte' via Google Visualization API]

You can call google.charts.setOnLoadCallback() multiple times. For the
same reason, I suppose we could allow google.charts.load() to be called
multiple times now if you only specify the 'callback' property rather than
load more packages.

Post by Henry Harrison
Legacy application that we haven't had the time to rewrite yet. We have
multiple charts on the same page with different functions that we use
on callback. Definite room for improvement but the ability to use
google.charts.load more than once was a simple workaround for us.
------------------------------
Date: Thu, 27 Aug 2015 08:28:32 -0400
Subject: Re: [visualization-api] Re: Introducing Frozen Google Charts
Hi Daniel
Is there any timeline for a resolution on point 1 of using the frozen
versions?
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
No resolution yet. It's been a lower priority since there is an easy
workaround for most applications. I'm curious why you need it.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMJRkRir0s1apYf5uKnkD_ay_UEiqvA1Nv%2BJCZvSeePfg%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMJRkRir0s1apYf5uKnkD_ay_UEiqvA1Nv%2BJCZvSeePfg%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/DUB131-W352569F494C552C3988F88A36F0%40phx.gbl
<https://groups.google.com/d/msgid/google-visualization-api/DUB131-W352569F494C552C3988F88A36F0%40phx.gbl?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[rishu oberoi]

Hi,

Changing to 1.0 version from 1 is no more showing up old UI of google
tables. Do we have to use the frozen version for that?

Post by 'Daniel LaLiberte' via Google Visualization API
You can call google.charts.setOnLoadCallback() multiple times. For the
same reason, I suppose we could allow google.charts.load() to be called
multiple times now if you only specify the 'callback' property rather than
load more packages.

Post by Henry Harrison
Legacy application that we haven't had the time to rewrite yet. We have
multiple charts on the same page with different functions that we use
on callback. Definite room for improvement but the ability to use
google.charts.load more than once was a simple workaround for us.
------------------------------
Date: Thu, 27 Aug 2015 08:28:32 -0400
Subject: Re: [visualization-api] Re: Introducing Frozen Google Charts
Hi Daniel
Is there any timeline for a resolution on point 1 of using the frozen
versions?
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
No resolution yet. It's been a lower priority since there is an easy
workaround for most applications. I'm curious why you need it.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMJRkRir0s1apYf5uKnkD_ay_UEiqvA1Nv%2BJCZvSeePfg%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMJRkRir0s1apYf5uKnkD_ay_UEiqvA1Nv%2BJCZvSeePfg%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/DUB131-W352569F494C552C3988F88A36F0%40phx.gbl
<https://groups.google.com/d/msgid/google-visualization-api/DUB131-W352569F494C552C3988F88A36F0%40phx.gbl?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Hi Rishu,

What you got when you loaded "1.0" up until sometime between Tuesday and
Wednesday (the rollout may have taken 24 hours this time) was v41, but now
it is v42. v41 is available via the frozen loader, as described in this
email announcement.

Post by rishu oberoi
Hi,
Changing to 1.0 version from 1 is no more showing up old UI of google
tables. Do we have to use the frozen version for that?

Post by 'Daniel LaLiberte' via Google Visualization API
You can call google.charts.setOnLoadCallback() multiple times. For the
same reason, I suppose we could allow google.charts.load() to be called
multiple times now if you only specify the 'callback' property rather than
load more packages.

Post by Henry Harrison
Legacy application that we haven't had the time to rewrite yet. We have
multiple charts on the same page with different functions that we use
on callback. Definite room for improvement but the ability to use
google.charts.load more than once was a simple workaround for us.
------------------------------
Date: Thu, 27 Aug 2015 08:28:32 -0400
Subject: Re: [visualization-api] Re: Introducing Frozen Google Charts
Hi Daniel
Is there any timeline for a resolution on point 1 of using the frozen
versions?
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
No resolution yet. It's been a lower priority since there is an easy
workaround for most applications. I'm curious why you need it.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMJRkRir0s1apYf5uKnkD_ay_UEiqvA1Nv%2BJCZvSeePfg%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMJRkRir0s1apYf5uKnkD_ay_UEiqvA1Nv%2BJCZvSeePfg%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.
--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/DUB131-W352569F494C552C3988F88A36F0%40phx.gbl
<https://groups.google.com/d/msgid/google-visualization-api/DUB131-W352569F494C552C3988F88A36F0%40phx.gbl?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2377b13a-0762-4597-bbc4-323b01118819%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2377b13a-0762-4597-bbc4-323b01118819%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas Fantou]

Hi Daniel,

We are using the Google Chart API, and rendering our html view with
wkhtmltopdf tool (converter html to pdf).
It has always been working fine even now with the last stable version,
however there is a strange behaviour with the new Frozen version; As far as
I have been able to debug, the google.charts.load() method never returns.
(Callback method is never triggered/google.visualization.DataTable() is
'undefined')

The frozen version works with our browsers, but not with the third party
tool as stated above. I am not sure how I can investigate further; is there
any reasons that would ring a bell about this ? (e.g. if platform isn't a
browser, the .load() will be stuck somewhere?)

Thanks,
Thomas

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Hi Thomas,

I can't imagine what might be happening when the Google Charts frozen v41
is loaded view wkhtmltopdf, but it sounds like that tool doesn't work with
the dynamic loading mechanism that we depend on. Does anything get loaded
beyond the loader itself?

Post by Lokesh Setia
Hi Daniel,
We are using the Google Chart API, and rendering our html view with
wkhtmltopdf tool (converter html to pdf).
It has always been working fine even now with the last stable version,
however there is a strange behaviour with the new Frozen version; As far as
I have been able to debug, the google.charts.load() method never returns.
(Callback method is never triggered/google.visualization.DataTable() is
'undefined')
The frozen version works with our browsers, but not with the third party
tool as stated above. I am not sure how I can investigate further; is there
any reasons that would ring a bell about this ? (e.g. if platform isn't a
browser, the .load() will be stuck somewhere?)
Thanks,
Thomas

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas Fantou]

Hi Daniel,

Well we haven't seen any problems with the rest. Also, like I said, the
loading works fine with the non-frozen versions.
I am not sure I've followed the issue about the loader attempting to load
the same scheme as the page, but since the request is not done through a
web browser, would that make a difference?

Post by 'Daniel LaLiberte' via Google Visualization API
Hi Thomas,
I can't imagine what might be happening when the Google Charts frozen v41
is loaded view wkhtmltopdf, but it sounds like that tool doesn't work with
the dynamic loading mechanism that we depend on. Does anything get loaded
beyond the loader itself?

Post by Lokesh Setia
Hi Daniel,
We are using the Google Chart API, and rendering our html view with
wkhtmltopdf tool (converter html to pdf).
It has always been working fine even now with the last stable version,
however there is a strange behaviour with the new Frozen version; As far as
I have been able to debug, the google.charts.load() method never returns.
(Callback method is never triggered/google.visualization.DataTable() is
'undefined')
The frozen version works with our browsers, but not with the third party
tool as stated above. I am not sure how I can investigate further; is there
any reasons that would ring a bell about this ? (e.g. if platform isn't a
browser, the .load() will be stuck somewhere?)
Thanks,
Thomas

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Hi Thomas,

First, google.charts.load() always uses https now.

My question was whether you can tell what is loaded by wkhtmltopdf after
google.charts.load() is called? If it loads the packages fine but just
doesn't call the callback, then the problem is most likely that the loader
doesn't know everything has finished loading.

Post by Lokesh Setia
Hi Daniel,
Well we haven't seen any problems with the rest. Also, like I said, the
loading works fine with the non-frozen versions.
I am not sure I've followed the issue about the loader attempting to load
the same scheme as the page, but since the request is not done through a
web browser, would that make a difference?

Post by 'Daniel LaLiberte' via Google Visualization API
Hi Thomas,
I can't imagine what might be happening when the Google Charts frozen v41
is loaded view wkhtmltopdf, but it sounds like that tool doesn't work with
the dynamic loading mechanism that we depend on. Does anything get loaded
beyond the loader itself?

Post by Lokesh Setia
Hi Daniel,
We are using the Google Chart API, and rendering our html view with
wkhtmltopdf tool (converter html to pdf).
It has always been working fine even now with the last stable version,
however there is a strange behaviour with the new Frozen version; As far as
I have been able to debug, the google.charts.load() method never returns.
(Callback method is never triggered/google.visualization.DataTable() is
'undefined')
The frozen version works with our browsers, but not with the third party
tool as stated above. I am not sure how I can investigate further; is there
any reasons that would ring a bell about this ? (e.g. if platform isn't a
browser, the .load() will be stuck somewhere?)
Thanks,
Thomas

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/b87fdff7-4572-4757-9fee-e891bb920cc0%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/b87fdff7-4572-4757-9fee-e891bb920cc0%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Thomas Fantou]

Hi,

Oh sorry about that, I believe it is the loading crashing; as I have tried
to give long delay to the javascript and let it try to load, but
"google.visualization" would always be undefined. (google = { charts: {} })

Post by 'Daniel LaLiberte' via Google Visualization API
Hi Thomas,
First, google.charts.load() always uses https now.
My question was whether you can tell what is loaded by wkhtmltopdf after
google.charts.load() is called? If it loads the packages fine but just
doesn't call the callback, then the problem is most likely that the loader
doesn't know everything has finished loading.

Post by Lokesh Setia
Hi Daniel,
Well we haven't seen any problems with the rest. Also, like I said, the
loading works fine with the non-frozen versions.
I am not sure I've followed the issue about the loader attempting to load
the same scheme as the page, but since the request is not done through a
web browser, would that make a difference?

Post by 'Daniel LaLiberte' via Google Visualization API
Hi Thomas,
I can't imagine what might be happening when the Google Charts frozen
v41 is loaded view wkhtmltopdf, but it sounds like that tool doesn't work
with the dynamic loading mechanism that we depend on. Does anything get
loaded beyond the loader itself?

Post by Lokesh Setia
Hi Daniel,
We are using the Google Chart API, and rendering our html view with
wkhtmltopdf tool (converter html to pdf).
It has always been working fine even now with the last stable version,
however there is a strange behaviour with the new Frozen version; As far as
I have been able to debug, the google.charts.load() method never returns.
(Callback method is never triggered/google.visualization.DataTable() is
'undefined')
The frozen version works with our browsers, but not with the third
party tool as stated above. I am not sure how I can investigate further; is
there any reasons that would ring a bell about this ? (e.g. if platform
isn't a browser, the .load() will be stuck somewhere?)
Thanks,
Thomas

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/5eb56be5-e779-489e-bdd5-1ae727e4e4c1%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/b87fdff7-4572-4757-9fee-e891bb920cc0%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/b87fdff7-4572-4757-9fee-e891bb920cc0%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Thomas Fantou]

google.charts.load('41', { 'callback': function () { console.log("koko");
}, 'packages': ['corechart', 'table'] });

It actually doesn't overwrite setOnLoadCallback, but there is now 2
callbacks. The log "koko" is showing just fine in browser, but not with the
tool

['Daniel LaLiberte' via Google Visualization API]

Thomas,

I poked around on http://wkhtmltopdf.org/index.html and didn't find out how
it works. It would help if someone could explain what this tool does with
dynamic http/https requests and generated DOM elements.

Post by Thomas Fantou
google.charts.load('41', { 'callback': function () { console.log("koko");
}, 'packages': ['corechart', 'table'] });
It actually doesn't overwrite setOnLoadCallback, but there is now 2
callbacks. The log "koko" is showing just fine in browser, but not with the
tool
--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/2def6b9f-2fb8-456f-b8dc-b9ff52f2a8ba%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/2def6b9f-2fb8-456f-b8dc-b9ff52f2a8ba%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Kevin Crawley]

Daniel,

Has there been any progress on determining why the loader will not work in
PhantomJS?

Thanks,
Kevin

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Kevin,

Sorry, no, I haven't had time to investigate further. Can you try again
and send me an email with the details of the error message? I might be
able to guess at this point.

Post by Lokesh Setia
Daniel,
Has there been any progress on determining why the loader will not work in
PhantomJS?
Thanks,
Kevin

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Kevin Crawley]

Daniel,

There isn't an error, the loader appears to never finish executing. The
library appears to be there `google.charts` is an object, but
`visualization` is conspicuously absent.

<Loading Image...>


<Loading Image...>

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
Sorry, no, I haven't had time to investigate further. Can you try again
and send me an email with the details of the error message? I might be
able to guess at this point.

Post by Lokesh Setia
Daniel,
Has there been any progress on determining why the loader will not work
in PhantomJS?
Thanks,
Kevin

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

Kevin,

OK, a silent failure means it may be more challenging to get clues about
what is happening. You say the loader appear to never finish loading, but
does it start? Is it loading any files? It would start by loading css
files, then js files. If it does appear to load all the files, but then
never calls the callback to proceed, that would indicate it doesn't know
the document has finished loading.

Post by Lokesh Setia
Daniel,
There isn't an error, the loader appears to never finish executing. The
library appears to be there `google.charts` is an object, but
`visualization` is conspicuously absent.
<https://lh3.googleusercontent.com/-OT0Vd9-i2-4/Ve759SQn5AI/AAAAAAAAAGg/QTF6awz2sgU/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.08.19%2BAM.png>
<https://lh3.googleusercontent.com/-iikKKNv_QO0/Ve75vKYCC1I/AAAAAAAAAGY/F7eWdLChf4o/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.07.19%2BAM.png>

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
Sorry, no, I haven't had time to investigate further. Can you try again
and send me an email with the details of the error message? I might be
able to guess at this point.

Post by Lokesh Setia
Daniel,
Has there been any progress on determining why the loader will not work
in PhantomJS?
Thanks,
Kevin

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Kevin Crawley]

Daniel,

Seems to get to util.css (which loads successfully) and then nothing more.

On Tue, Sep 8, 2015 at 10:17 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
OK, a silent failure means it may be more challenging to get clues about
what is happening. You say the loader appear to never finish loading, but
does it start? Is it loading any files? It would start by loading css
files, then js files. If it does appear to load all the files, but then
never calls the callback to proceed, that would indicate it doesn't know
the document has finished loading.

Post by Lokesh Setia
Daniel,
There isn't an error, the loader appears to never finish executing. The
library appears to be there `google.charts` is an object, but
`visualization` is conspicuously absent.
<https://lh3.googleusercontent.com/-OT0Vd9-i2-4/Ve759SQn5AI/AAAAAAAAAGg/QTF6awz2sgU/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.08.19%2BAM.png>
<https://lh3.googleusercontent.com/-iikKKNv_QO0/Ve75vKYCC1I/AAAAAAAAAGY/F7eWdLChf4o/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.07.19%2BAM.png>

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
Sorry, no, I haven't had time to investigate further. Can you try
again and send me an email with the details of the error message? I might
be able to guess at this point.

Post by Lokesh Setia
Daniel,
Has there been any progress on determining why the loader will not work
in PhantomJS?
Thanks,
Kevin

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNrnOj%3Dd%3DfJ%2B_Bgpqb_U_EVD2HeUsBjXAzu%3DAP2G5PjYQ%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNrnOj%3Dd%3DfJ%2B_Bgpqb_U_EVD2HeUsBjXAzu%3DAP2G5PjYQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

['Daniel LaLiberte' via Google Visualization API]

Kevin,

Sounds like the css load detection is failing then. The frozen code
loader actually waits for the css files to be loaded before proceeding,
which would be better than not waiting, but that means it has to be able to
detect that the files are loaded. Let's communicate by direct email about
how we might be able to fix this.

Post by Lokesh Setia
Daniel,
Seems to get to util.css (which loads successfully) and then nothing more.
On Tue, Sep 8, 2015 at 10:17 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
OK, a silent failure means it may be more challenging to get clues about
what is happening. You say the loader appear to never finish loading, but
does it start? Is it loading any files? It would start by loading css
files, then js files. If it does appear to load all the files, but then
never calls the callback to proceed, that would indicate it doesn't know
the document has finished loading.

Post by Lokesh Setia
Daniel,
There isn't an error, the loader appears to never finish executing. The
library appears to be there `google.charts` is an object, but
`visualization` is conspicuously absent.
<https://lh3.googleusercontent.com/-OT0Vd9-i2-4/Ve759SQn5AI/AAAAAAAAAGg/QTF6awz2sgU/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.08.19%2BAM.png>
<https://lh3.googleusercontent.com/-iikKKNv_QO0/Ve75vKYCC1I/AAAAAAAAAGY/F7eWdLChf4o/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.07.19%2BAM.png>

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
Sorry, no, I haven't had time to investigate further. Can you try
again and send me an email with the details of the error message? I might
be able to guess at this point.

Post by Lokesh Setia
Daniel,
Has there been any progress on determining why the loader will not
work in PhantomJS?
Thanks,
Kevin

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how
you load the Google Charts packages. For example, here is the usual
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help
us if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNrnOj%3Dd%3DfJ%2B_Bgpqb_U_EVD2HeUsBjXAzu%3DAP2G5PjYQ%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNrnOj%3Dd%3DfJ%2B_Bgpqb_U_EVD2HeUsBjXAzu%3DAP2G5PjYQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOMq1_uZst3%2BbQN9sepxw409uu6q3NtPV2wdKJDL6Dz%3Drm1koA%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOMq1_uZst3%2BbQN9sepxw409uu6q3NtPV2wdKJDL6Dz%3Drm1koA%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Kevin Crawley]

Daniel,

Okay, we can do that. Let me know how I can assist in getting this issue
put to bed.

On Tue, Sep 8, 2015 at 10:57 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
Sounds like the css load detection is failing then. The frozen code
loader actually waits for the css files to be loaded before proceeding,
which would be better than not waiting, but that means it has to be able to
detect that the files are loaded. Let's communicate by direct email about
how we might be able to fix this.

Post by Lokesh Setia
Daniel,
Seems to get to util.css (which loads successfully) and then nothing more.
On Tue, Sep 8, 2015 at 10:17 AM, 'Daniel LaLiberte' via Google

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
OK, a silent failure means it may be more challenging to get clues about
what is happening. You say the loader appear to never finish loading, but
does it start? Is it loading any files? It would start by loading css
files, then js files. If it does appear to load all the files, but then
never calls the callback to proceed, that would indicate it doesn't know
the document has finished loading.

Post by Lokesh Setia
Daniel,
There isn't an error, the loader appears to never finish executing. The
library appears to be there `google.charts` is an object, but
`visualization` is conspicuously absent.
<https://lh3.googleusercontent.com/-OT0Vd9-i2-4/Ve759SQn5AI/AAAAAAAAAGg/QTF6awz2sgU/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.08.19%2BAM.png>
<https://lh3.googleusercontent.com/-iikKKNv_QO0/Ve75vKYCC1I/AAAAAAAAAGY/F7eWdLChf4o/s1600/Screen%2BShot%2B2015-09-08%2Bat%2B10.07.19%2BAM.png>

Post by 'Daniel LaLiberte' via Google Visualization API
Kevin,
Sorry, no, I haven't had time to investigate further. Can you try
again and send me an email with the details of the error message? I might
be able to guess at this point.

Post by Lokesh Setia
Daniel,
Has there been any progress on determining why the loader will not
work in PhantomJS?
Thanks,
Kevin

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how
you load the Google Charts packages. For example, here is the
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not
include the ‘visualization’ parameter, and the version number is a
string. Only version ‘41’ is supported at this time, which corresponds to
the current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help
us if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> - 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it,
send an email to
.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8d5173e5-2160-43c9-80cd-57dc0070ab1b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/685ed8f3-a84c-4620-ab29-c8d9c2df9fd6%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNrnOj%3Dd%3DfJ%2B_Bgpqb_U_EVD2HeUsBjXAzu%3DAP2G5PjYQ%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJNrnOj%3Dd%3DfJ%2B_Bgpqb_U_EVD2HeUsBjXAzu%3DAP2G5PjYQ%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOMq1_uZst3%2BbQN9sepxw409uu6q3NtPV2wdKJDL6Dz%3Drm1koA%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOMq1_uZst3%2BbQN9sepxw409uu6q3NtPV2wdKJDL6Dz%3Drm1koA%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058
Road, Acton MA
--
You received this message because you are subscribed to a topic in the
Google Groups "Google Visualization API" group.
To unsubscribe from this topic, visit
https://groups.google.com/d/topic/google-visualization-api/hBCwxtXYNZ8/unsubscribe
.
To unsubscribe from this group and all its topics, send an email to
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMe6XBLusvhwJUd9U18co9P4GhNJ%3Did8U%2B%3DOzq4WUc9ug%40mail.gmail.com
<https://groups.google.com/d/msgid/google-visualization-api/CAOtcSJMe6XBLusvhwJUd9U18co9P4GhNJ%3Did8U%2B%3DOzq4WUc9ug%40mail.gmail.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

[Thomas Fantou]

Hi,

Might be related to what Kevin is experiencing,
I was debugging, 5 seconds after the .load(), which script and style were
living in the DOM: only the util.css

[Stefano Colao]

Hello, how to use DataTable arrayToDataTable with Frozen Google Charts?

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

There is no difference in how you use arrayToDataTable with Frozen Google
Charts. There should be no difference in anything, except how you load.

Post by Stefano Colao
Hello, how to use DataTable arrayToDataTable with Frozen Google Charts?

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/c94b9714-e65c-42dc-9ed6-3ebe2df2de60%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/c94b9714-e65c-42dc-9ed6-3ebe2df2de60%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058
***@Google.com <***@google.com> 5CC, Cambridge MA
***@GMail.com <***@gmail.com> 9 Juniper Ridge
Road, Acton MA

[Stefano Colao]

Thanks, it was my mistake, everything is working.

Post by 'Daniel LaLiberte' via Google Visualization API
There is no difference in how you use arrayToDataTable with Frozen Google
Charts. There should be no difference in anything, except how you load.

Post by Stefano Colao
Hello, how to use DataTable arrayToDataTable with Frozen Google Charts?

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/c94b9714-e65c-42dc-9ed6-3ebe2df2de60%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/c94b9714-e65c-42dc-9ed6-3ebe2df2de60%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Julian Claus]

I get the error:

*Uncaught TypeError: google.charts.Line is not a function*

I did the following:

<Loading Image...>

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Julian Claus]

I replaced "corechart" with "line" and it finally worked!

Post by Julian Claus
*Uncaught TypeError: google.charts.Line is not a function*
<https://lh3.googleusercontent.com/-SEu3-Vt46rE/ViiCEmlmLrI/AAAAAAAAjzw/N25DUoockVI/s1600/Unbenannt-1.png>

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Frédéric Gaye]

Hi Daniel,

It seems there a bug with Forzen 43 and use of
option focusTarget:'category'.
When we use both, it become impossible to mouse over a barchart to see the
tooltip (we see tooltip only if we put our mouse next to barchat) if we use
frozen 42 all is fine.

See this simple example

<script type="text/javascript"
src="https://www.gstatic.com/charts/loader.js"></script>
<script type="application/javascript"> google.charts.load('43', {packages:
['corechart'], 'language': 'fr'});
google.charts.setOnLoadCallback(drawChart);

function drawChart() {
var data = google.visualization.arrayToDataTable([
['Canaux', '28 derniers jours', { role: 'style' }, { role: 'annotation' },
'Période précédente'],
['Organic Search', 59200, '#337ab7', -3130, 58750 ],
['Referral', 6450, '#337ab7', -387, 6837],
['Direct', 5874, '#337ab7', -424, 6298 ],
['Social', 113, '#337ab7', -78, 191],
['(other)', 20, '#337ab7', 3, 17]
]);
var options = {
title: "Density of Precious Metals, in g/cm^3",
width: 600,
height: 400,
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.BarChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
<div id="barchart_values2" style="width: 900px; height: 300px;"></div>

Any idea to correct this point ?

Regards

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Sergey Grabkovsky' via Google Visualization API]

Thanks for notifying us of this bug! We will fix it soon.

On Mon, Nov 2, 2015 at 4:02 PM Frédéric Gaye <

Post by Lokesh Setia
Hi Daniel,
It seems there a bug with Forzen 43 and use of
option focusTarget:'category'.
When we use both, it become impossible to mouse over a barchart to see the
tooltip (we see tooltip only if we put our mouse next to barchat) if we use
frozen 42 all is fine.
See this simple example
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
['corechart'], 'language': 'fr'});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = google.visualization.arrayToDataTable([
['Canaux', '28 derniers jours', { role: 'style' }, { role: 'annotation'
}, 'Période précédente'],
['Organic Search', 59200, '#337ab7', -3130, 58750 ],
['Referral', 6450, '#337ab7', -387, 6837],
['Direct', 5874, '#337ab7', -424, 6298 ],
['Social', 113, '#337ab7', -78, 191],
['(other)', 20, '#337ab7', 3, 17]
]);
var options = {
title: "Density of Precious Metals, in g/cm^3",
width: 600,
height: 400,
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.BarChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
<div id="barchart_values2" style="width: 900px; height: 300px;"></div>
Any idea to correct this point ?
Regards

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--

Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>

Post by 'Daniel LaLiberte' via Google Visualization API
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *
*Sergey Grabkovsky* | SWE | ***@google.com

[Frédéric Gaye]

Hi Sergey,

Thanks for your (quickly) anwsers.

Note : there another "little" but boring bug. Now with frozen 42 and 43,
date in tooltip are by default in english. We need to
add google.charts.load('42', {packages: ['corechart'], 'language': 'fr'});
to have date in french. Is it possible to correct this to stay like before
frozen (that is to say, language are automatically detected and no need to
force with 'language': 'fr' to have french.

Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
Thanks for notifying us of this bug! We will fix it soon.
On Mon, Nov 2, 2015 at 4:02 PM Frédéric Gaye <

Post by Lokesh Setia
Hi Daniel,
It seems there a bug with Forzen 43 and use of
option focusTarget:'category'.
When we use both, it become impossible to mouse over a barchart to see
the tooltip (we see tooltip only if we put our mouse next to barchat) if we
use frozen 42 all is fine.
See this simple example
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
<script type="application/javascript"> google.charts.load('43',
{packages: ['corechart'], 'language': 'fr'});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = google.visualization.arrayToDataTable([
['Canaux', '28 derniers jours', { role: 'style' }, { role: 'annotation'
}, 'Période précédente'],
['Organic Search', 59200, '#337ab7', -3130, 58750 ],
['Referral', 6450, '#337ab7', -387, 6837],
['Direct', 5874, '#337ab7', -424, 6298 ],
['Social', 113, '#337ab7', -78, 191],
['(other)', 20, '#337ab7', 3, 17]
]);
var options = {
title: "Density of Precious Metals, in g/cm^3",
width: 600,
height: 400,
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.BarChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
<div id="barchart_values2" style="width: 900px; height: 300px;"></div>
Any idea to correct this point ?
Regards

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--

Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>

Post by 'Daniel LaLiberte' via Google Visualization API
- 978-394-1058

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *
*Sergey Grabkovsky* | SWE

['Sergey Grabkovsky' via Google Visualization API]

As far as I know, we have never autodetected the language/locale and
automatically loaded the correct version. So, if anything, this is not a
bug, but a feature request. We have discussed how we would do this before,
and I think we have a plan for how to proceed. However, I don't have any
estimates for when we might do this, since the browser APIs for language
detection haven't really stabilized yet.

On Tue, Nov 3, 2015 at 8:46 AM Frédéric Gaye <

Post by Frédéric Gaye
Hi Sergey,
Thanks for your (quickly) anwsers.
Note : there another "little" but boring bug. Now with frozen 42 and 43,
date in tooltip are by default in english. We need to
add google.charts.load('42', {packages: ['corechart'], 'language': 'fr'});
to have date in french. Is it possible to correct this to stay like before
frozen (that is to say, language are automatically detected and no need to
force with 'language': 'fr' to have french.
Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
Thanks for notifying us of this bug! We will fix it soon.
On Mon, Nov 2, 2015 at 4:02 PM Frédéric Gaye <

Hi Daniel,

Post by 'Sergey Grabkovsky' via Google Visualization API

Post by Frédéric Gaye
It seems there a bug with Forzen 43 and use of
option focusTarget:'category'.
When we use both, it become impossible to mouse over a barchart to see
the tooltip (we see tooltip only if we put our mouse next to barchat) if we
use frozen 42 all is fine.
See this simple example
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
<script type="application/javascript"> google.charts.load('43',
{packages: ['corechart'], 'language': 'fr'});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = google.visualization.arrayToDataTable([
['Canaux', '28 derniers jours', { role: 'style' }, { role: 'annotation'
}, 'Période précédente'],
['Organic Search', 59200, '#337ab7', -3130, 58750 ],
['Referral', 6450, '#337ab7', -387, 6837],
['Direct', 5874, '#337ab7', -424, 6298 ],
['Social', 113, '#337ab7', -78, 191],
['(other)', 20, '#337ab7', 3, 17]
]);
var options = {
title: "Density of Precious Metals, in g/cm^3",
width: 600,
height: 400,
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.BarChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
<div id="barchart_values2" style="width: 900px; height: 300px;"></div>
Any idea to correct this point ?
Regards

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--

Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>

Post by 'Daniel LaLiberte' via Google Visualization API
- 978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *
*Sergey Grabkovsky* | SWE

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
To post to this group, send email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *
*Sergey Grabkovsky* | SWE | ***@google.com

[Frédéric Gaye]

Hi Sergey,

Thanks.
I was thinking there was an autodetection (and a bug) because see theses 2
codes.


- The first one (old jsapi) show tooltip in my language (french) without
any language indication


<script type="text/javascript"
src="https://www.google.com/jsapi?autoload={'modules':[{'name':'visualization','version':'1','packages':['corechart']}]}"></script>
<script type="application/javascript">
google.setOnLoadCallback(drawChart);
function drawChart() {

var data = new google.visualization.DataTable();
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');

data.addRows([
[new Date("4/11/2015"),2189,new Date("3/11/2015"),2189],
[new Date("4/12/2015"),2389,new Date("3/12/2015"),2536],
[new Date("4/13/2015"),2189,new Date("3/13/2015"),2545],
[new Date("4/14/2015"),2129,new Date("3/14/2015"),2390],
]);
var options = {
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.LineChart(document.getElementById('barchart_values3'));
chart.draw(data, options);
}
</script>
<div id="barchart_values3" style="width: 900px; height: 300px;"></div>



- And the second (loader.js) , need to force/add 'language': 'fr' to
see tooltip in french instead of en ("by default").


<script type="text/javascript"
src="https://www.gstatic.com/charts/loader.js"></script>
<script type="application/javascript">google.charts.load('43', {packages:
['corechart'], *'language': 'fr'*});
google.charts.setOnLoadCallback(drawChart);


function drawChart() {
var data = new google.visualization.DataTable();
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');

data.addRows([
[new Date("4/11/2015"),2189,new Date("3/11/2015"),2189],
[new Date("4/12/2015"),2389,new Date("3/12/2015"),2536],
[new Date("4/13/2015"),2189,new Date("3/13/2015"),2545],
[new Date("4/14/2015"),2129,new Date("3/14/2015"),2390],
]);
var options = {
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.LineChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>

Any idea to show in the second code a "autodetected" french language
without any 'language': 'fr' ?

Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
As far as I know, we have never autodetected the language/locale and
automatically loaded the correct version. So, if anything, this is not a
bug, but a feature request. We have discussed how we would do this before,
and I think we have a plan for how to proceed. However, I don't have any
estimates for when we might do this, since the browser APIs for language
detection haven't really stabilized yet.
On Tue, Nov 3, 2015 at 8:46 AM Frédéric Gaye <

Post by Frédéric Gaye
Hi Sergey,
Thanks for your (quickly) anwsers.
Note : there another "little" but boring bug. Now with frozen 42 and 43,
date in tooltip are by default in english. We need to
add google.charts.load('42', {packages: ['corechart'], 'language': 'fr'});
to have date in french. Is it possible to correct this to stay like before
frozen (that is to say, language are automatically detected and no need to
force with 'language': 'fr' to have french.
Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
Thanks for notifying us of this bug! We will fix it soon.
On Mon, Nov 2, 2015 at 4:02 PM Frédéric Gaye <

Hi Daniel,

Post by 'Sergey Grabkovsky' via Google Visualization API

Post by Frédéric Gaye
It seems there a bug with Forzen 43 and use of
option focusTarget:'category'.
When we use both, it become impossible to mouse over a barchart to see
the tooltip (we see tooltip only if we put our mouse next to barchat) if we
use frozen 42 all is fine.
See this simple example
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
<script type="application/javascript"> google.charts.load('43',
{packages: ['corechart'], 'language': 'fr'});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = google.visualization.arrayToDataTable([
'annotation' }, 'Période précédente'],
['Organic Search', 59200, '#337ab7', -3130, 58750 ],
['Referral', 6450, '#337ab7', -387, 6837],
['Direct', 5874, '#337ab7', -424, 6298 ],
['Social', 113, '#337ab7', -78, 191],
['(other)', 20, '#337ab7', 3, 17]
]);
var options = {
title: "Density of Precious Metals, in g/cm^3",
width: 600,
height: 400,
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.BarChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
<div id="barchart_values2" style="width: 900px; height: 300px;"></div>
Any idea to correct this point ?
Regards

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--

Daniel LaLiberte

Post by 'Daniel LaLiberte' via Google Visualization API
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *
*Sergey Grabkovsky* | SWE

--
You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
<javascript:>.
<javascript:>.
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *

[Sergey]

So the focusTarget:'category' issue should be fixed now, with the latest
frozen 43 push.

As for the language autodetection... Which browser/OS are you using, and do
you have the browser configured in any special sort of way?

I'm on a Mac, and I tried to reproduce by setting Chrome's primary
language, and by changing my region, to no avail.

Post by Frédéric Gaye
Hi Sergey,
Thanks.
I was thinking there was an autodetection (and a bug) because see theses
2 codes.
- The first one (old jsapi) show tooltip in my language (french)
without any language indication
<script type="text/javascript" src="
https://www.google.com/jsapi?autoload={'modules':[{'name':'visualization
','version':'1','packages':['corechart']}]}"></script>
<script type="application/javascript">
google.setOnLoadCallback(drawChart);
function drawChart() {
var data = new google.visualization.DataTable();
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addRows([
[new Date("4/11/2015"),2189,new Date("3/11/2015"),2189],
[new Date("4/12/2015"),2389,new Date("3/12/2015"),2536],
[new Date("4/13/2015"),2189,new Date("3/13/2015"),2545],
[new Date("4/14/2015"),2129,new Date("3/14/2015"),2390],
]);
var options = {
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.LineChart(document.getElementById('barchart_values3'));
chart.draw(data, options);
}
</script>
<div id="barchart_values3" style="width: 900px; height: 300px;"></div>
- And the second (loader.js) , need to force/add 'language': 'fr' to
see tooltip in french instead of en ("by default").
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
['corechart'], *'language': 'fr'*});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = new google.visualization.DataTable();
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addRows([
[new Date("4/11/2015"),2189,new Date("3/11/2015"),2189],
[new Date("4/12/2015"),2389,new Date("3/12/2015"),2536],
[new Date("4/13/2015"),2189,new Date("3/13/2015"),2545],
[new Date("4/14/2015"),2129,new Date("3/14/2015"),2390],
]);
var options = {
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.LineChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
Any idea to show in the second code a "autodetected" french language
without any 'language': 'fr' ?
Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
As far as I know, we have never autodetected the language/locale and
automatically loaded the correct version. So, if anything, this is not a
bug, but a feature request. We have discussed how we would do this before,
and I think we have a plan for how to proceed. However, I don't have any
estimates for when we might do this, since the browser APIs for language
detection haven't really stabilized yet.
On Tue, Nov 3, 2015 at 8:46 AM Frédéric Gaye <

Post by Frédéric Gaye
Hi Sergey,
Thanks for your (quickly) anwsers.
Note : there another "little" but boring bug. Now with frozen 42 and 43,
date in tooltip are by default in english. We need to
add google.charts.load('42', {packages: ['corechart'], 'language': 'fr'});
to have date in french. Is it possible to correct this to stay like before
frozen (that is to say, language are automatically detected and no need to
force with 'language': 'fr' to have french.
Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
Thanks for notifying us of this bug! We will fix it soon.
On Mon, Nov 2, 2015 at 4:02 PM Frédéric Gaye <

Hi Daniel,

Post by 'Sergey Grabkovsky' via Google Visualization API

Post by Frédéric Gaye
It seems there a bug with Forzen 43 and use of
option focusTarget:'category'.
When we use both, it become impossible to mouse over a barchart to see
the tooltip (we see tooltip only if we put our mouse next to barchat) if we
use frozen 42 all is fine.
See this simple example
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
<script type="application/javascript"> google.charts.load('43',
{packages: ['corechart'], 'language': 'fr'});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = google.visualization.arrayToDataTable([
'annotation' }, 'Période précédente'],
['Organic Search', 59200, '#337ab7', -3130, 58750 ],
['Referral', 6450, '#337ab7', -387, 6837],
['Direct', 5874, '#337ab7', -424, 6298 ],
['Social', 113, '#337ab7', -78, 191],
['(other)', 20, '#337ab7', 3, 17]
]);
var options = {
title: "Density of Precious Metals, in g/cm^3",
width: 600,
height: 400,
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.BarChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
<div id="barchart_values2" style="width: 900px; height: 300px;"></div>
Any idea to correct this point ?
Regards

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how
you load the Google Charts packages. For example, here is the usual
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help
us if you could try it now with your charts and please let us know if you
experience any problems.
--

Daniel LaLiberte

Post by 'Daniel LaLiberte' via Google Visualization API
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *
*Sergey Grabkovsky* | SWE

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *

[Sergey]

OK, so I did some snooping around, and it appears that there was language
autodetection, but we won't be able to support it the same way, since we do
not have a server.

I'm not really sure how to advise you on this. We do intend to do some
language detection for frozen versions, but it will be done on the
client-side, so I don't know if it will work as well.

Post by Sergey
So the focusTarget:'category' issue should be fixed now, with the latest
frozen 43 push.
As for the language autodetection... Which browser/OS are you using, and
do you have the browser configured in any special sort of way?
I'm on a Mac, and I tried to reproduce by setting Chrome's primary
language, and by changing my region, to no avail.

Post by Frédéric Gaye
Hi Sergey,
Thanks.
I was thinking there was an autodetection (and a bug) because see theses
2 codes.
- The first one (old jsapi) show tooltip in my language (french)
without any language indication
<script type="text/javascript" src="
https://www.google.com/jsapi?autoload={'modules':[{'name':'visualization
','version':'1','packages':['corechart']}]}"></script>
<script type="application/javascript">
google.setOnLoadCallback(drawChart);
function drawChart() {
var data = new google.visualization.DataTable();
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addRows([
[new Date("4/11/2015"),2189,new Date("3/11/2015"),2189],
[new Date("4/12/2015"),2389,new Date("3/12/2015"),2536],
[new Date("4/13/2015"),2189,new Date("3/13/2015"),2545],
[new Date("4/14/2015"),2129,new Date("3/14/2015"),2390],
]);
var options = {
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.LineChart(document.getElementById('barchart_values3'));
chart.draw(data, options);
}
</script>
<div id="barchart_values3" style="width: 900px; height: 300px;"></div>
- And the second (loader.js) , need to force/add 'language': 'fr' to
see tooltip in french instead of en ("by default").
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
['corechart'], *'language': 'fr'*});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = new google.visualization.DataTable();
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addColumn({type:'date', role:'domain'});
data.addColumn('number', 'Sessions');
data.addRows([
[new Date("4/11/2015"),2189,new Date("3/11/2015"),2189],
[new Date("4/12/2015"),2389,new Date("3/12/2015"),2536],
[new Date("4/13/2015"),2189,new Date("3/13/2015"),2545],
[new Date("4/14/2015"),2129,new Date("3/14/2015"),2390],
]);
var options = {
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.LineChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
Any idea to show in the second code a "autodetected" french language
without any 'language': 'fr' ?
Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
As far as I know, we have never autodetected the language/locale and
automatically loaded the correct version. So, if anything, this is not a
bug, but a feature request. We have discussed how we would do this before,
and I think we have a plan for how to proceed. However, I don't have any
estimates for when we might do this, since the browser APIs for language
detection haven't really stabilized yet.
On Tue, Nov 3, 2015 at 8:46 AM Frédéric Gaye <

Post by Frédéric Gaye
Hi Sergey,
Thanks for your (quickly) anwsers.
Note : there another "little" but boring bug. Now with frozen 42 and
43, date in tooltip are by default in english. We need to
add google.charts.load('42', {packages: ['corechart'], 'language': 'fr'});
to have date in french. Is it possible to correct this to stay like before
frozen (that is to say, language are automatically detected and no need to
force with 'language': 'fr' to have french.
Regards

Post by 'Sergey Grabkovsky' via Google Visualization API
Thanks for notifying us of this bug! We will fix it soon.
On Mon, Nov 2, 2015 at 4:02 PM Frédéric Gaye <

Hi Daniel,

Post by 'Sergey Grabkovsky' via Google Visualization API

Post by Frédéric Gaye
It seems there a bug with Forzen 43 and use of
option focusTarget:'category'.
When we use both, it become impossible to mouse over a barchart to
see the tooltip (we see tooltip only if we put our mouse next to barchat)
if we use frozen 42 all is fine.
See this simple example
<script type="text/javascript" src="
https://www.gstatic.com/charts/loader.js"></script>
<script type="application/javascript"> google.charts.load('43',
{packages: ['corechart'], 'language': 'fr'});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = google.visualization.arrayToDataTable([
'annotation' }, 'Période précédente'],
['Organic Search', 59200, '#337ab7', -3130, 58750 ],
['Referral', 6450, '#337ab7', -387, 6837],
['Direct', 5874, '#337ab7', -424, 6298 ],
['Social', 113, '#337ab7', -78, 191],
['(other)', 20, '#337ab7', 3, 17]
]);
var options = {
title: "Density of Precious Metals, in g/cm^3",
width: 600,
height: 400,
focusTarget:'category',
legend: { position: 'none' },
tooltip: {textStyle:{ color: '#333', fontSize:12 }},
};
var chart = new
google.visualization.BarChart(document.getElementById('barchart_values2'));
chart.draw(data, options);
}
</script>
<div id="barchart_values2" style="width: 900px; height: 300px;"></div>
Any idea to correct this point ?
Regards

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes
are big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their
charts until it's exactly what they want. Some of those users might feel
more comfortable knowing that their charts will never change, regardless of
what improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how
you load the Google Charts packages. For example, here is the
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not
include the ‘visualization’ parameter, and the version number is a
string. Only version ‘41’ is supported at this time, which corresponds to
the current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details
about using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and
features should work the same as for the stable version it was created
from. But there are two minor, though important, limitations with
loading frozen versions, which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can
instead list all the packages that you'll need in one call, so there is
usually no need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all
the packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help
us if you could try it now with your charts and please let us know if you
experience any problems.
--

Daniel LaLiberte

Post by 'Daniel LaLiberte' via Google Visualization API
<https://plus.google.com/100631381223468223275?prsrc=2> -
978-394-1058

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it,
send an email to
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/851eebd7-3b47-4cb9-820c-67744230173b%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *
*Sergey Grabkovsky* | SWE

--
You received this message because you are subscribed to the Google
Groups "Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send
Visit this group at
http://groups.google.com/group/google-visualization-api.
To view this discussion on the web visit
https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/8ad55cdb-3485-45d1-8dc7-f03437d5896d%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
*[image: unnamed.gif] *

[Jesse Gardona]

Hello Daniel

Don't want to take up to much of your busy time. Just one question, I
would like to create a bubble/cluster global map just like periscope app (
I have included a screen shot), is this possible within the google maps
platform? Thank you

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[EC]

Hi, Daniel-
I noticed that my charts suddenly stopped working in UNIX, but remained
functional in Windows yesterday. I was stumped until I saw this post
today. You can see my thread at:
https://groups.google.com/forum/#!topic/google-visualization-api/F1MAY5Y47ZY
Thanks!

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[Shravan Pintu]

Hai daniel could you please post example for dynamic data for pie
charts.....because i have gone through the previous replys but couldnt find
out proper answer for pie chart.

Please explain in detail manner.....


Thanks in advance

[carinlynchin]

I know this is old...but i am having the same issue. I am using PHantomJS
and I get to the point where I want to load google. Google variable is an
object, but it never calls the callback. I have a console.log inside the
method for the callback which never shows up which tells me it is
definitely not calling the callback. I know you guys were going to take
this offline, but did you ever find a resolution. I have been trying to get
this to work for days.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

[carinlynchin]

If I set a timeout of 5 -10 seconds, then manually call the callback...then
there is no visualization so the x = new google.visualization.DataTable
doesn't exist

Post by carinlynchin
I know this is old...but i am having the same issue. I am using PHantomJS
and I get to the point where I want to load google. Google variable is an
object, but it never calls the callback. I have a console.log inside the
method for the callback which never shows up which tells me it is
definitely not calling the callback. I know you guys were going to take
this offline, but did you ever find a resolution. I have been trying to get
this to work for days.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include the
‘visualization’ parameter, and the version number is a string. Only
version ‘41’ is supported at this time, which corresponds to the current
stable release, and additional frozen versions will be announced as we
push out each new stable release. More details about using the frozen version
loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely, though
we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us if
you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

['Daniel LaLiberte' via Google Visualization API]

carinlynchin, if your problem is using the gstatic loader with PhantomJS,
you should try it now with the 'upcoming' release, which is v45 at this
time. I've just updated it to support dynamic loading, and it should work
in all variations I could think of, at least regarding what happens in the
browser. It's still not clear to me what happens on the server-side with
PhantomJS.

If it doesn't work, I would appreciate it if you could point me to a web
page that demonstrates the problem you are seeing. Code won't help me in
this case, since I have to see what ends up in the browser.

Post by carinlynchin
If I set a timeout of 5 -10 seconds, then manually call the
callback...then there is no visualization so the x = new
google.visualization.DataTable doesn't exist

Post by carinlynchin
I know this is old...but i am having the same issue. I am using PHantomJS
and I get to the point where I want to load google. Google variable is an
object, but it never calls the callback. I have a console.log inside the
method for the callback which never shows up which tells me it is
definitely not calling the callback. I know you guys were going to take
this offline, but did you ever find a resolution. I have been trying to get
this to work for days.

Post by 'Daniel LaLiberte' via Google Visualization API
*Introducing Frozen Google Charts*
When we push out new releases of Google Charts, some of the changes are
big, like entirely new chart types, but other changes are small, like
enhancements to the appearance or behavior of existing charts.
Many Google Chart creators fine-tune the look and feel of their charts
until it's exactly what they want. Some of those users might feel more
comfortable knowing that their charts will never change, regardless of what
improvements we make in the future. For those users, we're proud to
announce Frozen Google Charts.
To load a frozen version, you must make some small changes in how you
load the Google Charts packages. For example, here is the usual way of
<script type="text/javascript"
src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load('visualization', '1', {packages: ['corechart']});
google.setOnLoadCallback(drawChart);
</script>
You'll need to change your code to be like this (changes highlighted in
<script type="text/javascript"
src="*https://www.gstatic.com/charts/loader.js*
<https://www.gstatic.com/charts/loader.js>"></script>
<script type="text/javascript">
*google.charts.load(**'41'**,* {packages: ['corechart']});
*google.charts.setOnLoadCallback*(drawChart);
</script>
Note that when you call google.charts.load(), you should not include
the ‘visualization’ parameter, and the version number is a string.
Only version ‘41’ is supported at this time, which corresponds to the
current stable release, and additional frozen versions will be
announced as we push out each new stable release. More details about
using the frozen version loader will be available here
<https://google-developers.appspot.com/chart/interactive/docs/library_loading_enhancements>
.
When you use a frozen version of Google Charts, all charts and features
should work the same as for the stable version it was created from. But there
are two minor, though important, limitations with loading frozen versions,
which we expect to resolve in the near future.
1. You can only call google.charts.load() one time. You can instead
list all the packages that you'll need in one call, so there is usually no
need to make separate calls.
2. If you are using a ChartWrapper, you must explicitly load all the
packages you'll need rather than relying on the ChartWrapper to
automatically load them for you.
We expect that frozen versions will remain available indefinitely,
though we may retire frozen versions that have security concerns. We will
typically not provide support for frozen versions, except to suggest
upgrading to newer versions.
Even if you don't plan to use the frozen version 41, it would help us
if you could try it now with your charts and please let us know if you
experience any problems.
--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
- 978-394-1058

--

You received this message because you are subscribed to the Google Groups
"Google Visualization API" group.
To unsubscribe from this group and stop receiving emails from it, send an
googlegroups.com.
Visit this group at https://groups.google.com/
group/google-visualization-api.
To view this discussion on the web visit https://groups.google.com/d/
msgid/google-visualization-api/3f67c898-4189-43b9-9aa8-
fd2d1e37aeca%40googlegroups.com
<https://groups.google.com/d/msgid/google-visualization-api/3f67c898-4189-43b9-9aa8-fd2d1e37aeca%40googlegroups.com?utm_medium=email&utm_source=footer>
.
For more options, visit https://groups.google.com/d/optout.

--
Daniel LaLiberte <https://plus.google.com/100631381223468223275?prsrc=2>
***@Google.com <***@google.com> 5CC, Cambridge MA

[carinlynchin]

I would love to show you a page, but its server side. I changed it to 45
but it still doesn't call my callback. I'm not sure whats going on.

[carinlynchin]

Here are some screenshots tho... one showing the callback and the google
loads... the other showing the results of phantomjs... the "about to load"
refers to the fact that google.charts.load is about to go... the finished
loading refers to the fact that the page has completed loading (that code
is in anohter file where the phantom stuff is)

<Loading Image...>
<https://lh3.googleusercontent.com/--Db9Zru2wzc/V7IClUxHPNI/AAAAAAAAG5s/7RVKtaf6z_gvb9OjsgpNwrPcLMwjKNfNQCLcB/s1600/Screen%2BShot%2B2016-08-15%2Bat%2B1.53.59%2BPM.png>
<Loading Image...>