Add a gtk3 port of peerconnection_client on Linux

webrtc/examples/peerconnection/client/linux/main_wnd.cc

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 100 matching lines @@
   delete cb_data;
   return false;
 }
 
 gboolean Redraw(gpointer data) {
   GtkMainWnd* wnd = reinterpret_cast<GtkMainWnd*>(data);
   wnd->OnRedraw();
   return false;
 }
 
+gboolean Draw(GtkWidget* widget, cairo_t* cr, gpointer data) {
+  GtkMainWnd* wnd = reinterpret_cast<GtkMainWnd*>(data);
+  wnd->Draw(widget, cr);
+  return false;
+}
+
 }  // namespace
 
 //
 // GtkMainWnd implementation.
 //
 
 GtkMainWnd::GtkMainWnd(const char* server, int port, bool autoconnect,
                        bool autocall)
     : window_(NULL), draw_area_(NULL), vbox_(NULL), server_edit_(NULL),
       port_edit_(NULL), peer_list_(NULL), callback_(NULL),
@@ skipping 94 matching lines @@
   ASSERT(IsWindow());
   ASSERT(vbox_ == NULL);
 
   gtk_container_set_border_width(GTK_CONTAINER(window_), 10);
 
   if (peer_list_) {
     gtk_widget_destroy(peer_list_);
     peer_list_ = NULL;
   }
 
+#if GTK_MAJOR_VERSION == 2
   vbox_ = gtk_vbox_new(FALSE, 5);
+#else
+  vbox_ = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
+#endif
   GtkWidget* valign = gtk_alignment_new(0, 1, 0, 0);
   gtk_container_add(GTK_CONTAINER(vbox_), valign);
   gtk_container_add(GTK_CONTAINER(window_), vbox_);
 
+#if GTK_MAJOR_VERSION == 2
   GtkWidget* hbox = gtk_hbox_new(FALSE, 5);
+#else
+  GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
+#endif
 
   GtkWidget* label = gtk_label_new("Server");
   gtk_container_add(GTK_CONTAINER(hbox), label);
 
   server_edit_ = gtk_entry_new();
   gtk_entry_set_text(GTK_ENTRY(server_edit_), server_.c_str());
   gtk_widget_set_size_request(server_edit_, 400, 30);
   gtk_container_add(GTK_CONTAINER(hbox), server_edit_);
 
   port_edit_ = gtk_entry_new();
@@ skipping 59 matching lines @@
   ASSERT(draw_area_ == NULL);
 
   gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
   if (peer_list_) {
     gtk_widget_destroy(peer_list_);
     peer_list_ = NULL;
   }
 
   draw_area_ = gtk_drawing_area_new();
   gtk_container_add(GTK_CONTAINER(window_), draw_area_);
+  g_signal_connect(G_OBJECT(draw_area_), "draw", G_CALLBACK(&::Draw), this);
 
   gtk_widget_show_all(window_);
 }
 
 void GtkMainWnd::OnDestroyed(GtkWidget* widget, GdkEvent* event) {
   callback_->Close();
   window_ = NULL;
   draw_area_ = NULL;
   vbox_ = NULL;
   server_edit_ = NULL;
   port_edit_ = NULL;
   peer_list_ = NULL;
 }
 
 void GtkMainWnd::OnClicked(GtkWidget* widget) {
   // Make the connect button insensitive, so that it cannot be clicked more than
   // once.  Now that the connection includes auto-retry, it should not be
   // necessary to click it more than once.
   gtk_widget_set_sensitive(widget, false);
   server_ = gtk_entry_get_text(GTK_ENTRY(server_edit_));
   port_ = gtk_entry_get_text(GTK_ENTRY(port_edit_));
   int port = port_.length() ? atoi(port_.c_str()) : 0;
   callback_->StartLogin(server_, port);
 }
 
 void GtkMainWnd::OnKeyPress(GtkWidget* widget, GdkEventKey* key) {
   if (key->type == GDK_KEY_PRESS) {
     switch (key->keyval) {
-     case GDK_Escape:
-       if (draw_area_) {
-         callback_->DisconnectFromCurrentPeer();
-       } else if (peer_list_) {
-         callback_->DisconnectFromServer();
-       }
-       break;
+#if GTK_MAJOR_VERSION == 2
+      case GDK_Escape:
+#else
+      case GDK_KEY_Escape:
+#endif
+        if (draw_area_) {
+          callback_->DisconnectFromCurrentPeer();
+        } else if (peer_list_) {
+          callback_->DisconnectFromServer();
+        }
+        break;
 
-     case GDK_KP_Enter:
-     case GDK_Return:
-       if (vbox_) {
-         OnClicked(NULL);
-       } else if (peer_list_) {
-         // OnRowActivated will be called automatically when the user
-         // presses enter.
-       }
-       break;
+#if GTK_MAJOR_VERSION == 2
+      case GDK_KP_Enter:
+      case GDK_Return:
+#else
+      case GDK_KEY_KP_Enter:
+      case GDK_KEY_Return:
+#endif
+        if (vbox_) {
+          OnClicked(NULL);
+        } else if (peer_list_) {
+          // OnRowActivated will be called automatically when the user
+          // presses enter.
+        }
+        break;
 
-     default:
-       break;
+      default:
+        break;
     }
   }
 }
 
 void GtkMainWnd::OnRowActivated(GtkTreeView* tree_view, GtkTreePath* path,
                                 GtkTreeViewColumn* column) {
   ASSERT(peer_list_ != NULL);
   GtkTreeIter iter;
   GtkTreeModel* model;
   GtkTreeSelection* selection =
       gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
   if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
      char* text;
      int id = -1;
      gtk_tree_model_get(model, &iter, 0, &text, 1, &id,  -1);
      if (id != -1)
        callback_->ConnectToPeer(id);
      g_free(text);
   }
 }
 
 void GtkMainWnd::OnRedraw() {
   gdk_threads_enter();
 
   VideoRenderer* remote_renderer = remote_renderer_.get();
   if (remote_renderer && remote_renderer->image() != NULL &&
       draw_area_ != NULL) {
-    int width = remote_renderer->width();
-    int height = remote_renderer->height();
+    width_ = remote_renderer->width();
+    height_ = remote_renderer->height();
 
     if (!draw_buffer_.get()) {
-      draw_buffer_size_ = (width * height * 4) * 4;
+      draw_buffer_size_ = (width_ * height_ * 4) * 4;
       draw_buffer_.reset(new uint8_t[draw_buffer_size_]);
-      gtk_widget_set_size_request(draw_area_, width * 2, height * 2);
+      gtk_widget_set_size_request(draw_area_, width_ * 2, height_ * 2);
     }
 
     const uint32_t* image =
         reinterpret_cast<const uint32_t*>(remote_renderer->image());
     uint32_t* scaled = reinterpret_cast<uint32_t*>(draw_buffer_.get());
-    for (int r = 0; r < height; ++r) {
-      for (int c = 0; c < width; ++c) {
+    for (int r = 0; r < height_; ++r) {
+      for (int c = 0; c < width_; ++c) {
         int x = c * 2;
         scaled[x] = scaled[x + 1] = image[c];
       }
 
       uint32_t* prev_line = scaled;
-      scaled += width * 2;
-      memcpy(scaled, prev_line, (width * 2) * 4);
+      scaled += width_ * 2;
+      memcpy(scaled, prev_line, (width_ * 2) * 4);
 
-      image += width;
-      scaled += width * 2;
+      image += width_;
+      scaled += width_ * 2;
     }
 
     VideoRenderer* local_renderer = local_renderer_.get();
     if (local_renderer && local_renderer->image()) {
       image = reinterpret_cast<const uint32_t*>(local_renderer->image());
       scaled = reinterpret_cast<uint32_t*>(draw_buffer_.get());
       // Position the local preview on the right side.
-      scaled += (width * 2) - (local_renderer->width() / 2);
+      scaled += (width_ * 2) - (local_renderer->width() / 2);
       // right margin...
       scaled -= 10;
       // ... towards the bottom.
-      scaled += (height * width * 4) -
-                ((local_renderer->height() / 2) *
-                 (local_renderer->width() / 2) * 4);
+      scaled += (height_ * width_ * 4) - ((local_renderer->height() / 2) *
+                                          (local_renderer->width() / 2) * 4);
       // bottom margin...
-      scaled -= (width * 2) * 5;
+      scaled -= (width_ * 2) * 5;
       for (int r = 0; r < local_renderer->height(); r += 2) {
         for (int c = 0; c < local_renderer->width(); c += 2) {
           scaled[c / 2] = image[c + r * local_renderer->width()];
         }
-        scaled += width * 2;
+        scaled += width_ * 2;
       }
     }
 
+#if GTK_MAJOR_VERSION == 2
     gdk_draw_rgb_32_image(draw_area_->window,
-                          draw_area_->style->fg_gc[GTK_STATE_NORMAL],
-                          0,
-                          0,
-                          width * 2,
-                          height * 2,
-                          GDK_RGB_DITHER_MAX,
-                          draw_buffer_.get(),
-                          (width * 2) * 4);
+                          draw_area_->style->fg_gc[GTK_STATE_NORMAL], 0, 0,
+                          width_ * 2, height_ * 2, GDK_RGB_DITHER_MAX,
+                          draw_buffer_.get(), (width_ * 2) * 4);
+#else
+    gtk_widget_queue_draw(draw_area_);
+#endif
   }
 
   gdk_threads_leave();
 }
 
+void GtkMainWnd::Draw(GtkWidget* widget, cairo_t* cr) {
+#if GTK_MAJOR_VERSION != 2
+  cairo_format_t format = CAIRO_FORMAT_RGB24;
+  cairo_surface_t* surface = cairo_image_surface_create_for_data(
+      draw_buffer_.get(), format, width_ * 2, height_ * 2,
+      cairo_format_stride_for_width(format, width_ * 2));
+  cairo_set_source_surface(cr, surface, 0, 0);
+  cairo_rectangle(cr, 0, 0, width_ * 2, height_ * 2);
+  cairo_fill(cr);
+  cairo_surface_destroy(surface);
+#else
+  RTC_NOTREACHED();
+#endif
+}
+
 GtkMainWnd::VideoRenderer::VideoRenderer(
     GtkMainWnd* main_wnd,
     webrtc::VideoTrackInterface* track_to_render)
     : width_(0),
       height_(0),
       main_wnd_(main_wnd),
       rendered_track_(track_to_render) {
   rendered_track_->AddOrUpdateSink(this, rtc::VideoSinkWants());
 }
 
@@ skipping 27 matching lines @@
   libyuv::I420ToRGBA(buffer->DataY(), buffer->StrideY(),
                      buffer->DataU(), buffer->StrideU(),
                      buffer->DataV(), buffer->StrideV(),
                      image_.get(), width_ * 4,
                      buffer->width(), buffer->height());
 
   gdk_threads_leave();
 
   g_idle_add(Redraw, main_wnd_);
 }