3
* Copyright 2011, Google Inc.
5
* Redistribution and use in source and binary forms, with or without
6
* modification, are permitted provided that the following conditions are met:
8
* 1. Redistributions of source code must retain the above copyright notice,
9
* this list of conditions and the following disclaimer.
10
* 2. Redistributions in binary form must reproduce the above copyright notice,
11
* this list of conditions and the following disclaimer in the documentation
12
* and/or other materials provided with the distribution.
13
* 3. The name of the author may not be used to endorse or promote products
14
* derived from this software without specific prior written permission.
16
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
#include "talk/examples/peerconnection/client/linux/main_wnd.h"
31
#include <gdk/gdkkeysyms.h>
35
#include "talk/examples/peerconnection/client/defaults.h"
36
#include "talk/base/common.h"
37
#include "talk/base/logging.h"
38
#include "talk/base/stringutils.h"
40
using talk_base::sprintfn;
45
// Simple static functions that simply forward the callback to the
46
// GtkMainWnd instance.
49
gboolean OnDestroyedCallback(GtkWidget* widget, GdkEvent* event,
51
reinterpret_cast<GtkMainWnd*>(data)->OnDestroyed(widget, event);
55
void OnClickedCallback(GtkWidget* widget, gpointer data) {
56
reinterpret_cast<GtkMainWnd*>(data)->OnClicked(widget);
59
gboolean OnKeyPressCallback(GtkWidget* widget, GdkEventKey* key,
61
reinterpret_cast<GtkMainWnd*>(data)->OnKeyPress(widget, key);
65
void OnRowActivatedCallback(GtkTreeView* tree_view, GtkTreePath* path,
66
GtkTreeViewColumn* column, gpointer data) {
67
reinterpret_cast<GtkMainWnd*>(data)->OnRowActivated(tree_view, path, column);
70
// Creates a tree view, that we use to display the list of peers.
71
void InitializeList(GtkWidget* list) {
72
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
73
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
74
"List Items", renderer, "text", 0, NULL);
75
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
76
GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
77
gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store));
78
g_object_unref(store);
81
// Adds an entry to a tree view.
82
void AddToList(GtkWidget* list, const gchar* str, int value) {
83
GtkListStore* store = GTK_LIST_STORE(
84
gtk_tree_view_get_model(GTK_TREE_VIEW(list)));
87
gtk_list_store_append(store, &iter);
88
gtk_list_store_set(store, &iter, 0, str, 1, value, -1);
91
struct UIThreadCallbackData {
92
explicit UIThreadCallbackData(MainWndCallback* cb, int id, void* d)
93
: callback(cb), msg_id(id), data(d) {}
94
MainWndCallback* callback;
99
gboolean HandleUIThreadCallback(gpointer data) {
100
UIThreadCallbackData* cb_data = reinterpret_cast<UIThreadCallbackData*>(data);
101
cb_data->callback->UIThreadCallback(cb_data->msg_id, cb_data->data);
106
gboolean Redraw(gpointer data) {
107
GtkMainWnd* wnd = reinterpret_cast<GtkMainWnd*>(data);
114
// GtkMainWnd implementation.
117
GtkMainWnd::GtkMainWnd()
118
: window_(NULL), draw_area_(NULL), vbox_(NULL), server_edit_(NULL),
119
port_edit_(NULL), peer_list_(NULL), callback_(NULL),
120
server_("localhost") {
122
sprintfn(buffer, sizeof(buffer), "%i", kDefaultServerPort);
126
GtkMainWnd::~GtkMainWnd() {
130
void GtkMainWnd::RegisterObserver(MainWndCallback* callback) {
131
callback_ = callback;
134
bool GtkMainWnd::IsWindow() {
135
return window_ != NULL && GTK_IS_WINDOW(window_);
138
void GtkMainWnd::MessageBox(const char* caption, const char* text,
140
GtkWidget* dialog = gtk_message_dialog_new(GTK_WINDOW(window_),
141
GTK_DIALOG_DESTROY_WITH_PARENT,
142
is_error ? GTK_MESSAGE_ERROR : GTK_MESSAGE_INFO,
143
GTK_BUTTONS_CLOSE, "%s", text);
144
gtk_window_set_title(GTK_WINDOW(dialog), caption);
145
gtk_dialog_run(GTK_DIALOG(dialog));
146
gtk_widget_destroy(dialog);
149
MainWindow::UI GtkMainWnd::current_ui() {
151
return CONNECT_TO_SERVER;
159
webrtc::VideoRendererWrapperInterface* GtkMainWnd::local_renderer() {
160
if (!local_renderer_wrapper_.get())
161
local_renderer_wrapper_ =
162
webrtc::CreateVideoRenderer(new VideoRenderer(this));
163
return local_renderer_wrapper_.get();
166
webrtc::VideoRendererWrapperInterface* GtkMainWnd::remote_renderer() {
167
if (!remote_renderer_wrapper_.get())
168
remote_renderer_wrapper_ =
169
webrtc::CreateVideoRenderer(new VideoRenderer(this));
170
return remote_renderer_wrapper_.get();
173
void GtkMainWnd::QueueUIThreadCallback(int msg_id, void* data) {
174
g_idle_add(HandleUIThreadCallback,
175
new UIThreadCallbackData(callback_, msg_id, data));
178
bool GtkMainWnd::Create() {
179
ASSERT(window_ == NULL);
181
window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
183
gtk_window_set_position(GTK_WINDOW(window_), GTK_WIN_POS_CENTER);
184
gtk_window_set_default_size(GTK_WINDOW(window_), 640, 480);
185
gtk_window_set_title(GTK_WINDOW(window_), "PeerConnection client");
186
g_signal_connect(G_OBJECT(window_), "delete-event",
187
G_CALLBACK(&OnDestroyedCallback), this);
188
g_signal_connect(window_, "key-press-event", G_CALLBACK(OnKeyPressCallback),
194
return window_ != NULL;
197
bool GtkMainWnd::Destroy() {
201
gtk_widget_destroy(window_);
207
void GtkMainWnd::SwitchToConnectUI() {
208
LOG(INFO) << __FUNCTION__;
211
ASSERT(vbox_ == NULL);
213
gtk_container_set_border_width(GTK_CONTAINER(window_), 10);
216
gtk_widget_destroy(peer_list_);
220
vbox_ = gtk_vbox_new(FALSE, 5);
221
GtkWidget* valign = gtk_alignment_new(0, 1, 0, 0);
222
gtk_container_add(GTK_CONTAINER(vbox_), valign);
223
gtk_container_add(GTK_CONTAINER(window_), vbox_);
225
GtkWidget* hbox = gtk_hbox_new(FALSE, 5);
227
GtkWidget* label = gtk_label_new("Server");
228
gtk_container_add(GTK_CONTAINER(hbox), label);
230
server_edit_ = gtk_entry_new();
231
gtk_entry_set_text(GTK_ENTRY(server_edit_), server_.c_str());
232
gtk_widget_set_size_request(server_edit_, 400, 30);
233
gtk_container_add(GTK_CONTAINER(hbox), server_edit_);
235
port_edit_ = gtk_entry_new();
236
gtk_entry_set_text(GTK_ENTRY(port_edit_), port_.c_str());
237
gtk_widget_set_size_request(port_edit_, 70, 30);
238
gtk_container_add(GTK_CONTAINER(hbox), port_edit_);
240
GtkWidget* button = gtk_button_new_with_label("Connect");
241
gtk_widget_set_size_request(button, 70, 30);
242
g_signal_connect(button, "clicked", G_CALLBACK(OnClickedCallback), this);
243
gtk_container_add(GTK_CONTAINER(hbox), button);
245
GtkWidget* halign = gtk_alignment_new(1, 0, 0, 0);
246
gtk_container_add(GTK_CONTAINER(halign), hbox);
247
gtk_box_pack_start(GTK_BOX(vbox_), halign, FALSE, FALSE, 0);
249
gtk_widget_show_all(window_);
252
void GtkMainWnd::SwitchToPeerList(const Peers& peers) {
253
LOG(INFO) << __FUNCTION__;
255
// Clean up buffers from a potential previous session.
256
local_renderer_wrapper_ = NULL;
257
remote_renderer_wrapper_ = NULL;
260
gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
262
gtk_widget_destroy(vbox_);
266
} else if (draw_area_) {
267
gtk_widget_destroy(draw_area_);
269
draw_buffer_.reset();
272
peer_list_ = gtk_tree_view_new();
273
g_signal_connect(peer_list_, "row-activated",
274
G_CALLBACK(OnRowActivatedCallback), this);
275
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(peer_list_), FALSE);
276
InitializeList(peer_list_);
277
gtk_container_add(GTK_CONTAINER(window_), peer_list_);
278
gtk_widget_show_all(window_);
280
GtkListStore* store =
281
GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(peer_list_)));
282
gtk_list_store_clear(store);
285
AddToList(peer_list_, "List of currently connected peers:", -1);
286
for (Peers::const_iterator i = peers.begin(); i != peers.end(); ++i)
287
AddToList(peer_list_, i->second.c_str(), i->first);
290
void GtkMainWnd::SwitchToStreamingUI() {
291
LOG(INFO) << __FUNCTION__;
293
ASSERT(draw_area_ == NULL);
295
gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
297
gtk_widget_destroy(peer_list_);
301
draw_area_ = gtk_drawing_area_new();
302
gtk_container_add(GTK_CONTAINER(window_), draw_area_);
304
gtk_widget_show_all(window_);
307
void GtkMainWnd::OnDestroyed(GtkWidget* widget, GdkEvent* event) {
317
void GtkMainWnd::OnClicked(GtkWidget* widget) {
318
server_ = gtk_entry_get_text(GTK_ENTRY(server_edit_));
319
port_ = gtk_entry_get_text(GTK_ENTRY(port_edit_));
320
int port = port_.length() ? atoi(port_.c_str()) : 0;
321
callback_->StartLogin(server_, port);
324
void GtkMainWnd::OnKeyPress(GtkWidget* widget, GdkEventKey* key) {
325
if (key->type == GDK_KEY_PRESS) {
326
switch (key->keyval) {
329
callback_->DisconnectFromCurrentPeer();
330
} else if (peer_list_) {
331
callback_->DisconnectFromServer();
339
} else if (peer_list_) {
340
// OnRowActivated will be called automatically when the user
351
void GtkMainWnd::OnRowActivated(GtkTreeView* tree_view, GtkTreePath* path,
352
GtkTreeViewColumn* column) {
353
ASSERT(peer_list_ != NULL);
356
GtkTreeSelection* selection =
357
gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
358
if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
361
gtk_tree_model_get(model, &iter, 0, &text, 1, &id, -1);
363
callback_->ConnectToPeer(id);
368
void GtkMainWnd::OnRedraw() {
371
VideoRenderer* remote_renderer =
372
static_cast<VideoRenderer*>(remote_renderer_wrapper_->renderer());
373
if (remote_renderer && remote_renderer->image() != NULL &&
374
draw_area_ != NULL) {
375
int width = remote_renderer->width();
376
int height = remote_renderer->height();
378
if (!draw_buffer_.get()) {
379
draw_buffer_size_ = (width * height * 4) * 4;
380
draw_buffer_.reset(new uint8[draw_buffer_size_]);
381
gtk_widget_set_size_request(draw_area_, width * 2, height * 2);
384
const uint32* image = reinterpret_cast<const uint32*>(
385
remote_renderer->image());
386
uint32* scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
387
for (int r = 0; r < height; ++r) {
388
for (int c = 0; c < width; ++c) {
390
scaled[x] = scaled[x + 1] = image[c];
393
uint32* prev_line = scaled;
395
memcpy(scaled, prev_line, (width * 2) * 4);
401
VideoRenderer* local_renderer =
402
static_cast<VideoRenderer*>(local_renderer_wrapper_->renderer());
403
if (local_renderer && local_renderer->image()) {
404
image = reinterpret_cast<const uint32*>(local_renderer->image());
405
scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
406
// Position the local preview on the right side.
407
scaled += (width * 2) - (local_renderer->width() / 2);
410
// ... towards the bottom.
411
scaled += (height * width * 4) -
412
((local_renderer->height() / 2) *
413
(local_renderer->width() / 2) * 4);
415
scaled -= (width * 2) * 5;
416
for (int r = 0; r < local_renderer->height(); r += 2) {
417
for (int c = 0; c < local_renderer->width(); c += 2) {
418
scaled[c / 2] = image[c + r * local_renderer->width()];
424
gdk_draw_rgb_32_image(draw_area_->window,
425
draw_area_->style->fg_gc[GTK_STATE_NORMAL],
438
GtkMainWnd::VideoRenderer::VideoRenderer(GtkMainWnd* main_wnd)
439
: width_(0), height_(0), main_wnd_(main_wnd) {
442
GtkMainWnd::VideoRenderer::~VideoRenderer() {
445
bool GtkMainWnd::VideoRenderer::SetSize(int width, int height, int reserved) {
449
image_.reset(new uint8[width * height * 4]);
454
bool GtkMainWnd::VideoRenderer::RenderFrame(const cricket::VideoFrame* frame) {
457
int size = width_ * height_ * 4;
458
// TODO: Convert directly to RGBA
459
frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB,
463
// Convert the B,G,R,A frame to R,G,B,A, which is accepted by GTK.
464
// The 'A' is just padding for GTK, so we can use it as temp.
465
uint8* pix = image_.get();
466
uint8* end = image_.get() + size;
468
pix[3] = pix[0]; // Save B to A.
469
pix[0] = pix[2]; // Set Red.
470
pix[2] = pix[3]; // Set Blue.
471
pix[3] = 0xFF; // Fixed Alpha.
477
g_idle_add(Redraw, main_wnd_);
added
removed
protocols/jabber/googletalk/libjingle/talk/examples/peerconnection/client/linux/main_wnd.cc
