Refactored full-screen code under FullscreenWindowMac base class and...

plugin/mac/plugin_mac.mm

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 234 matching lines @@
         [o3dLayer setNeedsDisplay];
       }
       return;
     }
 
     ManageSafariTabSwitching(obj);
     obj->client()->Tick();
 
     bool in_fullscreen = obj->GetFullscreenMacWindow();
 
-#ifdef O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
     if (in_fullscreen) {
-      obj->FullscreenIdle();
+      obj->GetFullscreenMacWindow()->IdleCallback();
     }
-#endif
 
     // We're visible if (a) we are in fullscreen mode, (b) our cliprect
     // height and width are both a sensible size, ie > 1 pixel, or (c) if
     // we are rendering to render surfaces (CoreGraphics drawing model,
     // essentially offscreen rendering).
     //
     // We don't check for 0 as we have to size to 1 x 1 on occasion rather than
     // 0 x 0 to avoid crashing the Apple software renderer, but do not want to
     // actually draw to a 1 x 1 pixel area.
     bool plugin_visible = in_fullscreen ||
@@ skipping 93 matching lines @@
     }
   }
   CFReleaseIfNotNull(cfHFSPath);
   CFReleaseIfNotNull(cfPosixPath);
   CFReleaseIfNotNull(cfHFSURL);
   return posix_path;
 }
 
 
 
-// Convenience function for fetching SInt32 parameters from Carbon EventRefs.
-static SInt32 GetIntEventParam(EventRef inEvent, EventParamName    inName) {
-  SInt32    value = 0;
-  return (GetEventParameter(inEvent, inName, typeSInt32, NULL, sizeof(value),
-                            NULL, &value) == noErr) ? value : 0;
-}
-
-
-#pragma mark ____OVERLAY_WINDOW
-
-#ifdef O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
-
-// A little wrapper for ATSUSetAttributes to make calling it with one attribute
-// less annoying.
-static void MySetAttribute(ATSUStyle style,
-                           ATSUAttributeTag tag,
-                           ByteCount size,
-                           ATSUAttributeValuePtr value) {
-
-  ATSUAttributeTag      tags[2]   = {tag, 0};
-  ByteCount             sizes[2]  = {size, 0};
-  ATSUAttributeValuePtr values[2] = {value, 0};
-
-  ATSUSetAttributes(style, 1, tags, sizes, values);
-}
-
-// A little wrapper for ATSUSetLayoutControls to make calling it with one
-// attribute less annoying.
-static void MySetLayoutControl(ATSUTextLayout layout,
-                               ATSUAttributeTag tag,
-                               ByteCount size,
-                               ATSUAttributeValuePtr value) {
-
-  ATSUAttributeTag      tags[2]   = {tag, 0};
-  ByteCount             sizes[2]  = {size, 0};
-  ATSUAttributeValuePtr values[2] = {value, 0};
-
-  ATSUSetLayoutControls(layout, 1, tags, sizes, values);
-}
-
-// Returns the unicode 16 chars that we need to display as the fullscreen
-// message. Should be disposed with free() after use.
-static UniChar * GetFullscreenDisplayText(int *returned_length) {
-  // TODO this will need to be a localized string.
-  NSString* ns_display_text = @"Press ESC to exit fullscreen";
-  int count = [ns_display_text length];
-  UniChar* display_text_16 = (UniChar*) calloc(count, sizeof(UniChar));
-
-  [ns_display_text getCharacters:display_text_16];
-  *returned_length = count;
-  return display_text_16;
-}
-
-
-static void DrawToOverlayWindow(WindowRef overlayWindow) {
-  CGContextRef overlayContext = NULL;
-  CGFloat kWhiteOpaque[]  = {1.0, 1.0, 1.0, 1.0};
-  CGFloat kBlackNotOpaque[]  = {0.0, 0.0, 0.0, 0.5};
-  Rect bounds = {0, 0, 0, 0};
-  const char* kOverlayWindowFontName = "Arial";
-  const int kPointSize  = 22;
-  const float kShadowRadius = 5.0;
-  const float kRoundRectRadius = 9.0;
-  const float kTextLeftMargin = 15.0;
-  const float kTextBottomMargin = 22.0;
-
-  QDBeginCGContext(GetWindowPort(overlayWindow), &overlayContext);
-  GetWindowBounds(overlayWindow, kWindowContentRgn, &bounds);
-
-  // Make the global rect local.
-  bounds.right -= bounds.left;
-  bounds.left = 0;
-  bounds.bottom -= bounds.top;
-  bounds.top = 0;
-
-  CGRect cgTotalRect = Rect2CGRect(bounds);
-  CGContextSetShouldSmoothFonts(overlayContext, true);
-  CGContextClearRect(overlayContext, cgTotalRect);
-
-  CGColorSpaceRef myColorSpace = CGColorSpaceCreateDeviceRGB();
-  CGColorRef shadow = CGColorCreate(myColorSpace, kBlackNotOpaque);
-  CGColorRef roundRectBackColor = CGColorCreate(myColorSpace, kBlackNotOpaque);
-  CGSize shadowOffset = {0.0,0.0};
-
-  CGContextSetFillColor(overlayContext, kWhiteOpaque);
-  CGContextSetStrokeColor(overlayContext, kWhiteOpaque);
-
-    // Draw the round rect background.
-  CGContextSaveGState(overlayContext);
-  CGContextSetFillColorWithColor(overlayContext, roundRectBackColor);
-  CGRect cg_rounded_area =
-      CGRectMake(// Offset from left and bottom to give shadow its space.
-                 kShadowRadius, kShadowRadius,
-                 // Increase width and height so rounded corners
-                 // will be clipped out, except at bottom left.
-                 (bounds.right - bounds.left) + 30,
-                 (bounds.bottom - bounds.top) + 30);
-  // Save state before applying shadow.
-  CGContextSetShadowWithColor(overlayContext, shadowOffset,
-                              kShadowRadius, shadow);
-  PaintRoundedCGRect(overlayContext, cg_rounded_area, kRoundRectRadius, true);
-  // Restore graphics state to remove shadow.
-  CGContextRestoreGState(overlayContext);
-
-  // Draw the text.
-  int text_length = 0;
-  UniChar* display_text = GetFullscreenDisplayText(&text_length);
-
-  if ((text_length > 0) && (display_text != NULL)) {
-    ATSUStyle         style;
-    ATSUTextLayout    layout;
-    ATSUFontID        font;
-    Fixed             pointSize = Long2Fix(kPointSize);
-    Boolean           is_bold = true;
-
-    ATSUCreateStyle(&style);
-    ATSUFindFontFromName(kOverlayWindowFontName, strlen(kOverlayWindowFontName),
-                         kFontFullName, kFontNoPlatformCode, kFontNoScriptCode,
-                         kFontNoLanguageCode, &font);
-
-    MySetAttribute(style, kATSUFontTag, sizeof(font), &font);
-    MySetAttribute(style, kATSUSizeTag, sizeof(pointSize), &pointSize);
-    MySetAttribute(style, kATSUQDBoldfaceTag, sizeof(Boolean), &is_bold);
-
-
-    ATSUCreateTextLayout(&layout);
-    ATSUSetTextPointerLocation(layout, display_text,
-                               kATSUFromTextBeginning, kATSUToTextEnd,
-                               text_length);
-    ATSUSetRunStyle(layout, style, kATSUFromTextBeginning, kATSUToTextEnd);
-
-    MySetLayoutControl(layout, kATSUCGContextTag,
-                       sizeof(CGContextRef),  &overlayContext);
-
-    // Need to enable this for languages like Japanese to draw as something
-    // other than a series of squares.
-    ATSUSetTransientFontMatching(layout, true);
-
-
-    CGContextSetFillColor(overlayContext, kWhiteOpaque);
-    ATSUDrawText(layout, kATSUFromTextBeginning, kATSUToTextEnd,
-                 X2Fix(kShadowRadius + kTextLeftMargin),
-                 X2Fix(kShadowRadius + kTextBottomMargin));
-    ATSUDisposeStyle(style);
-    ATSUDisposeTextLayout(layout);
-    free(display_text);
-  }
-
-  CGColorRelease(roundRectBackColor);
-  CGColorRelease(shadow);
-  CGColorSpaceRelease (myColorSpace);
-
-  QDEndCGContext(GetWindowPort(overlayWindow), &overlayContext);
-}
-
-static OSStatus HandleOverlayWindow(EventHandlerCallRef inHandlerCallRef,
-                                    EventRef inEvent,
-                                    void *inUserData) {
-  OSType event_class = GetEventClass(inEvent);
-  OSType event_kind = GetEventKind(inEvent);
-
-  if (event_class == kEventClassWindow &&
-      event_kind == kEventWindowPaint) {
-      WindowRef theWindow = NULL;
-    GetEventParameter(inEvent, kEventParamDirectObject,
-                      typeWindowRef, NULL,
-                      sizeof(theWindow), NULL,
-                      &theWindow);
-    if (theWindow) {
-      CallNextEventHandler(inHandlerCallRef, inEvent);
-      DrawToOverlayWindow(theWindow);
-    }
-  }
-
-  return noErr;
-}
-
-
-
-static Rect GetOverlayWindowRect(bool visible) {
-#define kOverlayHeight 60
-#define kOverlayWidth 340
-  Rect screen_bounds = CGRect2Rect(CGDisplayBounds(CGMainDisplayID()));
-  Rect hidden_window_bounds = {screen_bounds.top - kOverlayHeight,
-                               screen_bounds.right - kOverlayWidth,
-                               screen_bounds.top,
-                               screen_bounds.right};
-  Rect visible_window_bounds = {screen_bounds.top,
-                                screen_bounds.right - kOverlayWidth,
-                                screen_bounds.top + kOverlayHeight,
-                                screen_bounds.right};
-
-  return (visible) ? visible_window_bounds : hidden_window_bounds;
-}
-
-
-static WindowRef CreateOverlayWindow(void) {
-  Rect        window_bounds = GetOverlayWindowRect(false);
-  WindowClass wClass = kOverlayWindowClass;
-  WindowRef   window = NULL;
-  OSStatus    err = noErr;
-  WindowAttributes  overlayAttributes = kWindowNoShadowAttribute |
-                                        kWindowIgnoreClicksAttribute |
-                                        kWindowNoActivatesAttribute |
-                                        kWindowStandardHandlerAttribute;
-  EventTypeSpec  eventTypes[] = {
-    {kEventClassWindow, kEventWindowPaint},
-    {kEventClassWindow, kEventWindowShown}
-  };
-
-  err = CreateNewWindow(wClass,
-                        overlayAttributes,
-                        &window_bounds,
-                        &window);
-  if (err)
-    return NULL;
-
-  SetWindowLevel(window, CGShieldingWindowLevel() + 1);
-  InstallEventHandler(GetWindowEventTarget(window), HandleOverlayWindow,
-                      sizeof(eventTypes)/sizeof(eventTypes[0]), eventTypes,
-                      NULL, NULL);
-  ShowWindow(window);
-
-  return window;
-}
-
-#endif  // O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
-
-
-// Maps the MacOS button numbers to the constants used by our
-// event mechanism.  Not quite as obvious as you might think, as the Mac
-// thinks the numbering should go left, right, middle and our W3C-influenced
-// system goes left, middle, right.
-// Defaults to left-button if passed a strange value.  Pass Cocoa mouse button
-// codes as-is (they start at 0), pass Carbon button codes - 1.
-o3d::Event::Button MacOSMouseButtonNumberToO3DButton(int inButton) {
-
-  switch(inButton) {
-    case 0:
-      return o3d::Event::BUTTON_LEFT;
-    case 1:
-      return o3d::Event::BUTTON_RIGHT;
-    case 2:
-      return o3d::Event::BUTTON_MIDDLE;
-    case 3:
-      return o3d::Event::BUTTON_4;
-    case 4:
-      return o3d::Event::BUTTON_5;
-  }
-
-  return o3d::Event::BUTTON_LEFT;
-}
-
-
-#pragma mark ____FULLSCREEN_WINDOW
-
-
-// Handles the CarbonEvents that we get sent for the fullscreen mode window.
-// Most of these can be converted to EventRecord events and handled by the
-// HandleMacEvent() function in main_mac.mm, but some have no equivalent in
-// that space, scroll-wheel events for example, and so must be handled here.
-static OSStatus HandleFullscreenWindow(EventHandlerCallRef inHandlerCallRef,
-                                       EventRef inEvent,
-                                       void *inUserData) {
-  OSType event_class = GetEventClass(inEvent);
-  OSType event_kind = GetEventKind(inEvent);
-  NPP instance = (NPP)inUserData;
-  PluginObject* obj = (PluginObject*)(instance->pdata);
-  HIPoint mouse_loc = { 0.0, 0.0 };
-  bool is_scroll_event = event_class == kEventClassMouse &&
-                         (event_kind == kEventMouseScroll ||
-                          event_kind == kEventMouseWheelMoved);
-
-  // If it's any kind of mouse event, get the global mouse loc.
-  if (event_class == kEventClassMouse) {
-    GetEventParameter(inEvent, kEventParamMouseLocation,
-                      typeHIPoint, NULL,
-                      sizeof(mouse_loc), NULL,
-                      &mouse_loc);
-  }
-
-  // Handle the two kinds of scroll message we understand.
-  if (is_scroll_event) {
-    SInt32 x_scroll = 0;
-    SInt32 y_scroll = 0;
-    EventMouseWheelAxis axis = kEventMouseWheelAxisY;
-
-    switch (event_kind) {
-      // The newer kind of scroll event, as sent when two-finger
-      // dragging on a touchpad.
-      case kEventMouseScroll:
-        x_scroll = GetIntEventParam(inEvent,
-                                    kEventParamMouseWheelSmoothHorizontalDelta);
-        y_scroll = GetIntEventParam(inEvent,
-                                    kEventParamMouseWheelSmoothVerticalDelta);
-
-        // only pass x or y value - pass whichever is larger
-        if (x_scroll && y_scroll) {
-          if (abs(x_scroll) > abs(y_scroll))
-            y_scroll = 0;
-          else
-            x_scroll = 0;
-        }
-        break;
-        // The older kind of scroll event, as sent when using the wheel on
-        // a third-party mouse.
-      case kEventMouseWheelMoved:
-        GetEventParameter(inEvent,  kEventParamMouseWheelAxis,
-                          typeMouseWheelAxis, NULL,
-                          sizeof(axis), NULL,
-                          &axis);
-
-        if (axis == kEventMouseWheelAxisY) {
-          y_scroll = GetIntEventParam(inEvent,
-                                      kEventParamMouseWheelDelta);
-        } else {
-          x_scroll = GetIntEventParam(inEvent,
-                                      kEventParamMouseWheelDelta);
-        }
-        break;
-    }
-
-    // Dispatch the event now that we have all the data.
-    if (x_scroll || y_scroll) {
-      o3d::Event event(o3d::Event::TYPE_WHEEL);
-      event.set_delta(x_scroll, y_scroll);
-      // Global and local locs are the same, in this case,
-      // as we have a fullscreen window at 0,0.
-      event.set_position(mouse_loc.x, mouse_loc.y,
-                         mouse_loc.x, mouse_loc.y, true);
-      obj->client()->AddEventToQueue(event);
-    }
-    return noErr;
-  } else if (event_class == kEventClassMouse &&
-             (event_kind == kEventMouseDown || event_kind == kEventMouseUp)) {
-
-    o3d::Event::Type type = (event_kind == kEventMouseDown) ?
-                            o3d::Event::TYPE_MOUSEDOWN :
-                            o3d::Event::TYPE_MOUSEUP;
-    o3d::Event event(type);
-    event.set_position(mouse_loc.x, mouse_loc.y,
-                       mouse_loc.x, mouse_loc.y, true);
-
-    EventMouseButton button = 0;
-    GetEventParameter(inEvent,  kEventParamMouseButton,
-                      typeMouseButton, NULL,
-                      sizeof(button), NULL,
-                      &button);
-    // Carbon mouse button numbers start at 1, so subtract 1 here -
-    // Cocoa mouse buttons, by contrast,  start at 0).
-    event.set_button(MacOSMouseButtonNumberToO3DButton(button - 1));
-
-    // add the modifiers to the event, if any
-    UInt32 carbonMods = GetIntEventParam(inEvent,
-                                         kEventParamKeyModifiers);
-    if (carbonMods) {
-      int modifier_state = 0;
-      if (carbonMods & controlKey) {
-        modifier_state |= o3d::Event::MODIFIER_CTRL;
-      }
-      if (carbonMods & shiftKey) {
-        modifier_state |= o3d::Event::MODIFIER_SHIFT;
-      }
-      if (carbonMods & optionKey) {
-        modifier_state |= o3d::Event::MODIFIER_ALT;
-      }
-      if (carbonMods & cmdKey) {
-        modifier_state |= o3d::Event::MODIFIER_META;
-      }
-
-      event.set_modifier_state(modifier_state);
-    }
-
-    obj->client()->AddEventToQueue(event);
-  } else {  // not a scroll event or a click
-
-    // All other events are currently handled by being converted to an
-    // old-style EventRecord as passed by the classic NPAPI interface
-    // and dispatched through our common routine.
-    EventRecord eventRecord;
-
-    if (ConvertEventRefToEventRecord(inEvent, &eventRecord)) {
-      HandleMacEvent(&eventRecord, (NPP)inUserData);
-      return noErr;
-    } else {
-      return eventNotHandledErr;
-    }
-  }
-  return noErr;
-}
-
-
-static WindowRef CreateFullscreenWindow(WindowRef window,
-                                        PluginObject *obj,
-                                        int mode_id) {
-  Rect        bounds = CGRect2Rect(CGDisplayBounds(CGMainDisplayID()));
-  OSStatus    err = noErr;
-  EventTypeSpec  eventTypes[] = {
-    {kEventClassKeyboard, kEventRawKeyDown},
-    {kEventClassKeyboard, kEventRawKeyRepeat},
-    {kEventClassKeyboard, kEventRawKeyUp},
-    {kEventClassMouse,    kEventMouseDown},
-    {kEventClassMouse,    kEventMouseUp},
-    {kEventClassMouse,    kEventMouseMoved},
-    {kEventClassMouse,    kEventMouseDragged},
-    {kEventClassMouse,    kEventMouseScroll},
-    {kEventClassMouse,    kEventMouseWheelMoved}
-  };
-
-  if (window == NULL)
-    err = CreateNewWindow(kSimpleWindowClass,
-                          kWindowStandardHandlerAttribute,
-                          &bounds,
-                          &window);
-  if (err)
-    return NULL;
-
-  SetWindowLevel(window, CGShieldingWindowLevel() + 1);
-
-  InstallEventHandler(GetWindowEventTarget(window), HandleFullscreenWindow,
-                      sizeof(eventTypes)/sizeof(eventTypes[0]), eventTypes,
-                      obj->npp(), NULL);
-  ShowWindow(window);
-  return window;
-}
-
-void CleanupFullscreenWindow(PluginObject *obj) {
-  WindowRef fs_window = obj->GetFullscreenMacWindow();
-#ifdef O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
-  WindowRef fs_o_window = obj->GetFullscreenOverlayMacWindow();
-#endif
-
-  obj->SetFullscreenMacWindow(NULL);
-#ifdef O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
-  obj->SetFullscreenOverlayMacWindow(NULL);
-#endif
-
-  if (fs_window) {
-    HideWindow(fs_window);
-    ReleaseWindowGroup(GetWindowGroup(fs_window));
-    DisposeWindow(fs_window);
-  }
-
-#ifdef O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
-  if(fs_o_window) {
-    HideWindow(fs_o_window);
-    ReleaseWindowGroup(GetWindowGroup(fs_o_window));
-    DisposeWindow(fs_o_window);
-  }
-#endif
-}
-
 #pragma mark ____SCREEN_RESOLUTION_MANAGEMENT
 
 
 // Constant kO3D_MODE_OFFSET is added to the position in the array returned by
 // CGDisplayAvailableModes to make it an ID. This makes IDs distinguishable from
 // array positions when debugging, and also means that ID 0 can have a special
 // meaning (current mode) rather than meaning the first resolution in the list.
 const int kO3D_MODE_OFFSET = 100;
 
 // Extracts data from the Core Graphics screen mode data passed in.
@@ skipping 47 matching lines @@
 
   return false;
 }
 
 
 static int GetCGDisplayModeID(NSDictionary* mode_dict) {
   return [[mode_dict valueForKey:@"Mode"] intValue];
 }
 
 // Returns DisplayMode data for the current state of the main display.
-static void GetCurrentDisplayMode(o3d::DisplayMode *mode) {
+void GetCurrentDisplayMode(o3d::DisplayMode *mode) {
   int width = 0;
   int height = 0;
   int refresh_rate = 0;
   int bpp = 0;
   int mode_id = 0;
 
   NSDictionary* current_mode =
       (NSDictionary*)CGDisplayCurrentMode(CGMainDisplayID());
 
   // To get the O3D mode id of the current mode, we need to find it in the list
@@ skipping 52 matching lines @@
       modes_found.push_back(o3d::DisplayMode(width, height, refresh_rate,
                                              i + o3d::kO3D_MODE_OFFSET));
   }
 
   modes->swap(modes_found);
 }
 
 
 #pragma mark ____FULLSCREEN_SWITCHING
 
-#define kTransitionTime 1.0
-
 namespace glue {
 namespace _o3d {
 
 bool PluginObject::RequestFullscreenDisplay() {
   // If already in fullscreen mode, do nothing.
   if (GetFullscreenMacWindow())
     return false;
 
   int target_width = 0;
   int target_height = 0;
 
   if (fullscreen_region_valid_ &&
       fullscreen_region_mode_id_ != Renderer::DISPLAY_MODE_DEFAULT) {
     o3d::DisplayMode the_mode;
     if (GetDisplayMode(fullscreen_region_mode_id_, &the_mode)) {
       target_width = the_mode.width();
       target_height = the_mode.height();
     }
   }
 
-  // check which mode we are in now
-  o3d::DisplayMode current_mode;
-  GetCurrentDisplayMode(&current_mode);
+  FullscreenWindowMac* fullscreen_window =
+      FullscreenWindowMac::Create(this, target_width, target_height);
+  SetFullscreenMacWindow(fullscreen_window);
+  Rect bounds = o3d::CGRect2Rect(fullscreen_window->GetWindowBounds());
 
-  WindowRef fullscreen_window = NULL;
-
-  // Determine if screen mode switching is actually required.
-  if (target_width != 0 &&
-      target_height != 0 &&
-      target_width != current_mode.width() &&
-      target_height != current_mode.height()) {
-    short short_target_width = target_width;
-    short short_target_height = target_height;
-    BeginFullScreen(&mac_fullscreen_state_,
-                    nil,  // Value of nil selects the main screen.
-                    &short_target_width,
-                    &short_target_height,
-                    &fullscreen_window,
-                    NULL,
-                    fullScreenCaptureAllDisplays);
-  } else {
-    SetSystemUIMode(kUIModeAllSuppressed, kUIOptionAutoShowMenuBar);
-    mac_fullscreen_state_ = NULL;
-  }
-
-  SetFullscreenMacWindow(o3d::CreateFullscreenWindow(
-      NULL,
-      this,
-      fullscreen_region_mode_id_));
-  Rect bounds = {0,0,0,0};
-  GetWindowBounds(GetFullscreenMacWindow(), kWindowContentRgn, &bounds);
-
-  o3d::SetWindowForAGLContext(mac_agl_context_, GetFullscreenMacWindow());
-  aglDisable(mac_agl_context_, AGL_BUFFER_RECT);
   renderer()->SetClientOriginOffset(0, 0);
   renderer_->Resize(bounds.right - bounds.left, bounds.bottom - bounds.top);
 
   fullscreen_ = true;
   client()->SendResizeEvent(renderer_->width(), renderer_->height(), true);
 
-#ifdef O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
-  SetFullscreenOverlayMacWindow(o3d::CreateOverlayWindow());
-  ShowWindow(mac_fullscreen_overlay_window_);
-  o3d::SlideWindowToRect(mac_fullscreen_overlay_window_,
-                         o3d::Rect2CGRect(o3d::GetOverlayWindowRect(true)),
-                         kTransitionTime);
-
-  // Hide the overlay text 4 seconds from now.
-  time_to_hide_overlay_ = [NSDate timeIntervalSinceReferenceDate] + 4.0;
-#endif
-
   return true;
 }
 
 void PluginObject::CancelFullscreenDisplay() {
   // if not in fullscreen mode, do nothing
   if (!GetFullscreenMacWindow())
     return;
 
-  o3d::SetWindowForAGLContext(mac_agl_context_, mac_window_);
-
-  o3d::CleanupFullscreenWindow(this);
-
+  GetFullscreenMacWindow()->Shutdown(last_buffer_rect_);
+  SetFullscreenMacWindow(NULL);
   renderer_->Resize(prev_width_, prev_height_);
-  aglSetInteger(mac_agl_context_, AGL_BUFFER_RECT, last_buffer_rect_);
-  aglEnable(mac_agl_context_, AGL_BUFFER_RECT);
-
-  if (mac_fullscreen_state_) {
-    EndFullScreen(mac_fullscreen_state_, 0);
-    mac_fullscreen_state_ = NULL;
-  } else {
-    SetSystemUIMode(kUIModeNormal, 0);
-  }
   fullscreen_ = false;
   client()->SendResizeEvent(prev_width_, prev_height_, false);
 
-
   // Somehow the browser window does not automatically activate again
   // when we close the fullscreen window, so explicitly reactivate it.
   if (mac_cocoa_window_) {
     NSWindow* browser_window = (NSWindow*) mac_cocoa_window_;
     [browser_window makeKeyAndOrderFront:browser_window];
   } else if (mac_window_) {
     SelectWindow(mac_window_);
   }
 }
 
-#ifdef O3D_PLUGIN_ENABLE_FULLSCREEN_MSG
-void PluginObject::FullscreenIdle() {
-  if ((mac_fullscreen_overlay_window_ != NULL) &&
-      (time_to_hide_overlay_ != 0.0) &&
-      (time_to_hide_overlay_ < [NSDate timeIntervalSinceReferenceDate])) {
-    time_to_hide_overlay_ = 0.0;
-    o3d::SlideWindowToRect(mac_fullscreen_overlay_window_,
-                           o3d::Rect2CGRect(o3d::GetOverlayWindowRect(false)),
-                           kTransitionTime);
-  }
-}
-#endif
-
 }  // namespace glue
 }  // namespace o3d