UIScrollView zoomToRect pas de zoom donné rect (créé à partir de UITouch CGPoint)

Ma demande a un UIScrollView avec une sous-vue. La sous-vue est prolongée d'une UIView qui imprime une page PDF pour elle-même à l'aide de calques dans le drawLayer événement.

Zoom en utilisant le construit en pinçant fonctionne très bien. setZoomScale fonctionne également comme prévu.

J'ai été aux prises avec la zoomToRect fonction. J'ai trouvé un exemple en ligne, ce qui rend une CGRect zoomRect variable à partir d'une donnée CGPoint.

Dans le touchesEnded fonction, si il y avait un double tap et ils sont tout le chemin de zoom, je veux effectuer un zoom avant sur PDFUIView j'ai créé comme s'ils étaient les pinçant avec le centre de la pince, où ils double-exploité.

Donc supposer que je passe le UITouch variable à ma fonction qui utilise zoomToRect si ils touchez deux fois.

J'ai commencé avec la fonction suivante que j'ai trouvé sur les pommes de site:

http://developer.apple.com/iphone/library/documentation/WindowsViews/Conceptual/UIScrollView_pg/ZoomZoom/ZoomZoom.html

Ce qui suit est une version modifiée pour mon UIScrollView classe étendue:

- (void)zoomToCenter:(float)scale withCenter:(CGPoint)center {     

    CGRect zoomRect;
    zoomRect.size.height = self.frame.size.height / scale;
    zoomRect.size.width  = self.frame.size.width  / scale;

    zoomRect.origin.x = center.x - (zoomRect.size.width  / 2.0);
    zoomRect.origin.y = center.y - (zoomRect.size.height / 2.0); 

    //return zoomRect;

    [self zoomToRect:zoomRect animated:YES];

}

Quand je fais cela, le UIScrollView semble zoom en utilisant le bas du bord droit de la zoomRect ci-dessus et non au centre.

Si je fais UIView comme ce

UIView *v = [[UIView alloc] initWithFrame:zoomRect]; 
[v setBackgroundColor:[UIView redColor]];
[self addSubview:v];

Le rouge de la boîte de montre avec le point de contact de morts dans le centre.

Note: je suis en train d'écrire cela à partir de mon PC, je me souviens de déconner avec les divisée en deux partie sur mon Mac, il suffit de supposer que ceci dessine un rectangle avec le point de contact dans le centre. Si le UIView a attiré hors du centre, mais agrandie vers le bon endroit, il serait tout bon.

Cependant, ce qui se passe, c'est quand il préformes la zoomToRect il semble qu'il utilise en bas à droite au large de la zoomRect en haut à gauche de l'agrandissement dans les résultats.

Aussi, j'ai remarqué que selon l'endroit où je clique sur le UIScrollView, il ancres différentes taches. Il semble presque comme il y a une croix au milieu, et qui reflète les points en quelque sorte comme si n'importe où à gauche du centre est un négatif de réflexion et de n'importe où à droite du centre est un reflet positif?

Cela semble compliqué, n'est-ce pas juste de zoom à l'rect qui a été établi que la UIView était en mesure de tirer?

J'ai utilisé beaucoup de recherches pour comprendre comment créer un document PDF que les échelles de haute qualité, donc je suis en supposant que l'utilisation de la CALayer peut être en déréglant le système de coordonnées? Mais à la UIScrollView il faut juste le traiter comme un point de vue avec 768x985 dimensions.

C'est un peu avancée, veuillez prendre le code pour la création de la zoomRect est tout bon. Il y a quelque chose de plus profond avec la CALayer dans le UIView qui est dans le UIScrollView....

OriginalL'auteur pmhart | 2010-03-05

4

Ok une autre réponse:

L'apple fourni routine qui fonctionne pour moi, mais vous avez besoin d'avoir le geste de reconnaissance convertir le touchez point à l'imageView coords - pas à la molette.

Apple exemple de cela, mais depuis que notre application fonctionne différemment (on changer la UIImageView), de sorte que le gestureRecongnizer a été mis en place sur le uiscrollview - qui fonctionne très bien, mais vous devez le faire dans le handleDoubleTap:

C'est vaguement basé sur l'apple exemple de code "TaptoZoom", mais comme je l'ai dit, nous avons besoin de notre geste de reconnaissance accroché à défilement de la vue.
```
- (void)handleDoubleTap:(UIGestureRecognizer *)gestureRecognizer {
    //double tap zooms in
    [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(handleSingleTap:) object:nil];
    float newScale = [imageScrollView zoomScale] * 1.5;
    //Note we need to get location of the tap in the imageView coords, not the imageScrollView
    CGRect zoomRect = [self zoomRectForScale:newScale withCenter:[gestureRecognizer locationInView:imageView]];
    [imageScrollView zoomToRect:zoomRect animated:YES];
}
```
Merci @Tom, la conversion de l'emplacement de l'affichage de l'image a fonctionné!
Ce qui est excellent. A travaillé pour moi.

OriginalL'auteur Tom Andersen

   Declare BOOL isZoom; in .h


     -(void)handleDoubleTap:(UIGestureRecognizer *)recognizer {  
            if(isZoom){
                CGPoint Pointview=[recognizer locationInView:self];
                CGFloat newZoomscal=3.0;

                newZoomscal=MIN(newZoomscal, self.maximumZoomScale);

                CGSize scrollViewSize=self.bounds.size;

                CGFloat w=scrollViewSize.width/newZoomscal;
                CGFloat h=scrollViewSize.height /newZoomscal;
                CGFloat x= Pointview.x-(w/2.0);
                CGFloat y = Pointview.y-(h/2.0);

                CGRect rectTozoom=CGRectMake(x, y, w, h);
                [self zoomToRect:rectTozoom animated:YES]; 

                [self setZoomScale:3.0 animated:YES]; 
                isZoom=NO;
            }
            else{ 
                [self setZoomScale:1.0 animated:YES]; 
                isZoom=YES;
            }
        }

OriginalL'auteur Hardik Darji

1

J'ai remarqué que l'apple que vous utilisez n'a pas de zoom correctement si l'image est en commençant à une zoomScale moins de 1 parce que le zoomRect origine est incorrect. J'ai édité pour fonctionner correctement. Voici le code:
```
- (CGRect)zoomRectForScale:(float)scale withCenter:(CGPoint)center {

CGRect zoomRect;

//the zoom rect is in the content view's coordinates. 
//   At a zoom scale of 1.0, it would be the size of the imageScrollView's bounds.
//   As the zoom scale decreases, so more content is visible, the size of the rect grows.
zoomRect.size.height = [self frame].size.height / scale;
zoomRect.size.width  = [self frame].size.width / scale;


//choose an origin so as to get the right center.
zoomRect.origin.x = (center.x * (2 - self.minimumZoomScale) - (zoomRect.size.width  / 2.0));
zoomRect.origin.y = (center.y * (2 - self.minimumZoomScale) - (zoomRect.size.height / 2.0));

return zoomRect;
}
```
La clé est cette partie multipliant la valeur centrale (2 - auto.minimumZoomScale).
Espérons que cette aide.

fin de commentaire, mais je ne pouvais pas résister ; si cela fonctionne: c'est de la pure chance. Multipliant les coordonnées d'un centre ne fait rien de significatif. Si vous avez besoin d'effectuer une traduction d'un centre, vous ajouter une valeur à la place. Mais plus probablement, le centre est incorrect parce qu'il a été calculé à partir du mauvais système de coordonnées de référence (par exemple, de la mauvaise vue)

OriginalL'auteur Jonah

Dans mon cas, c'était:

zoomRect.origin.x    = center.x / self.zoomScale - (zoomRect.size.width  / 2.0);
zoomRect.origin.y    = center.y / self.zoomScale  - (zoomRect.size.height / 2.0);

OriginalL'auteur Alex

0

J'ai eu quelque chose de similaire et c'était parce que je n'ai pas ajuster le centre.x et au centre.les valeurs de y en les divisant par l'échelle (à l'aide de centre.x/mise à l'échelle et au centre.y/mise à l'échelle). Peut-être que je ne suis pas la lecture de votre code de droit.

OriginalL'auteur Matthias
0

Je vais avoir le même problème et c'est assez frustrant... Le rectangle d'être nourri à la UIScrollView est parfait.. pourtant mon point de vue, peu importe ce que je fais tout ce qui implique la modification de la zoomScale par programmation toujours des zooms et des échelles de coordonner 0,0, n'importe quoi.

J'ai essayé en changeant simplement le zoomScale, j'ai essayé zoomToRect, j'ai tout essayé, et chacun la minute où je touche le zoomScale dans le code, il va de coordonnées 0,0.

Je n'ai également ajouter et explicite setContentSize à l'image redimensionnée dans la scrollview après une opération de zoom, ou sinon je ne peut pas défiler après un zoom ou de pincement.

Est-ce un bug 3.1.3 ou quoi?

OriginalL'auteur Speckpgh

J'ai essayé différentes solutions, mais cela semble la meilleure solution
Il est vraiment simple et conceptuelle?

CGRect frame = [[UIScreen mainScreen] applicationFrame];
scrollView.contentInset = UIEdgeInsetsMake(frame.size.height/2,
                 frame.size.width/2,
                 frame.size.height/2,
                 frame.size.width/2);

OriginalL'auteur jold

0

Je suis en désaccord avec l'un des commentaires ci-dessus en disant que vous ne devriez jamais vous multipliez le centre des coordonnées par un certain facteur.

Dire que vous êtes en train d'afficher un ensemble de 400x400px image ou un fichier PDF dans un 100x100 défilement de vue et que vous voulez autoriser les utilisateurs à doubler la taille du contenu jusqu'à ce qu'il est 1:1.
Si vous appuyez deux fois sur au point (75,75), vous vous attendez à zoom-dans le rectangle d'origine ont 100,100 et la taille 100x100 au sein de la nouvelle 200x200 l'affichage du contenu. Alors l'original tapant point (75,75) est maintenant (150,150) dans le nouveau 200x200 espace.

Maintenant, après zoom action n ° 1 est terminé, si vous avez de nouveau un double tap (75,75) à l'intérieur de la nouvelle 100x100 rectangle (qui est le carré en bas à droite de la grande 200x200 rectangle), vous vous attendez à l'utilisateur d'être montré en bas à droite 100x100 carré de la plus grande image, qui serait désormais zoom de 400x400 pixels.

Afin de calculer l'origine de cette dernière 100x100 rectangle à l'intérieur de la plus grande 400x400 rectangle, vous devez envisager l'ampleur et le contenu actuel de décalage (puisque avant cette dernière zoom action nous montraient le coin inférieur droit de la 100x100 rectangle à l'intérieur d'un 200x200 contenu rectangle).

Si la coordonnée x de la finale rectangle devient:
centre de.x/currentScale - (scrollView.cadre.taille.largeur/2) + scrollView.contentOffset.x/currentScale
= 75/.5- 100/2 + 100/.5= 150 - 50 + 200 = 300.

Dans ce cas, être un carré, le calcul de la coordonnée y est la même.
Et nous n'avons en effet de zoom dans le coin inférieur droit de 100x100 rectangle, qui, dans la plus grande 400x400 d'affichage de contenu a l'origine 300,300.

Donc, voici comment vous calculez le zoom du rectangle de la taille et de l'origine:
zoomRect.taille.hauteur = mScrollView.cadre.taille.hauteur/mise à l'échelle;
zoomRect.taille.largeur = mScrollView.cadre.taille.largeur/taille; de
```
zoomRect.origin.x = center.x/currentScale - (mScrollView.frame.size.width/2) + mScrollView.contentOffset.x/currentScale;
zoomRect.origin.y = center.y/currentScale - (mScrollView.frame.size.height/2) + mScrollView.contentOffset.y/currentScale;
```
Espérons que cela a du sens; c'est difficile à expliquer par écrit, sans esquisser les différents carrés/rectangles.

Cheers,
Raf Colasante

OriginalL'auteur Raffaello Colasante

Vous devez vous connecter pour publier un commentaire.