ฉันจะสลับ BooleanToVisibilityConverter ได้อย่างไร


143

ฉันใช้BooleanToVisibilityConverterใน WPF ผูกพันทรัพย์สินของการควบคุมที่Visibility Booleanนี้ทำงานได้ดี แต่ฉันต้องการหนึ่งของการควบคุมเพื่อซ่อนถ้าบูลเป็นและแสดงถ้ามันtruefalse


หมายเหตุ: เป็นเบต้า 4 - Silverlight ไม่รวม BooleanToVisibility - ดังนั้นคุณจะต้องใช้มันด้วยตัวคุณเองแล้วล่ะค่ะ
Simon_Weaver

เพิ่มคำแนะนำด้วยเสียงของผู้ใช้เพื่อรับ invert ที่รองรับvisualstudio.uservoice.com/forums/121579-visual-studio-2015/…
Thraka

ฉันไม่อยากจะเชื่อว่าพวกเขาไม่ได้ใช้พารามิเตอร์ตัวแปลงบางอย่างเพื่อทำสิ่งนี้
Kamil

คำตอบ:



250

คุณสามารถบรรลุเป้าหมายเดียวกันได้โดยใช้IValueConverterการนำไปใช้ทั่วไปที่สามารถแปลงค่าบูลีนเป็นค่าเป้าหมายที่กำหนดค่าได้จริงและเท็จ ด้านล่างนี้เป็นหนึ่งในการติดตั้งดังกล่าว:

public class BooleanConverter<T> : IValueConverter
{
    public BooleanConverter(T trueValue, T falseValue)
    {
        True = trueValue;
        False = falseValue;
    }

    public T True { get; set; }
    public T False { get; set; }

    public virtual object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value is bool && ((bool) value) ? True : False;
    }

    public virtual object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value is T && EqualityComparer<T>.Default.Equals((T) value, True);
    }
}

ถัดไป subclass มันที่Tเป็นVisibility:

public sealed class BooleanToVisibilityConverter : BooleanConverter<Visibility>
{
    public BooleanToVisibilityConverter() : 
        base(Visibility.Visible, Visibility.Collapsed) {}
}

ในที่สุดนี่คือวิธีที่คุณสามารถใช้ BooleanToVisibilityConverterข้างต้นใน XAML และกำหนดค่าให้ตัวอย่างเช่นใช้CollapsedสำหรับจริงและVisibleเท็จ:

<Application.Resources>
    <app:BooleanToVisibilityConverter 
        x:Key="BooleanToVisibilityConverter" 
        True="Collapsed" 
        False="Visible" />
</Application.Resources>

การผกผันนี้มีประโยชน์เมื่อคุณต้องการผูกเข้ากับคุณสมบัติบูลีนที่ตั้งชื่อIsHiddenตามต้องการIsVisibleด้วย


ฉันอาจจะหายไปบางอย่าง แต่คุณไม่เพียงต้องการคุณสมบัติที่ทำให้ไร้ผล? stackoverflow.com/questions/534575/…
OscarRyz

9
@OscarRyz: ด้วย UIs ที่ซับซ้อนมากขึ้นซึ่งเริ่มเพิ่มความยุ่งเหยิงที่น่ารำคาญให้กับโมเดลมุมมองไม่ต้องพูดถึงคุณสมบัติอื่นที่คุณต้องทดสอบตามหลักวิชาเพื่อรักษารหัสครอบคลุม ดูรุ่นที่ไม่ควรจะต้องได้รับที่ใกล้เคียงกับรายละเอียดการปฏิบัติของมุมมองมิฉะนั้นคุณอาจได้เป็นอย่างดีเพียงแค่มีVisibilityคุณสมบัติในรูปแบบมุมมองของคุณ
Aaronaught

มันง่ายมาก แต่มีประโยชน์มาก ขอบคุณ @AtifAziz
TheLastGIS

48
using System;
using System.Globalization;
using System.Windows;
using System.Windows.Data;

public sealed class BooleanToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var flag = false;
        if (value is bool)
        {
            flag = (bool)value;
        }
        else if (value is bool?)
        {
            var nullable = (bool?)value;
            flag = nullable.GetValueOrDefault();
        }
        if (parameter != null)
        {
            if (bool.Parse((string)parameter))
            {
                flag = !flag;
            }
        }
        if (flag)
        {
            return Visibility.Visible;
        }
        else
        {
            return Visibility.Collapsed;
        }
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var back = ((value is Visibility) && (((Visibility)value) == Visibility.Visible));
        if (parameter != null)
        {
            if ((bool)parameter)
            {
                back = !back;
            }
        }
        return back;
    }
}

จากนั้นผ่านจริงหรือเท็จเป็น ConverterParameter

       <Grid.Visibility>
                <Binding Path="IsYesNoButtonSetVisible" Converter="{StaticResource booleanToVisibilityConverter}" ConverterParameter="true"/>
        </Grid.Visibility>

4
ที่else if (value is bool?)ส่วน ReSharper บอกฉันว่า "การแสดงออกเป็นเท็จเสมอ" นอกจากนี้ส่วนหนึ่งสามารถเขียนรัดกุมมากเป็นif (flag) return flag ? Visibility.Visible : Visibility.Collapsed;
Danilo Bargen

1
ฉันอาจจะหายไปบางอย่าง แต่คุณไม่เพียงต้องการคุณสมบัติที่ทำให้ไร้ผล? stackoverflow.com/questions/534575/…
OscarRyz

1
var nullable = (bool?)value; flag = nullable.GetValueOrDefault();สามารถทำให้สั้นและเรียบง่ายมาก:flag = (bool?)value ?? false;
ตอบของ

45

เขียนของคุณเองเป็นทางออกที่ดีที่สุดสำหรับตอนนี้ นี่คือตัวอย่างของตัวแปลงที่สามารถทำได้ทั้งแบบปกติและแบบคว่ำ หากคุณมีปัญหาใด ๆ กับสิ่งนี้เพียงแค่ถาม

[ValueConversion(typeof(bool), typeof(Visibility))]
public class InvertableBooleanToVisibilityConverter : IValueConverter
{
    enum Parameters
    {
        Normal, Inverted
    }

    public object Convert(object value, Type targetType,
                          object parameter, CultureInfo culture)
    {
        var boolValue = (bool)value;
        var direction = (Parameters)Enum.Parse(typeof(Parameters), (string)parameter);

        if(direction == Parameters.Inverted)
            return !boolValue? Visibility.Visible : Visibility.Collapsed;

        return boolValue? Visibility.Visible : Visibility.Collapsed;
    }

    public object ConvertBack(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        return null;
    }
}
<UserControl.Resources>
  <Converters:InvertableBooleanToVisibilityConverter x:Key="_Converter"/>
</UserControl.Resources>

<Button Visibility="{Binding IsRunning, Converter={StaticResource _Converter}, ConverterParameter=Inverted}">Start</Button>

2
แค่ทำสิ่งหนึ่งที่แปลกประหลาด รหัส xaml "การผูก IsRunning" อยู่ที่ไหน sourcode หรือค่าสำหรับวัตถุ "IsRunning"?
What'sUP

IsRunning เป็นคุณสมบัติในมุมมองของฉัน บริบทของรหัสนี้มีความยาว แต่สั้น ๆ ก็คือฉันต้องซ่อนบางสิ่งบางอย่างเมื่อฉันเรียกใช้การคำนวณและสิ่งอื่น ๆ ที่ไม่ได้ซ่อนอยู่ ฉันสร้างตัวแปลงนี้เพื่อให้ฉันไม่ต้องมีคุณสมบัติหลายอย่างใน viewmodel ของฉัน
Michael Hohlios

2
คุณสามารถทำการแทนที่แบบดรBooleanToVisibilityConverterParameter direction = Parameter.Normal; if (parameter != null) direction = (Parameter)Enum.Parse(typeof(Parameter), (string)parameter);
อปดาวน์

20

นอกจากนี้ยังมีโปรเจ็กต์WPF Convertersบน Codeplex ในเอกสารของพวกเขาพวกเขาบอกว่าคุณสามารถใช้MapConverterเพื่อแปลงจากการมองเห็นการแจงเป็นบูล

<Label>
    <Label.Visible>
        <Binding Path="IsVisible">
            <Binding.Converter>
                <con:MapConverter>
                    <con:Mapping From="True" To="{x:Static Visibility.Visible}"/>
                    <con:Mapping From="False" To="{x:Static Visibility.Hidden}"/>
                </con:MapConverter>
            </Binding.Converter>
        </Binding>
    </Label.Visible>
</Label>

1
ตัวแปลง WPF ตอนนี้มี BooleanToVisibilityConverter ที่สามารถย้อนกลับได้
vinod

17

อีกวิธีหนึ่งในการผูกค่า Boolean ViewModel (IsButtonVisible) ด้วยคุณสมบัติการควบคุมการมองเห็น xaml ไม่มีการเข้ารหัสไม่มีการแปลงเพียงแค่จัดแต่งทรงผม

<Style TargetType={x:Type Button} x:Key="HideShow">
   <Style.Triggers>
      <DataTrigger Binding="{Binding IsButtonVisible}" Value="False">
          <Setter Property="Visibility" Value="Hidden"/>
      </DataTrigger>
   </Style.Triggers>
</Style>

<Button Style="{StaticResource HideShow}">Hello</Button>

15

หรือวิธีขี้เกียจที่แท้จริงเพียงแค่ใช้ประโยชน์จากสิ่งที่มีอยู่แล้วและพลิกมัน:

public class InverseBooleanToVisibilityConverter : IValueConverter
{
    private BooleanToVisibilityConverter _converter = new BooleanToVisibilityConverter();

    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var result = _converter.Convert(value, targetType, parameter, culture) as Visibility?;
        return result == Visibility.Collapsed ? Visibility.Visible : Visibility.Collapsed;
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var result = _converter.ConvertBack(value, targetType, parameter, culture) as bool?;
        return result == true ? false : true;
    }
}

5

หากคุณไม่ชอบการเขียนตัวแปลงที่กำหนดเองคุณสามารถใช้ทริกเกอร์ข้อมูลเพื่อแก้ปัญหานี้:

<Style.Triggers>
        <DataTrigger Binding="{Binding YourBinaryOption}" Value="True">
                 <Setter Property="Visibility" Value="Visible" />
        </DataTrigger>
        <DataTrigger Binding="{Binding YourBinaryOption}" Value="False">
                 <Setter Property="Visibility" Value="Collapsed" />
        </DataTrigger>
</Style.Triggers>

3

ฉันเพิ่งโพสต์ข้อความนี้ ฉันใช้ความคิดแบบเดียวกันกับที่ Michael Hohlios ทำ เฉพาะฉันใช้คุณสมบัติแทนการใช้ "พารามิเตอร์พารามิเตอร์"

การมองเห็นการเชื่อมโยงกับค่าบูลใน WPF

การใช้คุณสมบัติทำให้อ่านง่ายขึ้นในความคิดของฉัน

<local:BoolToVisibleOrHidden x:Key="BoolToVisConverter" Collapse="True" Reverse="True" />

เพียงแค่ติดตามความคิดเห็นของฉันเอง ถ้าคุณใช้คุณสมบัติคุณต้องสร้างวัตถุแยกต่างหากถ้าคุณต้องการสร้างให้กับตัวแปลงวัตถุที่เป็นแบบย้อนกลับและอีกอันไม่ หากคุณใช้พารามิเตอร์คุณสามารถใช้หนึ่งวัตถุสำหรับหลายรายการ แต่อาจทำให้สับสนได้หากคุณไม่สนใจ ดังนั้นจึงมีข้อดีข้อเสียของทั้งสอง
Rhyous

ฉันพบสิ่งนี้มีประโยชน์มากในการทำให้ตัวแปลง Boolean เป็น Colors ขอบคุณ
Federinik

3

นี่คือสิ่งที่ฉันเขียนและใช้บ่อยมาก มันใช้พารามิเตอร์ตัวแปลงบูลีนที่บ่งชี้ว่าจะกลับค่าหรือไม่แล้วใช้ XOR เพื่อดำเนินการปฏิเสธ:

[ValueConversion(typeof(bool), typeof(System.Windows.Visibility))]
public class BooleanVisibilityConverter : IValueConverter
{
    System.Windows.Visibility _visibilityWhenFalse = System.Windows.Visibility.Collapsed;

    /// <summary>
    /// Gets or sets the <see cref="System.Windows.Visibility"/> value to use when the value is false. Defaults to collapsed.
    /// </summary>
    public System.Windows.Visibility VisibilityWhenFalse
    {
        get { return _visibilityWhenFalse; }
        set { _visibilityWhenFalse = value; }
    }

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        bool negateValue;
        Boolean.TryParse(parameter as string, out negateValue);

        bool val = negateValue ^ System.Convert.ToBoolean(value); //Negate the value when negateValue is true using XOR
        return val ? System.Windows.Visibility.Visible : _visibilityWhenFalse;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        bool negateValue;
        Boolean.TryParse(parameter as string, out negateValue);

        if ((System.Windows.Visibility)value == System.Windows.Visibility.Visible)
            return true ^ negateValue;
        else
            return false ^ negateValue;
    }
}

นี่คือตารางความจริง XOR สำหรับการอ้างอิง:

        XOR
        x  y  XOR
        ---------
        0  0  0
        0  1  1
        1  0  1
        1  1  0

2

ฉันกำลังมองหาคำตอบทั่วไป แต่ไม่สามารถหาได้ ฉันเขียนตัวแปลงที่อาจช่วยผู้อื่น

มันขึ้นอยู่กับข้อเท็จจริงที่ว่าเราต้องแยกความแตกต่างหกกรณี:

  • True 2 Visible, False 2 Hidden
  • True 2 Visible, False 2 Collapsed
  • True 2 Hidden, False 2 มองเห็นได้
  • True 2 ถูกยุบ, False 2 มองเห็นได้
  • True 2 Hidden, False 2 Collapsed
  • True 2 ถูกยุบ, False 2 ถูกซ่อน

นี่คือการดำเนินการของฉันสำหรับ 4 รายแรก:

[ValueConversion(typeof(bool), typeof(Visibility))]
public class BooleanToVisibilityConverter : IValueConverter
{
    enum Types
    {
        /// <summary>
        /// True to Visible, False to Collapsed
        /// </summary>
        t2v_f2c,
        /// <summary>
        /// True to Visible, False to Hidden
        /// </summary>
        t2v_f2h,
        /// <summary>
        /// True to Collapsed, False to Visible
        /// </summary>
        t2c_f2v,
        /// <summary>
        /// True to Hidden, False to Visible
        /// </summary>
        t2h_f2v,
    }
    public object Convert(object value, Type targetType,
                          object parameter, CultureInfo culture)
    {
        var b = (bool)value;
        string p = (string)parameter;
        var type = (Types)Enum.Parse(typeof(Types), (string)parameter);
        switch (type)
        {
            case Types.t2v_f2c:
                return b ? Visibility.Visible : Visibility.Collapsed; 
            case Types.t2v_f2h:
                return b ? Visibility.Visible : Visibility.Hidden; 
            case Types.t2c_f2v:
                return b ? Visibility.Collapsed : Visibility.Visible; 
            case Types.t2h_f2v:
                return b ? Visibility.Hidden : Visibility.Visible; 
        }
        throw new NotImplementedException();
    }

    public object ConvertBack(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        var v = (Visibility)value;
        string p = (string)parameter;
        var type = (Types)Enum.Parse(typeof(Types), (string)parameter);
        switch (type)
        {
            case Types.t2v_f2c:
                if (v == Visibility.Visible)
                    return true;
                else if (v == Visibility.Collapsed)
                    return false;
                break;
            case Types.t2v_f2h:
                if (v == Visibility.Visible)
                    return true;
                else if (v == Visibility.Hidden)
                    return false;
                break;
            case Types.t2c_f2v:
                if (v == Visibility.Visible)
                    return false;
                else if (v == Visibility.Collapsed)
                    return true;
                break;
            case Types.t2h_f2v:
                if (v == Visibility.Visible)
                    return false;
                else if (v == Visibility.Hidden)
                    return true;
                break;
        }
        throw new InvalidOperationException();
    }
}

ตัวอย่าง:

Visibility="{Binding HasItems, Converter={StaticResource BooleanToVisibilityConverter}, ConverterParameter='t2v_f2c'}"

ฉันคิดว่าพารามิเตอร์จำง่าย

หวังว่าจะช่วยใครซักคน


2

คุณสามารถใช้QuickConverter QuickConverter

ด้วย QuickConverter คุณสามารถเขียนลอจิกแบบอินไลน์ด้วย BindingExpression ของคุณ

นี่คือตัวแปลง BooleanToVisibility แบบกลับด้าน:

Visibility="{qc:Binding '!$P ? Visibility.Visible : Visibility.Collapsed', P={Binding Example}}"

คุณสามารถเพิ่ม QuickConverter ผ่าน NuGet ดูเอกสารประกอบสำหรับการตั้งค่า ลิงก์: https://quickconverter.codeplex.com/


1

เขียนการแปลงของคุณเอง

public class ReverseBooleanToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
   {
       // your converter code here
   }
}

0

เวอร์ชันทางเดียวแบบง่ายซึ่งสามารถใช้ดังนี้:

Visibility="{Binding IsHidden, Converter={x:Static Ui:Converters.BooleanToVisibility}, ConverterParameter=true}

สามารถนำไปใช้เช่นนี้:

public class BooleanToVisibilityConverter : IValueConverter
{
  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
  {
    var invert = false;

    if (parameter != null)
    {
      invert = Boolean.Parse(parameter.ToString());
    }

    var booleanValue = (bool) value;

    return ((booleanValue && !invert) || (!booleanValue && invert)) 
      ? Visibility.Visible : Visibility.Collapsed;
  }

  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
  {
    throw new NotImplementedException();
  }
}

0

แปลงทุกอย่างเป็นทุกอย่าง (บูล, สตริง, enum, ฯลฯ ):

public class EverythingConverterValue
{
    public object ConditionValue { get; set; }
    public object ResultValue { get; set; }
}

public class EverythingConverterList : List<EverythingConverterValue>
{

}

public class EverythingConverter : IValueConverter
{
    public EverythingConverterList Conditions { get; set; } = new EverythingConverterList();

    public object NullResultValue { get; set; }
    public object NullBackValue { get; set; }

    public object Convert(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        return Conditions.Where(x => x.ConditionValue.Equals(value)).Select(x => x.ResultValue).FirstOrDefault() ?? NullResultValue;
    }
    public object ConvertBack(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        return Conditions.Where(x => x.ResultValue.Equals(value)).Select(x => x.ConditionValue).FirstOrDefault() ?? NullBackValue;
    }
}

ตัวอย่าง XAML:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                xmlns:conv="clr-namespace:MvvmGo.Converters;assembly=MvvmGo.WindowsWPF"
                xmlns:sys="clr-namespace:System;assembly=mscorlib">

<conv:EverythingConverter x:Key="BooleanToVisibilityConverter">
    <conv:EverythingConverter.Conditions>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Visible}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>True</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Collapsed}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>False</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
    </conv:EverythingConverter.Conditions>

</conv:EverythingConverter>

<conv:EverythingConverter x:Key="InvertBooleanToVisibilityConverter">
    <conv:EverythingConverter.Conditions>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Visible}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>False</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Collapsed}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>True</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
    </conv:EverythingConverter.Conditions>
</conv:EverythingConverter>

<conv:EverythingConverter x:Key="MarriedConverter" NullResultValue="Single">
    <conv:EverythingConverter.Conditions>
        <conv:EverythingConverterValue ResultValue="Married">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>True</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
        <conv:EverythingConverterValue ResultValue="Single">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>False</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
    </conv:EverythingConverter.Conditions>
    <conv:EverythingConverter.NullBackValue>
        <sys:Boolean>False</sys:Boolean>
    </conv:EverythingConverter.NullBackValue>
</conv:EverythingConverter>


0

แทนที่จะเขียนรหัสของคุณเอง / สร้างใหม่พิจารณาใช้CalcBinding :

Automatic two way convertion of bool expression to Visibility and back if target property has such type: description

    <Button Visibility="{c:Binding !IsChecked}" /> 
    <Button Visibility="{c:Binding IsChecked, FalseToVisibility=Hidden}" />

CalcBinding ยังมีประโยชน์มากสำหรับสถานการณ์อื่น ๆ อีกมากมาย


-2

ฉันรู้ว่านี่เป็นวันที่ แต่คุณไม่จำเป็นต้องใช้สิ่งใดอีกเลย

สิ่งที่ฉันทำคือลบล้างมูลค่าของทรัพย์สินเช่นนี้:

<!-- XAML code -->
<StackPanel Name="x"  Visibility="{Binding    Path=Specials, ElementName=MyWindow, Converter={StaticResource BooleanToVisibilityConverter}}"></StackPanel>    
<StackPanel Name="y"  Visibility="{Binding Path=NotSpecials, ElementName=MyWindow, Converter={StaticResource BooleanToVisibilityConverter}}"></StackPanel>        

....

//Code behind
public bool Specials
{
    get { return (bool) GetValue(SpecialsProperty); }
    set
    {
        NotSpecials= !value; 
        SetValue(SpecialsProperty, value);
    }
}

public bool NotSpecials
{
    get { return (bool) GetValue(NotSpecialsProperty); }
    set { SetValue(NotSpecialsProperty, value); }
}

และใช้งานได้ดี!

ฉันพลาดอะไรไปรึเปล่า?


7
คุณคิดว่านี่เป็นวิธีแก้ปัญหาที่ง่ายกว่าและสำหรับสถานที่ให้บริการเดียวอาจเป็นกรณีนี้ (ไม่สามารถใช้ซ้ำได้สำหรับคุณสมบัติหลาย ๆ แห่งคุณต้องใช้มันสำหรับทุก ๆ คุณสมบัติ) ฉันรู้สึกว่านี่เป็นสถานที่ที่ไม่ถูกต้องสำหรับการนำไปใช้งานเนื่องจากไม่มีส่วนเกี่ยวข้องกับ viewmodel / codeBehind และทุกอย่างที่มีมุมมอง
Mike Fuchs
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.