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

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

Voir aussi

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 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.

Certains gestionnaires de fenêtres de Linux affichent toujours les fenêtres d'utilitaire devant les fenêtres normales.

Remarque : sous Mac OS^® X, le réglage de alwaysInFront sur true n'a aucune incidence lorsque la propriété displayState de la scène de la fenêtre est fullScreen ou fullScreenInteractive. Sous Linux, les fenêtres plein écran dont la propriété alwaysInFront est définie sur true s'affichent toujours devant les autres fenêtres dont la propriété alwaysInFront est définie sur true.

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. Le réglage direct de la propriété bounds ne distribue pas d'événement moving ou resizing. Pour permettre à d'autres composants de préparer ou d'annuler une opération de déplacement ou de redimensionnement imminente, votre logique de changement des limites peut distribuer des événements moving et resizing avec la méthode NativeWindow dispatchEvent() et vérifier ensuite si l'événement a été annulé par un écouteur enregistré.

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 déclenché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 et la hauteur spécifiées sont inférieures au minimum ou supérieures à la taille maximale autorisée, soit en raison des propriétés minSize et maxSize de la fenêtre, soit des limites du système d'exploitation minimum et maximum, les dimensions de la fenêtre sont définies sur la taille autorisée la plus proche. La largeur et la hauteur minimales de tout chrome système affiché peuvent également être à l'origine d'une fenêtre plus grande que la taille spécifiée.

Voir aussi

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

Voir aussi

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 au minimum ou supérieure à la hauteur maximale autorisée, soit en raison des propriétés minSize et maxSize de la fenêtre, soit des limites minimum et maximum du système d'exploitation, la hauteur de la fenêtre est définie sur la taille autorisée la plus proche.

Voir aussi

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.

Tous les gestionnaires de fenêtres de Linux ne tiennent pas compte du paramètre maximizable.

Voir aussi

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.

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.

Voir aussi

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.

Voir aussi

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.

Tous les gestionnaires de fenêtres de Linux ne tiennent pas compte du paramètre minimizable.

Voir aussi

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.

Voir aussi

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

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

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

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.

Voir aussi

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é.

Voir aussi

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.

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.

Voir aussi

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.

Voir aussi

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.

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.

Voir aussi

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.

Voir aussi

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.

La taille de fenêtre la plus petite 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.

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. Utilisez la propriété NativeWindow.supportsTransparency pour déterminer si la transparence de la fenêtre est prise en charge.

Voir aussi

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.

Voir aussi

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().

Remarque : sous 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.

Voir aussi

windowObj.visible = true;

displayObj.stage.nativeWindow.visible = true;

window.nativeWindow.visible = true;

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 au minimum ou supérieure à la largeur maximale autorisée, soit en raison des propriétés minSize et maxSize de la fenêtre, soit des limites minimum et maximum du système d'exploitation, la largeur de la fenêtre est définie sur la taille autorisée la plus proche.

Voir aussi

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.

Voir aussi

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.

Voir aussi

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 dans 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, si nécessaire, à 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 mais peut être modifiée en définissant les limites de la fenêtre. Le changement n'est pas visible si la propriété visible de la fenêtre est false.

Voir aussi

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

Voir aussi

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.

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.

Voir aussi

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

Voir aussi

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 :

• 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.

Voir aussi

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.

Si la fenêtre est déjà réduite, aucune action n'est entreprise et aucun événement n'est distribué.

Certains gestionnaires de fenêtres de Linux ne permettent pas de minimiser les fenêtres d'utilitaire.

Voir aussi

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.

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.

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.

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.

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.

La méthode restore() 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à dans l'état NativeWindowDisplayState.NORMAL, aucune action n'est effectuée et aucun événement n'est distribué.

Voir aussi

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.

import flash.display.NativeWindow;
import flash.events.MouseEvent;

public class MovableWindow extends NativeWindow{
    private function MovableWindow():void{
        super(new NativeWindowInitOptions());
        this.stage.addEventListener(MouseEvent.MOUSE_DOWN, onMoveCommand);
        this.activate();
    }
    
    private function onMoveCommand(event:MouseEvent):void{
        this.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

public class ResizableWindow extends NativeWindow
{
    public function ResizableWindow()
    {
        var options:NativeWindowInitOptions = new NativeWindowInitOptions();
        super(options);
        this.stage.align = StageAlign.TOP_LEFT;
        this.stage.scaleMode = StageScaleMode.NO_SCALE;
        this.stage.addEventListener(MouseEvent.MOUSE_DOWN, onResizeCommand);
        this.activate();
    }

    private function onResizeCommand(event:MouseEvent):void{
        var resizeFrom:String = "";
        if(event.localY < this.height * .33){resizeFrom = "T";}
        else if(event.localY > this.height * .66){resizeFrom = "B";}
        if(event.localX < this.width * .33){resizeFrom += "L";}
        else if(event.localX > this.width * .66){resizeFrom += "R";}
        
        this.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 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 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.

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.

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.

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.

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.

Voir aussi

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.

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();
  }
}