Définir CGRectmake avec CGPoint et/ou CGSize

C'est une question très simple dont je n'arrive pas à trouver la réponse.
Comment faire :

CGRectMake(1, 3, size)

CGRectMake(pointB, size)

 CGRectMake(pointB, size.width, size.height)

au lieu de

CGRectMake(self.someview.frame.origin.x, self.someview.frame.origin.y, self.someotherview.frame.size.width, self.someotherview.frame.size.height)

??
Merci!!!! 🙂

EDIT:

La méthode CGRectmake prend CGFloat. Je voudrais qu'il prenne CGSize, et/ou CGpoint comme arguments de la méthode.

double possible de Comment puis-je créer un CGRect à partir d'un CGPoint et CGSize?

OriginalL'auteur Plot | 2013-01-28

Je pense que c'est ce que vous avez à l'esprit:

    - (void) logRects
    {
        CGFloat
            x      = 10.0,
            y      = 20.0,
            width  = 50.0,
            height = 60.0;

        CGPoint point = {x, y};
        CGSize  size  = {width, height};

        CGRect  rect1 = {1, 3, size};
        CGRect  rect2 = {point, size};
        CGRect  rect3 = {point, size.width, size.height};

            //using designated (named) initialisers
        CGRect  rect4 = {.origin.x=3, .origin.y=5, .size = {100,100}};

            //with designated initialisers, order doesn't matter
        CGRect  rect5 = {.size=size, .origin.x=3, .origin.y=5};

        NSLog (@"rect1 %@",NSStringFromCGRect(rect1));
        NSLog (@"rect2 %@",NSStringFromCGRect(rect2));
        NSLog (@"rect3 %@",NSStringFromCGRect(rect3));
        NSLog (@"rect4 %@",NSStringFromCGRect(rect4));
        NSLog (@"rect5 %@",NSStringFromCGRect(rect5));
    }

Mais note de la discussion ici:

Pourquoi utiliser des fonctions comme CGRectMake?

Ce type de composé de la syntaxe littérale me semble beaucoup plus facile à lire et à écrire, bien que les fonctions ont l'avantage lorsqu'il s'agit de futureproofing ( + de saisie semi-automatique).

mise à jour

voir aussi cette plus récente q&a:

CGRect de syntaxe, je n'ai pas vu avant

OriginalL'auteur foundry

6

CGRectMake(1, 3, taille):
```
    CGRectMake(1, 3, size.width, size.heigh)
```
CGRectMake(pointB, taille):
```
    CGRectMake(pointB.x, pointB.y, size.width, size.height)
```
CGRectMake(pointB, taille.la largeur, la taille.hauteur):
```
    CGRectMake(pointB.x, pointB.y, size.width, size.height)
```
Un CGRect ressemble à ceci:
```
struct CGRect {
  CGPoint origin;
  CGSize size;
};
typedef struct CGRect CGRect;
```
Et CGPoint et CGSize juste ressembler à ceci:
```
struct CGPoint {
  CGFloat x;
  CGFloat y;
};
typedef struct CGPoint CGPoint;

struct CGSize {
  CGFloat width;
  CGFloat height;
};
typedef struct CGSize CGSize;
```
CGRectMake est la fonction suivante:
```
CG_INLINE CGRect
CGRectMake(CGFloat x, CGFloat y, CGFloat width, CGFloat height)
{
  CGRect rect;
  rect.origin.x = x; 
  rect.origin.y = y;
  rect.size.width = width; 
  rect.size.height = height;
  return rect;
}
```
Ainsi, au lieu de:
```
CGRect r = CGRectMake(pointB.x, pointB.y, size.width, size.height)
```
Vous pouvez simplement écrire:
```
CGRect r;

r.origin = pointB;
r.size = size;
```
Si vous avez envie de créer votre propre CGRectMake, n'hésitez pas à le faire:
```
CG_INLINE CGRect
MyPrivateCGRectMake(CGPoint p, CGSize s)
{
  CGRect rect;
  rect.origin = p;
  rect.size = s;
  return rect;
}
```
Mais il n'y a aucun moyen que vous pouvez modifier les arguments d'une fonction accepte.

En fait c'est ce que je veux éviter ! Si vous avez pointB et de la taille, pourquoi devriez-vous réécrire .x, .y, .la largeur ou la.la hauteur ? Vos réponses CGFloats. Je voudrais CGRectmake de prendre CGSize, et/ou CGpoint int sa méthode
se comporte de la façon qu'il a été défini, pas de la manière que vous aimeriez qu'il se comporter. CGRectMake tout simplement ne fonctionne pas de cette façon, il n'est pas possible de changer la façon dont il fonctionne. Vous pouvez écrire votre propre fonction si vous le souhaitez, MyCGRectMake qui prend un point et une taille en paramètre, mais il n'y a aucun moyen que vous pouvez modifier les paramètres de CGRectMake.
Ok merci. Je pense que j'ai vu mon patron le faire une fois, et je ne me souviens pas comment...
Vous pouvez définir une macro, mais vous auriez encore de le nommer différemment CGRectMake, sinon la macro de manière récursive d'appel lui-même qui mène à une erreur de compilation.
Ahhh oui bonne idée!!!! Je vais essayer ça 🙂 merci !

OriginalL'auteur Mecki

Vous devez vous connecter pour publier un commentaire.