NativeWindow  - AS3

Indique si cette fenêtre est la fenêtre de l’application active.

Utilisez la méthode activate() pour activer une fenêtre.

Eléments de l’API associés

Spécifie si cette fenêtre est toujours devant d’autres fenêtres (y compris celles d’autres applications).

Il existe deux groupes de fenêtres dans l’ordre de profondeur du système. Les fenêtres du groupe alwaysInFront sont toujours affichées devant toutes les autres fenêtres. L’ordre de profondeur entre des fenêtres du même groupe est déterminé normalement. En d’autres termes, l’activation d’une fenêtre la déplace devant d’autres fenêtres de son groupe.

Si vous changez alwaysInFront de false à true, la fenêtre est déplacée au-dessus de toutes les autres fenêtres. Si vous changez la propriété de true à false, la fenêtre est déplacée à l’arrière des fenêtres « alwaysInFront », mais toujours devant d’autres fenêtres. Si vous réglez la propriété sur sa valeur actuelle, l’ordre de profondeur de la fenêtre ne change pas. La définition de la propriété alwaysInFront d’une fenêtre ayant une fenêtre propriétaire est sans effet.

La propriété alwaysInFront ne doit que rarement être définie sur true car les fenêtres ayant ce réglage apparaissent devant les fenêtres d’autres applications même lorsque l’autre application est active.

Remarques concernant le comportement du SE :

• Sous Linux, certains gestionnaires de fenêtres n’affichent pas les fenêtres dont la propriété alwaysInFront est définie sur devant des fenêtres plein écran.
• Sous Mac^® OS X, le réglage de alwaysInFront sur true est sans effet lorsque la propriété displayState de la scène de la fenêtre est fullScreen ou fullScreenInteractive.

windowObj.alwaysInFront = true;

displayObject.stage.nativeWindow.alwaysInFront=true;

window.nativeWindow.alwaysInFront = true;

La taille et l’emplacement de cette fenêtre.

Les dimensions d’une fenêtre incluent les chromes système. Les dimensions de la scène d’une fenêtre équivalent à celles de la fenêtre, moins la taille des chromes système. La modification de la largeur et de la hauteur de la fenêtre change les stageWidth et stageHeight de la scène. Le contraire s’applique également ; la modification des dimensions de la scène change la taille de la fenêtre.

Dans une fenêtre HTML racine, les propriétés outerWidth et outerHeigth équivalent aux propriétés height et width de la fenêtre. Les propriétés innerWidth et innerHeight équivalent aux propriétés stage.stageWidth et stage.stageHeight, moins l’épaisseur des barres de défilement automatiques affichées par la fenêtre.

Un événement resize est distribué chaque fois que la largeur ou la hauteur de cette fenêtre change. De même, un événement move est distribué chaque fois que l’origine (x,y) de cette fenêtre change. Sous Mac OS et Windows, la définition directe de la propriété bounds ne distribue pas d’événement moving ou resizing. Toutefois, sous Linux, l’objet NativeWindow distribue un événement moving et resizing lorsque vous définissez la propriété bounds.

La définition de la propriété bounds d’une fenêtre équivaut à la définition de ses propriétés x, y, width et height. De même, définir l’une des dimensions individuelles revient à définir la propriété bounds. Lorsque vous définissez simultanément toutes les dimensions via la propriété bounds, moins d’événements sont distribués.

L’ordre dans lequel sont définies les dimensions individuelles n’est pas garanti. Sur les gestionnaires de fenêtres de Linux qui ne permettent pas d’agrandir les fenêtres au-delà de la zone du bureau, il est possible de bloquer la modification d’une propriété individuelle, même si la modification de toutes les propriétés aurait de toute façon entraîné la création d’une fenêtre autorisée.

Si la largeur ou la hauteur spécifiée est inférieure à la largeur ou hauteur minimale, ou supérieure à la largeur ou hauteur maximale autorisée, la largeur ou la hauteur de la fenêtre est définie sur la taille autorisée la plus proche. Les facteurs qui déterminent les largeurs et les hauteurs minimales et maximales sont les suivants :

• Propriétés minSize et maxSize de l’objet NativeWindow
• Limites minimales et maximales du système d’exploitation, qui sont les valeurs de NativeWindow.systemMinSize et NativeWindow.systemMaxSize
• Largeur et hauteur maximales d’une fenêtre dans Adobe AIR, chacune de 4 095 pixels. (Dans AIR 1.5 et les versions antérieures, la largeur et la hauteur maximales d’une fenêtre sont de 2 880 pixels chacune.)
• Largeur et hauteur minimales requises par tout chrome système affiché.

Les valeurs en pixels sont arrondies au nombre entier le plus proche lorsque la position ou les dimensions d’une fenêtre sont modifiées.

Eléments de l’API associés

windowObj.bounds = new Rectangle(200, 200, 1000, 800);

displayObject.stage.nativeWindow.bounds = new Rectangle(20, 20, 800, 600);

window.nativeWindow.bounds = new air.Rectangle(20, 20, 800, 600);

Indique si cette fenêtre a été fermée.

L’accès aux propriétés suivantes dans une fenêtre fermée renvoie une erreur d’opération non autorisée :

• title
• bounds
• x, y, width, height
• displayState
• visible

De même, l’appel des méthodes suivantes sur une fenêtre fermée renvoie également une erreur d’opération non autorisée :

• minimize()
• maximize()
• restore()
• startResize()
• startMove()

var isWindowClosed:Boolean = windowObj.closed;

var isWindowClosed:Boolean = displayObject.stage.nativeWindow.closed;

var isWindowClosed = window.nativeWindow.closed;

Etat d’affichage de cette fenêtre.

Les constantes pour les valeurs possibles sont définies dans la classe NativeWindowDisplayState :

• NativeWindowDisplayState.NORMAL
• NativeWindowDisplayState.MINIMIZED
• NativeWindowDisplayState.MAXIMIZED

Eléments de l’API associés

var state:String = windowObj.displayState;

La hauteur de cette fenêtre en pixels.

Les dimensions d’une fenêtre comprennent tout chrome système affiché. La hauteur de la zone d’affichage utilisable est disponible depuis la propriété Stage.stageHeight.

Changer la propriété height d’une fenêtre équivaut à changer la hauteur à l’aide de la propriété bounds.

Si la hauteur spécifiée est inférieure à la hauteur minimale, ou supérieure à la hauteur maximale autorisée, la largeur ou la hauteur de la fenêtre est définie sur la taille autorisée la plus proche. Les facteurs qui déterminent les hauteurs minimales et maximales sont les suivants :

• Propriétés minSize.x et maxSize.x de l’objet NativeWindow
• Limites minimales et maximales du système d’exploitation, qui sont les valeurs de NativeWindow.systemMinSize.x et NativeWindow.systemMaxSize.x.
• Hauteur maximale d’une fenêtre dans Adobe AIR, qui est de 4 095 pixels (2 880 pixels dans AIR 1.5 et les versions antérieures).

Sous Linux, la définition de la propriété height est une opération asynchrone.

Pour détecter la fin du changement de hauteur, écoutez l’événement resize, qui est distribué sur toutes les plates-formes.

Les valeurs en pixels sont arrondies au nombre entier le plus proche lorsque la hauteur d’une fenêtre est modifiée.

Eléments de l’API associés

Indique si les fenêtres natives sont prises en charge sur le système client.

Indique le paramètre maximizable utilisé pour créer cette fenêtre.

Le paramètre maximizable ne peut pas être modifié après la création d’une fenêtre.

Remarque : sous Linux, certains gestionnaires de fenêtres permettent à l’utilisateur d’agrandir les fenêtres même lorsque la propriété maximizable est définie sur false.

Eléments de l’API associés

Taille maximale pour cette fenêtre.

La limite de taille est spécifiée comme coordonnées d’un objet Point. La propriété x du point correspond à la largeur de la fenêtre et la propriété y à sa hauteur.

La restriction maxSize est imposée pour les opérations de redimensionnement de la fenêtre qui sont invoquées au moyen du code ActionScript et du système d’exploitation.

La définition de maxSize change les limites de la fenêtre si les limites actuelles sont supérieures à la nouvelle taille maximale.

Si la largeur ou la hauteur spécifiée est supérieure à la largeur ou à la hauteur maximale autorisée, la largeur de fenêtre est alors définie sur la taille autorisée la plus proche. Les facteurs qui déterminent les largeurs et les hauteurs minimales et maximales sont les suivants :

• Limite maximale du système d’exploitation, qui est la valeur NativeWindow.systemMaxSize.
• Largeur et hauteur maximales d’une fenêtre dans Adobe AIR, qui sont chacune de 4 095 pixels. (Dans AIR 1.5 et les versions antérieures, la largeur et la hauteur maximales d’une fenêtre sont de 2 880 pixels chacune.)

Remarque : sous certains systèmes d’exploitation tels que Mac OS X, l’agrandissement d’une fenêtre n’augmente la taille de la fenêtre que jusqu’à la valeur maxSize, même si la fenêtre agrandie est plus petite que l’écran du système d’exploitation. La fenêtre demeure dans l’état d’affichage agrandi.

Eléments de l’API associés

windowObj.maxSize = new Point(1040,920);

displayObject.stage.nativeWindow.maxSize = new Point(800,600);

window.nativeWindow.maxSize = new air.Point(960,960);

Le menu natif pour cette fenêtre.

Lorsqu’un objet NativeMenu est attribué à la propriété menu de la fenêtre, un menu natif s’affiche pour une fenêtre si NativeWindow.supportsMenu est true, à moins que la propriété systemChrome de la fenêtre soit NativeWindowSystemChrome.NONE.

Remarque : l’attribution d’un menu à une fenêtre lorsque NativeWindow.supportsMenu est false ou lorsque la propriété systemChrome de la fenêtre est NativeWindowSystemChrome.NONE est autorisée, mais n’a aucune incidence. Utilisez la propriété NativeWindow.supportsMenu pour déterminer si le système d’exploitation prend en charge les fenêtres de l’application. Faire appel à d’autres méthodes (comme Capabilities.os) pour déterminer les prises en charge peut entraîner des erreurs de programmation (si certains systèmes d’exploitation cible possibles ne sont pas pris en compte).

Eléments de l’API associés

Indique le paramètre minimizable utilisé pour créer cette fenêtre.

Le paramètre minimizable ne peut pas être modifié après la création d’une fenêtre.

Remarque : sous Linux, certains gestionnaires de fenêtres permettent à l’utilisateur de réduire les fenêtres même lorsque la propriété minimizable est définie sur false.

Eléments de l’API associés

Taille minimale pour cette fenêtre.

La limite de taille est spécifiée comme coordonnées d’un objet Point. La propriété x du point correspond à la largeur de la fenêtre et la propriété y à sa hauteur.

Le réglage de minSize change les limites de la fenêtre si les limites actuelles sont inférieures à la nouvelle taille minimale.

La restriction minSize est imposée pour les opérations de redimensionnement de la fenêtre qui sont invoquées au moyen du code ActionScript et du système d’exploitation.

Remarque : la largeur et la hauteur de tout chrome système affiché risquent de rendre impossible le réglage d’une fenêtre à une taille aussi petite que la taille minimale spécifiée.

Eléments de l’API associés

windowObj.minSize = new Point(200,80);

displayObject.stage.nativeWindow.minSize = new Point(120,60);

window.nativeWindow.minSize = new air.Point(80,60);

Objet NativeWindow qui détient cette fenêtre.

La propriété des fenêtres est établie lorsqu’une fenêtre est créée et ne peut pas être modifiée. Pour créer une fenêtre ayant un propriétaire, définissez l’objet NativeWindow propriétaire en tant que propriété owner de l’objet NativeWindowInitOptions utilisé pour créer la fenêtre possédée.

Remarque : sous Linux, certains gestionnaires de fenêtres n’affichent pas les fenêtres possédées devant la fenêtre propriétaire lorsque celle-ci est en mode plein écran.

Eléments de l’API associés

Indique le paramètre renderMode de la fenêtre utilisé pour créer cette fenêtre.

La valeur renvoyée par NativeWindow.renderMode est l’une des constantes définies dans la classe NativeWindowRenderMode.

Le paramètre renderMode ne peut pas être modifié après la création d’une fenêtre.

Eléments de l’API associés

Indique le paramètre resizable utilisé pour créer cette fenêtre.

Le paramètre resizable ne peut pas être modifié après la création d’une fenêtre.

Eléments de l’API associés

Objet Stage pour cette fenêtre. L’objet Stage est l’objet racine dans l’architecture de la liste d’affichage utilisée dans le contenu SWF basé sur ActionScript 3.0.

La scène est la racine de la liste d’affichage pour la fenêtre. Ajoutez des objets visual display à une fenêtre en les ajoutant à la scène ou à un autre objet se trouvant déjà dans la liste d’affichage de cette scène. Les dimensions de la scène sont celles de la zone client de la fenêtre lorsque celle-ci utilise le chrome système. Les dimensions de la scène équivalent à celles de la fenêtre si le chrome système n’est pas utilisé.

Eléments de l’API associés

import flash.display.StageAlign;

windowObj.stage.align = StageAlign.TOP_LEFT;

Indique si AIR prend en charge les menus de fenêtre natifs sur le système de l’ordinateur actuel.

Lorsque NativeWindow.supportsMenu est true, un menu natif est affiché pour une fenêtre lorsqu’un objet NativeMenu est attribué à la propriété menu de cette fenêtre, à moins que la propriété systemChrome soit NativeWindowSystemChrome.NONE. Utilisez la propriété NativeWindow.supportsMenu pour déterminer si le système d’exploitation prend en charge les menus de fenêtre natifs de l’application. Faire appel à d’autres méthodes (comme Capabilities.os) pour déterminer les prises en charge peut entraîner des erreurs de programmation (si certains systèmes d’exploitation cible possibles ne sont pas pris en compte).

Remarque : l’attribution d’un menu à une fenêtre lorsque NativeWindow.supportsMenu est false ou lorsque la propriété systemChrome de la fenêtre est NativeWindowSystemChrome.NONE est autorisée, mais n’a aucune incidence.

Eléments de l’API associés

Indique si AIR prend en charge le repérage de notification de fenêtre sur le système de l’ordinateur actuel.

Lorsque NativeWindow.supportsNotification est true, l’appel de la méthode notifyUser() de la fenêtre entraîne l’affichage d’un repère visuel indiquant à l’utilisateur qu’un événement intéressant s’est produit. Ce repère visuel est conforme à la convention du système d’exploitation du système natif. Par exemple, sous Windows^®, l’icône de la barre des tâches clignote.

Remarque : l’appel de notifyUser() lorsque NativeWindow.supportsNotification est false est autorisé mais n’a aucune incidence.

Eléments de l’API associés

Indique si AIR prend en charge les fenêtres natives avec des pixels transparents.

Lorsque NativeWindow.supportsTransparency est true, la transparence des pixels d’une fenêtre native est respectée si la propriété transparent de la fenêtre est définie sur true. L’opacité de tous les pixels est définie sur 1 si NativeWindow.supportsTransparency est false, quelle que soit la valeur de la propriété transparent de la fenêtre. Les pixels complètement transparents apparaissent en noir lorsque la propriété NativeWindow.supportsTransparency est définie sur false. Utilisez la propriété NativeWindow.supportsTransparency pour déterminer si le système d’exploitation prend en charge la transparence. Faire appel à d’autres méthodes (comme Capabilities.os) pour déterminer les prises en charge peut entraîner des erreurs de programmation (si certains systèmes d’exploitation cible possibles ne sont pas pris en compte).

Remarque : la valeur de cette propriété peut changer en fonction des préférences de l’utilisateur du système d’exploitation si une application est en cours d’exécution.

Eléments de l’API associés

Indique le paramètre de chrome système utilisé pour créer cette fenêtre.

Les valeurs renvoyées par NativeWindow.systemChrome sont l’une des constantes définies dans la classe NativeWindowSystemChrome.

Le paramètre de chrome système ne peut pas être modifié après la création d’une fenêtre.

Eléments de l’API associés

var sysChromeType:String = windowObj.systemChrome;

var sysChromeType:String = displayObject.stage.nativeWindow.systemChrome;

var sysChromeType = window.nativeWindow.systemChrome;

import flash.display.NativeWindow;
import flash.display.NativeWindowSystemChrome;
import flash.display.NativeWindowInitOptions;

public function deChromeWindow(oldWindow:NativeWindow):NativeWindow{
    if(oldWindow.systemChrome != NativeWindowSystemChrome.NONE){
        var newOptions:NativeWindowInitOptions = new NativeWindowInitOptions();
        newOptions.systemChrome = NativeWindowSystemChrome.NONE;
        newOptions.transparent = true;
        
        var newWindow:NativeWindow = new NativeWindow(newOptions);
        newWindow.stage.stageWidth = oldWindow.stage.stageWidth;
        newWindow.stage.stageHeight = oldWindow.stage.stageHeight;
        newWindow.stage.align = oldWindow.stage.align;
        newWindow.stage.scaleMode = oldWindow.stage.scaleMode;
        
        for(var i:int = 0; i < oldWindow.stage.numChildren; i++){
            newWindow.stage.addChild(oldWindow.stage.getChildAt(i));
        }
        newWindow.activate();
        oldWindow.close();
        
        return newWindow;
    }
    return oldWindow;
}

La taille de fenêtre la plus grande autorisée par le système d’exploitation.

La limite de taille est spécifiée comme coordonnées d’un objet Point. La propriété x du point correspond à la largeur de la fenêtre et la propriété y à sa hauteur.

Outre la limite de taille du système d’exploitation, AIR présente une limite de taille de fenêtre maximale de 4 095 par 4 095 pixels (2 880 par 2 880 pixels dans AIR 1.5 et les versions antérieures). Une application peut définir une limite à l’aide de la propriété maxSize de l’objet NativeWindow.

La taille de fenêtre la plus petite autorisée par le système d’exploitation.

The size limit is specified as the coordinates of a Point object. La propriété x du point correspond à la largeur de la fenêtre et la propriété y à sa hauteur.

Le titre de la fenêtre.

Le titre apparaît dans le chrome système pour la fenêtre, le cas échéant, ainsi que dans d’autres emplacements dépendant du système (la barre des tâches, par exemple).

windowObj.title = "Window Title";

Indique le paramètre de transparence utilisé pour créer cette fenêtre.

La propriété transparent ne peut pas être modifiée après la création d’une fenêtre. La transparence affecte l’apparence visuelle et le comportement de la souris de la fenêtre. Sous Windows et Mac OS X, la fenêtre ne capture pas les événements de souris lorsque la valeur alpha du pixel est inférieure à un certain seuil, compris entre 0,06 et 0,01 selon le système d’exploitation. Sous Linux, la fenêtre capture les événements de souris au-dessus des zones complètement transparentes, ce qui, par conséquent, empêche les utilisateurs d’accéder à d’autres fenêtres ou éléments sur le bureau.

Remarque : la transparence de la fenêtre n’est pas toujours prise en charge. Il est possible que la transparence ne soit pas disponible selon la configuration du système d’exploitation de l’utilisateur, auquel cas la fenêtre est créée sans transparence. Les zones qui auraient été transparentes sont donc créées en noir. Use the NativeWindow.supportsTransparency property to determine whether window transparency is supported.

Eléments de l’API associés

Indique le paramètre type utilisé pour créer cette fenêtre.

Les valeurs renvoyées par NativeWindow.type sont l’une des constantes définies dans la classe NativeWindowType.

Le paramètre type ne peut pas être modifié après la création d’une fenêtre.

Eléments de l’API associés

Spécifie si cette fenêtre est visible.

Une fenêtre invisible n’est pas affichée sur le bureau, mais toutes les méthodes et les propriétés window sont valides.

Par défaut, visible est définie sur false. Pour afficher une fenêtre, réglez visible sur true ou appelez NativeWindow.activate().

Si cette fenêtre a un propriétaire, l’état visible de la fenêtre propriétaire détermine si cette fenêtre est affichée. Si la fenêtre propriétaire n’est pas affichée, toutes les fenêtres possédées ne sont pas affichées, même si leurs propriétés visible sont définies sur true.

Remarque : sur Mac OS X, la définition de visible=false sur une fenêtre réduite ne supprime pas l’icône de la fenêtre du dock. Si un utilisateur clique ensuite sur l’icône du Dock, la fenêtre revient à l’état visible et s’affiche sur le bureau.

Eléments de l’API associés

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

La largeur de cette fenêtre en pixels.

Les dimensions indiquées pour une fenêtre native comprennent tout chrome système affiché. La largeur de la zone d’affichage utilisable est disponible depuis la propriété Stage.stageWidth.

Changer la propriété width d’une fenêtre équivaut à changer la largeur à l’aide de la propriété bounds.

Si la largeur spécifiée est inférieure à la hauteur minimale, ou supérieure à la largeur maximale autorisée, la largeur ou la largeur de la fenêtre est définie sur la taille autorisée la plus proche. Les facteurs qui déterminent les largeurs minimales et maximales sont les suivants :

• Propriétés minSize.y et maxSize.y de l’objet NativeWindow
• Limites minimales et maximales du système d’exploitation, qui sont les valeurs de NativeWindow.systemMinSize.y et NativeWindow.systemMaxSize.y.
• Largeur maximale d’une fenêtre dans Adobe AIR, qui est de 4 095 pixels (2 880 pixels dans AIR 1.5 et les versions antérieures).

Sous Linux, la définition de la propriété width est une opération asynchrone.

Pour détecter la fin du changement de largeur, écoutez l’événement resize, qui est distribué sur toutes les plates-formes.

Les valeurs en pixels sont arrondies au nombre entier le plus proche lorsque la largeur d’une fenêtre est modifiée.

Eléments de l’API associés

Coordonnée de l’axe horizontal de l’angle supérieur gauche de cette fenêtre par rapport à l’origine du bureau du système d’exploitation.

Sur les systèmes équipés de plusieurs écrans, x peut être négatif. Si vous enregistrez la valeur, par exemple pour repositionner une fenêtre à son emplacement précédent, pensez à toujours vérifier que la fenêtre est placée dans un emplacement utilisable lorsque la position est restaurée. Les modifications de la résolution ou de l’organisation de l’écran peuvent entraîner le placement de la fenêtre en dehors de l’écran. Utilisez la classe Screen pour obtenir des informations sur la géométrie du bureau.

Changer la propriété x d’une fenêtre équivaut à changer l’emplacement à l’aide de la propriété bounds.

Sous Linux, la définition de la propriété x est une opération asynchrone.

Pour détecter la fin du changement de position, écoutez l’événement move, qui est distribué sur toutes les plates-formes.

Les valeurs en pixels sont arrondies au nombre entier le plus proche la coordonnée x d’une fenêtre est modifiée.

Eléments de l’API associés

Coordonnée de l’axe vertical de l’angle supérieur gauche de cette fenêtre par rapport à l’angle supérieur gauche du bureau du système d’exploitation.

Sur les systèmes équipés de plusieurs écrans, y peut être négatif. Si vous enregistrez la valeur, par exemple pour repositionner une fenêtre à son emplacement précédent, pensez à toujours vérifier que la fenêtre est placée dans un emplacement utilisable lorsque la position est restaurée. Les modifications de la résolution ou de l’organisation de l’écran peuvent entraîner le placement de la fenêtre en dehors de l’écran. Utilisez la classe Screen pour obtenir des informations sur la géométrie du bureau.

Changer la propriété y d’une fenêtre équivaut à changer l’emplacement à l’aide de la propriété bounds.

Sous Linux, la définition de la propriété y est une opération asynchrone.

Pour détecter la fin du changement de position, écoutez l’événement move, qui est distribué sur toutes les plates-formes.

Les valeurs en pixels sont arrondies au nombre entier le plus proche la coordonnée y d’une fenêtre est modifiée.

Eléments de l’API associés

Crée une occurrence de NativeWindow et une fenêtre de système d’exploitation correspondante.

Les paramètres définis dans le paramètre initOptions ne peuvent pas être modifiés après la création de la fenêtre. Les paramètres initOptions non valides entraînent le renvoi d’une erreur d’opération non autorisée. Les paramètres qui sont valides mais non disponibles sur le système actuel ne renvoient pas d’exception. Les fonctionnalités de la fenêtre propres au système d’exploitation actuel peuvent être détectées, le cas échéant, à l ’aide des membres statiques NativeWindow tels que systemMaxSize.

La taille de la fenêtre par défaut est déterminée par le système d’exploitation et les fenêtres sont créées dans un état invisible. Pour empêcher la visibilité des modifications de la fenêtre, ne définissez pas la propriété visible de la fenêtre sur true et n’appelez pas la méthode activate() tant que les modifications de la fenêtre ne sont pas terminées.

Eléments de l’API associés

import flash.display.NativeWindowInitOptions;
import flash.display.NativeWindowSystemChrome;
import flash.display.NativeWindowType;
import flash.display.NativeWindow;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.geom.Rectangle;

var windowOptions:NativeWindowInitOptions = new NativeWindowInitOptions();
windowOptions.systemChrome = NativeWindowSystemChrome.STANDARD;
windowOptions.type = NativeWindowType.NORMAL;

var newWindow:NativeWindow = new NativeWindow(windowOptions);
newWindow.stage.scaleMode = StageScaleMode.NO_SCALE;
newWindow.stage.align = StageAlign.TOP_LEFT;
newWindow.bounds = new Rectangle(100, 100, 800, 800);

newWindow.activate();

Active cette fenêtre.

L’activation d’une fenêtre :

• Rend la fenêtre visible
• Déplace la fenêtre vers l’avant
• Donne à la fenêtre le focus keyboard et mouse

Sous Linux, activate() est une opération asynchrone.

L’objet NativeWindow distribue un événement activate sur toutes les plates-formes.

Eléments de l’API associés

displayObject.stage.nativeWindow.activate();

windowObj.activate();

window.nativeWindow.activate();

Ferme cette fenêtre.

Un événement close est distribué dès que l’opération de fermeture se termine. Un événement closing n’est pas distribué. Si l’annulation de cette opération de fermeture doit être autorisée, distribuez un événement closing et vérifiez si des écouteurs enregistrés annulent le comportement par défaut avant d’appeler la méthode close.

Lors de la fermeture d’une fenêtre, toutes les fenêtres dont elle est propriétaire se ferment également. Les fenêtres possédées ne distribuent pas d’événements closing.

Si les occurrences d’objets d’affichage actuellement dans la fenêtre ne sont pas référencées en un autre endroit, elles sont nettoyées et détruites, sauf dans la fenêtre de l’application initiale créée par AIR. Pour que les objets d’affichage de la fenêtre d’origine soient nettoyés, supprimez-les de la scène dans la fenêtre.

Après sa fermeture, l’objet NativeWindow demeure une référence valide, mais l’accès à la plupart des propriétés et des méthodes renvoie une erreur d’opération non autorisée.

Les fenêtres fermées ne peuvent pas être rouvertes. Si la fenêtre est déjà fermée, aucune action n’est effectuée et aucun événement n’est distribué.

Remarque : pour masquer une fenêtre sans la fermer, définissez la propriété visible de la fenêtre sur false.

Eléments de l’API associés

windowObj.close();

displayObj.stage.nativeWindow.close();

window.close(); //overriddable in HTMLHost

window.nativeWindow.close(); //not overriddable

public function closeCommand():Boolean{
    var closeEvent:Event = new Event(Event.CLOSING,true,true);
    windowObj.dispatchEvent(closeEvent);
    if(!closeEvent.isDefaultPrevented()){
        windowObj.close();
        return true;
    } else {
      return false;
    }
}

<script src="AIRAliases.js" type="text/javascript"></script>
<script type="text/javascript">
    var dirtyData = false;
    function closeWindow(){
            var closingEvent = new air.Event(air.Event.CLOSING,true,true);
            window.nativeWindow.dispatchEvent(closingEvent);
               if(!closingEvent.isDefaultPrevented()){
                   window.nativeWindow.close();
                //or use: window.close(); 
               return true;
           } else {
               return false;
        }
    }
        
    function onClosing(event){
        if(dirtyData){
            event.preventDefault();
            //Save data...
        }
    }    

    window.nativeWindow.addEventListener(air.Event.CLOSING,onClosing);        
</script>

Convertit un point en coordonnées pixels par rapport à l’origine de la scène de la fenêtre (un point global en termes de liste d’affichage), en un point sur le bureau virtuel.

Les coordonnées de bureau virtuel sont relatives à l’angle supérieur gauche du moniteur principal.

Paramètres

Eléments de l’API associés

Renvoie une liste des objets NativeWindow appartenant à cette fenêtre.

Il est impossible de changer la propriété des objets NativeWindows en ajoutant ou en supprimant des objets du vecteur renvoyé. Il est impossible de changer la propriété des fenêtres après la création d’une fenêtre.

Eléments de l’API associés

Agrandit cette fenêtre.

L’appel de maximize() distribue un événement displayStateChange et, le cas échéant, un événement move et resize. Le chrome système distribue un événement displayStateChanging pouvant être annulé lorsqu’une commande maximize est lancée par un utilisateur, mais votre logique maximize doit implémenter ce comportement, si nécessaire.

La méthode maximize() s’exécute de façon asynchrone. Pour détecter la fin du changement d’état, écoutez l’événement displayStateChange. Si la fenêtre est déjà agrandie, aucune action n’est effectuée et aucun événement n’est distribué.

Remarques concernant le comportement du SE :

• Sous certains systèmes d’exploitation tels que Mac OS X, dans lesquels l’agrandissement d’une fenêtre n’empêche pas le redimensionnement, l’appel de maximize() effectue un zoom sur la fenêtre pour qu’elle remplisse l’écran, mais n’empêche pas son redimensionnement ultérieur. Le redimensionnement d’une fenêtre sur laquelle un zoom a été effectué restaure également l’état d’affichage.
• Sous certains systèmes d’exploitation tels que Mac OS X, ainsi que dans certains gestionnaires de fenêtres sous Linux, les fenêtres ne sont pas agrandies au-delà de la largeur et de la hauteur définies dans la propriété maxSize. Par contre, sous d’autres systèmes d’exploitation, la fenêtre s’agrandit pour occuper la totalité de l’écran, même si l’écran est plus large que la propriété maxSize.
• Certains gestionnaires de fenêtres de Linux ne permettent pas d’agrandir les fenêtres d’utilitaire.

Eléments de l’API associés

public function maximizeWindow(nativeWin:NativeWindow):Boolean{
  if(nativeWin.displayState != NativeWindowDisplayState.MAXIMIZED){
    var beforeState:String = nativeWin.displayState;
    var afterState:String = NativeWindowDisplayState.MAXIMIZED;
    var displayStateEvent:NativeWindowDisplayStateEvent = 
        new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
    nativeWin.dispatchEvent(displayStateEvent);
    if(!displayStateEvent.isDefaultPrevented()){
        nativeWin.maximize();
        return true;
    } else {
      return false;
    }
  }
  return false;
}

function maximizeWindow(nativeWin){
    if(nativeWin.displayState != air.NativeWindowDisplayState.MAXIMIZED){
        var beforeState = nativeWin.displayState;
        var afterState = air.NativeWindowDisplayState.MAXIMIZED;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            nativeWin.maximize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Réduit cette fenêtre.

L’appel de minimize() distribue un événement displayStateChange et, le cas échéant, un événement move et resize. Un chrome système distribue un événement displayStateChanging pouvant être annulé lorsqu’une commande minimize est lancée par un utilisateur alors que l’appel direct de minimize() ne le fait pas. Votre logique minimize peut implémenter ce comportement, si nécessaire.

La méthode minimize() s’exécute de façon asynchrone. Pour détecter la fin du changement d’état, écoutez l’événement displayStateChange, distribué sur toutes les plates-formes. Si la fenêtre est déjà réduite, aucune action n’est entreprise et aucun événement n’est distribué.

Toutes les fenêtres dont est propriétaire cette fenêtre sont masquées lorsqu’elles sont réduites. Les fenêtres possédées ne distribuent pas d’événement displayStateChanging ou displayStateChange.

Remarques :

• Sous Windows, minimiser une fenêtre invisible (visible == false) rend la fenêtre visible.
• Certains gestionnaires de fenêtres de Linux ne permettent pas de minimiser les fenêtres d’utilitaire.

Eléments de l’API associés

public function minimizeWindow(nativeWin:NativeWindow):Boolean{
    if(nativeWin.displayState != NativeWindowDisplayState.MINIMIZED){
        var beforeState:String = nativeWin.displayState;
        var afterState:String = NativeWindowDisplayState.MINIMIZED;
        var displayStateEvent:NativeWindowDisplayStateEvent = 
            new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            nativeWin.minimize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

 
function minimizeWindow(){
    if(window.nativeWindow.displayState != air.NativeWindowDisplayState.MINIMIZED){
        var beforeState = window.nativeWindow.displayState;
        var afterState = air.NativeWindowDisplayState.MINIMIZED;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        window.nativeWindow.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            window.nativeWindow.minimize();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Déclenche un repère visuel via le système d’exploitation indiquant qu’un événement intéressant s’est produit.

Lorsque NativeWindow.supportsNotification est true, le repère visuel se conforme à la convention du système d’exploitation du système natif. Par exemple, dans Windows, l’icône de la barre des tâches clignote.

Le paramètre type détermine l’intensité du repère. Les constantes pour les valeurs autorisées sont définies dans la classe NotificationType et peuvent être :

• NotificationType.INFORMATIONAL
• NotificationType.CRITICAL

Les repères fournis pour des notifications informelles durent peu de temps ; ceux fournis pour des notifications cruciales durent jusqu’à ce que l’utilisateur active cette fenêtre. Tous les gestionnaires de fenêtres de Linux ne prennent pas en charge ces deux niveaux de notification. Pour ce type de gestionnaires de fenêtres, la méthode notifyUser() a le même effet, quelle que soit l’option spécifiée.

Remarque : l’appel de notifyUser() lorsque NativeWindow.supportsNotification est false est autorisé mais n’a aucune incidence.

Paramètres

Envoie directement cette fenêtre derrière la fenêtre spécifiée.

N’active ni n’acquiert le focus pour la fenêtre ou l’application. Les fenêtres réduites ou masquées (visible est défini sur false) ne peuvent pas être réorganisées.

Une fenêtre possédée ne peut jamais être placée derrière sa fenêtre propriétaire. Si cette fenêtre possède une fenêtre propriétaire, la fenêtre propriétaire et les autres fenêtres possédées sont également placées derrière la cible. Si la fenêtre cible possède une fenêtre propriétaire, elle est placée derrière la fenêtre propriétaire de la cible.

Certains gestionnaires de fenêtres de Linux ne permettent pas de placer des fenêtres d’utilitaire derrière des fenêtres normales.

Paramètres

windowBehind.orderInBackOf(windowFront);

displayObjBehind.stage.nativeWindow.orderInBackOf(displayObjectFront.stage.nativeWindow);

jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);

Déplace cette fenêtre directement devant la fenêtre spécifiée.

N’active ni n’acquiert le focus pour la fenêtre ou l’application. Les fenêtres réduites ou masquées (visible est défini sur false) ne peuvent pas être réorganisées.

Une fenêtre ne peut jamais être placée devant une fenêtre qu’elle possède. Si cette fenêtre possède une fenêtre propriétaire, la fenêtre propriétaire et les autres fenêtres possédées sont également placées devant la cible. Si la fenêtre cible possède une fenêtre propriétaire, elle est également placée devant toutes les autres fenêtres ayant le même propriétaire que la cible.

Certains gestionnaires de fenêtres de Linux ne permettent pas de placer des fenêtres normales devant des fenêtres d’utilitaire.

Paramètres

windowFront.orderInFrontOf(windowBehind);

displayObjFront.stage.nativeWindow.orderInFrontOf(displayObjectBehind.stage.nativeWindow);

jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);

Envoie cette fenêtre derrière les autres fenêtres visibles.

N’active ni n’acquiert le focus pour cette fenêtre ou l’application. Les fenêtres réduites ou masquées (visible est défini sur false) ne peuvent pas être réorganisées.

Si alwaysInFront est défini sur true, l’appel de cette méthode n’envoie pas cette fenêtre derrière des fenêtres ayant alwaysInFront défini sur false.

Une fenêtre possédée ne peut jamais être placée derrière sa fenêtre propriétaire. Si cette fenêtre possède une fenêtre propriétaire, la fenêtre propriétaire et les autres fenêtres possédées sont également placées au bas de la liste d’affichage de la fenêtre. Cette fenêtre est placée derrière toutes les autres fenêtres appartenant à la même fenêtre. Si cette fenêtre possède d’autres fenêtres, ces fenêtres sont également placées à l’arrière-plan et conservent leur ordre respectif.

Certains gestionnaires de fenêtres de Linux ne permettent pas de placer des fenêtres d’utilitaire derrière des fenêtres normales.

windowObj.orderToBack();

displayObj.stage.nativeWindow.orderToBack();

window.nativeWindow.orderToBack();

Déplace cette fenêtre devant toute autre fenêtre visible.

N’active ni n’acquiert le focus pour cette fenêtre ou l’application. Les fenêtres réduites ou masquées (visible est défini sur false) ne peuvent pas être réorganisées.

Si alwaysInFront est défini sur false, l’appel de cette méthode n’envoie pas cette fenêtre devant des fenêtres ayant alwaysInFront défini sur true.

Une fenêtre ne peut jamais être placée devant une fenêtre qu’elle possède. Si cette fenêtre possède d’autres fenêtres, ces fenêtres sont également déplacées à l’avant-plan et conservent leur ordre respectif. Si cette fenêtre possède une fenêtre propriétaire, la fenêtre propriétaire et les autres fenêtres possédées sont également placées devant la liste d’affichage de la fenêtre. Cette fenêtre est placée devant les autres fenêtres ayant la même fenêtre propriétaire.

Certains gestionnaires de fenêtres de Linux ne permettent pas de placer des fenêtres normales devant des fenêtres d’utilitaire.

windowObj.orderToFront();

displayObj.stage.nativeWindow.orderToFront();

window.nativeWindow.orderToFront();

Restaure cette fenêtre d’un état réduit ou agrandi.

L’appel de restore() distribue un événement displayStateChange et, le cas échéant, un événement move et resize. Le chrome système distribue un événement displayStateChanging pouvant être annulé lorsqu’une commande restore est lancée par un utilisateur, mais votre logique restore doit implémenter ce comportement, le cas échéant.

Si la fenêtre est déjà dans l’état NativeWindowDisplayState.NORMAL, aucune action n’est effectuée et aucun événement n’est distribué.

Pour détecter la fin du changement d’état, écoutez l’événement displayStateChange, qui est distribué sur toutes les plates-formes.

Eléments de l’API associés

public function restoreWindow(nativeWin:NativeWindow):Boolean{
    if(nativeWin.displayState != NativeWindowDisplayState.NORMAL){
        var beforeState:String = nativeWin.displayState;
        var afterState:String = NativeWindowDisplayState.NORMAL;
        var displayStateChangingEvent:NativeWindowDisplayStateEvent = 
            new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        nativeWin.dispatchEvent(displayStateChangingEvent);
        if(!displayStateChangingEvent.isDefaultPrevented()){
            nativeWin.restore();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

function restoreWindow(nativeWin){
    if(window.nativeWindow.displayState != air.NativeWindowDisplayState.NORMAL){
        var beforeState = window.nativeWindow.displayState;
        var afterState = air.NativeWindowDisplayState.NORMAL;
        var displayStateEvent = 
            new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING,
                                              true,true,beforeState,afterState);
        window.nativeWindow.dispatchEvent(displayStateEvent);
        if(!displayStateEvent.isDefaultPrevented()){
            window.nativeWindow.restore();
            return true;
        } else {
          return false;
        }
     }
     return false;
}

Commence le déplacement commandé par le système de cette fenêtre.

Lorsqu’elle est appelée d’un événement mouseDown, cette méthode lance une séquence de déplacement gérée par la souris qui continue jusqu’à ce que l’événement mouseUp ait lieu.

Lorsque cette méthode est appelée d’un autre code, elle lance une séquence de déplacement gérée par un clavier ou une souris cohérente avec la séquence par défaut du système d’exploitation.

Lors d’une séquence de déplacement, une série d’événements est distribuée lors du déplacement de l’origine de la fenêtre. Pour chaque déplacement incrémentiel, un événement moving est d’abord distribué puis, si l’événement moving n’est pas annulé, l’emplacement de la fenêtre est mis à jour et un événement move est distribué. Si un événement moving est annulé, la séquence move est arrêtée immédiatement.

var initOpts:NativeWindowInitOptions = new NativeWindowInitOptions();
var win:NativeWindow = new NativeWindow(initOpts);
win.activate();
win.stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);

function mouseDownHandler(event:MouseEvent):void
{
    win.startMove();
}

Commence une opération de redimensionnement commandée par le système de cette fenêtre.

Lorsqu’elle est appelée d’un gestionnaire d’événement mouseDown, cette méthode lance une séquence de redimensionnement effectuée par la souris qui continue jusqu’à ce que l’événement mouseUp ait lieu.

Lorsque cette méthode est appelée d’un autre code, elle lance une séquence de redimensionnement effectuée par un clavier ou une souris cohérente avec la séquence par défaut du système d’exploitation.

Lors d’une séquence de redimensionnement, une série d’événements est distribuée lors du changement de dimensions de la fenêtre. Pour chaque changement incrémentiel, un événement resizing est d’abord distribué puis, si l’événement resizing n’est pas annulé, les dimensions de la fenêtre sont mises à jour et un événement resize est distribué. Si un événement resizing est annulé, la séquence move est arrêtée immédiatement.

Paramètres

Eléments de l’API associés

stage.addEventListener(MouseEvent.MOUSE_DOWN, onResizeCommand);

function onResizeCommand(event:MouseEvent):void
{
    var win:NativeWindow = event.target.nativeWindow;
    var resizeFrom:String = "";
    if (event.stageY < win.height * .33)
    {
        resizeFrom = NativeWindowResize.TOP;
    }
    else if (event.stageY > win.height * .66)
    {
        resizeFrom = NativeWindowResize.BOTTOM;
    }
    if (event.stageX < win.width * .33)
    {
        resizeFrom += NativeWindowResize.LEFT;
    }
    else if (event.stageX > win.width * .66)
    {
        resizeFrom += NativeWindowResize.RIGHT;
    }
    win.startResize(resizeFrom);    
}

Distribué par cet objet NativeWindow après l’activation de la fenêtre.

Remarque : cet événement n’a ni « phase de capture », ni « phase de propagation », ce qui signifie que des écouteurs d’événement doivent être ajoutés directement aux cibles potentielles, que la cible soit dans la liste d’affichage ou non.

Les périphériques AIR pour TV ne distribuent jamais automatiquement cet événement. Il est cependant possible de le distribuer manuellement.

Les propriétés de cet événement sont les suivantes :

Distribué par cet objet NativeWindow après la fermeture de la fenêtre.

Les propriétés de cet événement sont les suivantes :

Distribué par cet objet NativeWindow immédiatement avant la fermeture de la fenêtre. Cet événement peut être annulé pour empêcher la fermeture de la fenêtre.

Les propriétés de cet événement sont les suivantes :

Distribué par cet objet NativeWindow après la désactivation de la fenêtre.

Remarque : cet événement n’a ni « phase de capture », ni « phase de propagation », ce qui signifie que des écouteurs d’événement doivent être ajoutés directement aux cibles potentielles, que la cible soit dans la liste d’affichage ou non.

Les périphériques AIR pour TV ne distribuent jamais automatiquement cet événement. Il est cependant possible de le distribuer manuellement.

Les propriétés de cet événement sont les suivantes :

Distribué par cet objet NativeWindow après le changement de la propriété displayState de la fenêtre.

Ne redimensionnez pas la fenêtre et ne modifiez pas son état d’affichage dans le gestionnaire d’événement displayStateChange.

Les propriétés de cet événement sont les suivantes :

Distribué par cet objet NativeWindow immédiatement avant le changement de l’état d’affichage de la fenêtre. Cet événement peut être annulé pour empêcher le changement.

Les propriétés de cet événement sont les suivantes :

function displayStateChanging_handler(displayStateEvent:NativeWindowDisplayStateEvent):void
{
  //shouldStopStateChange is an application-defined Boolean indicating 
  //that display state changes should be canceled
  if (displayStateEvent.type == NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING 
                                  &&    shouldStopStateChange)
  {
    displayStateEvent.preventDefault();
  }
}

Distribué par cet objet NativeWindow après le déplacement de la fenêtre sur le bureau.

Un événement move est distribué lorsque l’origine (propriétés x ou y) de la fenêtre change, ce qui peut avoir lieu en raison d’un déplacement de la fenêtre commandé par le système ; réduction, agrandissement ou restauration de la fenêtre ; ou changement de l’emplacement de la fenêtre en définissant les propriétés x, y ou bounds.

Remarque : évitez les actions pouvant ouvrir des boîtes de dialogue du système d’exploitation simultanées dans les fonctions du gestionnaire pour les événements moving et move d’un objet NativeWindow. Ceci peut avoir lieu, par exemple, si les deux fonctions du gestionnaire renvoient une erreur. Si ceci a lieu, la seconde boîte de dialogue ouverte n’enregistre pas les clics de la souris et doit être fermée à l’aide du clavier.

Les propriétés de cet événement sont les suivantes :

Distribué par l’objet NativeWindow immédiatement avant le déplacement de la fenêtre sur le bureau. Cet événement peut être annulé pour empêcher ou modifier le déplacement.

Remarque : évitez les actions pouvant ouvrir des boîtes de dialogue du système d’exploitation simultanées dans les fonctions du gestionnaire pour les événements moving et move d’un objet NativeWindow. Ceci peut avoir lieu, par exemple, si les deux fonctions du gestionnaire renvoient une erreur. Si ceci a lieu, la seconde boîte de dialogue ouverte n’enregistre pas les clics de la souris et doit être fermée à l’aide du clavier.

Les propriétés de cet événement sont les suivantes :

Remarque : sous Linux, la méthode preventDefault() n’est pas prise en charge pour cet événement.

Distribué par cet objet NativeWindow après le redimensionnement de la fenêtre. Un événement resize est distribué lorsque la taille (propriétés width ou height) de la fenêtre change, ce qui peut avoir lieu en raison d’un redimensionnement de la fenêtre commandé par le système ; réduction, agrandissement ou restauration de la fenêtre ; ou changement de la taille de la fenêtre en définissant les propriétés width, height ou bounds. Les événements resize de NativeWindow sont distribués lors des boucles de redimensionnement commandées par le système. En revanche, les événements resize de l’objet Stage sont distribués lorsque la Scène est prête pour le dessin.

Les propriétés de cet événement sont les suivantes :

Eléments de l’API associés

Distribué par cet objet NativeWindow immédiatement avant le redimensionnement de la fenêtre sur le bureau. Cet événement peut être annulé pour empêcher ou modifier le redimensionnement.

Les propriétés de cet événement sont les suivantes :

Remarque : sous Linux, la méthode preventDefault() n’est pas prise en charge pour cet événement.

function boundsChanging_handler(boundsEvent:NativeWindowBoundsEvent):void
{
  //shouldStopResize is an application-defined Boolean indicating 
  //that resize operations should be canceled
  if (boundsEvent.type == NativeWindowBoundsEvent.RESIZING && shouldStopResize)
  {
    boundsEvent.preventDefault();
  }
}