Aura under Linux

chrome/browser/ui/gtk/gtk_util.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/gtk/gtk_util.h"
 
 #include <cairo/cairo.h>
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 
@@ skipping 171 matching lines @@
 
 #else
 
 TabContents* GetBrowserWindowSelectedTabContents(BrowserWindow* window) {
   BrowserWindowGtk* browser_window = static_cast<BrowserWindowGtk*>(
       window);
   return browser_window->browser()->GetSelectedTabContents();
 }
 
 GtkWidget* GetBrowserWindowFocusedWidget(BrowserWindow* window) {
+#if defined(USE_AURA)
+  // TODO(saintlou): This entire module should be removed from Aura soon

[Ben Goodger (Google), 2011/09/16 01:11:18]

Why do you need to build this file?

[Emmanuel Saint-loubert-Bié, 2011/09/16 02:34:54]

There are a few methods that we need, but will be gone post-GTK. We could also
break them up.

+  return NULL;
+#else
   return gtk_window_get_focus(window->GetNativeHandle());
+#endif
 }
 
 #endif
 
 }  // namespace
 
 namespace event_utils {
 
 // TODO(shinyak) This function will be removed after refactoring.
 WindowOpenDisposition DispositionFromGdkState(guint state) {
@@ skipping 181 matching lines @@
 
   // Move to user expected desktop if window is already visible.
   if (GTK_WIDGET(window)->window) {
     ui::ChangeWindowDesktop(
         ui::GetX11WindowFromGtkWidget(GTK_WIDGET(window)),
         ui::GetX11WindowFromGtkWidget(GTK_WIDGET(parent)));
   }
 }
 
 void MakeAppModalWindowGroup() {
+#if defined(USE_AURA)
+  // TODO(saintlou): This entire module should be removed from Aura soon
+  return;
+#else
   // Older versions of GTK+ don't give us gtk_window_group_list() which is what
   // we need to add current non-browser modal dialogs to the list. If
   // we have 2.14+ we can do things the correct way.
   GtkWindowGroup* window_group = gtk_window_group_new();
   for (BrowserList::const_iterator it = BrowserList::begin();
        it != BrowserList::end(); ++it) {
     // List all windows in this current group
     GtkWindowGroup* old_group =
         gtk_window_get_group((*it)->window()->GetNativeHandle());
 
     GList* all_windows = gtk_window_group_list_windows(old_group);
     for (GList* window = all_windows; window; window = window->next) {
       gtk_window_group_add_window(window_group, GTK_WINDOW(window->data));
     }
     g_list_free(all_windows);
   }
   g_object_unref(window_group);
+#endif
 }
 
 void AppModalDismissedUngroupWindows() {
+#if defined(USE_AURA)
+  // TODO(saintlou): This entire module should be removed from Aura soon
+  return;
+#else
   if (BrowserList::begin() != BrowserList::end()) {
     std::vector<GtkWindow*> transient_windows;
 
     // All windows should be part of one big modal group right now.
     GtkWindowGroup* window_group = gtk_window_get_group(
         (*BrowserList::begin())->window()->GetNativeHandle());
     GList* windows = gtk_window_group_list_windows(window_group);
 
     for (GList* item = windows; item; item = item->next) {
       GtkWindow* window = GTK_WINDOW(item->data);
       GtkWindow* transient_for = gtk_window_get_transient_for(window);
       if (transient_for) {
         transient_windows.push_back(window);
       } else {
         GtkWindowGroup* window_group = gtk_window_group_new();
         gtk_window_group_add_window(window_group, window);
         g_object_unref(window_group);
       }
     }
 
     // Put each transient window in the same group as its transient parent.
     for (std::vector<GtkWindow*>::iterator it = transient_windows.begin();
          it != transient_windows.end(); ++it) {
       GtkWindow* transient_parent = gtk_window_get_transient_for(*it);
       GtkWindowGroup* group = gtk_window_get_group(transient_parent);
       gtk_window_group_add_window(group, *it);
     }
   }
+#endif
 }
 
 void RemoveAllChildren(GtkWidget* container) {
   gtk_container_foreach(GTK_CONTAINER(container), RemoveWidget, container);
 }
 
 void ForceFontSizePixels(GtkWidget* widget, double size_pixels) {
   PangoFontDescription* font_desc = pango_font_description_new();
   // pango_font_description_set_absolute_size sets the font size in device
   // units, which for us is pixels.
@@ skipping 343 matching lines @@
 
   gtk_style_detach(our_style);
   g_object_unref(our_style);
 }
 
 void DrawThemedToolbarBackground(GtkWidget* widget,
                                  cairo_t* cr,
                                  GdkEventExpose* event,
                                  const gfx::Point& tabstrip_origin,
                                  GtkThemeService* theme_service) {
+#if !defined(USE_AURA)
   // Fill the entire region with the toolbar color.
   GdkColor color = theme_service->GetGdkColor(
       ThemeService::COLOR_TOOLBAR);
   gdk_cairo_set_source_color(cr, &color);
   cairo_fill(cr);
 
   // The toolbar is supposed to blend in with the active tab, so we have to pass
   // coordinates for the IDR_THEME_TOOLBAR bitmap relative to the top of the
   // tab strip.
   CairoCachedSurface* background = theme_service->GetSurfaceNamed(
       IDR_THEME_TOOLBAR, widget);
   background->SetSource(cr, tabstrip_origin.x(), tabstrip_origin.y());
   // We tile the toolbar background in both directions.
   cairo_pattern_set_extend(cairo_get_source(cr), CAIRO_EXTEND_REPEAT);
   cairo_rectangle(cr,
                   tabstrip_origin.x(),
                   tabstrip_origin.y(),
                   event->area.x + event->area.width - tabstrip_origin.x(),
                   event->area.y + event->area.height - tabstrip_origin.y());
   cairo_fill(cr);
+#endif
 }
 
 GdkColor AverageColors(GdkColor color_one, GdkColor color_two) {
   GdkColor average_color;
   average_color.pixel = 0;
   average_color.red = (color_one.red + color_two.red) / 2;
   average_color.green = (color_one.green + color_two.green) / 2;
   average_color.blue = (color_one.blue + color_two.blue) / 2;
   return average_color;
 }
@@ skipping 375 matching lines @@
 }
 
 // Performs Cut/Copy/Paste operation on the |window|.
 // If the current render view is focused, then just call the specified |method|
 // against the current render view host, otherwise emit the specified |signal|
 // against the focused widget.
 // TODO(suzhe): This approach does not work for plugins.
 void DoCutCopyPaste(BrowserWindow* window,
                     void (RenderViewHost::*method)(),
                     const char* signal) {
+#if defined(USE_AURA)
+  // TODO(saintlou): This entire module should be removed from Aura soon
+  return;
+#else
   GtkWidget* widget = GetBrowserWindowFocusedWidget(window);
   if (widget == NULL)
     return;  // Do nothing if no focused widget.
 
   TabContents* current_tab = GetBrowserWindowSelectedTabContents(window);
   if (current_tab && widget == current_tab->GetContentNativeView()) {
     (current_tab->render_view_host()->*method)();
   } else {
     guint id;
     if ((id = g_signal_lookup(signal, G_OBJECT_TYPE(widget))) != 0)
       g_signal_emit(widget, id, 0);
   }
+#endif
 }
 
 void DoCut(BrowserWindow* window) {
   DoCutCopyPaste(window, &RenderViewHost::Cut, "cut-clipboard");
 }
 
 void DoCopy(BrowserWindow* window) {
   DoCutCopyPaste(window, &RenderViewHost::Copy, "copy-clipboard");
 }
 
 void DoPaste(BrowserWindow* window) {
   DoCutCopyPaste(window, &RenderViewHost::Paste, "paste-clipboard");
 }
 
 }  // namespace gtk_util