Générateur d'images fractales (8)

11032009 Dans: Pas à pas

À force de jouer avec le générateur, quelque chose me chagrine: un nouvel utilisateur ne saurait même pas qu'il peut agir sur la vue à la souris. Nous allons donc modifier son pointeur pour apporter cette information.

Comportement voulu

Voici le fonctionnement que j'attends:

  • Fèches haut/basQuand on appuie sur la touche Contrôle, le curseur de la souris doit se transformer en flèches. Ceci, dès que le pointeur se trouve dans la vue.
  • Main ouverte Sinon, si le bouton n'est pas appuyé, le curseur est une main ouverte.
  • Main ferméeS'il est appuyé, une main fermé.

Changer le pointeur

Je vais déjà vous expliquer comment fonctionne ce système de curseurs sous Cocoa, la doc d'Apple me semblant assez indigeste pour quelque chose d'aussi simple.

La classe NSCursor dispose d'un ensemble de méthodes de classes qui renvoient un nouvel NSCursor, ayant des apparences diverses (croix, main, flèches, etc.). Fixer le pointeur est aussi simple que ceci:

[[crosshairCursor] set];

Qui donnera une apparence de croix au pointeur.

Cependant, NSCursor possède un mécanisme plus élaboré, basé sur une pile:

  • Quand une instance de NSCursor reçoit un appel à -[NSCursor push], cette instance devient le curseur courant, et l'ancien curseur est empilé.
  • Quand la classe NSCursor reçoit un appel à +[NSCursor pop], le curseur sur le haut de la pile est retiré et devient le nouveau curseur.

C'est ce mécanisme que nous allons utiliser, puisqu'il nous simplifie la vie, en mémorisant dans quel état il faut remettre le curseur.

Événements clavier

Il nous faut surveiller l'appui sur la touche Contrôle:

- (void)flagsChanged:(NSEvent *)theEvent
{
    if(pointeurDansLaVue)
    {

-[NSResponder flagsChanged:] est appelée dès qu'une touche spéciale est appuyée, que le pointeur soit dans la vue ou non.
J'ai donc créé une variable d'instance pointeurDansLaVue. Nous fixerons sa valeur dans les méthodes indiquant l'entrée ou la sortie du pointeur de la vue.

        if([theEvent modifierFlags] & NSControlKeyMask)

On regarde si la touche Contrôle est appuyée.

            [[NSCursor resizeUpDownCursor] push];

On change le curseur (en mémorisant l'ancien).

        else
            [NSCursor pop];

Sinon, Contrôle n'est plus appuyée: il faut rétablir le curseur précédent.

    }
}

Il faut également rajouter ce code:

- (BOOL) acceptsFirstResponder
{
    return YES;
}

Autrement, nous ne recevrions pas les événements clavier.

Entrée et sortie de la vue

Tracking Area

Cocoa propose de surveiller la position du pointeur par le biais de la classe NSTrackingArea, qui représente un rectangle de la vue. Ajoutons les variables d'instance:

@interface CFRFractalView : NSView {
    IBOutlet CFRMandelbrotRender* render;

    NSTrackingArea* trackingArea;   
    BOOL pointeurDansLaVue; 
}

Et initialisons-les:

- (id)initWithFrame:(NSRect)frame {
    self = [super initWithFrame:frame];
    if (self)
    {
        trackingArea = nil;
        pointeurDansLaVue = NO;
    }
    return self;
}

Apple conseille de créer les tracking areas lorsque la vue est insérée dans la fenêtre:

- (void)viewDidMoveToWindow
{
    trackingArea = [[NSTrackingArea alloc] initWithRect:[self bounds] 
        options:(NSTrackingMouseEnteredAndExited 
        | NSTrackingInVisibleRect | NSTrackingActiveInKeyWindow) 
        owner:self 
        userInfo:nil];

Nous fournissons à la méthode d'initialisation:

  • le rectangle définissant la tracking area
    Nous lui passons le rectangle définissant la vue. Il s'agit du rectangle de départ, la tracking area changeant de dimensions lors des redimensionnements de la vue.
  • Des options, combinées par l'opérateur OU:
    • NSTrackingMouseEnteredAndExited indique que nous voulons que les méthodes -mouseEntered: et -mouseExited: soient appelées lors de l'entrée, respectivement de la sortie du pointeur.
    • NSTrackingInVisibleRect nous permet de ne pas nous préoccuper de redimensionner la tracking area.
    • NSTrackingActiveInKeyWindow dit de ne surveiller le pointeur que quand la fenêtre est active.
  • owner est le propriétaire de la tracking area. Il est possible de déléguer cette gestion, mais ici c'est notre vue qui s'en occupe.
  • userInfo permet de passer des informations à l'intérieur du NSEvent reçues par les méthodes d'événement. Inutile pour nous.

    [self addTrackingArea:trackingArea];
    

    }

Nous associons ensuite la tracking area à la vue.

Événements mouseEntered et mouseExited

- (void)mouseEntered:(NSEvent *)theEvent
{
    [[NSCursor openHandCursor] push];
    pointeurDansLaVue = YES;
}

Quand le pointeur entre dans la vue, nous changeons le curseur en une main ouverte, et mettons à jour pointeurDansLaVue, nécessaire à la méthode -flagsChanged: décrite plus haut.

- (void)mouseExited:(NSEvent *)theEvent
{
    pointeurDansLaVue = NO;
    [NSCursor pop];
}

Quand le pointeur sort de la vue, nous rétablissons le curseur précédent, a priori la flèche normale.

Événements mouseDown et mouseUp

- (void)mouseUp:(NSEvent *)theEvent
{
    [NSCursor pop]; 
}

Lorsque le bouton de la souris est relâché, nous rétablissons le curseur précédent.

Pour les clics:

- (void)mouseDown:(NSEvent *)theEvent
{

Lors d'un clic…

    if([theEvent modifierFlags] & NSControlKeyMask)
    {

… si la touche Contrôle est appuyée…

        [[NSCursor resizeUpDownCursor] push];

Utiliser un curseur en formes de doubles-flèches. À vrai dire, ce curseur est déjà le curseur actuel (puisque la touche Contrôle a été enfoncée avant le clic), mais cet appel permet de contrebalancer le [NSCursor pop] de la méthode -mouseDown:…

    }
    else
    {
        [[NSCursor closedHandCursor] push];

… appel lui même nécessaire pour contrebalancer cet appel à adopter un curseur en main fermée.

    }
}

Nous en avons fini avec ces histoires de curseurs. Je vous accorde que ça semble un peu bricolé, mais on ne peut guère faire autrement.

Résultat

Il n'y a plus qu'à essayer: ça fait tout de suite beaucoup plus pro !

Version de Mac OS X

La classe NSTrackingArea fut introduite avec Mac OS 10.5. Autrefois, on utilisait le mécanisme des tracking rectangles, qui est similaire mais plus compliqué à mettre en œuvre. Toujours est-il que nous perdons la compatibilité avec les anciens systèmes, alors prévenons leurs utilisateurs avec un joli message d'erreur. Pour cela:

  • Clic droit sur Info.plist > Open As > Plain Text File
  • avant la balise </dict> finale, insérez:
    <key>LSMinimumSystemVersion</key>
    <string>10.5.0</string>

À bientôt pour la suite.

Le projet XCode complet à télécharger.

Renaud Pradenc
Céroce.com

Générateur d'images fractales (7)

05032009 Dans: Pas à pas

Aujourd'hui nous allons permettre — enfin ! — de se déplacer dans l'ensemble de Mandelbrot.

Retirer la mesure de performance

Commencez par ouvrir MyDocument.xib et retirez l'instance de CFRMesurePerf qui ne nous est plus nécessaire.

Navigation

L'utilisateur naviguera de la façon suivante:

  • se déplacer sur le repère se fait en glissant la souris avec le bouton principal (gauche) appuyé.
  • le zoom se fait grâce à la molette de la souris, ou pour les souris qui n'en seraient pas pourvues, en maintenant la touche Contrôle appuyée, et en glissant la souris avec le bouton appuyé.

Le déplacement

Rappelez-vous que la classe CFRMandelbrotRender contient une variable d'instance centre:

Complexe_t centre;  // Centre du repère

De fait, se déplacer dans l'ensemble consiste à déplacer le centre du repère, à recalculer la bitmap et à l'afficher.

Glissé de la souris

Je vous rappelle que NSView hérite de NSResponder. Or, la méthode -[NSReponder mouseDragged:] est appelée lorsque la souris est glissée sur la vue, avec le bouton principal appuyé :

- (void)mouseDragged:(NSEvent *)theEvent
{

    // Déplacer le centre de la vue
    [render decalerCentreX:-[theEvent deltaX] 
                        y:[theEvent deltaY]];

Je vais revenir tout de suite sur la méthode decalerCentreX:y:. Les méthodes -[NSEvent deltaX] et -[NSEvent deltaY] permettent d'obtenir le nombre de points dont s'est déplacé le pointeur de la souris pendant le glissé.

    [self setNeedsDisplay:YES];
}

Cette méthode demande à la vue se réafficher dans la prochaine boucle d'affichage : la méthode -drawRect: sera appelée à nouveau.

Décaler le centre

Venons-en à la méthode -[CRFMandelbrotRender decalerCentreX:y:]. Nous avons ici une conversion d'échelle à faire. En effet, les décalages lui sont exprimés en pixels, et il nous faut les exprimer en coordonnées "repère":

- (void) decalerCentreX:(NSInteger)pixelsHoriz
                    y:(NSInteger)pixelsVerti
{
    double facteurReperePixel = largeur / largeurBitmap;

D'abord, nous calculons le rapport d'échelle entre la largeur du repère, et celle de la bitmap (en pixels, comme la vue).

    double deltaX = pixelsHoriz * facteurReperePixel;
    double deltaY = pixelsVerti * facteurReperePixel;

Nous appliquons alors ce facteur aux décalages en pixels pour obtenir les décalages en coordonnées "repère".

    centre.reel += deltaX;
    centre.imag += deltaY;
}

Enfin, nous translatons le centre du repère.

Et voilà, lancez le programme, ça fonctionne.

Le zoom à la molette

Zoomer

Zoomer consiste à modifier la variable largeur de CFRMandelbrotRender, qui représente la largeur de l'intervalle de calcul:

double largeur;

Ainsi, si vous divisez la largeur par 2, vous zoomez de 200%; si vous multipliez la largeur par 2, vous dézoomez de 50%:

- (void) zoomerDuFacteur:(double)facteur
{
    largeur = largeur * facteur;

    // Corriger les valeurs extrêmes
    if(largeur < 0.0001)
        largeur = 0.0001;
    else if(largeur > 8.0)
        largeur = 8.0;
}

J'ai ajouté la correction des valeurs extrêmes après quelques essais . Les limites sont empiriques; d'ailleurs, nous changerons sans doute la limite basse un jour.

Gestion de la molette

Quand la molette est actionnée, la méthode -[NSResponder scrollWheel:] est appelée:

- (void)scrollWheel:(NSEvent *)theEvent
{
    // deltaY est > 0 quand la molette est tournée en avant.
    //  Il vaut +/- 0.1 pour un petit mouvement et +/- 10 pour un grand.
    double deltaY = [theEvent deltaY];

Il m'a fallu faire quelques essais pour régler l'amplitude du zoom. J'ai mesuré que tourner lentement la molette vers l'avant donnait un deltaY aux alentours de 0,1, et la tourner vite, autour de 10.
deltaY est négatif quand on la molette est tournée vers l'arrière.

    [render zoomerDuFacteur: 1.0 + deltaY/20.0];

La division par 20 de deltaY est là encore empirique. Par exemple, en tournant rapidement la molette vers l'arrière, vous obtenez un facteur de zoom de l'ordre de 1+ (-10)/20) = 0.5, soit un zoom x2.

    [self setNeedsDisplay:YES];
}

Lancez le programme: ça zoome !

Le zoom par Contrôle + glissé

Modifions la méthode -mouseDragged:

- (void)mouseDragged:(NSEvent *)theEvent
{
    // La touche Contrôle est-elle appuyée ?
    if([theEvent modifierFlags] & NSControlKeyMask)
    {

Il nous faut d'abord savoir si la touche Contrôle est appuyée pour distinguer les deux type de glissés.

        // Zoomer/dézoomer
        double deltaRelatif = 2.0 * ([theEvent deltaY] / [self bounds].size.height);

Par soucis d'ergonomie, ce qui nous intéresse, n'est pas le déplacement absolu de la souris, mais son déplacement relatif. D'où le calcul de deltaY/(hauteur de la vue). J'ai ensuite ajouté un facteur 2, déterminé — vous l'aurez deviné — de façon empirique.

        [render zoomerDuFacteur: 1.0 + deltaRelatif];
    }
    else
    {
        // Déplacer le centre de la vue
        [render decalerCentreX:-[theEvent deltaX] y:[theEvent deltaY]];     
    }
    [self setNeedsDisplay:YES];
}

Le reste a déjà été expliqué.

Le résultat

Lancez le programme, et admirez le résultat. Personnellement, je trouve l'affichage encore un peu lent.

En zoomant loin en avant, on reconnaît enfin la structure "fractale" de l'ensemble (le même motif se répétant à des échelles différentes).

Répétitions de la structure fractale

Zoom sur un détail Cependant, les détails ne sont alors plus très présents. C'est parce que nous avons fixé le nombre d'itérations maximales trop bas. Heureusement, nous permettrons prochainement de modifier ce seuil.

À bientôt.

Le projet XCode complet à télécharger.

Renaud Pradenc
Céroce.com


Sponsors