brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d992c0cbff
mutter/po/clutter-1.0.pot

2168 lines
46 KiB
Plaintext
Raw Normal View History

po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
# SOME DESCRIPTIVE TITLE.
Updated galician translations
2011-09-04 16:18:55 +00:00
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
"Project-Id-Version: PACKAGE VERSION\n"
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
"Report-Msgid-Bugs-To: http://bugzilla.clutter-project.org/enter_bug.cgi?"
"product=clutter\n"
Updated galician translations
2011-09-04 16:18:55 +00:00
"POT-Creation-Date: 2011-09-04 17:58+0200\n"
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: 8bit\n"
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3851
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X coordinate"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3852
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X coordinate of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3867
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Y coordinate"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3868
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Y coordinate of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3883 ../clutter/clutter-behaviour-ellipse.c:477
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3884
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Width of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3898 ../clutter/clutter-behaviour-ellipse.c:493
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3899
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Height of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3917
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Fixed X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3918
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Forced X position of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3936
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Fixed Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3937
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Forced Y position of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3953
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Fixed position set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3954
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to use fixed positioning for the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3976
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Min Width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3977
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Forced minimum width request for the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3996
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Min Height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:3997
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Forced minimum height request for the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4016
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Natural Width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4017
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Forced natural width request for the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4036
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Natural Height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4037
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Forced natural height request for the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4053
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Minimum width set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4054
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to use the min-width property"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4069
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Minimum height set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4070
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to use the min-height property"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4085
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Natural width set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4086
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to use the natural-width property"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4103
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Natural height set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4104
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to use the natural-height property"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4123
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Allocation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4124
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The actor's allocation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4180
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Request Mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4181
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The actor's request mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4196
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Depth"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4197
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Position on the Z axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4211
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Opacity"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4212
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Opacity of an actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4231
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Offscreen redirect"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4232
msgid "Flags controlling when to flatten the actor into a single image"
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4250
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Visible"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4251
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the actor is visible or not"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4266
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Mapped"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4267
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the actor will be painted"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4281
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Realized"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4282
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the actor has been realized"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4298
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Reactive"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4299
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the actor is reactive to events"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4311
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Has Clip"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4312
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the actor has a clip set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4327
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Clip"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4328
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The clip region for the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4342 ../clutter/clutter-actor-meta.c:207
#: ../clutter/clutter-binding-pool.c:319 ../clutter/clutter-input-device.c:236
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Name"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4343
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Name of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4357
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Scale X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4358
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Scale factor on the X axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4373
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Scale Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4374
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Scale factor on the Y axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4389
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Scale Center X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4390
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal scale center"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4405
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Scale Center Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4406
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical scale center"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4421
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Scale Gravity"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4422
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The center of scaling"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4439
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rotation Angle X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4440
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The rotation angle on the X axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4455
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rotation Angle Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4456
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The rotation angle on the Y axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4471
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rotation Angle Z"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4472
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The rotation angle on the Z axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4487
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rotation Center X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4488
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The rotation center on the X axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4504
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rotation Center Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4505
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The rotation center on the Y axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4521
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rotation Center Z"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4522
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The rotation center on the Z axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4538
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rotation Center Z Gravity"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4539
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Center point for rotation around the Z axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4557
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Anchor X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4558
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X coordinate of the anchor point"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4574
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Anchor Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4575
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Y coordinate of the anchor point"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4590
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Anchor Gravity"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4591
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The anchor point as a ClutterGravity"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4610
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Show on set parent"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4611
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the actor is shown when parented"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4631
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Clip to Allocation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4632
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Sets the clip region to track the actor's allocation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4642
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Text Direction"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4643
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Direction of the text"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4661
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Has Pointer"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4662
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the actor contains the pointer of an input device"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4679
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Actions"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4680
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Adds an action to the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4694
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Constraints"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor.c:4695
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Adds a constraint to the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor-meta.c:193 ../clutter/clutter-child-meta.c:142
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor-meta.c:194
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The actor attached to the meta"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor-meta.c:208
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The name of the meta"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor-meta.c:221 ../clutter/clutter-input-device.c:315
#: ../clutter/clutter-shader.c:307
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Enabled"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-actor-meta.c:222
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the meta is enabled"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-align-constraint.c:270
#: ../clutter/clutter-bind-constraint.c:349 ../clutter/clutter-clone.c:340
#: ../clutter/clutter-snap-constraint.c:321
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Source"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-align-constraint.c:271
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The source of the alignment"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-align-constraint.c:284
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Align Axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-align-constraint.c:285
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The axis to align the position to"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-align-constraint.c:304
#: ../clutter/clutter-desaturate-effect.c:304
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Factor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-align-constraint.c:305
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The alignment factor, between 0.0 and 1.0"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-alpha.c:345 ../clutter/clutter-animation.c:528
#: ../clutter/clutter-animator.c:1802
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Timeline"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-alpha.c:346
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Timeline used by the alpha"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-alpha.c:361
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Alpha value"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-alpha.c:362
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Alpha value as computed by the alpha"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-alpha.c:382 ../clutter/clutter-animation.c:484
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-alpha.c:383
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Progress mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:468
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Object"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:469
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Object to which the animation applies"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:485
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The mode of the animation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:499 ../clutter/clutter-animator.c:1786
#: ../clutter/clutter-media.c:194 ../clutter/clutter-state.c:1486
#: ../clutter/clutter-timeline.c:294
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Duration"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:500
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Duration of the animation, in milliseconds"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:514 ../clutter/clutter-timeline.c:263
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Loop"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:515
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the animation should loop"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:529
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The timeline used by the animation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:542 ../clutter/clutter-behaviour.c:304
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Alpha"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animation.c:543
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The alpha used by the animation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animator.c:1787
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The duration of the animation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-animator.c:1803
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The timeline of the animation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour.c:305
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Alpha Object to drive the behaviour"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-depth.c:178
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Start Depth"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-depth.c:179
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Initial depth to apply"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-depth.c:194
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "End Depth"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-depth.c:195
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Final depth to apply"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:397
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Start Angle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:398
#: ../clutter/clutter-behaviour-rotate.c:280
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Initial angle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:413
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "End Angle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:414
#: ../clutter/clutter-behaviour-rotate.c:298
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Final angle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:429
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Angle x tilt"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:430
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Tilt of the ellipse around x axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:445
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Angle y tilt"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:446
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Tilt of the ellipse around y axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:461
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Angle z tilt"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:462
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Tilt of the ellipse around z axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:478
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Width of the ellipse"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:494
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Height of ellipse"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:509
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Center"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:510
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Center of ellipse"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:524
#: ../clutter/clutter-behaviour-rotate.c:333 ../clutter/clutter-timeline.c:310
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Direction"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-ellipse.c:525
#: ../clutter/clutter-behaviour-rotate.c:334
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Direction of rotation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-opacity.c:181
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Opacity Start"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-opacity.c:182
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Initial opacity level"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-opacity.c:199
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Opacity End"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-opacity.c:200
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Final opacity level"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-path.c:222
#: ../clutter/clutter-path-constraint.c:212
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Path"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-path.c:223
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The ClutterPath object representing the path to animate along"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:279
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Angle Begin"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:297
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Angle End"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:315
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:316
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Axis of rotation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:351
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Center X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:352
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X coordinate of the center of rotation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:369
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Center Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:370
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Y coordinate of the center of rotation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:387
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Center Z"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-rotate.c:388
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Z coordinate of the center of rotation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:222
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X Start Scale"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:223
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Initial scale on the X axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:241
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X End Scale"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:242
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Final scale on the X axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:260
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Y Start Scale"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:261
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Initial scale on the Y axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:279
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Y End Scale"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-behaviour-scale.c:280
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Final scale on the Y axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bind-constraint.c:350
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The source of the binding"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bind-constraint.c:363
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Coordinate"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bind-constraint.c:364
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The coordinate to bind"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bind-constraint.c:378
#: ../clutter/clutter-path-constraint.c:226
#: ../clutter/clutter-snap-constraint.c:366
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Offset"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bind-constraint.c:379
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The offset in pixels to apply to the binding"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-binding-pool.c:320
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The unique name of the binding pool"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bin-layout.c:261 ../clutter/clutter-bin-layout.c:585
#: ../clutter/clutter-box-layout.c:395 ../clutter/clutter-table-layout.c:652
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal Alignment"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bin-layout.c:262
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal alignment for the actor inside the layout manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bin-layout.c:270 ../clutter/clutter-bin-layout.c:602
#: ../clutter/clutter-box-layout.c:404 ../clutter/clutter-table-layout.c:667
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical Alignment"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bin-layout.c:271
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical alignment for the actor inside the layout manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bin-layout.c:586
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Default horizontal alignment for the actors inside the layout manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-bin-layout.c:603
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Default vertical alignment for the actors inside the layout manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box.c:544
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Layout Manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box.c:545
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The layout manager used by the box"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box.c:564 ../clutter/clutter-rectangle.c:267
#: ../clutter/clutter-stage.c:1763
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Color"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box.c:565
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The background color of the box"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box.c:579
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Color Set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box.c:580
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the background color is set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:370
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Expand"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:371
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Allocate extra space for the child"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:377 ../clutter/clutter-table-layout.c:631
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal Fill"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:378 ../clutter/clutter-table-layout.c:632
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Whether the child should receive priority when the container is allocating "
"spare space on the horizontal axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:386 ../clutter/clutter-table-layout.c:638
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical Fill"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:387 ../clutter/clutter-table-layout.c:639
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Whether the child should receive priority when the container is allocating "
"spare space on the vertical axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:396 ../clutter/clutter-table-layout.c:653
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal alignment of the actor within the cell"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:405 ../clutter/clutter-table-layout.c:668
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical alignment of the actor within the cell"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1305
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1306
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the layout should be vertical, rather than horizontal"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1321 ../clutter/clutter-flow-layout.c:901
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Homogeneous"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1322
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Whether the layout should be homogeneous, i.e. all childs get the same size"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1337
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pack Start"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1338
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to pack items at the start of the box"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1351
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Spacing"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1352
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Spacing between children"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1366 ../clutter/clutter-table-layout.c:1742
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Use Animations"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1367 ../clutter/clutter-table-layout.c:1743
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether layout changes should be animated"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1388 ../clutter/clutter-table-layout.c:1764
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Easing Mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1389 ../clutter/clutter-table-layout.c:1765
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The easing mode of the animations"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1406 ../clutter/clutter-table-layout.c:1782
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Easing Duration"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-box-layout.c:1407 ../clutter/clutter-table-layout.c:1783
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The duration of the animations"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-cairo-texture.c:582
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Surface Width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-cairo-texture.c:583
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The width of the Cairo surface"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-cairo-texture.c:597
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Surface Height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-cairo-texture.c:598
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The height of the Cairo surface"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-cairo-texture.c:615
Post-release version bump to 1.7.9
2011-08-15 14:16:24 +00:00
msgid "Auto Resize"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-cairo-texture.c:616
Post-release version bump to 1.7.9
2011-08-15 14:16:24 +00:00
msgid "Whether the surface should match the allocation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-child-meta.c:127
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Container"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-child-meta.c:128
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The container that created this data"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-child-meta.c:143
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The actor wrapped by this data"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:542
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pressed"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:543
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the clickable should be in pressed state"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:556
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Held"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:557
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the clickable has a grab"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:574 ../clutter/clutter-settings.c:573
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Long Press Duration"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:575
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "The minimum duration of a long press to recognize the gesture"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:593
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Long Press Threshold"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-click-action.c:594
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "The maximum threshold before a long press is cancelled"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-clone.c:341
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Specifies the actor to be cloned"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-colorize-effect.c:307
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Tint"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-colorize-effect.c:308
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The tint to apply"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-deform-effect.c:527
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal Tiles"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-deform-effect.c:528
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The number of horizontal tiles"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-deform-effect.c:543
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical Tiles"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-deform-effect.c:544
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The number of vertical tiles"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-deform-effect.c:561
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Back Material"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-deform-effect.c:562
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The material to be used when painting the back of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-desaturate-effect.c:305
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The desaturation factor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-device-manager.c:131
#: ../clutter/clutter-input-device.c:344
#: ../clutter/x11/clutter-keymap-x11.c:316
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Backend"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-device-manager.c:132
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The ClutterBackend of the device manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:596
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal Drag Threshold"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:597
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The horizontal amount of pixels required to start dragging"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:624
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical Drag Threshold"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:625
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The vertical amount of pixels required to start dragging"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:646
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Drag Handle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:647
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The actor that is being dragged"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:660
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Drag Axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-drag-action.c:661
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Constraints the dragging to an axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:885
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Orientation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:886
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The orientation of the layout"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:902
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether each item should receive the same allocation"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:917 ../clutter/clutter-table-layout.c:1713
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Column Spacing"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:918
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The spacing between columns"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:934 ../clutter/clutter-table-layout.c:1727
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Row Spacing"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:935
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The spacing between rows"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:949
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Minimum Column Width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:950
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Minimum width for each column"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:965
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Maximum Column Width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:966
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Maximum width for each column"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:980
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Minimum Row Height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:981
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Minimum height for each row"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:996
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Maximum Row Height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-flow-layout.c:997
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Maximum height for each row"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:220
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Id"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:221
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Unique identifier of the device"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:237
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The name of the device"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:251
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Device Type"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:252
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The type of the device"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:267
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Device Manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:268
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The device manager instance"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:281
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Device Mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:282
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The mode of the device"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:296
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Has Cursor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:297
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the device has a cursor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:316
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the device is enabled"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:329
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Number of Axes"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:330
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The number of axes on the device"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-input-device.c:345
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The backend instance"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-interval.c:397
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Value Type"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-interval.c:398
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The type of the values in the interval"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-layout-meta.c:117
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Manager"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-layout-meta.c:118
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The manager that created this data"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#. Translate to default:RTL if you want your widgets
#. * to be RTL, otherwise translate to default:LTR.
#. *
#. * Do *not* translate it to "predefinito:LTR": if it
#. * it isn't default:LTR or default:RTL it will not work
#.
#: ../clutter/clutter-main.c:490
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "default:LTR"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1321
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Show frames per second"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1323
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Default frame rate"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1325
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Make all warnings fatal"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1328
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Direction for the text"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1331
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Disable mipmapping on text"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1334
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Use 'fuzzy' picking"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1337
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Clutter debugging flags to set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1339
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Clutter debugging flags to unset"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1343
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Clutter profiling flags to set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1345
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Clutter profiling flags to unset"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1348
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Enable accessibility"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1530
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Clutter Options"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-main.c:1531
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Show Clutter Options"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:77
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "URI"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:78
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "URI of a media file"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:91
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Playing"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:92
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Whether the actor is playing"
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:106
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Progress"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:107
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Current progress of the playback"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:120
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Subtitle URI"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:121
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "URI of a subtitle file"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:136
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Subtitle Font Name"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:137
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The font used to display subtitles"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:151
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Audio Volume"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:152
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The volume of the audio"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:165
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Can Seek"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:166
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the current stream is seekable"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:180
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Buffer Fill"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:181
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The fill level of the buffer"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-media.c:195
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The duration of the stream, in seconds"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-path-constraint.c:213
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The path used to constrain an actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-path-constraint.c:227
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The offset along the path, between -1.0 and 2.0"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-rectangle.c:268
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The color of the rectangle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-rectangle.c:281
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Border Color"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-rectangle.c:282
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The color of the border of the rectangle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-rectangle.c:297
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Border Width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-rectangle.c:298
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The width of the border of the rectangle"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-rectangle.c:312
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Has Border"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-rectangle.c:313
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the rectangle should have a border"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-script.c:434
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Filename Set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-script.c:435
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the :filename property is set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-script.c:449 ../clutter/clutter-texture.c:1081
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Filename"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-script.c:450
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The path of the currently parsed file"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:414
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Double Click Time"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:415
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The time between clicks necessary to detect a multiple click"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:430
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Double Click Distance"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:431
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The distance between clicks necessary to detect a multiple click"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:446
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Drag Threshold"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:447
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The distance the cursor should travel before starting to drag"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:462 ../clutter/clutter-text.c:2848
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font Name"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:463
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"The description of the default font, as one that could be parsed by Pango"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:478
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font Antialias"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:479
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Whether to use antialiasing (1 to enable, 0 to disable, and -1 to use the "
"default)"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:495
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font DPI"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:496
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"The resolution of the font, in 1024 * dots/inch, or -1 to use the default"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:512
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font Hinting"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:513
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Whether to use hinting (1 to enable, 0 to disable and -1 to use the default)"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:534
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font Hint Style"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:535
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The style of hinting (hintnone, hintslight, hintmedium, hintfull)"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:556
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font Subpixel Order"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:557
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The type of subpixel antialiasing (none, rgb, bgr, vrgb, vbgr)"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:574
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "The minimum duration for a long press gesture to be recognized"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:581
Updated galician translations
2011-08-28 15:36:57 +00:00
msgid "Fontconfig configuration timestamp"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-settings.c:582
Updated galician translations
2011-08-28 15:36:57 +00:00
msgid "Timestamp of the current fontconfig configuration"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:255
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertex Source"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:256
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Source of vertex shader"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:272
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Fragment Source"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:273
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Source of fragment shader"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:290
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Compiled"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:291
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the shader is compiled and linked"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:308
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the shader is enabled"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:519
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
#, c-format
msgid "%s compilation failed: %s"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:520
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertex shader"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader.c:521
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Fragment shader"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader-effect.c:415
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Shader Type"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-shader-effect.c:416
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The type of shader used"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-snap-constraint.c:322
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The source of the constraint"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-snap-constraint.c:335
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "From Edge"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-snap-constraint.c:336
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The edge of the actor that should be snapped"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-snap-constraint.c:350
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "To Edge"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-snap-constraint.c:351
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The edge of the source that should be snapped"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-snap-constraint.c:367
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The offset in pixels to apply to the constraint"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1705
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Fullscreen Set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1706
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the main stage is fullscreen"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1722
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Offscreen"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1723
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the main stage should be rendered offscreen"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1735 ../clutter/clutter-text.c:2961
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Cursor Visible"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1736
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the mouse pointer is visible on the main stage"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1750
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "User Resizable"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1751
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the stage is able to be resized via user interaction"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1764
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The color of the stage"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1778
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Perspective"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1779
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Perspective projection parameters"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1794
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Title"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1795
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Stage Title"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1810
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Use Fog"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1811
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to enable depth cueing"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1825
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Fog"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1826
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Settings for the depth cueing"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1842
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Use Alpha"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1843
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether to honour the alpha component of the stage color"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1859
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Key Focus"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1860
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The currently key focused actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1876
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "No Clear Hint"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1877
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the stage should clear its contents"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1890
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Accept Focus"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-stage.c:1891
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the stage should accept focus on show"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-state.c:1472
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "State"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-state.c:1473
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Currently set state, (transition to this state might not be complete)"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-state.c:1487
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Default transition duration"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:585
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Column Number"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:586
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The column the widget resides in"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:593
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Row Number"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:594
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The row the widget resides in"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:601
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Column Span"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:602
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The number of columns the widget should span"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:609
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Row Span"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:610
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The number of rows the widget should span"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:617
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal Expand"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:618
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Allocate extra space for the child in horizontal axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:624
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical Expand"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:625
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Allocate extra space for the child in vertical axis"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:1714
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Spacing between columns"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-table-layout.c:1728
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Spacing between rows"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2849
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The font to be used by the text"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2866
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font Description"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2867
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The font description to be used"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2883
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Text"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2884
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The text to render"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2898
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Font Color"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2899
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Color of the font used by the text"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2913
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Editable"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2914
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the text is editable"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2929
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Selectable"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2930
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the text is selectable"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2944
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Activatable"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2945
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether pressing return causes the activate signal to be emitted"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2962
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the input cursor is visible"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2976 ../clutter/clutter-text.c:2977
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Cursor Color"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2991
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Cursor Color Set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:2992
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the cursor color has been set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3007
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Cursor Size"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3008
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The width of the cursor, in pixels"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3022
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Cursor Position"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3023
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The cursor position"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3038
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Selection-bound"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3039
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The cursor position of the other end of the selection"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3054 ../clutter/clutter-text.c:3055
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Selection Color"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3069
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Selection Color Set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3070
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the selection color has been set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3085
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Attributes"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3086
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "A list of style attributes to apply to the contents of the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3108
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Use markup"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3109
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether or not the text includes Pango markup"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3125
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Line wrap"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3126
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "If set, wrap the lines if the text becomes too wide"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3141
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Line wrap mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3142
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Control how line-wrapping is done"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3157
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Ellipsize"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3158
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The preferred place to ellipsize the string"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3174
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Line Alignment"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3175
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The preferred alignment for the string, for multi-line text"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3191
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Justify"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3192
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the text should be justified"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3207
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Password Character"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3208
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "If non-zero, use this character to display the actor's contents"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3222
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Max Length"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3223
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Maximum length of the text inside the actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3246
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Single Line Mode"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3247
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the text should be a single line"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3261 ../clutter/clutter-text.c:3262
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Selected Text Color"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3276
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Selected Text Color Set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-text.c:3277
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Whether the selected text color has been set"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:995
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Sync size of actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:996
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Auto sync size of actor to underlying pixbuf dimensions"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1003
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Disable Slicing"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1004
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Forces the underlying texture to be singular and not made of smaller space "
"saving individual textures"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1013
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Tile Waste"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1014
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Maximum waste area of a sliced texture"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1022
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Horizontal repeat"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1023
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Repeat the contents rather than scaling them horizontally"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1030
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Vertical repeat"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1031
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Repeat the contents rather than scaling them vertically"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1038
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Filter Quality"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1039
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Rendering quality used when drawing the texture"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1047
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pixel Format"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1048
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The Cogl pixel format to use"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1056
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Cogl Texture"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1057
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The underlying Cogl texture handle used to draw this actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1064
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Cogl Material"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1065
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The underlying Cogl material handle used to draw this actor"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1082
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The path of the file containing the image data"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1089
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Keep Aspect Ratio"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1090
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Keep the aspect ratio of the texture when requesting the preferred width or "
"height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1116
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Load asynchronously"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1117
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Load files inside a thread to avoid blocking when loading images from disk"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1133
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Load data asynchronously"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1134
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid ""
"Decode image data files inside a thread to reduce blocking when loading "
"images from disk"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1158
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pick With Alpha"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1159
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Shape actor with alpha channel when picking"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1557 ../clutter/clutter-texture.c:1967
#: ../clutter/clutter-texture.c:2062 ../clutter/clutter-texture.c:2343
#, c-format
Post-release version bump to 1.7.7
2011-07-26 13:12:08 +00:00
msgid "Failed to load the image data"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1703
#, c-format
Post-release version bump to 1.7.7
2011-07-26 13:12:08 +00:00
msgid "YUV textures are not supported"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-texture.c:1712
#, c-format
Post-release version bump to 1.7.7
2011-07-26 13:12:08 +00:00
msgid "YUV2 textues are not supported"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-timeline.c:264
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Should the timeline automatically restart"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-timeline.c:278
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Delay"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-timeline.c:279
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Delay before start"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-timeline.c:295
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Duration of the timeline in milliseconds"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-timeline.c:311
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Direction of the timeline"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-timeline.c:326
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Auto Reverse"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/clutter-timeline.c:327
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Whether the direction should be reversed when reaching the end"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/evdev/clutter-input-device-evdev.c:147
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "sysfs Path"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/evdev/clutter-input-device-evdev.c:148
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Path of the device in sysfs"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/evdev/clutter-input-device-evdev.c:163
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Device Path"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/evdev/clutter-input-device-evdev.c:164
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Path of the device node"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-backend-x11.c:483
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X display to use"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-backend-x11.c:489
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X screen to use"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-backend-x11.c:494
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Make X calls synchronous"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-backend-x11.c:501
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Enable XInput support"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-keymap-x11.c:317
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The Clutter backend"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:545
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pixmap"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:546
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The X11 Pixmap to be bound"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:554
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pixmap width"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:555
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The width of the pixmap bound to this texture"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:563
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pixmap height"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:564
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The height of the pixmap bound to this texture"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:572
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Pixmap Depth"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:573
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The depth (in number of bits) of the pixmap bound to this texture"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:581
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Automatic Updates"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:582
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "If the texture should be kept in sync with any pixmap changes."
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:590
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Window"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:591
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "The X11 Window to be bound"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:599
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Window Redirect Automatic"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:600
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "If composite window redirects are set to Automatic (or Manual if false)"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:610
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Window Mapped"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:611
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "If window is mapped"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:620
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Destroyed"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:621
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "If window has been destroyed"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:629
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Window X"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:630
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "X position of window on screen according to X11"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:638
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Window Y"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:639
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Y position of window on screen according to X11"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:646
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "Window Override Redirect"
msgstr ""
Updated galician translations
2011-09-04 16:18:55 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:647
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no intention of dragging intltool into the build of a library that barely has localized messages.
2011-03-31 16:07:08 +00:00
msgid "If this is an override-redirect window"
msgstr ""
Reference in New Issue Copy Permalink