isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-26 21:02:14 +00:00
Code Issues Packages Projects Releases Wiki Activity
15000307fd
mutter/po/clutter-1.0.pot

2203 lines
48 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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
"POT-Creation-Date: 2011-11-13 18:51+0100\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"
Restore clutter-1.0.pot file
2011-09-08 14:35:47 +00:00
"Language: \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
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: 8bit\n"
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3886
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3887
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3902
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3903
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3918
#: ../clutter/deprecated/clutter-behaviour-ellipse.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 "Width"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3919
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3933
#: ../clutter/deprecated/clutter-behaviour-ellipse.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 "Height"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3934
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3952
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Forced X position of the actor"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3971
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3972
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3988
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:3989
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4011
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4012
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4031
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4032
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4051
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4052
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4071
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4072
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4088
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4089
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Minimum height set"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4105
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4120
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4121
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4138
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4139
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4158
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4159
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4215
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4216
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4231
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4232
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4246
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4247
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4266
Post-release version bump to 1.7.3
2011-06-13 22:46:21 +00:00
msgid "Offscreen redirect"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4267
Updated galician translations
2011-09-04 16:18:55 +00:00
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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4285
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4286
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4301
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4302
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4316
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4317
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4333
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4334
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4346
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4347
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4362
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4363
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4377 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4378
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4392
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4393
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4408
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4409
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4424
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4425
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Scale Center Y"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4441
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Scale Gravity"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4457
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4474
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4475
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4490
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4491
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4506
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4507
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Rotation Center X"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4523
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Rotation Center Y"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4540
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4556
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "The rotation center on the Z axis"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4573
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Center point for rotation around the Z axis"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4592
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4593
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4609
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Y coordinate of the anchor point"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4625
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4626
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4645
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4646
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4666
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4667
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4677
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4678
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4696
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4697
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4714
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4715
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4729
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4730
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor.c:4744
msgid "Effect"
msgstr ""
#: ../clutter/clutter-actor.c:4745
msgid "Add an effect to be applied on the actor"
msgstr ""
#: ../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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-actor-meta.c:221 ../clutter/clutter-input-device.c:315
#: ../clutter/deprecated/clutter-shader.c:309
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-align-constraint.c:281
#: ../clutter/clutter-bind-constraint.c:349 ../clutter/clutter-clone.c:345
#: ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-align-constraint.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 source of the alignment"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-align-constraint.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 "Align Axis"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-align-constraint.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 "The axis to align the position to"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-align-constraint.c:315
#: ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-align-constraint.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 "The alignment factor, between 0.0 and 1.0"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-alpha.c:345 ../clutter/clutter-animation.c:538
#: ../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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-alpha.c:382 ../clutter/clutter-animation.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 "Mode"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.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 "Object"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.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 "Object to which the animation applies"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.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 "The mode of the animation"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.c:509 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.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 "Duration of the animation, in milliseconds"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.c:524 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.c:525
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.c:539
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.c:552
#: ../clutter/deprecated/clutter-behaviour.c:240
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-animation.c:553
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-backend.c:333
msgid "Unable to initialize the Clutter backend"
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-backend.c:407
#, c-format
msgid "The backend of type '%s' does not support creating multiple stages"
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have 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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box.c:564 ../clutter/clutter-rectangle.c:267
#: ../clutter/clutter-stage.c:1790
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1303
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1304
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1319 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1320
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1335
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1336
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1349
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1350
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1364 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1365 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1386 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1387 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1404 ../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-11-13 17:52:21 +00:00
#: ../clutter/clutter-box-layout.c:1405 ../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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-click-action.c:574 ../clutter/clutter-settings.c:598
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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-clone.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 "Specifies the actor to be cloned"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-deform-effect.c:547
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-deform-effect.c:548
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-deform-effect.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 "Vertical Tiles"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-deform-effect.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 number of vertical tiles"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-deform-effect.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 "Back Material"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-deform-effect.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 "The material to be used when painting the back of the actor"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#. Translators: Leave this UNTRANSLATED if your language is
#. * left-to-right. If your language is right-to-left
#. * (e.g. Hebrew, Arabic), translate it to "default:RTL".
#. *
#. * Do NOT translate it to non-English e.g. "predefinito:LTR"! If
#. * it isn't default:LTR or default:RTL it will not work.
#.
#: ../clutter/clutter-main.c:752
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1610
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1612
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1614
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1617
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1620
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1623
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1626
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1628
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1632
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1634
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1637
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1829
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-main.c:1830
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-path-constraint.c:212
#: ../clutter/deprecated/clutter-behaviour-path.c:224
msgid "Path"
msgstr ""
#: ../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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-script.c:449 ../clutter/clutter-texture.c:1071
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:439
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:440
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:455
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:456
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:471
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:472
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:487 ../clutter/clutter-text.c:2995
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:488
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:503
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:504
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.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 "Font DPI"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.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 ""
"The resolution of the font, in 1024 * dots/inch, or -1 to use the default"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:537
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:538
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:559
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:560
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.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 "Font Subpixel Order"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.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 "The type of subpixel antialiasing (none, rgb, bgr, vrgb, vbgr)"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:599
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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:606
Updated galician translations
2011-08-28 15:36:57 +00:00
msgid "Fontconfig configuration timestamp"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:607
Updated galician translations
2011-08-28 15:36:57 +00:00
msgid "Timestamp of the current fontconfig configuration"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:624
msgid "Password Hint Time"
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-settings.c:625
msgid "How long to show the last input character in hidden entries"
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-shader-effect.c:482
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-shader-effect.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 "The type of shader used"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1732
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1733
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1749
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Whether the main stage should be rendered offscreen"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1762 ../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 "Cursor Visible"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../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 "Whether the mouse pointer is visible on the main stage"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1777
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Whether the stage is able to be resized via user interaction"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1791
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1805
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1806
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1821
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1822
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1837
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1838
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1852
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1853
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1869
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1870
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1886
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1887
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1903
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1904
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1917
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-stage.c:1918
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:2996
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3013
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3014
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3030
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3031
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3045
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3046
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3060
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3061
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3076
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3077
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3091
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3092
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 the input cursor is visible"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3123 ../clutter/clutter-text.c:3124
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3138
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3139
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3154
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3155
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3169
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3170
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3185
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3186
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3201 ../clutter/clutter-text.c:3202
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3216
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3217
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3232
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3233
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3255
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3256
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3272
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3273
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3288
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3289
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3304
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3305
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3321
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3322
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3338
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3339
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3354
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3355
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3369
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3370
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3393
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3394
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3408 ../clutter/clutter-text.c:3409
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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3423
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-11-13 17:52:21 +00:00
#: ../clutter/clutter-text.c:3424
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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:985
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:986
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:993
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:994
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Tile Waste"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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 "Maximum waste area of a sliced texture"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1012
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Repeat the contents rather than scaling them horizontally"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1020
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1021
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1028
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1029
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1037
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "The Cogl pixel format to use"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1046
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "The underlying Cogl texture handle used to draw this actor"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1054
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1055
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1072
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1079
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1080
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1106
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1107
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1123
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1124
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1148
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1149
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1547 ../clutter/clutter-texture.c:1930
#: ../clutter/clutter-texture.c:2024 ../clutter/clutter-texture.c:2305
#, 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1693
#, 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-11-13 17:52:21 +00:00
#: ../clutter/clutter-texture.c:1702
#, 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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/clutter-timeline.c:310
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:526
#: ../clutter/deprecated/clutter-behaviour-rotate.c:335
msgid "Direction"
msgstr ""
#: ../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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/deprecated/clutter-behaviour.c:241
msgid "Alpha Object to drive the behaviour"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-depth.c:180
msgid "Start Depth"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-depth.c:181
msgid "Initial depth to apply"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-depth.c:196
msgid "End Depth"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-depth.c:197
msgid "Final depth to apply"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:399
msgid "Start Angle"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:400
#: ../clutter/deprecated/clutter-behaviour-rotate.c:282
msgid "Initial angle"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:415
msgid "End Angle"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:416
#: ../clutter/deprecated/clutter-behaviour-rotate.c:300
msgid "Final angle"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:431
msgid "Angle x tilt"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:432
msgid "Tilt of the ellipse around x axis"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:447
msgid "Angle y tilt"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:448
msgid "Tilt of the ellipse around y axis"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:463
msgid "Angle z tilt"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:464
msgid "Tilt of the ellipse around z axis"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:480
msgid "Width of the ellipse"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:496
msgid "Height of ellipse"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:511
msgid "Center"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:512
msgid "Center of ellipse"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-ellipse.c:527
#: ../clutter/deprecated/clutter-behaviour-rotate.c:336
msgid "Direction of rotation"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-opacity.c:183
msgid "Opacity Start"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-opacity.c:184
msgid "Initial opacity level"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-opacity.c:201
msgid "Opacity End"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-opacity.c:202
msgid "Final opacity level"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-path.c:225
msgid "The ClutterPath object representing the path to animate along"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:281
msgid "Angle Begin"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:299
msgid "Angle End"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:317
msgid "Axis"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:318
msgid "Axis of rotation"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:353
msgid "Center X"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:354
msgid "X coordinate of the center of rotation"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:371
msgid "Center Y"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:372
msgid "Y coordinate of the center of rotation"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:389
msgid "Center Z"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-rotate.c:390
msgid "Z coordinate of the center of rotation"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:224
msgid "X Start Scale"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:225
msgid "Initial scale on the X axis"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:243
msgid "X End Scale"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:244
msgid "Final scale on the X axis"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:262
msgid "Y Start Scale"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:263
msgid "Initial scale on the Y axis"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:281
msgid "Y End Scale"
msgstr ""
#: ../clutter/deprecated/clutter-behaviour-scale.c:282
msgid "Final scale on the Y axis"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:257
msgid "Vertex Source"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:258
msgid "Source of vertex shader"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:274
msgid "Fragment Source"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:275
msgid "Source of fragment shader"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:292
msgid "Compiled"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:293
msgid "Whether the shader is compiled and linked"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:310
msgid "Whether the shader is enabled"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:521
#, c-format
msgid "%s compilation failed: %s"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:522
msgid "Vertex shader"
msgstr ""
#: ../clutter/deprecated/clutter-shader.c:523
msgid "Fragment shader"
msgstr ""
#: ../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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/gdk/clutter-backend-gdk.c:287
#, c-format
msgid "Could not find a suitable CoglWinsys for a GdkDisplay of type %s"
msgstr ""
#: ../clutter/x11/clutter-backend-x11.c:506
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-backend-x11.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 "X screen to use"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-backend-x11.c:517
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-backend-x11.c:524
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.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 "Pixmap"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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 "The X11 Pixmap to be bound"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:553
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "The width of the pixmap bound to this texture"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.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 "Pixmap height"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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 "The height of the pixmap bound to this texture"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:571
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "The depth (in number of bits) of the pixmap bound to this texture"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.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 "Automatic Updates"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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 "If the texture should be kept in sync with any pixmap changes."
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:589
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "The X11 Window to be bound"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.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 "Window Redirect Automatic"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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 "If composite window redirects are set to Automatic (or Manual if false)"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.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 "Window Mapped"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +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 "If window is mapped"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:619
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "If window has been destroyed"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:628
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "X position of window on screen according to X11"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:637
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "Y position of window on screen according to X11"
msgstr ""
Updated Galician translations
2011-11-13 17:52:21 +00:00
#: ../clutter/x11/clutter-x11-texture-pixmap.c:645
po: Track Clutter's POT file in Git If no POT file is found, gettext will automatically create it; this, in turn, will cause msgmerge to be run, and that will cause the PO files to be touched and changed at the very first call for `make`. Having the PO files with unstaged changes will ultimately lead to merge issues will pulling from the remote repository between releases - unless `git checkout -f` is called prior to `git pull -r`. I think intltool only has some rule to avoid that from happening unless on dist, but I have no 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-11-13 17:52:21 +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 "If this is an override-redirect window"
msgstr ""
Reference in New Issue Copy Permalink