►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
D
A
B
A
Yeah,
so
I
guess
that's
kind
of
similar
to
what
jeremy
was
asking.
So
what
is
the
actual
thing
that
we
are
setting
the
underlying
win32
apis?
This
is
basically
we
leave
it
to.
The
default
should
be
false,
but
in
your
case,
it's
given
that
it's
set
in
the
designer
most
of
the
time.
The
design
already
has
a
notion
of
rendering
default
values
different.
I
think
it's
also
fine.
A
I
mean,
according
to
my
to
my
monitor,
it's
working
fine.
Let
me
actually
check
all
right.
Let's
check.
A
D
B
Specific
change
for
the
user
to
set
this
property,
so
I'm
just
trying
to.
D
B
D
B
C
E
C
As
we
change
anchor
top
to
anchor
bottom,
it
seems
fine
to
me.
I
don't
I'm
not
a
super
winforms
person,
so
I
don't
know
how
much
it
matches
the
names,
but
I've
done
enough
that
I
know
what
an
mdi
child
window
is
and
what
minimizing
is
and
anchors.
So
it's
perfectly
self-explanatory.
As
far
as
I'm
concerned,
yeah.
B
The
only
the
only
concern
that
I
had
is
that
the
property
says
the
anchor
talk
or
something
like
that.
So
if
tomorrow,
the
windows
changes
the
behavior
instead
of
the
the
top
left,
if
they
started
doing
the
top
right
or
maybe
bottom
right
right.
B
A
So
I
think
naming
wise
it's
good,
that
it
starts
with
the
mdi
children
prefix,
because
that
aligns
with
the
other
mdi
property.
My
question
is
the
mdi
children.
One
is
in
the
designer
category
form
versus
this.
One
seems
to
be
in
something
else.
I
mean
I
don't
know
what
this
property
evaluates
to,
but
you
probably
want
to
have
this
in
the
same
category
right.
So
when
you
open
the
property
grid,
they
both
show
up
in
the
same
under
the
same
node
right.
B
By
default
this
category
category-
and
they
can
change
it
to
alphabetically,
they
want,
but
normally
sometimes
most
of
the
times
people
do
it
because
they
don't
find
the
property,
they
don't
know
the
property
name
sometimes
or
they
don't
know
exact
property,
name
right
or
exact
category.
So
they
do
it
alphabetically
to
figure
it
out
where
it
is.
A
A
A
A
No,
I
I'm
copy
pasting
here
we
go
okay.
A
A
A
Apis,
we
added
in
dot
net
five,
where
basically
operating
system
we
have
a
you
know,
is
operating
system,
name
version
at
least,
and
then
you
can
specify
a
major
minor
and
so
on,
and
so
at
the
same
time
there
was
also
this
other
desire
that
when
you
actually
log
stuff,
let's
say
you
send
telemetry
back
to
azure
with
app
insights
or
something
you
want
to
know.
You
know
where
your
customers
are
running
your
applications,
and
so
one
of
the
way
to
do
that
is
to
say
cool.
A
We
give
people
an
api,
but
they
can
get
basically
a
string
that
indicates
where
they're
running.
But
then
we
don't
really
document
the
string.
We
don't
really
make
any
guarantees,
and
so
we
basically
go
out
of
our
way
to
make
it
really
hard
for
people
to
use
this
string
to
do
version
checks,
and
so
that's
how
we
ended
up
with
the
runtime
information
framework
description,
api,
which
basically
gives
you
you
know
some
sort
of
string
and
different
frameworks
actually
return
different
strings.
A
You
know,
dot-net
framework
says
dot-net
space
framework
and
then
I
think
the
version
of
mr
scallop
on.net
core
it's
dot-net
now
and
then
I
think
also
the
version
of
qalip.
I
think
mono
does
something
else
and
also
includes
a
commit
hash
or
something.
So
the
the
syntax
of
this
thing
is
not
like
super.
You
know
uniform,
so
the
accessibility
team
reached
out
to
us
and
says
hey,
that's
cool,
but
we
also
need
a
way
to
actually
when
we,
you
know,
walk
the
ui
structure.
There's
this,
I
think
ui
accessibility,
framework
and
windows.
A
Whatever
the
thing
is
called
uia.
I
think-
and
they
have
this
thing
called
framework
id
where
you
can
effectively
or
the
application
can
return,
what
toolkit
or
technology
it
used
to
compose
the
you
know
the
ui
right
and
in
winforms
it's
win32
based
in
wpf.
It's
not
so
wpf
doesn't
even
have
necessarily
windows
handles
for
everything,
you
control
and
so
basically
screen.
Readers
use
this
infrastructure
to
enumerate
the
controls
inside
of
a
ui
right,
and
so
the
framework
id
property
basically
allows
it
to
also
return
hey.
A
What
technology
did
I
use,
which
allows
the
screen
readers
to
do
something
smarter
and
you
know,
understand
a
bit
better
of
what
these
controls
actually
are,
and
so
today
the
the
two
strings
that
are
returned
from
this
are
just
wpf
and
winforms,
which
is
cool,
but
now
that
the
framework
and
dot
network
drifting
further
apart,
because
the
net
framework
is
feature
complete.
So
we
don't
fix
a
lot
of
the
accessibility
issues
in
it
anymore
because
it
would
break
people
when
we
do
that,
but
in
dot
net
core.
A
We
intend
to
do
this,
and
so
now
it
would
be
useful
for
screen
reader
to
know.
Well,
is
this
the
dot
net
core
flavor
of
winforms
or
the
framework
version
of
winforms
right
and
then,
of
course,
if
you
now
think
about
how
fast
on
echo
evolves,
they
also
have
the
same
problem.
Everybody
else
has
which
is
well
maybe.net.
Core
version
x
has
a
bug,
and
then
you
fixed
it
in
a
core
version.
Why?
So?
A
It
would
be
nice
for
us
to
know
whether
you're
running
on
x
versus
y,
so
we
can
actually
make
better
decisions
as
well,
so
long
story
short.
They
would
like
to
know
the
platform
plus
the
version
number.
So
basically,
we
have
two
options
to
deal
with.
That.
One
way
is,
we
could
say:
hey
we
expose,
or
we
use
the
framework
description
api
to
populate
that
field.
That
would
be
very
cheap
for
us
to
do.
A
Obviously,
the
only
real
caveat
here
is
that
we
would
say:
okay
now
we
need
to
document
the
format
of
the
of
the
framework
description
property
and
also
make
sure
that
every
framework
that
you
know
produces
that
string
that
the
string
is
actually
possible
and
returned
by
the
framework
id
property
right.
Those
are
the
two
options
that
I
see
and
I
think
I'm
leaning
towards
option
two
not
not
doing
a
new
api,
but
using
environment.version,
because
framework
description
would
be.
A
I
mean
it's
not
impossible
to
unify
the
strings,
but
my
gut
feel
is
that
if
we
change
the
strings,
we
break
some
people.
But
if
we
don't
change
the
strings,
then
we
make
it
somewhat
harder
to
parse
right.
So
that's
that's
kind
of
the
trade-offs.
I
personally
don't
think.
Based
on
the
conversation
we
had
with
dave
tryon
that
we
actually
need
to
know
the
platform
version,
because
by
definition,
whatever
we
do
is
only
done
for
dot
net
six.
A
So
if
the
string
includes
a
version,
number
you're,
obviously
running
on
dot,
net
six
and
higher
right,
so
you're
not
running
on.net
framework
right
framework
would
probably
continue
to
return
whatever
it
returns
today,
which
is
just
winforms
or
just
wpf.
And
this
way
you
know
you're
running
on
domain
framework.
A
E
F
We
also
will
have
that
extra
step
to
make
sure
that
we,
you
know,
change
how
we
populate
that
field
and
get
agreement
from
all
of
our
partners
about
how
we
present
that
value.
Now,
because
that
could
be
that
somebody
could
be.
E
Dependent
uaa
has
a
bunch
of
properties
that
are
fine,
they're,
just
they're,
just
integers
with
a
type
and
then,
and
you
understand
how
to
interpret
that
type
right,
and
so
we
just
we
just
added
new
enum
and
add
a
new
integer
that
says:
okay,
this
one
is
going
to
give
you
the
enhanced
property
information
or
the
enhanced
version.
Information.
A
E
A
B
A
Yeah
I
mean
this
is
the
other
option
we
have
is,
we
could
just
say:
hey
winforms,
basically,
just
changes
the
value
of
the
framework
id
property,
and
then
we
basically
have
an
app
compat
switch
that
you
can
turn
off
that
you
can
turn
on.
That
turns
the
behavior
to
the
to
the
current
behavior
right.
So,
if
you're
actually
broken
by
that,
you
could
do
that.
A
I
mean
the
nice
thing
with
that
is
that
it's
we
can
support
it
on
win7
out
of
the
gate.
We
don't
have
to
wait
for
windows
to
catch
up
basically,
but
we
can
also
say:
windows
can
in
parallel
also
add
the
new
property,
and
then
you
know
that
that's
also
not
a
bad
idea.
Right
like
it
seems
to
me
that
the
if
the
framework
id
is
this
compound
string,
we're
probably
not
the
only
framework
that
would
like
to
all
to
include
other
things.
A
C
Mean
I
see
the
uia
runtime
id
property,
it
looks
like
it's
supposed
to
be.
An
array
of
hints
turns
out
so
system.version,
so
just
splatting
the
version
in
that
one
if
you're
not
already
using
it,
might
be
an
answer,
but
maybe
it's
not
consumed
in
the
right
way.
C
Yeah
I
found
a
table
that
going
back
to
our
previous
thing,
listed
them
by
category
and
under
identification.
We
have
automation,
class,
name,
framework
labeled
by
name
process
id
runtime
id
and
native
window
handle
use
that
last
one.
That's
probably
not
important.
A
A
It's
a
four-digit
version
number,
so
you
can
decide
whether
you
return
all
four
or
just
the
first.
You
know
the
first
two
or
the
first
three,
depending
on
how
how
much
information
you
want
to
expose
it
probably
like
I'm
pretty
confident
that
it
returns
quality.