कोको: फ्रेम और सीमा के बीच अंतर क्या है?

Question

UIViewऔर इसके उपवर्गों में सभी गुण frameऔर हैं bounds। क्या फर्क पड़ता है?

Comments

फ्रेमवर्क

— onmyway133

मेरे लिए सबसे संक्षिप्त स्पष्टीकरण यहाँ है: videos.raywenderlich.com/courses/99-scroll-view-school/lessons/…

— व्लाद

2:30 वीडियो के बारे में कुछ भी संक्षिप्त नहीं है। मैं एक वाक्य या 2:30 से ज्यादा तेजी से पढ़ सकता हूं।

— dsjoerg

मेरे लिए यह बहुत अधिक स्पष्ट है अगर मैं इस तरह से सोचता हूं: फ़्रेम = सीमाएं और स्थिति

— सर्ग

Answer 1

सीमा एक की UIView है आयत , एक स्थान (एक्स, वाई) और आकार (चौड़ाई, ऊंचाई) अपनी ही समन्वय प्रणाली (0,0) के सापेक्ष के रूप में व्यक्त किया।

फ्रेम एक की UIView है आयत , एक स्थान (एक्स, वाई) और आकार (चौड़ाई, ऊंचाई) superview यह के भीतर निहित है के सापेक्ष के रूप में व्यक्त किया।

तो, एक ऐसे दृश्य की कल्पना करें, जिसका आकार 100x100 (चौड़ाई x ऊँचाई) 25,25 (x, y) पर स्थित है। निम्नलिखित कोड इस दृश्य की सीमा और फ़्रेम प्रिंट करता है:

// This method is in the view controller of the superview
- (void)viewDidLoad {
    [super viewDidLoad];

    NSLog(@"bounds.origin.x: %f", label.bounds.origin.x);
    NSLog(@"bounds.origin.y: %f", label.bounds.origin.y);
    NSLog(@"bounds.size.width: %f", label.bounds.size.width);
    NSLog(@"bounds.size.height: %f", label.bounds.size.height);

    NSLog(@"frame.origin.x: %f", label.frame.origin.x);
    NSLog(@"frame.origin.y: %f", label.frame.origin.y);
    NSLog(@"frame.size.width: %f", label.frame.size.width);
    NSLog(@"frame.size.height: %f", label.frame.size.height);
}

और इस कोड का आउटपुट है:

bounds.origin.x: 0
bounds.origin.y: 0
bounds.size.width: 100
bounds.size.height: 100

frame.origin.x: 25
frame.origin.y: 25
frame.size.width: 100
frame.size.height: 100

इसलिए, हम देख सकते हैं कि दोनों मामलों में, चौड़ाई और दृश्य की ऊंचाई समान है चाहे हम सीमा या फ्रेम को देख रहे हों। क्या अलग है x, दृश्य की y स्थिति है। सीमा के मामले में, x और y निर्देशांक 0,0 पर हैं क्योंकि ये निर्देशांक दृश्य के सापेक्ष हैं। हालाँकि, फ़्रेम x और y निर्देशांक पैरेंट दृश्य के भीतर दृश्य की स्थिति के सापेक्ष हैं (जो पहले हमने कहा था कि 25,25 पर था)।

वहाँ भी एक महान प्रस्तुति है जो UIViews को कवर करती है। स्लाइड 1-20 देखें जो न केवल फ्रेम और सीमा के बीच अंतर को स्पष्ट करते हैं बल्कि दृश्य उदाहरण भी दिखाते हैं।

Comments

तो x, y सीमा के लिए हमेशा 0,0 नहीं होगा क्योंकि इसके ऑब्जेक्ट का स्थान ... में ही है। या आप एक परिदृश्य दे सकते हैं जहां यह नहीं होगा?

— mk12

जहाँ तक मुझे पता है, सीमा के मूल हमेशा 0,0 हो जाएगा

— शेक

दरअसल, 0,0 के अलावा सीमा कुछ भी हो सकती है। SetBoundsOrigin का उपयोग करें: मूल को स्थानांतरित करने / अनुवाद करने के लिए। अधिक जानकारी के लिए "कोको के लिए प्रोग्रामिंग गाइड देखें" में "ज्यामिति" देखें।

— मुल्तेमी

UIScrollView एक उदाहरण है जहां सीमाएँ एक दृश्य के भीतर विभिन्न सामग्री क्षेत्रों को दिखाने के लिए स्थानांतरित हो सकती हैं।

— ब्रैड लार्सन

एक छोटी सी टिप - NSStringFromCGRect का उपयोग करके लॉग को लॉग करने के लिए कुछ समय बचा सकते हैं।

— बेरिलियम

Answer 2

संक्षिप्त जवाब

फ्रेम = माता-पिता के समन्वय प्रणाली के उपयोग से एक दृश्य का स्थान और आकार

• इसके लिए महत्वपूर्ण: माता-पिता में दृष्टिकोण रखना

सीमा = अपने स्वयं के समन्वय प्रणाली का उपयोग करके एक दृश्य का स्थान और आकार

• इसके लिए महत्वपूर्ण है: दृश्य की सामग्री या साक्षात्कार को अपने भीतर रखना

---

विस्तृत जवाब

फ़्रेम को याद रखने में मेरी मदद करने के लिए , मैं एक दीवार पर एक चित्र फ़्रेम के बारे में सोचता हूं । चित्र फ़्रेम दृश्य की सीमा की तरह है। मैं दीवार पर कहीं भी चित्र लटका सकता हूं। उसी तरह, मैं कहीं भी एक दृश्य डाल सकता हूं जो मैं एक माता-पिता के दृश्य के अंदर चाहता हूं (जिसे एक पर्यवेक्षण भी कहा जाता है)। जनक दृश्य दीवार की तरह है। IOS में समन्वय प्रणाली का मूल शीर्ष बाईं ओर है। हम अपने दृश्य को दृश्य के xy निर्देशांक (0, 0) पर सेट करके पर्यवेक्षण के मूल में रख सकते हैं, जो कि दीवार के शीर्ष बाएं कोने में हमारे चित्र को लटकाने जैसा है। इसे दाईं ओर ले जाने के लिए, x को बढ़ाएं, इसे नीचे ले जाने के लिए y को बढ़ाएं।

सीमा को याद रखने में मेरी मदद करने के लिए , मैं एक बास्केटबॉल कोर्ट के बारे में सोचता हूँ जहाँ कभी-कभी बास्केटबॉल को सीमा से बाहर खटखटाया जाता है । आप बास्केटबॉल कोर्ट में गेंद को ड्रिबल कर रहे हैं, लेकिन आप वास्तव में परवाह नहीं करते हैं कि कोर्ट कहाँ है। यह एक जिम में, या एक हाई स्कूल में या अपने घर के सामने हो सकता है। इससे कोई फर्क नहीं पड़ता। आप सिर्फ बास्केटबॉल खेलना चाहते हैं। उसी तरह, एक दृश्य की सीमा के लिए समन्वय प्रणाली केवल दृश्य के बारे में परवाह करती है। यह इस बारे में कुछ भी नहीं जानता कि यह दृश्य पैरेंट दृश्य में कहाँ स्थित है। सीमा का मूल (बिंदु (0, 0) डिफ़ॉल्ट रूप से) दृश्य के ऊपरी बाएँ कोने है। इस बिंदु के संबंध में कोई भी साक्षात्कार जो इस दृश्य को निर्धारित किया गया है। यह बास्केटबॉल को अदालत के सामने बाएं कोने में ले जाने जैसा है।

अब भ्रम तब होता है जब आप फ्रेम और सीमा की तुलना करने की कोशिश करते हैं। यह वास्तव में उतना बुरा नहीं है जितना कि यह पहली बार में लगता है। आइए कुछ चित्रों का उपयोग करके हमें समझने में मदद करें।

फ्रेम बनाम सीमा

बाईं ओर की पहली तस्वीर में हमारे पास एक दृश्य है जो उसके मूल दृश्य के शीर्ष बाईं ओर स्थित है। पीला आयत दृश्य के फ्रेम का प्रतिनिधित्व करता है। दाईं ओर हम दृश्य को फिर से देखते हैं लेकिन इस बार मूल दृश्य नहीं दिखाया गया है। ऐसा इसलिए है क्योंकि सीमा को माता-पिता के दृष्टिकोण के बारे में नहीं पता है। हरे रंग की आयत दृश्य की सीमा का प्रतिनिधित्व करती है। लाल डॉट दोनों छवियों में प्रतिनिधित्व करता मूल फ्रेम या सीमा से।

Frame
    origin = (0, 0)
    width = 80
    height = 130

Bounds 
    origin = (0, 0)
    width = 80
    height = 130

तो उस चित्र में फ्रेम और सीमा बिल्कुल समान थे। आइए एक उदाहरण देखें जहां वे अलग हैं।

Frame
    origin = (40, 60)  // That is, x=40 and y=60
    width = 80
    height = 130

Bounds 
    origin = (0, 0)
    width = 80
    height = 130

तो आप देख सकते हैं कि फ्रेम के xy निर्देशांक को बदलने से यह मूल दृश्य में चला जाता है। लेकिन दृश्य की सामग्री अभी भी बिल्कुल वैसी ही दिखती है। सीमा का कोई पता नहीं है कि कुछ भी अलग है।

अब तक फ्रेम और सीमा दोनों की चौड़ाई और ऊंचाई बिल्कुल एक जैसी रही है। यह हमेशा सच नहीं है, यद्यपि। देखो कि क्या होता है अगर हम दृश्य को 20 डिग्री दक्षिणावर्त घुमाते हैं। (परिवर्तन का उपयोग करके रोटेशन किया जाता है। अधिक जानकारी के लिए दस्तावेज़ीकरण और इन दृश्य और परत के उदाहरण देखें।)

Frame
    origin = (20, 52)  // These are just rough estimates.
    width = 118
    height = 187

Bounds 
    origin = (0, 0)
    width = 80
    height = 130

आप देख सकते हैं कि सीमाएं अभी भी समान हैं। उन्हें अभी भी नहीं पता कि कुछ हुआ है! फ्रेम मान सभी बदल गए हैं, हालांकि।

अब फ्रेम और सीमा के बीच अंतर देखना थोड़ा आसान है, है ना? लेख आप शायद समझ में नहीं आता फ्रेम और सीमा के रूप में एक दृश्य फ्रेम को परिभाषित करता है

... उस दृश्य के सबसे छोटे बाउंडिंग बॉक्स के संबंध में यह माता-पिता समन्वय प्रणाली है, जिसमें उस दृश्य पर लागू कोई भी परिवर्तन शामिल है।

यह ध्यान रखना महत्वपूर्ण है कि यदि आप एक दृश्य बदलते हैं, तो फ्रेम अपरिभाषित हो जाता है। तो वास्तव में, ऊपर की छवि में घुमाए गए हरे रंग की सीमा के आसपास मैंने जो पीला फ्रेम खींचा वह वास्तव में कभी मौजूद नहीं है। इसका मतलब है कि यदि आप घूमते हैं, स्केल करते हैं या कुछ अन्य परिवर्तन करते हैं तो आपको फ्रेम वैल्यू का उपयोग नहीं करना चाहिए। आप अभी भी सीमा मूल्यों का उपयोग कर सकते हैं, हालांकि। Apple डॉक्स को चेतावनी देता है:

महत्वपूर्ण: यदि किसी दृश्य की transformसंपत्ति में पहचान परिवर्तन शामिल नहीं है, तो उस दृश्य का ढांचा अपरिभाषित है और इसलिए इसके ऑटोरेस्पोन्गिंग व्यवहार के परिणाम हैं।

बल्कि ऑटोरेस्पोन्डिंग के बारे में दुर्भाग्यपूर्ण .... कुछ ऐसा है जो आप कर सकते हैं, हालांकि।

Apple डॉक्स स्थिति:

transformआपके दृश्य की संपत्ति को संशोधित करते समय , सभी परिवर्तन केंद्र बिंदु के सापेक्ष किए जाते हैं।

इसलिए यदि आपको परिवर्तन करने के बाद माता-पिता के आसपास के दृश्य को स्थानांतरित करने की आवश्यकता है, तो आप view.centerनिर्देशांक बदलकर कर सकते हैं । जैसे frame, centerजनक दृश्य की समन्वय प्रणाली का उपयोग करता है।

ठीक है, चलो हमारे रोटेशन से छुटकारा पाएं और सीमा पर ध्यान केंद्रित करें। अब तक सीमा की उत्पत्ति हमेशा (0, 0) पर रही है। यह हालांकि नहीं है। क्या होगा अगर हमारे विचार में एक बड़ा सबव्यू है जो एक साथ सभी को प्रदर्शित करने के लिए बहुत बड़ा है? हम इसे UIImageViewएक बड़ी छवि के साथ बनाएंगे । यहाँ फिर से ऊपर से हमारी दूसरी तस्वीर है, लेकिन इस बार हम देख सकते हैं कि हमारे दृश्य के सबव्यू की पूरी सामग्री कैसी दिखेगी।

Frame
    origin = (40, 60)
    width = 80
    height = 130

Bounds 
    origin = (0, 0)
    width = 80
    height = 130

छवि के केवल ऊपरी बाएं कोने को दृश्य की सीमा के अंदर फिट किया जा सकता है। अब देखिए कि अगर हम सीमा के मूल निर्देशांक को बदलते हैं तो क्या होता है।

Frame
    origin = (40, 60)
    width = 80
    height = 130

Bounds 
    origin = (280, 70)
    width = 80
    height = 130

फ्रेम पर्यवेक्षण में स्थानांतरित नहीं हुआ है, लेकिन फ्रेम के अंदर की सामग्री बदल गई है क्योंकि सीमा आयत की उत्पत्ति दृश्य के एक अलग हिस्से में शुरू होती है। यह एक के पीछे पूरा विचार है UIScrollViewऔर यह उपवर्ग (उदाहरण के लिए, ए UITableView) है। अधिक स्पष्टीकरण के लिए UIScrollView को समझना देखें ।

फ्रेम का उपयोग कब करें और सीमा का उपयोग कब करें

चूँकि frameइसके पैरेंट दृश्य में किसी दृश्य का स्थान संबंधित है, आप इसका उपयोग तब करते हैं जब आप बाहरी परिवर्तन कर रहे हों , जैसे इसकी चौड़ाई बदलना या दृश्य और इसके मूल दृश्य के शीर्ष के बीच की दूरी का पता लगाना।

का प्रयोग करें boundsजब आप कर रहे हैं आवक परिवर्तन , चीजों को ड्राइंग या दृश्य के भीतर subviews की व्यवस्था की तरह। यदि आप इस पर कुछ ट्रांसफ़ोमेशन कर चुके हैं, तो दृश्य का आकार पाने के लिए सीमा का भी उपयोग करें।

आगे के शोध के लिए लेख:

Apple डॉक्स

• ज्यामिति देखें
• दृश्य
• व्यू एंड विंडो आर्किटेक्चर

संबंधित StackOverflow प्रश्न

• UIView फ्रेम, सीमा और केंद्र
• UIView के फ्रेम, सीमा, केंद्र, उत्पत्ति, कब क्या उपयोग करना है?
• IPhone में री-ओरिएंटेशन के बाद "गलत" फ्रेम / विंडो का आकार

अन्य संसाधन

• आप शायद फ्रेम और सीमा को न समझें
• iOS फंडामेंटल्स: फ्रेम्स, सीमाएं, और CGGeometry
• CS193p व्याख्यान 5 - दृश्य, ड्राइंग, एनीमेशन

स्वयं अभ्यास करें

उपरोक्त लेखों को पढ़ने के अलावा, यह मुझे टेस्ट ऐप बनाने में बहुत मदद करता है। आप ऐसा ही कुछ करने की कोशिश करना चाह सकते हैं। (मुझे इस वीडियो पाठ्यक्रम से विचार मिला लेकिन दुर्भाग्य से यह मुफ्त नहीं है।)

यहाँ आपके संदर्भ के लिए कोड है:

import UIKit

class ViewController: UIViewController {


    @IBOutlet weak var myView: UIView!

    // Labels
    @IBOutlet weak var frameX: UILabel!
    @IBOutlet weak var frameY: UILabel!
    @IBOutlet weak var frameWidth: UILabel!
    @IBOutlet weak var frameHeight: UILabel!
    @IBOutlet weak var boundsX: UILabel!
    @IBOutlet weak var boundsY: UILabel!
    @IBOutlet weak var boundsWidth: UILabel!
    @IBOutlet weak var boundsHeight: UILabel!
    @IBOutlet weak var centerX: UILabel!
    @IBOutlet weak var centerY: UILabel!
    @IBOutlet weak var rotation: UILabel!

    // Sliders
    @IBOutlet weak var frameXSlider: UISlider!
    @IBOutlet weak var frameYSlider: UISlider!
    @IBOutlet weak var frameWidthSlider: UISlider!
    @IBOutlet weak var frameHeightSlider: UISlider!
    @IBOutlet weak var boundsXSlider: UISlider!
    @IBOutlet weak var boundsYSlider: UISlider!
    @IBOutlet weak var boundsWidthSlider: UISlider!
    @IBOutlet weak var boundsHeightSlider: UISlider!
    @IBOutlet weak var centerXSlider: UISlider!
    @IBOutlet weak var centerYSlider: UISlider!
    @IBOutlet weak var rotationSlider: UISlider!

    // Slider actions
    @IBAction func frameXSliderChanged(sender: AnyObject) {
        myView.frame.origin.x = CGFloat(frameXSlider.value)
        updateLabels()
    }
    @IBAction func frameYSliderChanged(sender: AnyObject) {
        myView.frame.origin.y = CGFloat(frameYSlider.value)
        updateLabels()
    }
    @IBAction func frameWidthSliderChanged(sender: AnyObject) {
        myView.frame.size.width = CGFloat(frameWidthSlider.value)
        updateLabels()
    }
    @IBAction func frameHeightSliderChanged(sender: AnyObject) {
        myView.frame.size.height = CGFloat(frameHeightSlider.value)
        updateLabels()
    }
    @IBAction func boundsXSliderChanged(sender: AnyObject) {
        myView.bounds.origin.x = CGFloat(boundsXSlider.value)
        updateLabels()
    }
    @IBAction func boundsYSliderChanged(sender: AnyObject) {
        myView.bounds.origin.y = CGFloat(boundsYSlider.value)
        updateLabels()
    }
    @IBAction func boundsWidthSliderChanged(sender: AnyObject) {
        myView.bounds.size.width = CGFloat(boundsWidthSlider.value)
        updateLabels()
    }
    @IBAction func boundsHeightSliderChanged(sender: AnyObject) {
        myView.bounds.size.height = CGFloat(boundsHeightSlider.value)
        updateLabels()
    }
    @IBAction func centerXSliderChanged(sender: AnyObject) {
        myView.center.x = CGFloat(centerXSlider.value)
        updateLabels()
    }
    @IBAction func centerYSliderChanged(sender: AnyObject) {
        myView.center.y = CGFloat(centerYSlider.value)
        updateLabels()
    }
    @IBAction func rotationSliderChanged(sender: AnyObject) {
        let rotation = CGAffineTransform(rotationAngle: CGFloat(rotationSlider.value))
        myView.transform = rotation
        updateLabels()
    }

    private func updateLabels() {

        frameX.text = "frame x = \(Int(myView.frame.origin.x))"
        frameY.text = "frame y = \(Int(myView.frame.origin.y))"
        frameWidth.text = "frame width = \(Int(myView.frame.width))"
        frameHeight.text = "frame height = \(Int(myView.frame.height))"
        boundsX.text = "bounds x = \(Int(myView.bounds.origin.x))"
        boundsY.text = "bounds y = \(Int(myView.bounds.origin.y))"
        boundsWidth.text = "bounds width = \(Int(myView.bounds.width))"
        boundsHeight.text = "bounds height = \(Int(myView.bounds.height))"
        centerX.text = "center x = \(Int(myView.center.x))"
        centerY.text = "center y = \(Int(myView.center.y))"
        rotation.text = "rotation = \((rotationSlider.value))"

    }

}

Comments

ऐसा लगता है कि बाउंड की चौड़ाई और ऊंचाई निरर्थक है और एक "मूल" संपत्ति पर्याप्त होगी (जैसा कि यह फ्लैश के साथ था)।

— इयान वॉर्बर्टन

"चीज़ों को आकर्षित करने या दृश्य के भीतर साक्षात्कार की व्यवस्था करने" के लिए सीमा का उपयोग करें। आपका मतलब है कि अगर मेरे पास एक दृश्य नियंत्रक है जिसमें दो बटन हैं तो मुझे दृश्य-नियंत्रक के दृश्य 'सीमा' का उपयोग करके बटन रखना चाहिए! मैंने हमेशा दृश्य के फ्रेम का उपयोग किया है ...

— Honey

@ हनी, मैं अपने iOS कौशल पर थोड़ा कठोर हूं क्योंकि मैं पिछले साल एंड्रॉइड पर काम कर रहा हूं। मेरा मानना ​​है कि एक व्यू कंट्रोलर का रूट दृश्य स्क्रीन को भरता है, इसलिए इसका फ्रेम और सीमा एक समान होनी चाहिए।

— सूर्याग

बनाया गया github.com/maniramezan/FrameVsBounds.git रेपो उदाहरण के आधार पर यहां दिया गया है ताकि एक दृश्य के boundsबनाम समझने में बेहतर मदद मिल सके frame।

— मैनमैन

धन्यवाद! अच्छे खर्च। एक छवि 1000 शब्दों से अधिक मूल्यवान है

— पेड्रो ट्रूजिलो

Answer 3

नीचे दिए गए कोड को चलाने का प्रयास करें

- (void)viewDidLoad {
    [super viewDidLoad];
    UIWindow *w = [[UIApplication sharedApplication] keyWindow];
    UIView *v = [w.subviews objectAtIndex:0];

    NSLog(@"%@", NSStringFromCGRect(v.frame));
    NSLog(@"%@", NSStringFromCGRect(v.bounds));
}

इस कोड का आउटपुट है:

केस डिवाइस ओरिएंटेशन पोर्ट्रेट है

{{0, 0}, {768, 1024}}
{{0, 0}, {768, 1024}}

केस डिवाइस ओरिएंटेशन लैंडस्केप है

{{0, 0}, {768, 1024}}
{{0, 0}, {1024, 768}}

जाहिर है, आप फ्रेम और सीमा के बीच अंतर देख सकते हैं

Comments

यह अब सच नहीं है (iOS 8)

— जूलियन क्राल

stackoverflow.com/questions/24150359/…

— जूलियन क्राल

Answer 4

फ्रेम आयत उस के साथ UIView को परिभाषित करता है अपने superview के संबंध में ।

सीमा रेक्ट मूल्यों को परिभाषित है कि की सीमा है NSView समन्वय प्रणाली है।

इस आयत में कुछ भी वास्तव में UIView में प्रदर्शित होगा।

Answer 5

फ्रेम अपने सुपर व्यू के कोऑर्डिनेट सिस्टम में मूल (ऊपरी बाएं कोने) और दृश्य का आकार है, इसका मतलब है कि आप फ्रेम के मूल को बदलकर दृश्य को इसके सुपर व्यू में अनुवाद करते हैं, दूसरी ओर सीमा आकार और मूल है स्वयं की समन्वय प्रणाली, इसलिए डिफ़ॉल्ट रूप से सीमा की उत्पत्ति (0,0) है।

ज्यादातर समय फ्रेम और सीमा के अनुरूप होते हैं, लेकिन यदि आपके पास फ्रेम ((140,65), (200,250) और दृश्य (0,0), और (200,250) का एक दृश्य है, उदाहरण के लिए और दृश्य झुका हुआ था। ताकि यह इसके निचले दाएं कोने पर खड़ा हो, तब सीमा अभी भी ((0,0), (200,250)) होगी, लेकिन फ्रेम नहीं है।

फ्रेम सबसे छोटा आयत होगा जो दृश्य को घेरता / घेरता है, इसलिए फ्रेम (जैसा कि फोटो में है) ((140,65), (320,320) होगा।

एक और अंतर उदाहरण के लिए है यदि आपके पास एक सुपरव्यू है जिसकी सीमाएं ((0,0), (200,200)) हैं और इस सुपर व्यू में एक सब व्यू है जिसका फ्रेम ((20,20), (100,100)) है और आपने सुपरबाउंड सीमा बदल दी है , (२०,२०), (२००,२००), तब उप-दृश्य फ़्रेम अभी भी ((२०,२०), (१००,१००) होगा, लेकिन इसके (२०,२०) द्वारा ऑफसेट किया जाएगा, क्योंकि इसके पर्यवेक्षक समन्वय प्रणाली (२०) द्वारा ऑफसेट किया गया था 20)।

मुझे आशा है कि यह किसी की मदद करता है।

Comments

अंतिम पैराग्राफ के बारे में: subView फ्रेम इसके सापेक्ष है superView। superViewकुछ भी करने के लिए सीमा को बदलने से subViewमूल संयोग नहीं होगा superView।

— staticVoidMan

Answer 6

इसकी SuperView के सापेक्ष इसकी फ़्रेम बनाएं जबकि इसके NSView के सापेक्ष सीमाएँ।

उदाहरण: X = 40, Y = 60। इसके अलावा 3 दृश्य हैं। यह आरेख आपको स्पष्ट विचार दिखाता है।

Answer 7

मुझे मेरे 5 सेंट जोड़ने दें।

फ़्रेम का उपयोग दृश्य के माता-पिता के दृश्य द्वारा किया जाता है, इसे मूल दृश्य के अंदर रखने के लिए।

सीमा का उपयोग दृश्य द्वारा स्वयं किया जाता है ताकि यह स्वयं की सामग्री हो (जैसे स्क्रॉल करते समय स्क्रॉल दृश्य करता है)। क्लिपटॉब भी देखें । दृश्य की सामग्री को ज़ूम इन / आउट करने के लिए भी उपयोग किया जा सकता है।

सादृश्य:
फ़्रेम ~ टीवी स्क्रीन
सीमा ~ कैमरा (ज़ूम, मूव, रोटेट)

Answer 8

ऊपर दिए गए उत्तर ने सीमा और फ्रेम के बीच के अंतर को बहुत अच्छी तरह से समझाया है।

सीमाएँ: अपने स्वयं के समन्वय प्रणाली के अनुसार एक आकार और स्थान।

फ़्रेम: इसके SuperView के सापेक्ष एक दृश्य आकार और स्थान।

फिर भ्रम होता है कि बाउंड्स द एक्स के मामले में, वाई हमेशा "0" होगा। यह सच नहीं है । इसे UIScrollView और UICollectionView में भी समझा जा सकता है।

जब सीमा x, y 0. नहीं हैं।
मान लें कि हमारे पास UIScrollView है। हमने पेजिनेशन लागू किया है। UIScrollView के 3 पृष्ठ हैं और इसकी ContentSize की चौड़ाई स्क्रीन चौड़ाई की तीन गुना है (मान लें कि स्क्रीनविद 320 है)। ऊँचाई स्थिर (मान 200) है।

scrollView.contentSize = CGSize(x:320*3, y : 200)

उप-दृश्यों के रूप में तीन UIImageViews जोड़ें और फ्रेम के x मान पर कड़ी नज़र रखें

let imageView0 = UIImageView.init(frame: CGRect(x:0, y: 0 , width : scrollView.frame.size.width, height : scrollView.frame.size.height))
let imageView1 :  UIImageView.init( frame: CGRect(x:320, y: 0 , width : scrollView.frame.size.width, height : scrollView.frame.size.height))
let imageView2 :  UIImageView.init(frame: CGRect(x:640, y: 0 , width : scrollView.frame.size.width, height : scrollView.frame.size.height))
scrollView.addSubview(imageView0)
scrollView.addSubview(imageView0)
scrollView.addSubview(imageView0)

1. पृष्ठ ०: जब स्क्रॉलव्यू ० पृष्ठ पर है तो सीमाएँ होंगी (x: 0, y: 0, चौड़ाई: ३२०, ऊँचाई: ६)

2. पृष्ठ 1: स्क्रॉल करें और पृष्ठ 1 पर जाएँ।
   अब सीमाएँ होंगी (x: 320, y: 0, चौड़ाई: 320, ऊँचाई: 200) याद रखें कि हमने अपने स्वयं के समन्वय प्रणाली के संबंध में कहा था। तो अब हमारे स्क्रॉलव्यू के "विजिबल पार्ट" का 320 में इसका "x" है। ImageView1 के फ्रेम को देखें।

3. पृष्ठ 2: स्क्रॉल करें और पृष्ठ 2 पर जाएँ : (x: 640, y: 0, चौड़ाई: 320, ऊँचाई: 200) फिर से चित्र 2 के फ्रेम पर एक नज़र डालें

UICollectionView के मामले के लिए भी। संग्रह दृश्य को देखने का सबसे आसान तरीका यह है कि आप इसे स्क्रॉल करें और इसकी सीमाओं को प्रिंट / लॉग इन करें और आपको यह विचार मिलेगा।

Answer 9

ऊपर दिए गए सभी उत्तर सही हैं और इस पर मेरी राय है:

फ्रेम और सीमा के बीच अंतर करने के लिए CONCEPTS डेवलपर को पढ़ना चाहिए:

1. पर्यवेक्षण के सापेक्ष (एक मूल विचार) यह = FRAME के ​​भीतर समाहित है
2. अपने स्वयं के समन्वय प्रणाली के सापेक्ष, इसके उप-स्थान = BOUNDS को निर्धारित करता है

"सीमा" भ्रामक है क्योंकि यह धारणा देता है कि निर्देशांक उस दृश्य की स्थिति है जिसके लिए इसे सेट किया गया है। लेकिन ये संबंधों में हैं और फ्रेम स्थिरांक के अनुसार समायोजित किए गए हैं।

Answer 10

फ्रेम और सीमा के बीच अंतर दिखाने के लिए एक और चित्रण। इस उदाहरण पर:

• View B का एक उपक्षेत्र है View A
• View B में स्थानांतरित कर दिया गया x:60, y: 20
• View B घुमाया गया था 45 degrees

Answer 11

फ्रेम बनाम बाध्य

• यदि आप X: 0, Y: 0, चौड़ाई: 400, ऊँचाई: 400 पर एक दृश्य बनाते हैं, तो इसका फ्रेम और सीमा समान हैं।
• यदि आप उस दृश्य को X: 400 में ले जाते हैं, तो इसका फ्रेम उस परिवर्तन को प्रतिबिंबित करेगा लेकिन इसकी सीमा नहीं होगी। याद रखें, सीमा दृश्य के अपने स्थान के सापेक्ष है, और आंतरिक रूप से दृश्य में कुछ भी नहीं बदला है।
• यदि आप दृश्य को रूपांतरित करते हैं, उदाहरण के लिए, इसे घुमाते हुए या इसे ऊपर स्केल करते हुए, तो फ्रेम प्रतिबिंबित करने के लिए बदल जाएगा, लेकिन सीमा अभी भी नहीं होगी - जहां तक ​​दृश्य आंतरिक रूप से चिंतित है, यह नहीं बदला है।
• यदि आप सीमाएँ बदलते हैं तो यह फ्रेम के अंदर की सामग्री को बदल देगा क्योंकि सीमा आयत की उत्पत्ति दृश्य के एक अलग हिस्से से शुरू होती है।

Answer 12

फ्रेम = माता-पिता के समन्वय प्रणाली के उपयोग से एक दृश्य का स्थान और आकार

सीमा = अपने स्वयं के समन्वय प्रणाली का उपयोग करके एक दृश्य का स्थान और आकार

एक दृश्य दो आयतों का उपयोग करके इसके आकार और स्थान को ट्रैक करता है: एक फ्रेम आयत और एक सीमा आयत। फ्रेम आयत पर्यवेक्षक के समन्वय प्रणाली का उपयोग करते हुए पर्यवेक्षक में दृश्य के स्थान और आकार को परिभाषित करता है। सीमा आयत आंतरिक समन्वय प्रणाली को परिभाषित करता है जो मूल और स्केलिंग सहित दृश्य की सामग्री को आकर्षित करते समय उपयोग किया जाता है। चित्र 2-1 फ्रेम आयत, बाईं ओर और सीमा आयत के बीच, दाईं ओर का संबंध दर्शाता है। ”

संक्षेप में, फ्रेम एक दृश्य के पर्यवेक्षण का विचार है, और सीमा दृश्य का अपना विचार है। प्रत्येक दृश्य के लिए एक से अधिक समन्वित प्रणालियां होना, दृश्य पदानुक्रम का हिस्सा है।

Comments

चित्र 2-1 कहाँ है?

— अलेक्जेंडर मायात्स्की