दिलचस्प पोस्ट
सभी तालिकाओं (पोस्टग्रेएसक्यूएल) में विशिष्ट मान कैसे खोजा जाए? सूचना: गैर ऑब्जेक्ट त्रुटि की संपत्ति पाने की कोशिश कर रहा है PHP: बाहर निकलने का उपयोग (); या मरो(); शीर्षलेख के बाद ("स्थान:"); सी में MIN और MAX मैं GWT की सीरियलाइजेशन नीति श्वेतसूची में एक प्रकार कैसे जोड़ूं? asp.net MVC आंशिक दृश्य नियंत्रक कार्रवाई JSON.parse अनपेक्षित वर्ण त्रुटि रिफ्लेक्शन के साथ राइट जेनेरिक मेथड चुनें स्क्रॉलव्यू के अंदर गैर स्क्रॉल सूची देखें एमवीसी पैटर्न और स्विंग पायथन में बाहरी कमांड कॉल करना जावा में फ्लोट की तुलना करने के लिए == का उपयोग करने में क्या गलत है? एचटीएमएल / सीएसएस में पूरे डिव के लिए एक href लिंक स्प्रिंग जावा कॉन्फ़िग बनाम जेबॉस 7 भौतिक डिजाइन में एप कॉमप्लेट का उपयोग करते हुए प्रासंगिक कार्य बार को कैसे अनुकूलित करें

जब मैं ऑटो लेआउट का इस्तेमाल किया जा रहा हूं, तो कैलायर के एंकर पॉइंट को कैसे समायोजित कर सकता हूं?

नोट : इस प्रश्न के बाद से चीजें आगे बढ़ गई हैं; एक अच्छी हालिया अवलोकन के लिए यहां देखें।


ऑटो लेआउट के पहले, आप फ्रेम को संचय करके, लंगर बिंदु को सेट करके और फ़्रेम को पुनर्स्थापित करते हुए दृश्य को बिना किसी दृश्य के परत के एंकर बिन्दु को बदल सकते हैं।

एक ऑटो लेआउट दुनिया में, हम किसी भी फ्रेम सेट नहीं करते हैं, लेकिन बाधाओं को एक दृश्य की स्थिति को समायोजित करने के कार्य के ऊपर नहीं लगता है, जहां हम इसे चाहते हैं। आप अपने दृष्टिकोण को बदलने के लिए बाधाओं को हैक कर सकते हैं, लेकिन रोटेशन या अन्य रीसाइज़िंग इवेंट पर, ये फिर से अमान्य हो जाते हैं।

निम्न उज्ज्वल विचार काम नहीं करता क्योंकि यह "लेआउट विशेषताओं (बायां और चौड़ाई) का अमान्य युग्म बनाना" बनाता है:

layerView.layer.anchorPoint = CGPointMake(1.0, 0.5); // Some other size-related constraints here which all work fine... [self.view addConstraint: [NSLayoutConstraint constraintWithItem:layerView attribute:NSLayoutAttributeLeft relatedBy:NSLayoutRelationEqual toItem:layerView attribute:NSLayoutAttributeWidth multiplier:0.5 constant:20.0]]; 

मेरा इरादा यह था कि layerView के दृश्य के किनारे को समायोजित लंगर बिंदु के साथ, इसकी चौड़ाई का आधा प्लस प्लस 20 (दूरी जो मुझे layerView के बायीं किनारे से अंदर करना चाहिए) के लिए सेट करना था।

क्या ऑटो लेआउट के साथ रखी गई एक दृश्य में दृश्य के स्थान को बदलने के बिना, एंकर पॉइंट को बदलना संभव है? क्या मुझे हार्डकोड किए गए मानों का उपयोग करने और प्रत्येक रोटेशन पर बाधा को संपादित करने की आवश्यकता है? मुझे उम्मीद नहीं है

मुझे लंगर बिंदु को बदलने की आवश्यकता है, ताकि जब मैं दृश्य में परिवर्तन लागू कर सकूं, तो मुझे सही दृश्य प्रभाव मिलेगा।

वेब के समाधान से एकत्रित समाधान "जब मैं ऑटो लेआउट का इस्तेमाल किया जा रहा हूं, तो कैलायर के एंकर पॉइंट को कैसे समायोजित कर सकता हूं?"

[संपादित करें: चेतावनी: पूरी आने वाली चर्चा संभवतः आउडीड हो जाएगी या कम से कम आईओएस 8 द्वारा कमजोर हो जाएगी, जो अब उस दृश्य को ट्रिगर करने की गलती नहीं कर सकता है, जब कि दृश्य परिणत लागू होता है।]

Autolayout बनाम रूपांतरण देखें

आटोलेयआउट व्यू रूपांतरण के साथ बिल्कुल अच्छी तरह से नहीं खेलता है। कारण, जहां तक ​​मुझे पता चल सकता है कि आप एक दृश्य के फ्रेम के साथ गड़बड़ नहीं करना चाहते हैं, जो कि एक परिणत (डिफ़ॉल्ट पहचान परिणत के अलावा) है – लेकिन वास्तव में यह है कि स्वायत्तता क्या है। जिस तरह से काम करता है, वह यह है कि लेआउट में layoutSubviews वाले समय- layoutSubviews पर सभी बाधाओं के माध्यम से तेज हो जाता है और तदनुसार सभी दृश्यों के फ़्रेम निर्धारित करता है।

दूसरे शब्दों में, बाधाएं जादू नहीं हैं; वे सिर्फ एक टू-डू सूची हैं layoutSubviews है, जहां कार्य किया जाता है। और यह फ़्रेम सेट करके करता है।

मैं इसके बारे में एक बग के रूप में मदद नहीं कर सकता अगर मैं इसे एक दृश्य में बदलता हूं:

 v.transform = CGAffineTransformMakeScale(0.5,0.5); 

मुझे यह देखने की उम्मीद है कि इसके केंद्र को उसी स्थान पर पहले और आधा आकार के रूप में दिखाई दिया। लेकिन इसकी बाधाओं पर निर्भर करता है, हो सकता है कि मैं जो कुछ भी देखूं।

[दरअसल, यहां एक दूसरा आश्चर्य है: किसी दृश्य को बदलना लागू करना, लेआउट को तुरन्त ट्रिगर करता है यह मुझे एक और बग लगता है या शायद यह पहले बग का दिल है मैं क्या उम्मीद करता हूं, कम से कम लेआउट समय तक ट्रांसफॉर्म होने से दूर रहना है, जैसे कि डिवाइस को घुमाया गया है – जैसे कि मैं लेआउट का समय तक फ्रेम एनीमेशन के साथ भाग ले सकता हूं। लेकिन वास्तव में लेआउट का समय तत्काल होता है, जो अभी गलत लगता है।]

समाधान 1: कोई प्रतिबंध नहीं

एक मौजूदा समाधान यह है कि यदि मैं एक सीमिपर्मेंट रूपांतरण को एक दृश्य में लागू करने जा रहा हूं (और इसे अस्थायी तौर पर किसी न किसी तरह से झंझटाना), तो उसे प्रभावित करने वाली सभी बाधाओं को दूर करने के लिए। दुर्भाग्य से, यह आम तौर पर स्क्रीन से गायब होने के कारण का कारण बनता है, क्योंकि ऑटोलेआउट अब भी होता है, और अब हमें कहने के लिए कोई बाधा नहीं है कि दृश्य कहां दें। तो बाधाओं को हटाने के अलावा, मैंने दृश्य के translatesAutoresizingMaskIntoConstraints को सेट किया हैअनुरूपणमास्क इनकनेक्टनेंट्स को हाँ। दृश्य अब पुराने तरीके से काम करता है, आटोलेआउट द्वारा प्रभावी ढंग से अप्रभावित है। (यह स्वायत्तता से प्रभावित होता है, जाहिर है, लेकिन निहित autoresizing मुखौटा बाधाओं का कारण उसके व्यवहार ऐसा ही होता है जैसे कि यह autolayout से पहले था।)

समाधान 2: केवल उचित प्रतिबंधों का उपयोग करें

यदि यह थोड़ी कठोर लगता है, तो एक और समाधान है कि किसी बाधाओं को एक इच्छित रूपांतरण के साथ सही ढंग से काम करने के लिए सेट करें अगर किसी दृश्य को अपनी आंतरिक निश्चित चौड़ाई और ऊंचाई के द्वारा पूर्ण रूप से आकार दिया जाता है, और उसके केंद्र द्वारा विशुद्ध रूप से जोड़ा जाता है, उदाहरण के लिए, मेरी स्केल ट्रांस्फ़ॉर्म मुझे आशा करता है जैसा मुझे उम्मीद है। इस कोड में, मैं एक otherView (अन्य otherView ) पर मौजूदा बाधाओं को हटा देता हूं और उन चार बाधाओं के साथ उन्हें प्रतिस्थापित कर देता हूं, इसे एक निश्चित चौड़ाई और ऊंचाई देता है और इसे अपने केंद्र द्वारा विशुद्ध रूप से otherView है। उसके बाद, मेरा स्केल काम करता है:

 NSMutableArray* cons = [NSMutableArray array]; for (NSLayoutConstraint* con in self.view.constraints) if (con.firstItem == self.otherView || con.secondItem == self.otherView) [cons addObject:con]; [self.view removeConstraints:cons]; [self.otherView removeConstraints:self.otherView.constraints]; [self.view addConstraint: [NSLayoutConstraint constraintWithItem:self.otherView attribute:NSLayoutAttributeCenterX relatedBy:0 toItem:self.view attribute:NSLayoutAttributeLeft multiplier:1 constant:self.otherView.center.x]]; [self.view addConstraint: [NSLayoutConstraint constraintWithItem:self.otherView attribute:NSLayoutAttributeCenterY relatedBy:0 toItem:self.view attribute:NSLayoutAttributeTop multiplier:1 constant:self.otherView.center.y]]; [self.otherView addConstraint: [NSLayoutConstraint constraintWithItem:self.otherView attribute:NSLayoutAttributeWidth relatedBy:0 toItem:nil attribute:0 multiplier:1 constant:self.otherView.bounds.size.width]]; [self.otherView addConstraint: [NSLayoutConstraint constraintWithItem:self.otherView attribute:NSLayoutAttributeHeight relatedBy:0 toItem:nil attribute:0 multiplier:1 constant:self.otherView.bounds.size.height]]; 

इसका नतीजा यह है कि यदि आपके पास कोई बाधा नहीं है जो किसी दृश्य के फ्रेम को प्रभावित करते हैं, तो आटोलेयआउट दृश्य के फ्रेम को नहीं छूएगा – जो कि एक रूपांतरण में शामिल होने के बाद क्या हो रहा है।

समाधान 3: एक सबव्यू का उपयोग करें

उपर्युक्त समाधान दोनों के साथ समस्या यह है कि हम अपने दृष्टिकोण की स्थिति में कमी के लाभों को खो देते हैं। तो यह एक समाधान है जो यह हल करता है। एक अदृश्य दृश्य से प्रारंभ करें, जिसका काम केवल एक मेजबान के रूप में कार्य करने के लिए है, और इसकी स्थिति बनाने के लिए बाधाओं का उपयोग करें उस के अंदर, वास्तविक दृश्य को एक सबव्यू के रूप में रखें। मेजबान दृश्य के भीतर सबव्यू को स्थानांतरित करने के लिए बाधाओं का उपयोग करें, लेकिन उन बाधाओं को उन सीमाओं तक सीमित करें, जो एक परिवर्तन को लागू करते समय वापस नहीं लड़ेंगे।

यहाँ एक उदाहरण है:

यहां छवि विवरण दर्ज करें

सफेद दृश्य मेजबान दृश्य है; आप बहाना चाहिए कि यह पारदर्शी है और इसलिए अदृश्य है। लाल दृश्य इसकी उपवहनी है, मेजबान दृश्य के केंद्र में अपने केंद्र को पिन करके तैनात अब हम किसी भी समस्या के बिना उसके केंद्र के चारों ओर लाल दृश्य को स्केल और घुमा सकते हैं, और वास्तव में इस उदाहरण से पता चलता है कि हमने ऐसा किया है:

 self.otherView.transform = CGAffineTransformScale(self.otherView.transform, 0.5, 0.5); self.otherView.transform = CGAffineTransformRotate(self.otherView.transform, M_PI/8.0); 

और इस बीच मेजबान दृश्य पर बाधाएं इसे सही जगह पर रखते हैं क्योंकि हम डिवाइस को घुमाते हैं।

समाधान 4: इसके बजाय लेयर ट्रांसफ़ॉर्म्स का उपयोग करें

दृश्य को बदलने के बजाय, परत परिवर्तन का उपयोग करें, जो लेआउट को ट्रिगर नहीं करते हैं और इस प्रकार बाधाओं के साथ तत्काल संघर्ष का कारण नहीं बनते हैं।

उदाहरण के लिए, यह सरल "ध्रुव" दृश्य एनीमेशन अच्छी तरह से ऑटोलेआउट के अंतर्गत टूट सकता है:

 [UIView animateWithDuration:0.3 delay:0 options:UIViewAnimationOptionAutoreverse animations:^{ v.transform = CGAffineTransformMakeScale(1.1, 1.1); } completion:^(BOOL finished) { v.transform = CGAffineTransformIdentity; }]; 

हालांकि अंत में दृश्य के आकार में कोई परिवर्तन नहीं हुआ था, बल्कि इसके transform का निर्धारण करने का कारण लेआउट होता है, और बाधाएं दृश्य के चारों ओर कूद सकती हैं (क्या यह एक बग या क्या लगता है?) लेकिन अगर हम कोर एनीमेशन के साथ एक ही बात करते हैं (एएएबीएसीएसीएनिमेशन का उपयोग करते हुए और एनीमेशन को दृश्य की परत में लागू करने के लिए), लेआउट नहीं होता, और यह ठीक काम करता है:

 CABasicAnimation* ba = [CABasicAnimation animationWithKeyPath:@"transform"]; ba.autoreverses = YES; ba.duration = 0.3; ba.toValue = [NSValue valueWithCATransform3D:CATransform3DMakeScale(1.1, 1.1, 1)]; [v.layer addAnimation:ba forKey:nil]; 

मेरे पास एक समान इस्यूई था और एप्पल पर बस Autolayout टीम से वापस सुना था। वे कंटेनर व्यू दृष्टिकोण का उपयोग करने का सुझाव देते हैं मैट सुझाव देता है लेकिन लेआउट्स ओवरव्यू करने के लिए वे यूआईवीयूवी का एक उपवर्ग बनाते हैं और कस्टम लेआउट लागू करते हैं कोड – यह एक जादू की तरह काम करता है

हैडर फ़ाइल इस तरह दिखती है ताकि आप सीधे अंतरफलक बिल्डर से अपने पसंदीदा विकल्प को लिंक कर सकें

 #import <UIKit/UIKit.h> @interface BugFixContainerView : UIView @property(nonatomic,strong) IBOutlet UIImageView *knobImageView; @end 

और एम फाइल उस विशेष कोड को लागू करती है:

 #import "BugFixContainerView.h" @implementation BugFixContainerView - (void)layoutSubviews { static CGPoint fixCenter = {0}; [super layoutSubviews]; if (CGPointEqualToPoint(fixCenter, CGPointZero)) { fixCenter = [self.knobImageView center]; } else { self.knobImageView.center = fixCenter; } } @end 

जैसा कि आप देख सकते हैं, यह दृश्य के केंद्र बिंदु को पकड़ लेता है, जब दृश्य को पहली बार बुलाया जाता है और दृश्य को स्थानांतरित करने के लिए आगे की कॉल में उस स्थान को फिर से जोड़ता है। यह उस अर्थ में, Autolayout कोड को ओवरराइट करता है, कि यह [सुपर लेआउटसंपादन] के बाद होता है; जिसमें ऑटोलेआउट कोड शामिल है

जैसे कि अब कोई भी ऑटोलेआउट से बचने की आवश्यकता नहीं है, लेकिन जब डिफ़ॉल्ट व्यवहार हो तो अब आप उपयुक्त नहीं हो सकते हैं। बेशक आप जिस उदाहरण में है उससे अधिक जटिल चीजें लागू कर सकते हैं लेकिन यह सब मुझे जरूरी था क्योंकि मेरा ऐप केवल पोर्ट्रेट मोड का उपयोग कर सकता है

मुझे एक आसान तरीका मिल रहा है और यह आईओएस 8 और आईओएस 9 पर काम करता है।

जब आप फ़्रेम-आधारित लेआउट का उपयोग करते हैं तो एंकरपॉइंट समायोजित करना पसंद करते हैं:

 let oldFrame = layerView.frame layerView.layer.anchorPoint = newAnchorPoint layerView.frame = oldFrame 

जब आप स्वत: लेआउट के साथ दृश्य के एंकर को समायोजित करते हैं, तो आप एक ही काम करते हैं लेकिन बाधाओं के रास्ते में जब लंगरपॉइंट (0.5, 0.5) से (1, 0.5) में बदल जाता है, तो परत दृश्य बाईं तरफ दृश्य चौड़ाई की आधा लंबाई से बाएं चलेगा, इसलिए आपको इसके लिए क्षतिपूर्ति की आवश्यकता होगी।

मुझे सवाल में बाधा नहीं समझती। इसलिए, मान लें कि आप एक निरंतर: परत के साथ सुपरएव्यू सेंटर एक्स के सापेक्ष centerX बाधा को जोड़ते हैं layercenterX = superView.centerX + constant

 layerView.layer.anchorPoint = CGPoint(1, 0.5) let centerXConstraint = ..... centerXConstraint.constant = centerXConstraint.constant + layerView.bounds.size.width/2 

यदि आप ऑटो लेआउट का उपयोग कर रहे हैं, तो मुझे नहीं पता कि मैन्युअल रूप से सेटिंग की स्थिति कितनी देर तक काम करेगी क्योंकि अंततः ऑटो लेआउट आपके द्वारा सेट किए गए स्थिति मान को लगाएगा, जब वह अपने स्वयं के लेआउट की गणना करेगा

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

 /** Set the anchorPoint of view without changing is perceived position. @param view view whose anchorPoint we will mutate @param anchorPoint new anchorPoint of the view in unit coords (eg, {0.5,1.0}) @param xConstraint an NSLayoutConstraint whose constant property adjust's view x.center @param yConstraint an NSLayoutConstraint whose constant property adjust's view y.center As multiple constraints can contribute to determining a view's center, the user of this function must specify which constraint they want modified in order to compensate for the modification in anchorPoint */ void SetViewAnchorPointMotionlesslyUpdatingConstraints(UIView * view,CGPoint anchorPoint, NSLayoutConstraint * xConstraint, NSLayoutConstraint * yConstraint) { // assert: old and new anchorPoint are in view's unit coords CGPoint const oldAnchorPoint = view.layer.anchorPoint; CGPoint const newAnchorPoint = anchorPoint; // Calculate anchorPoints in view's absolute coords CGPoint const oldPoint = CGPointMake(view.bounds.size.width * oldAnchorPoint.x, view.bounds.size.height * oldAnchorPoint.y); CGPoint const newPoint = CGPointMake(view.bounds.size.width * newAnchorPoint.x, view.bounds.size.height * newAnchorPoint.y); // Calculate the delta between the anchorPoints CGPoint const delta = CGPointMake(newPoint.x-oldPoint.x, newPoint.y-oldPoint.y); // get the x & y constraints constants which were contributing to the current // view's position, and whose constant properties we will tweak to adjust its position CGFloat const oldXConstraintConstant = xConstraint.constant; CGFloat const oldYConstraintConstant = yConstraint.constant; // calculate new values for the x & y constraints, from the delta in anchorPoint // when autolayout recalculates the layout from the modified constraints, // it will set a new view.center that compensates for the affect of the anchorPoint CGFloat const newXConstraintConstant = oldXConstraintConstant + delta.x; CGFloat const newYConstraintConstant = oldYConstraintConstant + delta.y; view.layer.anchorPoint = newAnchorPoint; xConstraint.constant = newXConstraintConstant; yConstraint.constant = newYConstraintConstant; [view setNeedsLayout]; } 

मैं मानता हूं कि यह संभवत: ऐसा सब कुछ नहीं है जिसके लिए आप उम्मीद कर रहे थे, क्योंकि आमतौर पर आप एंकरपॉइंट को संशोधित करना चाहते हैं, एक परिवर्तन करना है इसके लिए एक अधिक जटिल कार्य की आवश्यकता होगी जो लेआउट बाधाओं को अपडेट करने के लिए सभी फ़्रेम परिवर्तनों को प्रतिबिंबित करने के लिए आवश्यक होता है जो कि संपत्ति को परिणत करने के कारण हो सकते हैं यह मुश्किल है क्योंकि रूपांतरण फ्रेम पर बहुत कुछ कर सकता है। एक स्केलिंग या रोटेशन ट्रांस्फ़ॉर्म फ्रेम को बड़ा बना देगा, इसलिए हमें किसी भी चौड़ाई या ऊँचाई बाधाओं को अपडेट करना होगा, आदि।

यदि आप केवल अस्थायी एनीमेशन के लिए परिणत का उपयोग कर रहे हैं, तो इसके बाद के संस्करण में क्या पर्याप्त हो सकता है क्योंकि मेरा विश्वास नहीं है कि ऑटो लेआउट इन-फ़्लाइट एनीमेशन को छवियों को प्रस्तुत करने से रोक देगा जो बाधाओं के विशुद्ध क्षणिक उल्लंघन का प्रतिनिधित्व करते हैं।

tl: dr: आप एक बाधा के लिए एक आउटलेट बना सकते हैं ताकि इसे हटाया जा सके और फिर से वापस जोड़ दिया जा सके।


मैंने एक नई परियोजना बनाई और केंद्र में एक निश्चित आकार के साथ एक दृश्य जोड़ा। बाधाओं को नीचे की छवि में दिखाया गया है।

छोटे उदाहरण के लिए बाधाएं मैं सोच सकता था

इसके बाद मैंने उस दृश्य के लिए एक आउटलेट जोड़ा जो कि घुमाएगा और केंद्र एक्स संरेखण बाधा के लिए।

 @property (weak, nonatomic) IBOutlet UIView *rotatingView; @property (weak, nonatomic) IBOutlet NSLayoutConstraint *xAlignmentContstraint; 

बाद में देखने में viewDidAppear मैं नए एंकर बिंदु की गणना

 UIView *view = self.rotatingView; CGPoint rotationPoint = // The point I'm rotating around... (only X differs) CGPoint anchorPoint = CGPointMake((rotationPoint.x-CGRectGetMinX(view.frame))/CGRectGetWidth(view.frame), (rotationPoint.y-CGRectGetMinY(view.frame))/CGRectGetHeight(view.bounds)); CGFloat xCenterDifference = rotationPoint.x-CGRectGetMidX(view.frame); view.layer.anchorPoint = anchorPoint; 

तब मैं बाधा को हटाता हूं कि मेरे पास एक आउटलेट है, एक नया जो ऑफसेट है और इसे वापस फिर से जोड़ें। उसके बाद मैं बदल गया बाधा के साथ दृश्य को बताता हूं कि उसे बाधाओं को अपडेट करने की आवश्यकता होती है।

 [self.view removeConstraint:self.xAlignmentContstraint]; self.xAlignmentContstraint = [NSLayoutConstraint constraintWithItem:self.rotatingView attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:self.view attribute:NSLayoutAttributeCenterX multiplier:1.0 constant:xDiff]; [self.view addConstraint:self.xAlignmentContstraint]; [self.view needsUpdateConstraints]; 

अंत में मैं बस घूर्णन दृश्य में रोटेशन एनीमेशन जोड़ता हूं।

 CABasicAnimation *rotate = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"]; rotate.toValue = @(-M_PI_2); rotate.autoreverses = YES; rotate.repeatCount = INFINITY; rotate.duration = 1.0; rotate.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut]; [view.layer addAnimation:rotate forKey:@"myRotationAnimation"]; 

घूर्णन परत दिखता है जैसे वह केन्द्रित रहता है (जो इसे करना चाहिए) भले ही डिवाइस को घूर्णन या अन्यथा बाधाओं को अद्यतन करने के लिए कारण हो। नई बाधा और बदल एंकर बिंदु नेत्रहीन एक दूसरे को रद्द कर देते हैं।

मेरा वर्तमान समाधान देखने के लिए परत की स्थिति मैन्युअल रूप से समायोजित करना है viewDidLayoutSubviews यह कोड एक दृश्य उपवर्ग के लिए layoutSubviews दृश्य में भी इस्तेमाल किया जा सकता है, लेकिन मेरे मामले में मेरा दृश्य दृश्य नियंत्रक के अंदर एक शीर्ष-स्तरीय दृश्य है, इसलिए इसका मतलब था कि मुझे एक UIView subclass नहीं करना था।

यह बहुत अधिक प्रयास की तरह लगता है, इसलिए अन्य उत्तरों का सबसे स्वागत है

 -(void)viewDidLayoutSubviews { for (UIView *view in self.view.subviews) { CGPoint anchorPoint = view.layer.anchorPoint; // We're only interested in views with a non-standard anchor point if (!CGPointEqualToPoint(CGPointMake(0.5, 0.5),anchorPoint)) { CGFloat xDifference = anchorPoint.x - 0.5; CGFloat yDifference = anchorPoint.y - 0.5; CGPoint currentPosition = view.layer.position; // Use transforms if we can, otherwise manually calculate the frame change // Assuming a transform is in use since we are changing the anchor point. if (CATransform3DIsAffine(view.layer.transform)) { CGAffineTransform current = CATransform3DGetAffineTransform(view.layer.transform); CGAffineTransform invert = CGAffineTransformInvert(current); currentPosition = CGPointApplyAffineTransform(currentPosition, invert); currentPosition.x += (view.bounds.size.width * xDifference); currentPosition.y += (view.bounds.size.height * yDifference); currentPosition = CGPointApplyAffineTransform(currentPosition, current); } else { CGFloat transformXRatio = view.bounds.size.width / view.frame.size.width; if (xDifference < 0) transformXRatio = 1.0/transformXRatio; CGFloat transformYRatio = view.bounds.size.height / view.frame.size.height; if (yDifference < 0) transformYRatio = 1.0/transformYRatio; currentPosition.x += (view.bounds.size.width * xDifference) * transformXRatio; currentPosition.y += (view.bounds.size.height * yDifference) * transformYRatio; } view.layer.position = currentPosition; } } } 

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

यह मेरी परिस्थिति के लिए किसी भी तरह का इलाज करता है विचारों को देखने के लिए यहां सेट अप किया गया हैडडलोड:

 - (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading the view, typically from a nib. UIView *redView = [UIView new]; redView.translatesAutoresizingMaskIntoConstraints = NO; redView.backgroundColor = [UIColor redColor]; [self.view addSubview:redView]; [self.view addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"|-[redView]-|" options:0 metrics:nil views:NSDictionaryOfVariableBindings(redView)]]; [self.view addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|-[redView]-|" options:0 metrics:nil views:NSDictionaryOfVariableBindings(redView)]]; self.redView = redView; UIView *greenView = [UIView new]; greenView.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth; greenView.layer.anchorPoint = CGPointMake(1.0, 0.5); greenView.frame = redView.bounds; greenView.backgroundColor = [UIColor greenColor]; [redView addSubview:greenView]; self.greenView = greenView; CATransform3D perspective = CATransform3DIdentity; perspective.m34 = 0.005; self.redView.layer.sublayerTransform = perspective; } 

यह कोई फर्क नहीं पड़ता कि लाल दृश्य के फ्रेम इस बिंदु पर शून्य हैं, क्योंकि हरे रंग के दृश्य पर ऑटोोरिसिज़िंग मुखौटा है।

मैंने एक क्रिया विधि पर रोटेशन को बदल दिया, और यह परिणाम था:

यहां छवि विवरण दर्ज करें

यह डिवाइस रोटेशन के दौरान स्वयं को खोने लगता है, इसलिए मैंने इसे viewDidLayoutSubviews विधि में जोड़ा है:

 -(void)viewDidLayoutSubviews { [super viewDidLayoutSubviews]; [CATransaction begin]; [CATransaction setDisableActions:YES]; CATransform3D transform = self.greenView.layer.transform; self.greenView.layer.transform = CATransform3DIdentity; self.greenView.frame = self.redView.bounds; self.greenView.layer.transform = transform; [CATransaction commit]; } 

tl; dr मान लें कि आपने एंकर पॉइंट को बदल दिया (0, 0) लंगर बिंदु अब शीर्ष बाईं ओर है कभी भी आप ऑटो लेआउट में शब्द केंद्र देखते हैं, आपको शीर्ष-बाएं सोचना चाहिए।

जब आप अपने एंकरपॉइंट को समायोजित करते हैं, तो आप बस ऑटोलेआउट के शब्दों को बदलते हैं ऑटो लेआउट आपके एंकरपॉइंट में हस्तक्षेप नहीं करेगा और न ही इसके विपरीत। अगर आपको यह समझ में नहीं आता है, तो आप एक बुरे समय के लिए जा रहे हैं


उदाहरण:

चित्रा ए। कोई एंकर पॉइंट संशोधनों

 #Before changing anchor point to top-left view.size == superview.size view.center == superview.center 

चित्रा B. लंगर बिंदु ऊपर बाईं ओर बदल गया

 view.layer.anchorPoint = CGPointMake(0, 0) view.size == superview.size view.center == superview.topLeft <----- L0-0K, center is now top-left 

चित्रा ए और चित्रा बी वास्तव में एक ही दिखता है। कुछ नहीं बदला। सिर्फ किस केंद्र की परिभाषा बदलती है

मुझे लगता है कि आप उस विधि के साथ ऑटोलेआउट के उद्देश्य को हरा रहे हैं आपने उल्लेख किया था कि चौड़ाई और दायां किनारे पर्यवेक्षण पर निर्भर है, तो बस सोच की उस पंक्ति में बाधाओं को क्यों न जोड़ें?

एंकरपॉइंट / ट्रांस्ड पैराडाइम खो दें और कोशिश करें:

 [self.view addConstraint: [NSLayoutConstraint constraintWithItem:layerView attribute:NSLayoutAttributeRight relatedBy:NSLayoutRelationEqual toItem:self.view attribute:NSLayoutAttributeWidth multiplier:1.0f constant:-somePadding]]; [self.view addConstraint: [NSLayoutConstraint constraintWithItem:layerView attribute:NSLayoutAttributeWidth relatedBy:NSLayoutRelationEqual toItem:someViewWeDependTheWidthOn attribute:NSLayoutAttributeWidth multiplier:0.5f // because you want it to be half of someViewWeDependTheWidthOn constant:-20.0f]]; // your 20pt offset from the left 

NSLayoutAttributeRight बाधा का मतलब बिल्कुल anchorPoint = CGPointMake(1.0, 0.5) , और NSLayoutAttributeWidth बाधा लगभग आपके पिछले कोड के NSLayoutAttributeLeft के NSLayoutAttributeLeft

इस सवाल और उत्तर से मुझे अपनी समस्याओं को हल करने के लिए प्रेरणा मिली, Autolayout और स्केलिंग के साथ, लेकिन स्क्रॉलएव्यू के साथ। मैंने गिथूब पर अपने समाधान का एक उदाहरण बनाया:

https://github.com/hansdesmedt/AutoLayout-scrollview-scale

यह एक यूआईएसक्रोलव्यू का एक उदाहरण है जिसे कस्टम पेजिंग पूरी तरह से ऑटोलेआउट में बनाया गया है और स्केलेबल (कैटरन्सफोर्म 3 डी मैकेस्केल) लंबे प्रेस के साथ और ज़ूम करने के लिए टैप करें। आईओएस 6 और 7 संगत

यह एक बड़ा विषय है और मैंने सभी टिप्पणियों को नहीं पढ़ा है, लेकिन एक ही समस्या का सामना करना पड़ रहा है।

मेरे पास XIB से autolayout के साथ एक दृश्य था और मैं इसकी परिणति संपत्ति को अद्यतन करना चाहता था व्यू को कंटेनर दृश्य में एम्बेड करना मेरी समस्या का समाधान नहीं करता है क्योंकि ऑटोलेआउट कंटेनर व्यू पर अजीब तरीके से काम कर रहा था। यही कारण है कि मैंने सिर्फ कंटेनर व्यू को शामिल करने के लिए दूसरा कंटेनर दृश्य जोड़ा था जिसमें मेरा विचार था और उस पर परिवर्तन लागू किया गया था।