788 addDelicately(comp, curParent, index); 789 790 // If the oldZindex == -1, the component gets inserted, 791 // rather than it changes its z-order. 792 if (!peerRecreated && oldZindex != -1) { 793 // The new 'index' cannot be == -1. 794 // It gets checked at the checkAdding() method. 795 // Therefore both oldZIndex and index denote 796 // some existing positions at this point and 797 // this is actually a Z-order changing. 798 comp.mixOnZOrderChanging(oldZindex, index); 799 } 800 } 801 } 802 803 /** 804 * Traverses the tree of components and reparents children heavyweight component 805 * to new heavyweight parent. 806 * @since 1.5 807 */ 808 private void reparentTraverse(ContainerPeer parentPeer, Container child) { 809 checkTreeLock(); 810 811 for (int i = 0; i < child.getComponentCount(); i++) { 812 Component comp = child.getComponent(i); 813 if (comp.isLightweight()) { 814 // If components is lightweight check if it is container 815 // If it is container it might contain heavyweight children we need to reparent 816 if (comp instanceof Container) { 817 reparentTraverse(parentPeer, (Container)comp); 818 } 819 } else { 820 // Q: Need to update NativeInLightFixer? 821 comp.getPeer().reparent(parentPeer); 822 } 823 } 824 } 825 826 /** 827 * Reparents child component peer to this container peer. 828 * Container must be heavyweight. 829 * @since 1.5 830 */ 831 private void reparentChild(Component comp) { 832 checkTreeLock(); 833 if (comp == null) { 834 return; 835 } 836 if (comp.isLightweight()) { 837 // If component is lightweight container we need to reparent all its explicit heavyweight children 838 if (comp instanceof Container) { 839 // Traverse component's tree till depth-first until encountering heavyweight component 840 reparentTraverse((ContainerPeer)getPeer(), (Container)comp); 841 } 842 } else { 843 comp.getPeer().reparent((ContainerPeer)getPeer()); 844 } 845 } 846 847 /** 848 * Adds component to this container. Tries to minimize side effects of this adding - 849 * doesn't call remove notify if it is not required. 850 * @since 1.5 4172 return; 4173 } 4174 // An invalid container with not-null layout should be ignored 4175 // by the mixing code, the container will be validated later 4176 // and the mixing code will be executed later. 4177 if (getLayout() != null && !isValid()) { 4178 return; 4179 } 4180 for (int index = fromZorder; index <= toZorder; index++) { 4181 Component comp = getComponent(index); 4182 if (!comp.isLightweight()) { 4183 comp.applyCurrentShape(); 4184 } 4185 if (comp instanceof Container && 4186 ((Container)comp).hasHeavyweightDescendants()) { 4187 ((Container)comp).recursiveApplyCurrentShape(); 4188 } 4189 } 4190 } 4191 4192 private void recursiveShowHeavyweightChildren() { 4193 if (!hasHeavyweightDescendants() || !isVisible()) { 4194 return; 4195 } 4196 for (int index = 0; index < getComponentCount(); index++) { 4197 Component comp = getComponent(index); 4198 if (comp.isLightweight()) { 4199 if (comp instanceof Container) { 4200 ((Container)comp).recursiveShowHeavyweightChildren(); 4201 } 4202 } else { 4203 if (comp.isVisible()) { 4204 ComponentPeer peer = comp.getPeer(); 4205 if (peer != null) { 4206 peer.setVisible(true); 4207 } 4208 } 4209 } 4210 } 4211 } 4212 4213 private void recursiveHideHeavyweightChildren() { 4214 if (!hasHeavyweightDescendants()) { 4215 return; 4216 } 4217 for (int index = 0; index < getComponentCount(); index++) { 4218 Component comp = getComponent(index); 4219 if (comp.isLightweight()) { 4220 if (comp instanceof Container) { 4221 ((Container)comp).recursiveHideHeavyweightChildren(); 4222 } 4223 } else { 4224 if (comp.isVisible()) { 4225 ComponentPeer peer = comp.getPeer(); 4226 if (peer != null) { 4227 peer.setVisible(false); 4228 } 4229 } 4230 } 4231 } 4232 } 4233 4234 private void recursiveRelocateHeavyweightChildren(Point origin) { 4235 for (int index = 0; index < getComponentCount(); index++) { 4236 Component comp = getComponent(index); 4237 if (comp.isLightweight()) { 4238 if (comp instanceof Container && 4239 ((Container)comp).hasHeavyweightDescendants()) 4240 { 4241 final Point newOrigin = new Point(origin); 4242 newOrigin.translate(comp.getX(), comp.getY()); 4243 ((Container)comp).recursiveRelocateHeavyweightChildren(newOrigin); 4244 } 4245 } else { 4246 ComponentPeer peer = comp.getPeer(); 4247 if (peer != null) { 4248 peer.setBounds(origin.x + comp.getX(), origin.y + comp.getY(), 4249 comp.getWidth(), comp.getHeight(), 4250 ComponentPeer.SET_LOCATION); 4251 } 4252 } 4253 } | 788 addDelicately(comp, curParent, index); 789 790 // If the oldZindex == -1, the component gets inserted, 791 // rather than it changes its z-order. 792 if (!peerRecreated && oldZindex != -1) { 793 // The new 'index' cannot be == -1. 794 // It gets checked at the checkAdding() method. 795 // Therefore both oldZIndex and index denote 796 // some existing positions at this point and 797 // this is actually a Z-order changing. 798 comp.mixOnZOrderChanging(oldZindex, index); 799 } 800 } 801 } 802 803 /** 804 * Traverses the tree of components and reparents children heavyweight component 805 * to new heavyweight parent. 806 * @since 1.5 807 */ 808 @SuppressWarnings("deprecation") 809 private void reparentTraverse(ContainerPeer parentPeer, Container child) { 810 checkTreeLock(); 811 812 for (int i = 0; i < child.getComponentCount(); i++) { 813 Component comp = child.getComponent(i); 814 if (comp.isLightweight()) { 815 // If components is lightweight check if it is container 816 // If it is container it might contain heavyweight children we need to reparent 817 if (comp instanceof Container) { 818 reparentTraverse(parentPeer, (Container)comp); 819 } 820 } else { 821 // Q: Need to update NativeInLightFixer? 822 comp.getPeer().reparent(parentPeer); 823 } 824 } 825 } 826 827 /** 828 * Reparents child component peer to this container peer. 829 * Container must be heavyweight. 830 * @since 1.5 831 */ 832 @SuppressWarnings("deprecation") 833 private void reparentChild(Component comp) { 834 checkTreeLock(); 835 if (comp == null) { 836 return; 837 } 838 if (comp.isLightweight()) { 839 // If component is lightweight container we need to reparent all its explicit heavyweight children 840 if (comp instanceof Container) { 841 // Traverse component's tree till depth-first until encountering heavyweight component 842 reparentTraverse((ContainerPeer)getPeer(), (Container)comp); 843 } 844 } else { 845 comp.getPeer().reparent((ContainerPeer)getPeer()); 846 } 847 } 848 849 /** 850 * Adds component to this container. Tries to minimize side effects of this adding - 851 * doesn't call remove notify if it is not required. 852 * @since 1.5 4174 return; 4175 } 4176 // An invalid container with not-null layout should be ignored 4177 // by the mixing code, the container will be validated later 4178 // and the mixing code will be executed later. 4179 if (getLayout() != null && !isValid()) { 4180 return; 4181 } 4182 for (int index = fromZorder; index <= toZorder; index++) { 4183 Component comp = getComponent(index); 4184 if (!comp.isLightweight()) { 4185 comp.applyCurrentShape(); 4186 } 4187 if (comp instanceof Container && 4188 ((Container)comp).hasHeavyweightDescendants()) { 4189 ((Container)comp).recursiveApplyCurrentShape(); 4190 } 4191 } 4192 } 4193 4194 @SuppressWarnings("deprecation") 4195 private void recursiveShowHeavyweightChildren() { 4196 if (!hasHeavyweightDescendants() || !isVisible()) { 4197 return; 4198 } 4199 for (int index = 0; index < getComponentCount(); index++) { 4200 Component comp = getComponent(index); 4201 if (comp.isLightweight()) { 4202 if (comp instanceof Container) { 4203 ((Container)comp).recursiveShowHeavyweightChildren(); 4204 } 4205 } else { 4206 if (comp.isVisible()) { 4207 ComponentPeer peer = comp.getPeer(); 4208 if (peer != null) { 4209 peer.setVisible(true); 4210 } 4211 } 4212 } 4213 } 4214 } 4215 4216 @SuppressWarnings("deprecation") 4217 private void recursiveHideHeavyweightChildren() { 4218 if (!hasHeavyweightDescendants()) { 4219 return; 4220 } 4221 for (int index = 0; index < getComponentCount(); index++) { 4222 Component comp = getComponent(index); 4223 if (comp.isLightweight()) { 4224 if (comp instanceof Container) { 4225 ((Container)comp).recursiveHideHeavyweightChildren(); 4226 } 4227 } else { 4228 if (comp.isVisible()) { 4229 ComponentPeer peer = comp.getPeer(); 4230 if (peer != null) { 4231 peer.setVisible(false); 4232 } 4233 } 4234 } 4235 } 4236 } 4237 4238 @SuppressWarnings("deprecation") 4239 private void recursiveRelocateHeavyweightChildren(Point origin) { 4240 for (int index = 0; index < getComponentCount(); index++) { 4241 Component comp = getComponent(index); 4242 if (comp.isLightweight()) { 4243 if (comp instanceof Container && 4244 ((Container)comp).hasHeavyweightDescendants()) 4245 { 4246 final Point newOrigin = new Point(origin); 4247 newOrigin.translate(comp.getX(), comp.getY()); 4248 ((Container)comp).recursiveRelocateHeavyweightChildren(newOrigin); 4249 } 4250 } else { 4251 ComponentPeer peer = comp.getPeer(); 4252 if (peer != null) { 4253 peer.setBounds(origin.x + comp.getX(), origin.y + comp.getY(), 4254 comp.getWidth(), comp.getHeight(), 4255 ComponentPeer.SET_LOCATION); 4256 } 4257 } 4258 } |