►
Description
PnP Web Cast around client-side web part localization. More details from http://dev.office.com/blogs
A
Welcome
everybody:
this
is
SharePoint
Patterson
practices
webcast
and
this
time
we're
gonna
talk
about
localization
with
SharePoint,
remember,
client,
side
of
webparts.
My
name
is
ruben
and
I'm
a
senior
program
manager
from
the
sharepoint
engineering
teams
and
with
me
today,
person
responsible
of
the
demo
will
be
wall,
deck
master
cards.
So
while
they
really
do
the
intro
so
slow
here.
B
A
Indeed,
India,
this
is
an
interesting
topic,
because
even
the
realities,
if
you
think
about
the
realities
of
SharePoint,
a
reach
across
the
world,
there's
multiple,
multiple
countries-
worship
on
this
used-
I,
don't
know
the
exact
number,
but
over
there's
multiple
languages.
What
people
are
actually
using
in
sharepoint
online
or
in
on-premises.
So
with
the
clients
lightweight
points,
we
absolutely
need
to
be
able
to
localize
the
labels
and
the
content
of
those
web
parts.
A
So
sharepoint
patterson
practices
is
owned
by
the
sharepoint
engineering.
So
we
in
the
richmond
are
actually
coordinating
the
support,
but
we
work
together
with
community
and
we
work
together
with
community
so
that
we
can
collect
the
feedback
from
a
community
and
work
together
with
the
community
to
solve
issues
in
an
open
source
manner.
The
SharePoint
matters
and
practices
is
providing
code,
samples,
Gardens
documentation
in
MSDN.
We
have
monthly
community
calls
by
big
special
interest
code
calls
we
have
case
studies.
A
The
concentration
is
on
the
SharePoint
framework,
obviously,
which
is
gonna,
go
see
a
relatively
soon
when
this
video
is
recorded
and
it
might
have
been
t8
already
when
you're
watching
the
video
and
Ober
so
we'll
also
concentrate
on
the
SharePoint
model
and
office.
365
API
and
Microsoft
craft
in
general,
AKMs
SharePoint
PMP
is
just
a
URL
to
remember
now,
let's
jump
back
on
the
content
and
we
can
actually
start
with
the
dua.
A
So
let's
talk
about
the
translation
of
the
of
the
client-side
web
part
I
mean,
can
I
use
this
super
simplistic
web
part
as
the
reference.
So
we
want
to
make
sure
that
we
concentrate
on
the
functionality
and
the
scenario
rather
than
let's
say
having
a
flashy
web
part,
and
we
will
have
plenty
of
flashy
web
parts
in
the
future
as
well,
but
for
showing
the
scenario
I
think
the
simplicity
is
the
key.
So
let's
talk
about
this
one
with
wild-like
as
well,
so,
first
topic.
What
we
need
to
translate,
obviously,
is
the
web
part
body.
A
So
that's
something
in
this
particular
case
for
the
web.
Part
which
is
translated
or
typically
should
be
translated
based
on
the
language
of
the
site
and
it's
kind
of
a
label.
It's
a
static
string
which
we
have
inside
of
the
web
part.
You
don't
control
that
in
this
case,
because
we're
not
exposing
that
as
a
property
from
a
property
paying,
as
you
can
see
in
this
particular
case,
so
based
on
the
site,
setting
the
site
language
and
the
user
language
preferences.
B
B
The
workbench
there's
one
thing
that
gives
away
that.
Actually,
the
organize
that
you
see
now
on
a
screen
works
in
Dutch.
So
if
you
look
at
toolbar,
where
you
see
save
this
card
mobile
tablet
preview,
the
mobile
label
is
actually
in
Dutch
because
because
the
the
workbench
that
you
see
I
ran
that
in
in
the
context
of
a
site
that
uses
Dutch
as
as
a
language.
B
So
based
on
that
you
can,
you
can
see
that
the
word
range
itself
is
shown
in
Dutch,
but
because
we
didn't
included
that
or
we
included
the
text
only
you
see
it
in
English
right.
So
there
would
be
definitely
a
thing
that
you
want
to
switch
the
languages
to
as
the
language
of
the
site
or
or
the
user
is
being
switched
as
well.
That's.
A
A
good
point
and
looking
into
actually
on
the
web
part
picker
as
well.
We
can
see
that
some
of
the
out
of
the
box
web
parts,
like
the
the
the
picture
web
part
that
actually
has
implemented
the
localization,
probably
because
we're
seeing
that
with
part
Ning
using
a
Dutch
translation
and
but
for
some
of
the
web
parts
like
Yammer
feet,
its
Yammer
feed,
it
hasn't
been
actually
translated
or
off
your
office.
A
365
video
as
well
and,
in
this
case,
we're
playing
around
with
greeting
web
part
that
has
not
been
translated
in
the
manifest
of
the
web
part.
So
the
title
of
the
web
part
is
still
creating
in
this
particular
case,
so
which
is
actually
running
us
to
the
second
case,
which
is
really
around.
How
do
we
translate,
then?
The
titles
of
the
web
part?
So
what
does
the
end
user
see
in
the
web?
A
Part
picker
when
they're
adding
the
web
part
in
to
the
site
itself
and
like
mention
in
this
case
the
creating
web
part
is
not
translated.
The
title
is
creating,
regardless
of
the
language
settings
and
like
we
can
see
for
some
of
the
out-of-the-box
web
part,
but
some
box
web
parts
are
translated
accordingly,
so
they've
are
slightly
further
down
on
the
development
cycle.
From
that
perspective,
cooch,
then,
from
a
translation
perspective,
whenever
you
are
configuring
the
web
part,
and
then
we
have
few
considerations
here
as
well,
so
we
have
the
property
pane
label
off.
A
So
these
are
the
actual
labels
of
the
of
the
properties
which
people
are
able
to
add
on
the
well
configure
on
the
on
the
particular
web
part,
and
if
you
want,
you
can
absolutely
translate
this
and
typically
that
would
be
the
right
thing
to
do,
because
if
you're
translating
the
static
labels
and
the
title
of
the
web
part,
you
should
be
translating
this
as
well.
Now,
if
it's
an
enterprise
development
scenario,
it
might
be
actually
architectural
decision
that
we
assume
that
the
people
who
are
configuring
web
parts
don't
and
they
all
understand,
English.
A
So
therefore,
let's
keep
the
language
in
English,
which
will
most
likely
reduce,
let's
say,
training
costs,
because
everything
will
be
consistent.
But
again,
if
you
are
using
a
reusable
or
creating
at
reusable
back
part
which
is
used
across,
maybe
multiple
companies
even
then
probably
want
to
actually
have
the
translations
for
the
property
pane
labels
in
place
as
well
and
then
the
final
kind
of
a
thing
is:
it's
been
the
actual
property
values
and
potential
content.
A
So
this
is
then-
and
this
is
kind
of
an
additional
dimension
on
this
discussion-
sure
we
can
translate
the
labels
of
the
and
the
title
of
the
web
part.
But
what
about
contents
and
what
happened?
What
about
the
scenarios
where
and
the
same
web
part
is
put
on
the
front
page
of
the
intranet
or
our
collaboration
site
and
this
front
page
is
being
accessed
in
multiple
different
languages.
A
So
how
do
I
make
sure
that
my
my
content
of
the
of
the
web
part
is
being
translated
as
well
and
that's
why
we
need
to
do
some
additional
tricks.
So
in
this
case,
as
an
example,
in
this
example
scenario,
we
are
showing
three
different
localizations,
so
our
translations
in
a
simplistic
way.
So
we
have
the
e
and
u-s-d-a
de
so
German
and
in
L
and
L,
which
is
Dutch
in
this
case,
or
Netherland
middle
and
dish,
no
just
kidding
neither
a
lamb
dish.
A
A
Now,
if
you
have
enabled
additional
languages
on
the
site
and
by
default
in
SharePoint
Online,
we
actually
enable
all
of
the
25
languages
on
the
side,
and
that
means
that
the
site
has
readiness
to
translate
the
labels,
for
example
the
site,
setting
text
or
the
site,
condense
text,
or
the
reasons
in
the
navigation
text
to
those
25
languages.
And
then,
when
a
user
accesses
the
site.
A
If
the
user
has
set
a
preferred
language
to
be
something
else,
then
the
default
language
of
the
site
and
that
something
else
is
enabled
on
the
site
as
a
language,
then
we
translate
that
site
or
those
labels
based
on
the
end-user
language
and
I,
do
not
understand
that.
That's
relatively
complex
way
of
putting
that
unless
you
can
actually
well
back,
explain
that
anymore,
but
it
needs.
We
all
got
a
complex
thing.
B
B
B
A
Correct
and
obviously
we
wanna
have
that
same
because
out-of-the-box
web
parts
are
doing
that
by
default
when
you're
implementing
your
custom
web
part.
You
want
to
do
the
same
thing
as
well,
so
you
want
to
flip
the
labels
and
texts
and
like
the
titles
of
the
web
parts.
So
what
we're
seeing
in
a
web
part
beaker
did
the
same
language,
what
the
user
prefers
to
actually
see
within
the
site.
A
Now
the
follow-up
question:
what
you
actually
had
was
that
okay,
so
okay,
that
takes
care
of
the
labels
that
taste
care
of
in
quotes
the
static
texts
within
the
web
part.
What
about
this
content?
Why
do
we
have
those
tree
here?
Well,
this
is
kind
of
a
debatable
approach,
and
so,
in
our
case,
we
wanted
to
demonstrate
also
the
scenario
which
quite
often,
people
might
run
into.
A
We
translate
in
the
SharePoint
static
labels
to
order
to
box
web
parts
do
translate
static
labels
as
well,
based
on
the
inches
of
selected
or
preferred
language,
but
we
don't
actually
translate
content
if
the
content
would
need
to
be
translated,
you
would
need
to
implement
something
custom
or
something
additional
thing,
and
what
I
mean
with
that?
One
is
that
the
content
is
content
if
we'd
say
as
an
example
that
Hello
text
box
what
we
can
see
underneath
the
en-us,
and
that
is
not
by
default-
translated
because
it's
content
in
this
case.
A
What
we've
done
is
that
in
this
particular
web
part,
this
completely
custom
implementation,
where
it's
exposing
as
an
example,
three
different
localizations,
the
English
German
and
Dutch,
and
then
you
can
actually
feel
what
would
be
the
text
if
the
interior
language
would
be
matching
to
that
local,
you
could.
We
could
just
as
well
at
20
30
25
s
here
and
but
that
form
a
simplicity
perspective.
We
wanted
to
have
a
same
ballistic
demo,
which
is
showing
how
to
make
this
happen.
A
A
B
A
You
can,
in
the
in
this
particular
implementation
and
like
this
kind
of
a
simplistic
scenario,
we're
actually
dynamically
adding
those
properties
on
the
web
part.
So
what
we're
doing
is
that
we're
accessing
the
list
of
languages
enabled
on
a
site,
or
we
could
actually
do
that
and
then
expose
those
as
an
option
within
the
web
part
site.
A
B
All
right
so
with
that,
let's
have
a
look,
how
you
can
translate
web
parts
to
multiple
languages.
So
first,
let's
add
the
web
part
that
we've
built
example
that
we
have
to
the
page
and,
as
you
can
see
here,
the
organs
that
we
have
runs
within
the
context
of
a
site
created
in
Dutch,
which
is
why
all
of
the
labels
are
in
Dutch
and
if
I
add
the
ad,
add
the
upper
to
page.
Here
you
can
see
it
if
I
open
it
Spain.
B
We
will
see
the
labels
here
in
English,
which
in
a
way
is
odd,
but
we
will
get
back
to
that,
and
here
we
see
the
ability
to
pro
provide
the
greeting
in
all
of
the
languages
enabled
on
this
side.
So
the
context
side
that
we
use
here
is
created
in
English
and
has
Dutch
and
German
in
German
enabled
as
additional
null
languages
that
users
can
use.
B
B
Part
make
sense
so
with
so
with
that,
let's
have
a
look
at
how
this
work
and
what
the
different
options
are
to
actually
translate
the
web
part
to
the
most
poles
and
wishes.
So
the
first
thing
that
you
can
do
is
you
can
translate
the
manifest.
The
manifest
is
the
part
where
the
the
meta
data
about
about
the
web
part
is
included,
and
some
of
the
things
that
you
type
in
here
within
the
manifest
show
actually
inside
the
toolbox.
So,
for
example,
things
like
title.
B
Description
and
icon
show
our
back
here.
If
you
choose
to
add
the
web
part,
you
will
see
it
here
right
and
here
there
are
some
of
yet
about
the
values
included
when,
within
the
manifest,
are
of
type
I,
localized
string,
which
allows
you
to
provide
not
only
one
value
but
actually
multiple
of
them,
where
each
one
corresponds
to
a
language
you
support.
So
as
in
here
we
have
default
one.
B
So
imagine
that
our
web
part
would
be
added
to
a
finished
site
which
we
don't
support,
so
we
always
have
the
fallback
and
that's
correct
with
it.
Whenever
you
enter
the
value
for
a
a
localized
string
property,
you
always
have
to
include
India
the
default,
and
then,
on
top
of
that,
you
can
add
more
strings
for
like
here
in
Dutch,
German,
Finnish
Spanish.
Anything
else
right.
So
that's
the
way
it
works,
and
the
only
thing
is
that
currently,
when
we
record
this,
the
workbench
doesn't
show
the
strings.
B
So
no
matter
which
language
you
choose
and
what
is
the
language
of
the
site
you
would
use,
it
will
always
show
up
in
English.
It
will
always
pick
default
string
and
often
this
is
in
English,
but
you
could
choose
to
have
default
in
Spanish
or
French.
Whatever
you
like,
like
write,
whatever
is
to
come,
the
most
common
language
used
within
your
company
yeah
and.
A
B
Expect
that
at
some
point
in
time
we'll
be
able
to
actually
see
different
strings
within
the
warband
toolbox
when,
when
you
work
with
size
that
actually
offered
this
support
right.
So
yes,
if
you
would
have
translation
for
a
Dutch
and
you
would
be
on
a
in
the
workbench
run
within
the
context
of
a
site
index
that
you
would
actually
be
able
to
see
in
the
labels
in
Dutch,
so
that
during
development
you
can
already
test
whether
everything
fits
on
a
screen
and
works
as
expected.
Yeah
right
so
currently
it
only.
B
B
Description
within
the
manifest
yeah,
so
that's
the
one
thing
that
that
you
can
provide
multiple
values
for
another
thing
that
you
can
you
that
you
can
insulate
are
actually
properties
within
run
pretty
plain,
so
these
strings,
like
here
like
header,
section
and
name
of
the
fields,
and
this
is
done
in
another
way.
So
if
we
go
you
you
go
to
the
code
here.
Here
is
the
year.
The
method
called
get
property.
B
Yeah
exactly
so
here
you
can
see
that
we
have
two
labels
that
we
actually
point
to
right.
So
there
is
one
string
here
and
another
here,
and
the
interesting
part
here
is
that
we
actually
include
the
pointer
to
this
train,
but
not
string
itself.
So
the
text
that
you
see
here
on
the
screen
greeting
to
show
in
the
web
part
it's
not
the
text
that
we
include
here
actually
so
here
we
point
to
a
a
resource
file
down.
We
have
here
in
our
locks
holder,
which
is
defined
here
in
the
my
string:
dot
d
dot.
B
Yes,
so
here
we
have
reading
group,
name,
property
paint,
screws
option
and
then
for
English
and
for
Dutch.
We
actually
include
these
strings
that
we
actually
show
in
this
screen
and
based
on
the
language
of
the
site
framework
will,
by
itself
load
the
right
language
by
itself
right.
So
you
you
don't
have
to
do
anything
other
than
specify
the
files
and
they
are
named
after
the
locale
lower
case.
B
So
here
the
the
interesting
thing
is
that,
even
though
I
start
the
workbench
within
the
context
of
a
site
created
in
Dutch,
actually
the
labels
that
I
see
here
are
in
English,
and
the
reason
for
that
is
that
workbench
for
the
labels
doesn't
really
adhere
to
the
context
of
the
site.
Well,
in
a
way
it
does,
but
not
for
this
part.
For
this
part,
it
will
only
load
the
language
that
you
choose
to
start
the
workbench
in
and
if
you
don't
specify
anything,
it
is
e'en
us.
B
B
Can
if
I
go
to
settings
font
size
I'm,
quite
sure
that
we'll
be
able
to
do
some
creative
editing
afterwards
to
make
all
this
go
away
or
not
so
now
what
you
can
do
here
is,
you
can
say,
as
you
would
gulp
serve,
and
because
we
use
the
workbench
that
that
is
available
in
365.
We
will
also
say
no
Bratton
Houser,
but
then
we
will
say
something
like
locale,
M,
L
and
L.
B
So
that
means
that
we
debug
our
project
and
we
want
to
debug
it
in
Dutch.
So
with
that,
when
we
build,
what
you
will
see
is
that
you
will
see
in
the
usual
build
probe
up
process
right.
So
nothing
will
change
here,
but
on
the
output
side,
and
you
actually
see
on
a
screen
some
additional
info
that
I
used
to
test
this.
But
here,
if
we
now
reload,
this
page
pay
attention
to
the
text
here.
So
now
all
this-
and
this
will
actually
be
in
Dutch.
B
B
They
can
include
because
the
workbench
also
supports
these,
the
pseudo
locales
and
that's
a
thing
that
you
can
use
to
check.
Whether
so
imagine
that
you
would
build
a
web
part
in
English
and
if
you
would
translate
strings
to
Dutch
or
drink
Herman,
there
is
a
chance
that
the
length
of
the
strings
will
expand
a
lot
right
because
the
languages
are
just
not
the
same.
B
But
if
you
don't
know
the
English
or
the
Dutch
phrase
up
front
when
you
build
the
web
part,
you
might
not
know
how
much
place
you
have
to
make
available
for
the
string
on
the
page
right.
So,
for
example,
here
the
button
or
strings
here
or
here
it
might
be
hard
for
you
to
think
about
like
how
much
space
do
you
need
so
we're
pseudo
locales?
What
you
can
do
is
you
can
include
the
dummy
strings
that
represent
the
maximum
length
of
your
translations.
B
So
with
that,
let's
do
another
test,
and
this
time
we
will
start
the
workbench
with
the
ups
clock
and
that's
that's
additional
locale
that
we
have
included
in
projects
and
if
you
look
at
the
way
it
looks
is
gibberish
all
right.
So
if
you
look
closely,
it
is
English
text
because
that's
what
you
use,
but
then
there
are
two
things
additional.
So,
first
of
all,
and
let
me
just
open
that
side-by-side
with
English
so
that
we
will
be
able
to
compare
it.
B
So
we
will
leave
the
ups
block
here
and
then
we
will
do
do
the
English
here
and
we
will
close
this
one.
So
you
can
now
see
that
this
is
exactly
the
same
text.
Greeting
webpart
configuration
which
is
kind
of
what
sets
here,
but
then
with
some
additional
text
and
then
we
have
some
additional
dead
next
year.
B
So
that's
a
nice
trick
that
you
can
test
that
that
that
you
can
use
to
test
that
you
have
enough
room
on
a
screen
to
accommodate
these
longer
strings
and
then
another
thing
that
that
you
can
tell
tested
here
is
use
of
the
characters
right,
because
these
are
all
of
these
are
non-standard
ASCII
characters.
So
imagine
that
you
would
use
a
non-standard
font
in
within
the
web
part
with
this.
You
can
see
that
you
can
verify
that
the
phone
that
you
use
will
support
correctly
the
non-standard
ASCII
as
well.
B
So
if
we
go
back
to
command
line
and
if
we
start
the
UPS
block
character
set
and
pretty
we'll
build
it
again
and
once
that
done
we'll
be
able
to
refresh
the
web
part
and
actually
see
so
now
it
should
be
available.
Now,
let
me
go
back
to
web
part
to
the
workbench
refresh
the
page,
and
now
we
can
see
all
of
the
gibberish
screen
strings
here
and
we
can
actually
verify
that
all
of
them
fit
on
a
screen.
B
Well,
almost
all
of
them,
because
here
and
that's
exactly
why
you
include
bracket
and
an
exclamation
mark.
You
can
see
that
this
string
is
actually
being
cut,
so
it
fits
here,
but
we
don't
see
its
end,
so
this
one
here
wraps,
but
this
one,
don't
that's
not
right.
So
with
that,
you
can
see
that
there
is
potentially
not
enough
room
on
a
screen
to
accommodate
it,
and
that
might
be
an
issue
within
the
control
within
CSS.
So
that
might
indicate
something
that
you
might
need
to
investigate
closer.
B
But
here,
for
example,
the
the
button
you
you
can
see
that
that
expands
accordingly.
So
with
that,
you
should
be
okay
for
including
additional
strings
right
and
actually
the
same
approach
you
can
use
within
the
body
right.
So
here
you've
seen
that
we
include
the
labels
in
property
pane,
and
you
can
also
see
that
we
use
exactly
the
same
approach
here
in
button.
B
So
here,
if
we
go
back
to
the
project-
and
let
me
open
this
one
and
close
these
two
guys-
we
can
go
back
to
our
component
greeting
when
we
actually
show
that
once
again,
we
embed
exactly
the
same
tags
from
strings
which
way
we
import
here
in
in
the
class.
We
refer
to
for
one
of
the
strings
that
we
have
defined
here
and
then
on
the
runtime.
B
We
load
it
either
in
english,
dutch
QPS
block
or
some
other
locale
that
we
have,
and
actually,
if
you
think
about
it,
the
essential
part
is
that
the
keys
in
all
these
files
are
actually
in
sync
right.
So,
if
you
have
here
these
three
guys,
you
should
have
exactly
the
same
three
keys
in
all
of
these
aisles
as
well
right.
So
here
I
had
in
one
of
them.
B
I
had
four
so
here:
I
had
default,
I
have
four
I
have
one
which
is
all
which
I
don't
know
you
use
anymore,
but
it
proves
point
that
at
this
point
you
have
to
keep
them
in
sync,
because
if
you
would
add
one
here,
let's
add
another
one:
let's
add
one
called
test,
and
that
would
be
a
string,
but
you
don't
have
it
here
in
in
English
or
on
run
time.
You
would
have
a
missing
string
right,
so
you
would
have
an
EM
gap
on
the
screen
right.
B
So
you
definitely
don't
want
to
do
that,
so
you
have
to
ensure
that
all
of
these
are
in
ins.
In
sync,
that's
all
of
that
keys
defined
here
are
also
included
here
and
here
in
all
these
tiles,
and
then
the
final
part
is
actually
how
we
do
deal
with
movie.
So
mu
E
is
the
ability
that
you
have
to
offer
additional
languages
in
your
sh
inside.
So,
as
I
said,
this
site
is
created
originally
in
English,
but
I
edit,
two
languages,
German
and
Dutch,
which
you
can
see
here.
B
A
B
B
B
B
So
we'll
go
to
the
parchment,
which
is
on
our
side,
settings
aspx
and
we'll
open
this
one,
and
here
you
can
see
that
the
full
language
is
English,
which
is
the
one
that
I
used
to
create
the
side
and
also
I
added
here
in
German
and
Dutch.
If
I
would
go
to
another
side
that
I
have
here
to
language
on
their
side,
you
will
see
that
I
only
have
have
English
enabled
and
I
didn't
choose
anything
else
right.
So
all
of
these
are
available,
but
boy
I
didn't
enable
them
on
this
side,
which
means
yep.
A
Which
means
that
we
have
fallen
back
on
English,
sorry
for
for
jumping
on
that
one.
But
could
you
actually
well
that
goes
to
your
user
profile
as
well,
and
just
just
the
show?
Why
did
we
cut
the
one
side
in
Dutch
and
this
does
take
a
while?
We
can
might
actually
edit
this
request
away
from
the
well.
That's
an
admin,
UI
I'm
thinking,
just
your
user
profile
and
Delft.
It
was
about
because.
B
A
B
You
choose
as
admin
that
you
want
to
see
things
in
Dutch.
Then
you
see
things
in
that.
Right.
Sure
sure,
fair
point,
fair
point
right.
So
here's
exactly
the
place
where
you
can
say
whether
you
want
to
see
things
in
Dutch
or
English,
right
and
I
chose
to
have
to
see
them
in
Dutch,
so
that
we
can
see
how
the
language
would
switch.
But
you
you
can
easily
move
them
to
up
and
down
to
set
to
set
the
order,
the
preference
of
your
languages
right.
B
B
Yeah,
yes,
so
here
we
have
the
office
and
that's
why
all
of
this
work
right.
So
this
is
exactly
why
we
see
it's
real
languages
here,
because
we
enables
three
languages
on
this
site
right,
so
the
languages
that
you
see
here
correspond
to
the
languages
enabled
here.
So
here
we
have
English
German
Dutch,
and
here
we
see
English,
German
Dutch,
so.
A
B
A
A
B
Here
we
are
back
in
our
side
and
the
way
it
works
is
there
actually
a
few
steps
so
when
we
open
the
property
pane,
what
we
first
do
is,
first
from
the
side
that
that
that
that
we
are
at
we
load
the
list
of
all
of
the
languages
enabled
for
this
site
and
based
on
that,
we
render
these
text
boxes
here
so
in
code.
This
translates
to
here.
We
first
go
to
our
own
property.
B
Pane
configuration
start
event,
which
is
event
that
triggers
whenever
you
open
property
pain
within
the
web
part,
and
then
we
say
okay,
so
we
are
going
to
load
some
things
and
actually,
in
this
case
itself,
as
that
you
actually
don't
get
it
get
to
see
it,
but
in
in
case
it
will
be
slower.
You
will
actually
see
a
spinner
that
says
reload
and
languages.
Now
this
way,
then
we
get
the
list
of
languages
enabled
in
this
side
and
the
way
we
do
that
is
we
do
it
arrests.
B
So
here
let
me
reload
the
page,
because
we
catch
that.
We
don't
want
to
load
that
every
time
and
let
me
clear
this
one
here
and
now,
when
I
open
property
pane,
you
can
see
the
requests
that
we
do
here
so
here
we
call
to
API
web
select,
support,
ui
language
IDs
and
what
we
get
back
are
the
else
it's
for
the
languages
enabled
on
the
side.
So
that's
English,
German
Dutch,
but
actually
we
don't
want
to
show
numbers
here
right.
B
So
in
order
to
do
it,
you
have
to
do
it
by
yourself,
so
we
included
here
a
list
of
all
of
the
locales
that
aren't
that
is
available
in
SharePoint,
and
then
we
can
go
with
with
that.
We
can
go,
go
back
and
forth
between
the
DL
said
and
the
label,
and
we
have
to
be
able
to
go
back
and
forth
because
these
are
the
languages
available
in
this
side.
B
B
A
B
A
B
Right
so
then
we
have
and
then
for
each
one
of
them.
We
create
text
field
that
we
will
actually
show
here.
So
here
we
have
for
each
loop
and
then
for
each
one.
We
will
get
text
field
that
we
show
here.
So
we
have
one
for
English,
German
and
Dutch
and
what's
interesting
here
is
that
up
front
when
we
build
the
web
parts,
we
don't
really
know
whether
we
have
three
languages,
5
or
10
and
which
languages
these
are.
B
So
we
cannot
really
if
you
would
go
back
to
manifest
we're
gonna,
say
here,
green
and
now
that
that
that
want
to
have
probe
probe
a
property
in
English
or
in
Dutch
or
in
Arabic
right,
because
we
well,
we
could
do
that,
but
there
will
be
quite
some
overhead
to
try
to
get
the
right
tags
for
each
one
of
them
right
and
also
here.
If
you
look
at
properties,
that's
also
empty
right,
because
we
don't
really
want
to
include
all
of
that
up
front.
B
Well,
what
also
works
is
for
you
just
to
specify
the
name
of
property
for
for
the
web,
part
to
which
you
want
to
bind
the
value.
So
here
on
the
fly
we
say
heating
and
that
will
be
ten
thirty,
thirty
one,
forty
three
thirty
three,
depending
on
your
language,
but
basically
what
we
do
is
we
create
web
part
hope
problem
per
tease
on
the
fly
right.
We
don't
define
them
upfront.
B
We
we
only
create
them
on
runtime,
based
on
the
languages
enabled
in
this
site
right
and
then
asked
labelled
that
we
shall
we
get
the
name.
So
here
we
show
env
D,
anele
anele
and
of
course
you
you
could
choose
to
show
the
name
of
a
language
then,
when,
when
we
are
done,
we
assign
all
that
to
an
array
that
we
didn't
use
in
our
properties,
pane
to
actually
show
all
of
the
fields
right.
B
So
typically,
you
would
include
array
directly
here
in
inline
if
you
have
a
set
of
fields
that
is
fixed,
but
in
our
case
that
depends
on
the
language
is
enabled
on
this
decide.
So
we
can
only
do
that
afterwards.
After
we
know
the
list
of
all
of
the
languages
enabled
in
this
side
right
and
then
we
refresh
the
pane
right,
because
now
we
have
all
the
fields
we
actually
want
them
to
render
themselves
within
the
paint.
So
we
have
to
refresh
the
page
because
it's
been
initially
opened,
it
was
empty.
B
So
once
again,
let
me
reload
the
page
and
if
you
pay
close
attention
and
within
the
video
you
will
be
able
to
stop
pause
and
go
frame
by
frame,
so
you'll
be
exactly
able
to
see
the
way
it
works.
If
you
now
pay
attention,
the
paint
is
empty
at
first
and
then
the
fields
appear
on
the
screen.
So
three
two
one
open
empty
empty.
Yes,
there
is
so
that's
exactly
that
time
that
it
takes
to
get
info
about
the
languages,
render
the
fields
or
actually
build
the
fields
and
then
render
them
in
a
pane.
B
And
so
we
have-
and
we
render
the
web
part
right
and
based
on
that,
we
can
then
include
these
three
guys.
So
here
we
have
the
same
text
in
dark,
german
and
english
and
based
on
the
language
currently
used
by
the
user.
We
can
now
show
the
text
within
the
body
and
the
way
we
do
that.
Yes,
here
we
go
to
render.
We
pass
that
to
react,
and
here
we
retrieve
that
from
we
get
the
language
from
context
page
context,
culture
info
current
UI
culture
name.
B
B
A
I
would
like
to
really
kind
of
explicitly
point
out
that
this
is
the
translation
of
the
content
once
again,
that's
a
completely
custom
implementation
and
for
this
particular
web
part
and
bright,
and
that's
kind
of
a
conceptual
implementation
which
wanted
to
show
from
a
consideration
perspective
the
label
translations.
Those
are
obviously
working
much
more
easily
because
you
don't
actually
need
to
worry
about
the
dynamic,
the
creation
of
properties
and
all
of
that
you'll
just
define
the
string
values
for
the
photo
language
themselves,
but
I
think
that
sums
up.
B
A
The
content
is
an
advanced
scenario
and-
and
we
wanted
to
show
that
and
clearly
flag
that
in
this
webcast
as
well,
because
so
that
people
understand
that
hey
wait,
a
minute.
Ok,
con,
isn't
translated
by
default
and
I
would
have
to
implement
something
clever
to
make
that
happen
as
well.
You
can
do
that,
but
it
requires
additional
work
and
the
shape
and
context
other
the
SharePoint
context.
Language
actually
depends
on
the
site,
settings
and
the
user
settings.
So
there's
two
elements
on
the
selection
of
a
UI
language.
A
The
languages
have
to
be
first
enabled
on
a
site
by
default.
All
of
the
25
languages
are
enabled
on
the
site,
regardless
of
the
latif,
odd
languages
of
the
sign,
and
then
the
user
has
to
have
a
preferred
language
set
due
to
whatever
in
the
user
profile.
You
can
actually
go
to
the
user
profile
properties
and
set
your
preferred
language,
and
that
will
then
actually
flip
the
UI
to
be
translated
automatically
and
USA
a
webpart
developer.
You
can
actually
read
that
value
and
then
start
translating
your
content
and
information.
A
Based
on
that
now,
as
like
you
saw
on
a
demo
from
wandick
localization
of
actual
labels,
it's
relatively
you
see
it's
just
a
matter
of
getting
that
translation
and
to
be
fair.
Maybe
we
oversimplify
the
message
even
from
a
implementation,
technical
perspective,
the
label
translation
is
easy
and
getting
this
the
actual
label
text
translated,
could
be
a
slightly
more
complex
because
at
least
in
translations
of
Finnish
in
SharePoint,
at
they're,
pretty
funky,
and
when
the.
What
are
the
translation?
How
do
we
translate?
A
If
you
need
to
have
this
kind
of
a
dynamic
handling
or
the
translation
of
the
content,
then
that's
a
slightly
more
complex
scenario
and
there's
multiple
options
and
considerations
around
that
one:
the
UI
implementation
there
has
to
be
dynamic,
there's
additional
things
to
consider
as
well.
So
that's
clearly
an
advanced
scenario,
and
it
might
be
that
in
in
your
web
part
case,
you
don't
need
to
do
that.
Good
example,
and
like
mentioned
before
the
demo,
is
that,
if
you're
showing
an
image
well,
image
is
most
likely
the
same
regardless
of
the
UI
language.
B
B
A
Really
one
of
the
things
what
I
want
to
call
out
and
if
you
watched
any
of
this
webcast
and
ambassadors
well,
we
clearly
we
intentionally
want
to
keep
this
relatively
simple
so
that
you
can
easily
adapt
on
the
course
scenario
like
in
this
case
and
the
web.
The
sample
itself
shows
only
the
course,
an
area
around
translation
when
you're
actually
implementing
your
real-world
web
port.
Obviously
it
won't
be
looking
like
that,
most
likely
with
a
blue
background
and
all
of
that
stuff,
it
will
be
much
more
fancier
and
if
it
will
will
have
awesome
functionalities.
A
But
then
you
can
combine
these
learnings
and
scenarios
to
your
custom
implementation
to
make
it
translate
as
well.
So
we
absolutely
recommend
you
to
have
a
look
on
on
the
on
the
samples
which
are
available,
and
this
particular
sample
obviously
will
be
reference
in
the
video
notes
as
well,
but
I
think
that's
it.
Thank
you,
Wanda
for
joining
and
we'll
come
up
with
come
up
with
a
new
webcast
sooner
or
later.
Thank
you.