// pWin为移动的窗口，pSib为pWin移动在该窗口之上。若pSib为空，则pWin窗口在最上层
static void ReflectStackChange(WindowPtr pWin, WindowPtr pSib, VTKind kind){
    Bool WasViewable = (Bool) pWin->viewable;
    Bool anyMarked;
    WindowPtr pFirstChange;
    WindowPtr pLayerWin;
    ScreenPtr pScreen = pWin->drawable.pScreen;
    if (!pWin->parent)
        return; // if this is a root window, can't be restacked
    // pWin为移动窗口，pSib为空，pWin置底；若pWin下一个相邻窗口为pSib，栈层次未变，则什么都不做
    // pFirstChange：表示第一个被暴露的窗口
    // pWin向下移，则pFirstChange为pWin相邻的下一个窗口。pWin与pSib中间有兄弟窗口，当pWin在pSib上方时，需下移。
    // pWin向上移，则pFirstChange为pWin本身
    pFirstChange = MoveWindowInStack(pWin, pSib);
    if (WasViewable) {
        // miMarkOverlappedWindows，标记与pWin窗口重叠的兄弟窗口及其子窗口所在位置，这些窗口可能需要重绘
        // 若pFirstChange为pWin（窗口上移），则标记pWin及其子窗口，同时标记与pWin窗口（包括边框）重叠的兄弟窗口以及其子窗口
        // 若pFirstChange不为pWin（窗口下移），标记与pWin窗口重叠的兄弟窗口以及其子窗口
        anyMarked = (*pScreen->MarkOverlappedWindows) (pWin, pFirstChange, &pLayerWin);
        // pLayerWin初始化为pWin，不清楚这里为什么要判断
        if (pLayerWin != pWin)
            pFirstChange = pLayerWin;
        if (anyMarked) {
            // 有窗口重叠。若无窗口则不需重绘，修改窗口树结构即可。此场景必有重叠，pWin窗口与其子窗口重叠。
            // miValidateTree，计算父窗口以及所有子窗口的可剪接区域（boarderClip和clipList），以及exposed和borderExposed区域
            (*pScreen->ValidateTree) (pLayerWin->parent, pFirstChange, kind);
            // miHandleValidateExposures，深度优先，先绘制边框，再绘制exposed区域的背景，然后发送Expose事件给客户端绘制
            // 边框和背景的绘制在server端完成，exposed区域的内容通过发送Expose事件由client发起绘制完成
            (*pScreen->HandleExposures) (pLayerWin->parent);
            // 一般为空，只有当视频窗口时，xv扩展才需处理
            if (pWin->drawable.pScreen->PostValidateTree)
                (*pScreen->PostValidateTree) (pLayerWin->parent, pFirstChange, kind);
        }
    }
    if (pWin->realized)
        // 处理焦点和光标
        WindowsRestructured();
}

struct _MetaGroup {
  int refcount;
  MetaX11Display *x11_display;
  GSList *windows;       // 窗口列表
  Window group_leader;  // 组长
  char *startup_id;
  char *wm_client_machine;
};

struct _MetaStack{
  GObject parent;
  MetaDisplay *display;  // The MetaDisplay containing this stack.
  GList *sorted;         // The MetaWindows of the windows we manage, sorted in order.
 
  // If this is zero, the local stack oughtn't to be brought up to date with the X server's stack, because it is in the middle of being updated.
  // If it is positive, the local stack is said to be "frozen", and will need to be thawed that many times before the stack can be brought up to date again.
  // You may freeze the stack with meta_stack_freeze() and thaw it with meta_stack_thaw().
  int freeze_count;    // 计数可实现嵌套freeze 
 
  // The last-known stack of all windows, bottom to top.  We cache it here so that subsequent times we'll be able to do incremental moves.
  GArray *last_all_root_children_stacked;
  gint n_positions; // Number of stack positions; same as the length of added, but kept for quick reference.
 
  unsigned int need_resort : 1;    // Is the stack in need of re-sorting?
  unsigned int need_relayer : 1;   // Are the windows in the stack in need of having their layers recalculated?
  unsigned int need_constrain : 1; // Are the windows in the stack in need of having their positions recalculated with respect to transiency (parent and child windows)?
};
 
// 窗口排序需考虑窗口的层次，窗口显示的约束等，先按层次排序，再按位置排序。
static void stack_ensure_sorted (MetaStack *stack) {
  // 对stack中的窗口分层，若层次有变化，则需重新计算窗口约束和重新排序。窗口的层次为窗口组中的最高层次
  stack_do_relayer (stack);
  // 显示约束，对于瞬态窗口，未脱离父子关系，则显示在窗口组的上层，对于脱离父子关系的瞬态窗口（MetaWindow::transient_for非空），则显示在原父窗口的上层
  stack_do_constrain (stack);
  // 重新排序，先按层，再按位置。重排完成后，延后调用check_fullscreen_func处理全屏窗口
  stack_do_resort (stack);
}
 
// 临时窗口类型（瞬态窗口）
gboolean meta_window_has_transient_type (MetaWindow *window)
{
  return (window->type == META_WINDOW_DIALOG ||
          window->type == META_WINDOW_MODAL_DIALOG ||
          window->type == META_WINDOW_TOOLBAR ||
          window->type == META_WINDOW_MENU ||
          window->type == META_WINDOW_UTILITY);
}

struct _MetaStackTracker {
  MetaDisplay *display;
  gulong xserver_serial;   // This is the serial of the last request we made that was reflected in xserver_stack
  GArray *verified_stack; // A combined stack containing X and Wayland windows but without any unverified operations applied.   
  // This is a queue of requests we've made to change the stacking order, where we haven't yet gotten a reply back from the server.
  GQueue *unverified_predictions; // Wayland server修改了X11窗口的配置，发送XConfigureWindow请求该X11 server，但还未收到X11 server的回复
 
  // This is how we think the stack is, based on verified_stack, and on the unverified_predictions we've made subsequent to verified_stack.
  GArray *predicted_stack;  // 操作和更新栈时，MetaWindow窗口栈的一个临时列表
 
  // Idle function used to sync the compositor's view of the window stack up with our best guess before a frame is drawn.
  guint sync_stack_later;
};

// src/core/keybindings.c
static void handle_switch (MetaDisplay *display, MetaWindow *event_window, ClutterKeyEvent *event, MetaKeyBinding  *binding, gpointer dummy) {
  gboolean backwards = meta_key_binding_is_reversed (binding);
  // backwards = false;
  do_choose_window (display, event_window, event, binding, backwards);
}
 
static void do_choose_window (MetaDisplay *display, MetaWindow *event_window, ClutterKeyEvent *event, MetaKeyBinding  *binding, gboolean backward){
  MetaWorkspaceManager *workspace_manager = display->workspace_manager;
  // type = META_TAB_LIST_NORMAL
  MetaTabList type = binding->handler->data;
  // 获取当前焦点窗口的下一个窗口
  MetaWindow *window = meta_display_get_tab_next (display, type, workspace_manager->active_workspace, NULL, backward);
 
  // 激活该窗口
  if (window)
    meta_window_activate (window, event->time);
}

void meta_window_activate (MetaWindow *window, guint32 timestamp){
  // We're not really a pager, but the behavior we want is the same as if we were such.
  // If we change the pager behavior later, we could revisit this and just add extra flags to window_activate.
  meta_window_activate_full (window, timestamp, META_CLIENT_TYPE_PAGER, NULL);
}
 
// 激活窗口以及与该窗口相关的transient_for属性的窗口
void meta_window_activate_full (MetaWindow *window, guint32 timestamp, MetaClientType  source_indication, MetaWorkspace  *workspace){
  MetaWorkspaceManager *workspace_manager = window->display->workspace_manager;
  // timestamp为0表示最新事件，默认取当前时间戳，比任何窗口的user_time时间戳新
  gboolean allow_workspace_switch = (timestamp != 0);
  if (timestamp != 0 && XSERVER_TIME_IS_BEFORE (timestamp, window->display->last_user_time)){
    // client通过类型为_NET_ACTIVE_WINDOW的atom请求，更新了display的交互时间，比该事件要新，则只设置window的wm_state_demands_attention为真，下次再处理
    meta_window_set_demands_attention(window);
    return;
  }
 
  // 获取最新时间戳
  if (timestamp == 0)
    timestamp = meta_display_get_current_time_roundtrip (window->display);
  // 更新窗口的net_wm_user_time，以及display->last_user_time
  meta_window_set_user_time (window, timestamp);
  /* disable show desktop mode unless we're a desktop component */
  maybe_leave_show_desktop_mode (window);
 
  // For non-transient windows, we just set up a pulsing indicator, rather than move windows or workspaces. See http://bugzilla.gnome.org/show_bug.cgi?id=482354
  if (window->transient_for == NULL && !allow_workspace_switch && !meta_window_located_on_workspace (window, workspace)){
    // 不在工作台中，且事件时间戳为0的普通窗口
    meta_window_set_demands_attention (window);
    return;
  }
  else if (window->transient_for != NULL) {
      /* Move transients to current workspace - preference dialogs should appear over the source window.  */
      // 3类窗口需切换至该工作台，有可能切换不成功，其中两类是由于transient_for属性脱离的关系的窗口，祖先和子孙窗口
      // 1. 自身窗口
      // 2. 将transient_for递归指向该窗口的所有窗口，即该窗口的子孙窗口
      // 3. 该窗口的transient_for指向的窗口，以及transient_for递归指向的祖先窗口。也就是该窗口的祖先窗口
      meta_window_change_workspace (window, workspace);
    }
  // 取消窗口的阴影，client设置该窗口为阴影，当激活时，需取消其阴影窗口
  if (window->shaded)
    meta_window_unshade (window, timestamp);
  // 恢复窗口显示，以及脱离关系的祖先窗口，该窗口的transient_for指向的窗口
  unminimize_window_and_all_transient_parents (window);
 
  // 将窗口显示在最上面，在此上下文下，条件为真，更新compositor，actor的窗口栈顺序
  if (meta_prefs_get_raise_on_click () || source_indication == META_CLIENT_TYPE_PAGER)
    meta_window_raise (window);
  // 窗口在此工作台中，则获取焦点，不在该工作台中，则切换至窗口所在工作台，并使窗口获得焦点
  if (meta_window_located_on_workspace (window, workspace))
    meta_window_focus (window, timestamp);
  else
    meta_workspace_activate_with_focus (window->workspace, window, timestamp);
  // 发送一个ping请求，检测client是否有响应，则弹出关闭对话框
  meta_window_check_alive (window, timestamp);
}

// managed为顶层窗口有序列表，队尾窗口显示在最顶层。
// 更新MetaStackTracker中窗口列表序列，并将更新同步至X11 server，并启动META_LATER_SYNC_STACK延时调用stack_tracker_sync_stack_later，该函数用于同步compositor的窗口栈
void meta_stack_tracker_restack_managed (MetaStackTracker *tracker, const guint64 *managed, int n_managed){
  guint64 *windows;
  int n_windows;
  int old_pos, new_pos;
  if (n_managed == 0)
    return;
  // 获取tracker中的窗口列表，为有序列表，队尾的窗口显示在最顶层
  meta_stack_tracker_get_stack (tracker, &windows, &n_windows);
  // If the top window has to be restacked, we don't want to move it to the very top of the stack,
  // since apps expect override-redirect windows to stay near the top of the X stack;
  // we instead move it above all managed windows (or above the guard window if there are no non-hidden managed windows.)
  old_pos = n_windows - 1;
  // 跳过tracker中不存在的窗口，找到第一个顶级窗口或者guard窗口，顶级窗口为可显示的非override redirect窗口；guard窗口为可显示窗口与非显示窗口的分界线
  for (old_pos = n_windows - 1; old_pos >= 0; old_pos--) {
    MetaWindow *old_window = meta_display_lookup_stack_id (tracker->display, windows[old_pos]);
    if ((old_window && !old_window->override_redirect && !old_window->unmanaging) || meta_stack_tracker_is_guard_window (tracker, windows[old_pos]))
      break;
  }
 
  new_pos = n_managed - 1;
  if (managed[new_pos] != windows[old_pos]){
    // Move the first managed window in the new stack above all managed windows
    // 更新MetaStackTracer，将new窗口移至old窗口位置，其它窗口对应移一位。对于X11窗口，发送XConfigureWindow至X11 server同步窗口叠层。
   meta_stack_tracker_raise_above (tracker, managed[new_pos], windows[old_pos]);
    // 重新获取windows，更新了window在tracer中的位置
    meta_stack_tracker_get_stack (tracker, &windows, &n_windows);
  }
  old_pos--;
  new_pos--;
 
  while (old_pos >= 0 && new_pos >= 0) {
    if (meta_stack_tracker_is_guard_window (tracker, windows[old_pos]))
      break;
    // 窗口的相对位置未变，则跳过
    if (windows[old_pos] == managed[new_pos]){
      old_pos--;
      new_pos--;
      continue;
    }
    // window不在tracker中，或者为override_redirect和unmanaging窗口，则跳过。managed中不存在这些窗口
    MetaWindow *old_window = meta_display_lookup_stack_id (tracker->display, windows[old_pos]);
    if (!old_window || old_window->override_redirect || old_window->unmanaging){
       old_pos--;
       continue;
    }
    // 更新MetaStackTracer，将new_pos窗口移至new_pos+1窗口后面，其它窗口对应移一位。对于X11窗口，发送XConfigureWindow至X11 server同步窗口叠层。
   meta_stack_tracker_lower_below (tracker, managed[new_pos], managed[new_pos + 1]);
    meta_stack_tracker_get_stack (tracker, &windows, &n_windows);
    // Moving managed[new_pos] above windows[old_pos] moves the window at old_pos down by one, we'll examine it again to see if it matches the next new window
    old_pos--;
    new_pos--;
  }
  while (new_pos > 0) {
      meta_stack_tracker_lower_below (tracker, managed[new_pos], managed[new_pos - 1]);
      new_pos--;
    }
}
 
// 将window移至sibling位置，其它窗口相应移一位，类似于ALT+TAB键的窗口切换，下层窗口移至最前面
static void meta_stack_tracker_raise_above (MetaStackTracker *tracker, guint64 window, guint64 sibling) {
  gulong serial = 0;
  MetaX11Display *x11_display = tracker->display->x11_display;
  if (META_STACK_ID_IS_X11 (window)) {
    // 向X11 server同步窗口堆叠层次请求，由X11 server处理该请求
    XWindowChanges changes;
    changes.sibling = sibling ? find_x11_sibling_downwards (tracker, sibling) : None;
    if (changes.sibling != find_x11_sibling_downwards (tracker, window)){
      serial = XNextRequest (x11_display->xdisplay);
      meta_x11_error_trap_push (x11_display);
      changes.stack_mode = changes.sibling ? Above : Below;
      XConfigureWindow (x11_display->xdisplay, (Window)window, (changes.sibling ? CWSibling : 0) | CWStackMode, &changes);
      meta_x11_error_trap_pop (x11_display);
    }
  }
  // 更新MetaStackTracer的窗口列表
  meta_stack_tracker_record_raise_above (tracker, window, sibling, serial);
}
 
static void meta_stack_tracker_record_raise_above (MetaStackTracker *tracker, guint64 window, guint64 sibling, gulong serial){
  MetaStackOp *op = g_new0 (MetaStackOp, 1);
  op->any.type = STACK_OP_RAISE_ABOVE;
  op->any.serial = serial;
  op->any.window = window;
  op->raise_above.sibling = sibling;
  stack_tracker_apply_prediction (tracker, op);
}
 
static void stack_tracker_apply_prediction (MetaStackTracker *tracker, MetaStackOp *op) {
  gboolean free_at_end = FALSE;
  // If this operation doesn't involve restacking X windows then it's implicitly verified.
  // We can apply it immediately unless there are outstanding X restacks that haven't yet been confirmed.
  if (op->any.serial == 0 && tracker->unverified_predictions->length == 0) {
    if (meta_stack_op_apply (tracker, op, tracker->verified_stack, APPLY_DEFAULT))
      meta_stack_tracker_queue_sync_stack (tracker);
    free_at_end = TRUE;
  }
  else {
    g_queue_push_tail (tracker->unverified_predictions, op);
  }
  // 启动MetaLater，用于延后处理compositor的窗口栈同步（stack_tracker_sync_stack_later）
  if (!tracker->predicted_stack || meta_stack_op_apply (tracker, op, tracker->predicted_stack, APPLY_DEFAULT))
    meta_stack_tracker_queue_sync_stack (tracker);
  if (free_at_end)
    meta_stack_op_free (op);
}
 
void meta_stack_tracker_queue_sync_stack (MetaStackTracker *tracker){
  if (tracker->sync_stack_later == 0) {
    tracker->sync_stack_later = meta_later_add (META_LATER_SYNC_STACK, stack_tracker_sync_stack_later, tracker, NULL);
  }
}

static gboolean stack_tracker_sync_stack_later (gpointer data){
  meta_stack_tracker_sync_stack (data);
  return FALSE;
}
 
void meta_stack_tracker_sync_stack (MetaStackTracker *tracker){
  guint64 *windows;
  GList *meta_windows;
  int n_windows;
  int i;
 
  if (tracker->sync_stack_later) {
    meta_later_remove (tracker->sync_stack_later);
    tracker->sync_stack_later = 0;
  }
  // 将override redirect层的窗口提到最上层，有可能更新MetaStackTracker的窗口栈，形成循环调用
  meta_stack_tracker_keep_override_redirect_on_top (tracker);
  meta_stack_tracker_get_stack (tracker, &windows, &n_windows);
  meta_windows = NULL;
  for (i = 0; i < n_windows; i++){
    guint64 window = windows[i];
    if (META_STACK_ID_IS_X11 (window)){
      MetaX11Display *x11_display = tracker->display->x11_display;
      MetaWindow *meta_window = NULL;
 
      if (x11_display)
         meta_window = meta_x11_display_lookup_x_window (x11_display, (Window) window);
       // When mapping back from xwindow to MetaWindow we have to be a bit careful;
       // children of the root could include unmapped windows created by toolkits for internal purposes, including ones that we have registered in our XID => window table.
       // (Wine uses a toplevel for _NET_WM_USER_TIME_WINDOW; see window-prop.c:reload_net_wm_user_time_window() for registration.)
       if (meta_window && ((Window)window == meta_window->xwindow || (meta_window->frame && (Window)window == meta_window->frame->xwindow)))
         meta_windows = g_list_prepend (meta_windows, meta_window);
    }
    else
      meta_windows = g_list_prepend (meta_windows, meta_display_lookup_stamp (tracker->display, window));
  }
  // 同步compositor的窗口栈，即MetaWindowActor栈
  meta_compositor_sync_stack (tracker->display->compositor, meta_windows);
  g_list_free (meta_windows);
  meta_display_restacked (tracker->display);
}
 
void meta_compositor_sync_stack (MetaCompositor  *compositor, GList *stack){
  MetaCompositorPrivate *priv = meta_compositor_get_instance_private (compositor);
  GList *old_stack;
  // This is painful because hidden windows that we are in the process of animating out of existence.
  // They'll be at the bottom of the stack of X windows, but we want to leave them in their old position until the animation effect finishes.
  /* Sources: first window is the highest */
  stack = g_list_copy (stack); /* The new stack of MetaWindow */
  old_stack = g_list_reverse (priv->windows); /* The old stack of MetaWindowActor */
  priv->windows = NULL;
  while (TRUE){
    MetaWindowActor *old_actor = NULL, *stack_actor = NULL, *actor;
    MetaWindow *old_window = NULL, *stack_window = NULL, *window;
 
    // Find the remaining top actor in our existing stack (ignoring windows that have been hidden and are no longer animating)
    while (old_stack) {
      old_actor = old_stack->data;
      old_window = meta_window_actor_get_meta_window (old_actor);
      if ((old_window->hidden || old_window->unmanaging) && !meta_window_actor_effect_in_progress (old_actor)){
        old_stack = g_list_delete_link (old_stack, old_stack);
        old_actor = NULL;
      }
      else
        break;
    }
 
    /* And the remaining top actor in the new stack */
    while (stack) {
      stack_window = stack->data;
      stack_actor = meta_window_actor_from_window (stack_window);
      if (!stack_actor) {
        stack = g_list_delete_link (stack, stack);
      }
      else
        break;
    }
    if (!old_actor && !stack_actor) /* Nothing more to stack */
      break;
 
    // We usually prefer the window in the new stack, but if we found a hidden window in the process of being animated out of existence in the old stack we use that instead.
    // We've filtered out non-animating hidden windows above.
    if (old_actor && (!stack_actor || old_window->hidden || old_window->unmanaging)){
      actor = old_actor;
      window = old_window;
    }
    else{
      actor = stack_actor;
      window = stack_window;
    }
 
    // OK, we know what actor we want next. Add it to our window list, and remove it from both source lists.
    // (It will be at the front of at least one, hopefully it will be near the front of the other.)
    priv->windows = g_list_prepend (priv->windows, actor);
    stack = g_list_remove (stack, window);
    old_stack = g_list_remove (old_stack, actor);
  }
  sync_actor_stacking (compositor);
  update_top_window_actor (compositor);
}
 
// 根据compositor的MetaWindowActor序更新ClutterActor类型中的窗口栈
static void sync_actor_stacking (MetaCompositor *compositor){
  MetaCompositorPrivate *priv = meta_compositor_get_instance_private (compositor);
  GList *children;
  GList *expected_window_node;
  GList *tmp;
  GList *old;
  GList *backgrounds;
  gboolean has_windows;
  gboolean reordered;
 
  // NB: The first entries in the lists are stacked the lowest
  // Restacking will trigger full screen redraws, so it's worth a little effort to make sure we actually need to restack before we go ahead and do it
  children = clutter_actor_get_children (priv->window_group);
  has_windows = FALSE;
  reordered = FALSE;
  // We allow for actors in the window group other than the actors we know about, but it's up to a plugin to try and keep them stacked correctly
  // First we collect a list of all backgrounds, and check if they're at the bottom. Then we check if the window actors are in the correct sequence
  backgrounds = NULL;
  expected_window_node = priv->windows;
  for (old = children; old != NULL; old = old->next){
    ClutterActor *actor = old->data;
    if (META_IS_BACKGROUND_GROUP (actor) || META_IS_BACKGROUND_ACTOR (actor)){
      backgrounds = g_list_prepend (backgrounds, actor);
      // background actor在window actor的上面，则需要重排
      if (has_windows)
        reordered = TRUE;
    }
    else if (META_IS_WINDOW_ACTOR (actor) && !reordered){
      has_windows = TRUE;
      // 跟composite的窗口序一致，则不需要重排，否则需要重排
      if (expected_window_node != NULL && actor == expected_window_node->data)
        expected_window_node = expected_window_node->next;
      else
        reordered = TRUE;
    }
  }
  g_list_free (children);
  if (!reordered){
    g_list_free (backgrounds);
    return;
  }
 
  // reorder the actors by lowering them in turn to the bottom of the stack. windows first, then background.
  // We reorder the actors even if they're not parented to the window group, to allow stacking to work with intermediate actors (eg during effects)
  for (tmp = g_list_last (priv->windows); tmp != NULL; tmp = tmp->prev){
    ClutterActor *actor = tmp->data, *parent;
    parent = clutter_actor_get_parent (actor);
    clutter_actor_set_child_below_sibling (parent, actor, NULL);
  }
 
  // we prepended the backgrounds above so the last actor in the list should get lowered to the bottom last.
  for (tmp = backgrounds; tmp != NULL; tmp = tmp->next){
    ClutterActor *actor = tmp->data, *parent;
    parent = clutter_actor_get_parent (actor);
    clutter_actor_set_child_below_sibling (parent, actor, NULL);
  }
  g_list_free (backgrounds);
}

static void meta_window_show (MetaWindow *window){
  gboolean takes_focus_on_map;
  gboolean place_on_top_on_map;
  gboolean notify_demands_attention = FALSE;
  MetaDisplay *display = window->display;
  MetaWindow *focus_window = window->display->focus_window;  /* May be NULL! */
  gboolean did_show = FALSE;
  gboolean needs_stacking_adjustment = FALSE;
  // window是否需要获取光标，是否需要顶层显示
  window_state_on_map (window, &takes_focus_on_map, &place_on_top_on_map);
 
  // Now, in some rare cases we should *not* put a new window on top.
  // These cases include certain types of windows showing for the first time,
  // and any window which would be covered because of another window being set "above" ("always on top").
 
  // FIXME: Although "place_on_top_on_map" and "takes_focus_on_map" are generally based on the window type,
  // there is a special case when the focus window is a terminal for them both to be false; this should probably rather be a term in the "if" condition below.
  if (focus_window != NULL && window->showing_for_first_time && ((!place_on_top_on_map && !takes_focus_on_map) || window_would_be_covered (window))) {
    if (!meta_window_is_ancestor_of_transient (focus_window, window)){
      needs_stacking_adjustment = TRUE;
      if (!window->placed)
        window->denied_focus_and_not_transient = TRUE;
    }
  }
  if (!window->placed){
    if (window->monitor && meta_prefs_get_auto_maximize() && window->showing_for_first_time && window->has_maximize_func){
      MetaRectangle work_area;
      meta_window_get_work_area_for_monitor (window, window->monitor->number, &work_area);
      /* Automaximize windows that map with a size > MAX_UNMAXIMIZED_WINDOW_AREA of the work area */
      if (window->rect.width * window->rect.height > work_area.width * work_area.height * MAX_UNMAXIMIZED_WINDOW_AREA){
        window->maximize_horizontally_after_placement = TRUE;
        window->maximize_vertically_after_placement = TRUE;
      }
    }
    meta_window_force_placement (window, FALSE);
  }
  if (needs_stacking_adjustment){
    // This window isn't getting focus on map.  We may need to do some special handing with it in regards to
    // the stacking of the window, the MRU position of the window and the demands attention setting of the window.
 
    // Firstly, set the flag so we don't give the window focus anyway and confuse people.
   gboolean overlap = windows_overlap (window, focus_window);
    takes_focus_on_map = FALSE;
    /* We want alt tab to go to the denied-focus window */
    ensure_mru_position_after (window, focus_window);
 
    // We don't want the denied-focus window to obscure the focus window,
    // and if we're in both click-to-focus mode and raise-on-click mode then we want to maintain the invariant that MRU order == stacking order.
    // The need for this if comes from the fact that in sloppy/mouse focus the focus window may not overlap other windows and also can be considered "below" them;
    // this combination means that placing the denied-focus window "below" the focus window in the stack when it doesn't overlap it confusingly places
    // that new window below a lot of other windows.
    if (overlap || (meta_prefs_get_focus_mode () == G_DESKTOP_FOCUS_MODE_CLICK && meta_prefs_get_raise_on_click ()))
      meta_window_stack_just_below (window, focus_window);
 
    // If the window will be obscured by the focus window, then the user might not notice the window appearing so set the demands attention hint.
    // We set the hint ourselves rather than calling meta_window_set_demands_attention() because that would cause a recalculation of overlap,
    // and a call to set_net_wm_state() which we are going to call ourselves here a few lines down.
    if (overlap && !window->wm_state_demands_attention){
      window->wm_state_demands_attention = TRUE;
      notify_demands_attention = TRUE;
    }
  }
  if (window->hidden){
    meta_stack_freeze (window->display->stack);
    window->hidden = FALSE;
    meta_stack_thaw (window->display->stack);
    did_show = TRUE;
  }
  if (window->iconic){
    window->iconic = FALSE;
    set_wm_state (window);
  }
  if (!window->visible_to_compositor){
    MetaCompEffect effect = META_COMP_EFFECT_NONE;
    window->visible_to_compositor = TRUE;
    switch (window->pending_compositor_effect){
      case META_COMP_EFFECT_CREATE:
      case META_COMP_EFFECT_UNMINIMIZE:
        effect = window->pending_compositor_effect;
        break;
      case META_COMP_EFFECT_NONE:
      case META_COMP_EFFECT_DESTROY:
      case META_COMP_EFFECT_MINIMIZE:
        break;
    }
    meta_compositor_show_window (window->display->compositor, window, effect);
    window->pending_compositor_effect = META_COMP_EFFECT_NONE;
  }
 
  // We don't want to worry about all cases from inside implement_showing(); we only want to worry about focus if this window has not been shown before.
  if (window->showing_for_first_time){
    window->showing_for_first_time = FALSE;
    if (takes_focus_on_map){
      guint32     timestamp;
      timestamp = meta_display_get_current_time_roundtrip (window->display);
      meta_window_focus (window, timestamp);
    }
    else if (display->x11_display){
      // Prevent EnterNotify events in sloppy/mouse focus from erroneously focusing the window that had been denied focus.
      // FIXME: This introduces a race; I have a couple ideas for a better way to accomplish the same thing, but they're more involved so do it this way for now.
      meta_x11_display_increment_focus_sentinel (display->x11_display);
    }
  }
  set_net_wm_state (window);
  if (did_show && window->struts){
    invalidate_work_areas (window);
  }
  // 注册MetaLater(META_LATER_CHECK_FULLSCREEN)，延后调用check_fullscreen_func处理全屏
  if (did_show)
    meta_display_queue_check_fullscreen (window->display);
 
  // we have shown the window, we no longer want to consider the initial timestamp in any subsequent deliberations whether to focus this window or not, so clear the flag.
  window->initial_timestamp_set = FALSE;
 
  if (notify_demands_attention){
    g_object_notify_by_pspec (G_OBJECT (window), obj_props[PROP_DEMANDS_ATTENTION]);
    g_signal_emit_by_name (window->display, "window-demands-attention", window);
  }
 
  // on_window_shown (src/wayland/meta-window-wayland.c) : 更新状态
  if (did_show)
    g_signal_emit (window, window_signals[SHOWN], 0);
}

static void meta_window_x11_focus (MetaWindow *window, guint32 timestamp){
  MetaWindowX11 *window_x11 = META_WINDOW_X11 (window);
  MetaWindowX11Private *priv = meta_window_x11_get_instance_private (window_x11);
  // For output-only or shaded windows, focus the frame.
  // This seems to result in the client window getting key events though, so I don't know if it's icccm-compliant.
 
  // Still, we have to do this or keynav breaks for these windows.
  // meta_window_x11_is_focusable : input为真，或者使用"WM_TAKE_FOCUS" atom
  // meta_window_wayland_is_focusable : input为真，可输入的窗口
  if (window->frame && (window->shaded || !meta_window_is_focusable (window))) {
    meta_display_set_input_focus (window->display, window, TRUE, timestamp);
  }
  else {
    if (window->input) {
      meta_display_set_input_focus (window->display,  window, FALSE, timestamp);
    }
    if (priv->wm_take_focus) {
      if (!window->input){
        // The "Globally Active Input" window case, where the window doesn't want us to call XSetInputFocus on it, but does want us to send a WM_TAKE_FOCUS.
        // Normally, we want to just leave the focus undisturbed until the window responds to WM_TAKE_FOCUS,
        // but if we're unmanaging the current focus window we *need* to move the focus away, so we focus the no focus window before sending WM_TAKE_FOCUS,
        // and eventually the default focus window excluding this one, if meanwhile we don't get any focus request.
        if (window->display->focus_window != NULL && window->display->focus_window->unmanaging){
          meta_display_unset_input_focus (window->display, timestamp);
          maybe_focus_default_window (window->display, window, timestamp);
        }
      }
      request_take_focus (window, timestamp);
    }
  }
}
 
void meta_display_set_input_focus (MetaDisplay *display, MetaWindow *window, gboolean focus_frame, guint32 timestamp){
  if (meta_display_timestamp_too_old (display, &timestamp))
    return;
  if (display->x11_display){
    meta_x11_display_set_input_focus (display->x11_display, window, focus_frame, timestamp);
  }
  meta_display_update_focus_window (display, window);
  display->last_focus_time = timestamp;
  if (window == NULL || window != display->autoraise_window)
    meta_display_remove_autoraise_callback (display);
}

// 发送SetInputFocus请求给X11 server，由X11 server处理input focus事件；发送ChangeProperty请求，修改根窗口"_NET_ACTIVE_WINDOW"属性
void meta_x11_display_set_input_focus (MetaX11Display *x11_display, MetaWindow *window, gboolean focus_frame, uint32_t timestamp){
  Window xwindow;
  gulong serial;
  if (window)
    xwindow = focus_frame ? window->frame->xwindow : window->xwindow;
  else
    xwindow = x11_display->no_focus_window;
 
  meta_x11_error_trap_push (x11_display);
  // 发送SetInputFocus请求给X11 server
  meta_x11_display_set_input_focus_internal (x11_display, xwindow, timestamp);
  serial = XNextRequest (x11_display->xdisplay);
  // 修改根窗口"_NET_ACTIVE_WINDOW"属性，发送ChangeProperty请求
  meta_x11_display_update_focus_window (x11_display, xwindow, serial, TRUE);
  meta_x11_error_trap_pop (x11_display);
}
 
static void meta_x11_display_set_input_focus_internal (MetaX11Display *x11_display, Window xwindow, uint32_t timestamp){
  meta_x11_error_trap_push (x11_display);
  // In order for mutter to know that the focus request succeeded, we track the serial of the "focus request" we made, but if we take the serial of the XSetInputFocus request,
  // then there's no way to determine the difference between focus events as a result of the SetInputFocus and focus events that other clients send around the same time.
  // Ensure that we know which is which by making two requests that the server will process at the same time.
  XGrabServer (x11_display->xdisplay);
  // 发送SetInputFocus请求给X11 server，X11处理SetInputFocus实际工作
  XSetInputFocus (x11_display->xdisplay, xwindow, RevertToPointerRoot,timestamp);
  // 更改timestamp_pinging_window窗口属性"_MUTTER_FOCUS_SET"类型，发送ChangeProperty请求该X11 server。
  XChangeProperty (x11_display->xdisplay, x11_display->timestamp_pinging_window, x11_display->atom__MUTTER_FOCUS_SET, XA_STRING, 8, PropModeAppend, NULL, 0);
 
  XUngrabServer (x11_display->xdisplay);
  XFlush (x11_display->xdisplay);
  meta_x11_error_trap_pop (x11_display);
}
 
void meta_x11_display_update_focus_window (MetaX11Display *x11_display, Window xwindow, gulong serial, gboolean focused_by_us){
  x11_display->focus_serial = serial;
  x11_display->focused_by_us = !!focused_by_us;
  if (x11_display->focus_xwindow == xwindow)
    return;
  x11_display->focus_xwindow = xwindow;
  meta_x11_display_update_active_window_hint (x11_display);
}
 
static void meta_x11_display_update_active_window_hint (MetaX11Display *x11_display){
  MetaWindow *focus_window;
  gulong data[1];
  if (x11_display->display->closing)
    return; /* Leave old value for a replacement */
  focus_window = meta_x11_display_lookup_x_window (x11_display, x11_display->focus_xwindow);
 
  if (focus_window)
    data[0] = focus_window->xwindow;
  else
    data[0] = None;
 
  meta_x11_error_trap_push (x11_display);
  XChangeProperty (x11_display->xdisplay, x11_display->xroot, x11_display->atom__NET_ACTIVE_WINDOW, XA_WINDOW, 32, PropModeReplace, (guchar*) data, 1);
  meta_x11_error_trap_pop (x11_display);
}