pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Restore Insert Horizontal Rule functionality.
2012-06-03, Elliott Sales de Andrade
3a742f00a0f4
Restore Insert Horizontal Rule functionality.
/*
* @file gtkwebviewtoolbar.c GTK+ WebView Toolbar
* @ingroup pidgin
*/
/* pidgin
*
* Pidgin is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*
*/
#include
"internal.h"
#include
"pidgin.h"
#include
"imgstore.h"
#include
"notify.h"
#include
"prefs.h"
#include
"request.h"
#include
"pidginstock.h"
#include
"util.h"
#include
"debug.h"
#include
"gtkdialogs.h"
#include
"gtkwebviewtoolbar.h"
#include
"gtksmiley.h"
#include
"gtkthemes.h"
#include
"gtkutils.h"
#include
<gdk/gdkkeysyms.h>
#if !GTK_CHECK_VERSION(2,18,0)
#define gtk_widget_get_visible(x) GTK_WIDGET_VISIBLE((x))
#define gtk_widget_is_sensitive(x) GTK_WIDGET_IS_SENSITIVE((x))
#if !GTK_CHECK_VERSION(2,12,0)
#define gtk_widget_set_tooltip_text(w, t) \
gtk_tooltips_set_tip(priv->tooltips, (w), (t), NULL)
#endif
#endif
#define GTK_WEBVIEWTOOLBAR_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbarPriv))
/******************************************************************************
* Structs
*****************************************************************************/
typedef
struct
_GtkWebViewToolbarPriv
{
PurpleConversation
*
active_conv
;
GtkWidget
*
wide_view
;
GtkWidget
*
lean_view
;
#if !GTK_CHECK_VERSION(2,12,0)
GtkTooltips
*
tooltips
;
#endif
GtkWidget
*
font_label
;
GtkWidget
*
font_menu
;
GtkWidget
*
bold
;
GtkWidget
*
italic
;
GtkWidget
*
underline
;
GtkWidget
*
strike
;
GtkWidget
*
larger_size
;
GtkWidget
*
normal_size
;
GtkWidget
*
smaller_size
;
GtkWidget
*
font
;
GtkWidget
*
fgcolor
;
GtkWidget
*
bgcolor
;
GtkWidget
*
clear
;
GtkWidget
*
insert_menu
;
GtkWidget
*
image
;
GtkWidget
*
link
;
GtkWidget
*
insert_hr
;
GtkWidget
*
smiley
;
GtkWidget
*
attention
;
GtkWidget
*
call
;
GtkWidget
*
font_dialog
;
GtkWidget
*
fgcolor_dialog
;
GtkWidget
*
bgcolor_dialog
;
GtkWidget
*
link_dialog
;
GtkWidget
*
smiley_dialog
;
GtkWidget
*
image_dialog
;
char
*
sml
;
}
GtkWebViewToolbarPriv
;
/******************************************************************************
* Globals
*****************************************************************************/
static
GtkHBoxClass
*
parent_class
=
NULL
;
/******************************************************************************
* Prototypes
*****************************************************************************/
static
void
toggle_button_set_active_block
(
GtkToggleButton
*
button
,
gboolean
is_active
,
GtkWebViewToolbar
*
toolbar
);
static
gboolean
gtk_webviewtoolbar_popup_menu
(
GtkWidget
*
widget
,
GdkEventButton
*
event
,
GtkWebViewToolbar
*
toolbar
);
/******************************************************************************
* Helpers
*****************************************************************************/
static
void
do_bold
(
GtkWidget
*
bold
,
GtkWebViewToolbar
*
toolbar
)
{
g_return_if_fail
(
toolbar
!=
NULL
);
gtk_webview_toggle_bold
(
GTK_WEBVIEW
(
toolbar
->
webview
));
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
do_italic
(
GtkWidget
*
italic
,
GtkWebViewToolbar
*
toolbar
)
{
g_return_if_fail
(
toolbar
!=
NULL
);
gtk_webview_toggle_italic
(
GTK_WEBVIEW
(
toolbar
->
webview
));
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
do_underline
(
GtkWidget
*
underline
,
GtkWebViewToolbar
*
toolbar
)
{
g_return_if_fail
(
toolbar
!=
NULL
);
gtk_webview_toggle_underline
(
GTK_WEBVIEW
(
toolbar
->
webview
));
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
do_strikethrough
(
GtkWidget
*
strikethrough
,
GtkWebViewToolbar
*
toolbar
)
{
g_return_if_fail
(
toolbar
!=
NULL
);
gtk_webview_toggle_strike
(
GTK_WEBVIEW
(
toolbar
->
webview
));
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
do_small
(
GtkWidget
*
smalltb
,
GtkWebViewToolbar
*
toolbar
)
{
g_return_if_fail
(
toolbar
!=
NULL
);
/* Only shrink the font on activation, not deactivation as well */
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
smalltb
)))
gtk_webview_font_shrink
(
GTK_WEBVIEW
(
toolbar
->
webview
));
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
do_big
(
GtkWidget
*
large
,
GtkWebViewToolbar
*
toolbar
)
{
g_return_if_fail
(
toolbar
);
/* Only grow the font on activation, not deactivation as well */
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
large
)))
gtk_webview_font_grow
(
GTK_WEBVIEW
(
toolbar
->
webview
));
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
gboolean
destroy_toolbar_font
(
GtkWidget
*
widget
,
GdkEvent
*
event
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
widget
!=
NULL
)
gtk_webview_toggle_fontface
(
GTK_WEBVIEW
(
toolbar
->
webview
),
""
);
if
(
priv
->
font_dialog
!=
NULL
)
{
gtk_widget_destroy
(
priv
->
font_dialog
);
priv
->
font_dialog
=
NULL
;
}
return
FALSE
;
}
static
void
realize_toolbar_font
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkFontSelection
*
sel
;
sel
=
GTK_FONT_SELECTION
(
GTK_FONT_SELECTION_DIALOG
(
priv
->
font_dialog
)
->
fontsel
);
gtk_widget_hide_all
(
gtk_widget_get_parent
(
sel
->
size_entry
));
gtk_widget_show_all
(
sel
->
family_list
);
gtk_widget_show
(
gtk_widget_get_parent
(
sel
->
family_list
));
gtk_widget_show
(
gtk_widget_get_parent
(
gtk_widget_get_parent
(
sel
->
family_list
)));
}
static
void
cancel_toolbar_font
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
destroy_toolbar_font
(
widget
,
NULL
,
toolbar
);
}
static
void
apply_font
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
/* this could be expanded to include font size, weight, etc.
but for now only works with font face */
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkFontSelectionDialog
*
fontsel
=
GTK_FONT_SELECTION_DIALOG
(
priv
->
font_dialog
);
gchar
*
fontname
=
gtk_font_selection_dialog_get_font_name
(
fontsel
);
if
(
fontname
)
{
const
gchar
*
family_name
=
NULL
;
PangoFontDescription
*
desc
=
NULL
;
desc
=
pango_font_description_from_string
(
fontname
);
family_name
=
pango_font_description_get_family
(
desc
);
if
(
family_name
)
{
gtk_webview_toggle_fontface
(
GTK_WEBVIEW
(
toolbar
->
webview
),
family_name
);
}
pango_font_description_free
(
desc
);
g_free
(
fontname
);
}
cancel_toolbar_font
(
NULL
,
toolbar
);
}
static
void
toggle_font
(
GtkWidget
*
font
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
;
g_return_if_fail
(
toolbar
);
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
font
)))
{
char
*
fontname
=
gtk_webview_get_current_fontface
(
GTK_WEBVIEW
(
toolbar
->
webview
));
if
(
!
priv
->
font_dialog
)
{
priv
->
font_dialog
=
gtk_font_selection_dialog_new
(
_
(
"Select Font"
));
if
(
fontname
)
{
char
*
fonttif
=
g_strdup_printf
(
"%s 12"
,
fontname
);
gtk_font_selection_dialog_set_font_name
(
GTK_FONT_SELECTION_DIALOG
(
priv
->
font_dialog
),
fonttif
);
g_free
(
fonttif
);
}
else
{
gtk_font_selection_dialog_set_font_name
(
GTK_FONT_SELECTION_DIALOG
(
priv
->
font_dialog
),
DEFAULT_FONT_FACE
);
}
g_signal_connect
(
G_OBJECT
(
priv
->
font_dialog
),
"delete_event"
,
G_CALLBACK
(
destroy_toolbar_font
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
GTK_FONT_SELECTION_DIALOG
(
priv
->
font_dialog
)
->
ok_button
),
"clicked"
,
G_CALLBACK
(
apply_font
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
GTK_FONT_SELECTION_DIALOG
(
priv
->
font_dialog
)
->
cancel_button
),
"clicked"
,
G_CALLBACK
(
cancel_toolbar_font
),
toolbar
);
g_signal_connect_after
(
G_OBJECT
(
priv
->
font_dialog
),
"realize"
,
G_CALLBACK
(
realize_toolbar_font
),
toolbar
);
}
gtk_window_present
(
GTK_WINDOW
(
priv
->
font_dialog
));
g_free
(
fontname
);
}
else
{
cancel_toolbar_font
(
font
,
toolbar
);
}
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
gboolean
destroy_toolbar_fgcolor
(
GtkWidget
*
widget
,
GdkEvent
*
event
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
widget
!=
NULL
)
gtk_webview_toggle_forecolor
(
GTK_WEBVIEW
(
toolbar
->
webview
),
""
);
if
(
priv
->
fgcolor_dialog
!=
NULL
)
{
gtk_widget_destroy
(
priv
->
fgcolor_dialog
);
priv
->
fgcolor_dialog
=
NULL
;
}
return
FALSE
;
}
static
void
cancel_toolbar_fgcolor
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
destroy_toolbar_fgcolor
(
widget
,
NULL
,
toolbar
);
}
static
void
do_fgcolor
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkColorSelectionDialog
*
dialog
;
GtkColorSelection
*
colorsel
;
GdkColor
text_color
;
char
*
open_tag
;
dialog
=
GTK_COLOR_SELECTION_DIALOG
(
priv
->
fgcolor_dialog
);
colorsel
=
GTK_COLOR_SELECTION
(
dialog
->
colorsel
);
open_tag
=
g_malloc
(
30
);
gtk_color_selection_get_current_color
(
colorsel
,
&
text_color
);
g_snprintf
(
open_tag
,
23
,
"#%02X%02X%02X"
,
text_color
.
red
/
256
,
text_color
.
green
/
256
,
text_color
.
blue
/
256
);
gtk_webview_toggle_forecolor
(
GTK_WEBVIEW
(
toolbar
->
webview
),
open_tag
);
g_free
(
open_tag
);
cancel_toolbar_fgcolor
(
NULL
,
toolbar
);
}
static
void
toggle_fg_color
(
GtkWidget
*
color
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
color
)))
{
GtkWidget
*
colorsel
;
GdkColor
fgcolor
;
char
*
color
=
gtk_webview_get_current_forecolor
(
GTK_WEBVIEW
(
toolbar
->
webview
));
if
(
!
priv
->
fgcolor_dialog
)
{
priv
->
fgcolor_dialog
=
gtk_color_selection_dialog_new
(
_
(
"Select Text Color"
));
colorsel
=
GTK_COLOR_SELECTION_DIALOG
(
priv
->
fgcolor_dialog
)
->
colorsel
;
if
(
color
)
{
gdk_color_parse
(
color
,
&
fgcolor
);
gtk_color_selection_set_current_color
(
GTK_COLOR_SELECTION
(
colorsel
),
&
fgcolor
);
}
g_signal_connect
(
G_OBJECT
(
priv
->
fgcolor_dialog
),
"delete_event"
,
G_CALLBACK
(
destroy_toolbar_fgcolor
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
GTK_COLOR_SELECTION_DIALOG
(
priv
->
fgcolor_dialog
)
->
ok_button
),
"clicked"
,
G_CALLBACK
(
do_fgcolor
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
GTK_COLOR_SELECTION_DIALOG
(
priv
->
fgcolor_dialog
)
->
cancel_button
),
"clicked"
,
G_CALLBACK
(
cancel_toolbar_fgcolor
),
toolbar
);
}
gtk_window_present
(
GTK_WINDOW
(
priv
->
fgcolor_dialog
));
g_free
(
color
);
}
else
{
cancel_toolbar_fgcolor
(
color
,
toolbar
);
}
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
gboolean
destroy_toolbar_bgcolor
(
GtkWidget
*
widget
,
GdkEvent
*
event
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
widget
!=
NULL
)
{
gtk_webview_toggle_backcolor
(
GTK_WEBVIEW
(
toolbar
->
webview
),
""
);
}
if
(
priv
->
bgcolor_dialog
!=
NULL
)
{
gtk_widget_destroy
(
priv
->
bgcolor_dialog
);
priv
->
bgcolor_dialog
=
NULL
;
}
return
FALSE
;
}
static
void
cancel_toolbar_bgcolor
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
destroy_toolbar_bgcolor
(
widget
,
NULL
,
toolbar
);
}
static
void
do_bgcolor
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkColorSelectionDialog
*
dialog
;
GtkColorSelection
*
colorsel
;
GdkColor
text_color
;
char
*
open_tag
;
dialog
=
GTK_COLOR_SELECTION_DIALOG
(
priv
->
bgcolor_dialog
);
colorsel
=
GTK_COLOR_SELECTION
(
dialog
->
colorsel
);
open_tag
=
g_malloc
(
30
);
gtk_color_selection_get_current_color
(
colorsel
,
&
text_color
);
g_snprintf
(
open_tag
,
23
,
"#%02X%02X%02X"
,
text_color
.
red
/
256
,
text_color
.
green
/
256
,
text_color
.
blue
/
256
);
gtk_webview_toggle_backcolor
(
GTK_WEBVIEW
(
toolbar
->
webview
),
open_tag
);
g_free
(
open_tag
);
cancel_toolbar_bgcolor
(
NULL
,
toolbar
);
}
static
void
toggle_bg_color
(
GtkWidget
*
color
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
color
)))
{
GtkWidget
*
colorsel
;
GdkColor
bgcolor
;
char
*
color
=
gtk_webview_get_current_backcolor
(
GTK_WEBVIEW
(
toolbar
->
webview
));
if
(
!
priv
->
bgcolor_dialog
)
{
priv
->
bgcolor_dialog
=
gtk_color_selection_dialog_new
(
_
(
"Select Background Color"
));
colorsel
=
GTK_COLOR_SELECTION_DIALOG
(
priv
->
bgcolor_dialog
)
->
colorsel
;
if
(
color
)
{
gdk_color_parse
(
color
,
&
bgcolor
);
gtk_color_selection_set_current_color
(
GTK_COLOR_SELECTION
(
colorsel
),
&
bgcolor
);
}
g_signal_connect
(
G_OBJECT
(
priv
->
bgcolor_dialog
),
"delete_event"
,
G_CALLBACK
(
destroy_toolbar_bgcolor
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
GTK_COLOR_SELECTION_DIALOG
(
priv
->
bgcolor_dialog
)
->
ok_button
),
"clicked"
,
G_CALLBACK
(
do_bgcolor
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
GTK_COLOR_SELECTION_DIALOG
(
priv
->
bgcolor_dialog
)
->
cancel_button
),
"clicked"
,
G_CALLBACK
(
cancel_toolbar_bgcolor
),
toolbar
);
}
gtk_window_present
(
GTK_WINDOW
(
priv
->
bgcolor_dialog
));
g_free
(
color
);
}
else
{
cancel_toolbar_bgcolor
(
color
,
toolbar
);
}
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
clear_formatting_cb
(
GtkWidget
*
clear
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
clear
),
FALSE
,
toolbar
);
gtk_webview_clear_formatting
(
GTK_WEBVIEW
(
toolbar
->
webview
));
}
static
void
cancel_link_cb
(
GtkWebViewToolbar
*
toolbar
,
PurpleRequestFields
*
fields
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
gtk_toggle_button_set_active
(
GTK_TOGGLE_BUTTON
(
priv
->
link
),
FALSE
);
priv
->
link_dialog
=
NULL
;
}
static
void
close_link_dialog
(
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
priv
->
link_dialog
!=
NULL
)
{
purple_request_close
(
PURPLE_REQUEST_FIELDS
,
priv
->
link_dialog
);
priv
->
link_dialog
=
NULL
;
}
}
static
void
do_insert_link_cb
(
GtkWebViewToolbar
*
toolbar
,
PurpleRequestFields
*
fields
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
const
char
*
url
,
*
description
;
url
=
purple_request_fields_get_string
(
fields
,
"url"
);
if
(
gtk_webview_get_format_functions
(
GTK_WEBVIEW
(
toolbar
->
webview
))
&
GTK_WEBVIEW_LINKDESC
)
description
=
purple_request_fields_get_string
(
fields
,
"description"
);
else
description
=
NULL
;
if
(
description
==
NULL
)
description
=
url
;
#if 0
gtk_webview_insert_link(GTK_WEBVIEW(toolbar->webview),
gtk_text_buffer_get_insert(GTK_WEBVIEW(toolbar->webview)->text_buffer),
url, description);
#endif
gtk_toggle_button_set_active
(
GTK_TOGGLE_BUTTON
(
priv
->
link
),
FALSE
);
priv
->
link_dialog
=
NULL
;
}
static
void
insert_link_cb
(
GtkWidget
*
w
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
priv
->
link
)))
{
PurpleRequestFields
*
fields
;
PurpleRequestFieldGroup
*
group
;
PurpleRequestField
*
field
;
#if 0
GtkTextIter start, end;
#endif
char
*
msg
;
char
*
desc
=
NULL
;
fields
=
purple_request_fields_new
();
group
=
purple_request_field_group_new
(
NULL
);
purple_request_fields_add_group
(
fields
,
group
);
field
=
purple_request_field_string_new
(
"url"
,
_
(
"_URL"
),
NULL
,
FALSE
);
purple_request_field_set_required
(
field
,
TRUE
);
purple_request_field_group_add_field
(
group
,
field
);
if
(
gtk_webview_get_format_functions
(
GTK_WEBVIEW
(
toolbar
->
webview
))
&
GTK_WEBVIEW_LINKDESC
)
{
#if 0
if (gtk_text_buffer_get_selection_bounds(GTK_WEBVIEW(toolbar->webview)->text_buffer, &start, &end)) {
desc = gtk_webview_get_text(GTK_WEBVIEW(toolbar->webview), &start, &end);
}
#endif
field
=
purple_request_field_string_new
(
"description"
,
_
(
"_Description"
),
desc
,
FALSE
);
purple_request_field_group_add_field
(
group
,
field
);
msg
=
g_strdup
(
_
(
"Please enter the URL and description of the "
"link that you want to insert. The description "
"is optional."
));
}
else
{
msg
=
g_strdup
(
_
(
"Please enter the URL of the "
"link that you want to insert."
));
}
priv
->
link_dialog
=
purple_request_fields
(
toolbar
,
_
(
"Insert Link"
),
NULL
,
msg
,
fields
,
_
(
"_Insert"
),
G_CALLBACK
(
do_insert_link_cb
),
_
(
"Cancel"
),
G_CALLBACK
(
cancel_link_cb
),
NULL
,
NULL
,
NULL
,
toolbar
);
g_free
(
msg
);
g_free
(
desc
);
}
else
{
close_link_dialog
(
toolbar
);
}
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
insert_hr_cb
(
GtkWidget
*
widget
,
GtkWebViewToolbar
*
toolbar
)
{
gtk_webview_insert_hr
(
GTK_WEBVIEW
(
toolbar
->
webview
));
}
static
void
do_insert_image_cb
(
GtkWidget
*
widget
,
int
response
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
gtk_toggle_button_set_active
(
GTK_TOGGLE_BUTTON
(
priv
->
image
),
FALSE
);
#if 0
gchar *filename, *name, *buf;
char *filedata;
size_t size;
GError *error = NULL;
int id;
GtkTextIter iter;
GtkTextMark *ins;
if (response != GTK_RESPONSE_ACCEPT)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
return;
}
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));
if (filename == NULL) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
return;
}
/* The following triggers a callback that closes the widget */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
if (!g_file_get_contents(filename, &filedata, &size, &error)) {
purple_notify_error(NULL, NULL, error->message, NULL);
g_error_free(error);
g_free(filename);
return;
}
name = strrchr(filename, G_DIR_SEPARATOR) + 1;
id = purple_imgstore_add_with_id(filedata, size, name);
if (id == 0) {
buf = g_strdup_printf(_("Failed to store image: %s\n"), filename);
purple_notify_error(NULL, NULL, buf, NULL);
g_free(buf);
g_free(filename);
return;
}
g_free(filename);
ins = gtk_text_buffer_get_insert(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview)));
gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview)),
&iter, ins);
gtk_webview_insert_image_at_iter(GTK_WEBVIEW(toolbar->webview), id, &iter);
purple_imgstore_unref_by_id(id);
#endif
}
static
void
insert_image_cb
(
GtkWidget
*
save
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkWidget
*
window
;
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
priv
->
image
)))
{
window
=
gtk_file_chooser_dialog_new
(
_
(
"Insert Image"
),
NULL
,
GTK_FILE_CHOOSER_ACTION_OPEN
,
GTK_STOCK_CANCEL
,
GTK_RESPONSE_CANCEL
,
GTK_STOCK_OPEN
,
GTK_RESPONSE_ACCEPT
,
NULL
);
gtk_dialog_set_default_response
(
GTK_DIALOG
(
window
),
GTK_RESPONSE_ACCEPT
);
g_signal_connect
(
G_OBJECT
(
GTK_FILE_CHOOSER
(
window
)),
"response"
,
G_CALLBACK
(
do_insert_image_cb
),
toolbar
);
gtk_widget_show
(
window
);
priv
->
image_dialog
=
window
;
}
else
{
gtk_widget_destroy
(
priv
->
image_dialog
);
priv
->
image_dialog
=
NULL
;
}
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
#if 0
static void
destroy_smiley_dialog(GtkWebViewToolbar *toolbar)
{
GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
if (priv->smiley_dialog != NULL)
{
gtk_widget_destroy(priv->smiley_dialog);
priv->smiley_dialog = NULL;
}
}
static gboolean
close_smiley_dialog(GtkWebViewToolbar *toolbar)
{
GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->smiley), FALSE);
return FALSE;
}
static void
insert_smiley_text(GtkWidget *widget, GtkWebViewToolbar *toolbar)
{
GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
char *smiley_text, *escaped_smiley;
smiley_text = g_object_get_data(G_OBJECT(widget), "smiley_text");
escaped_smiley = g_markup_escape_text(smiley_text, -1);
gtk_webview_insert_smiley(GTK_WEBVIEW(toolbar->webview),
GTK_WEBVIEW(toolbar->webview)->protocol_name,
escaped_smiley);
g_free(escaped_smiley);
close_smiley_dialog(toolbar);
}
/* smiley buttons list */
struct smiley_button_list {
int width, height;
GtkWidget *button;
const GtkIMHtmlSmiley *smiley;
struct smiley_button_list *next;
};
static struct smiley_button_list *
sort_smileys(struct smiley_button_list *ls, GtkWebViewToolbar *toolbar,
int *width, const GtkIMHtmlSmiley *smiley)
{
GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
GtkWidget *image;
GtkWidget *button;
GtkRequisition size;
struct smiley_button_list *cur;
struct smiley_button_list *it, *it_last;
const gchar *filename = smiley->file;
gchar *face = smiley->smile;
PurpleSmiley *psmiley = NULL;
gboolean supports_custom = (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_CUSTOM_SMILEY);
cur = g_new0(struct smiley_button_list, 1);
it = ls;
it_last = ls; /* list iterators*/
image = gtk_image_new_from_file(filename);
gtk_widget_size_request(image, &size);
if (size.width > 24 &&
smiley->flags & GTK_WEBVIEW_SMILEY_CUSTOM) { /* This is a custom smiley, let's scale it */
GdkPixbuf *pixbuf = NULL;
GtkImageType type;
type = gtk_image_get_storage_type(GTK_IMAGE(image));
if (type == GTK_IMAGE_PIXBUF) {
pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
} else if (type == GTK_IMAGE_ANIMATION) {
GdkPixbufAnimation *animation;
animation = gtk_image_get_animation(GTK_IMAGE(image));
pixbuf = gdk_pixbuf_animation_get_static_image(animation);
}
if (pixbuf != NULL) {
GdkPixbuf *resized;
resized = gdk_pixbuf_scale_simple(pixbuf, 24, 24,
GDK_INTERP_HYPER);
gtk_image_set_from_pixbuf(GTK_IMAGE(image), resized); /* This unrefs pixbuf */
gtk_widget_size_request(image, &size);
g_object_unref(G_OBJECT(resized));
}
}
(*width) += size.width;
button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(button), image);
g_object_set_data(G_OBJECT(button), "smiley_text", face);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(insert_smiley_text), toolbar);
gtk_widget_set_tooltip_text(button, face);
/* these look really weird with borders */
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
psmiley = purple_smileys_find_by_shortcut(smiley->smile);
/* If this is a "non-custom" smiley, check to see if its shortcut is
"shadowed" by any custom smiley. This can only happen if the connection
is custom smiley-enabled */
if (supports_custom && psmiley && !(smiley->flags & GTK_WEBVIEW_SMILEY_CUSTOM)) {
gchar tip[128];
g_snprintf(tip, sizeof(tip),
_("This smiley is disabled because a custom smiley exists for this shortcut:\n %s"),
face);
gtk_widget_set_tooltip_text(button, tip);
gtk_widget_set_sensitive(button, FALSE);
} else if (psmiley) {
/* Remove the button if the smiley is destroyed */
g_signal_connect_object(G_OBJECT(psmiley), "destroy", G_CALLBACK(gtk_widget_destroy),
button, G_CONNECT_SWAPPED);
}
/* set current element to add */
cur->height = size.height;
cur->width = size.width;
cur->button = button;
cur->smiley = smiley;
cur->next = ls;
/* check where to insert by height */
if (ls == NULL)
return cur;
while (it != NULL) {
it_last = it;
it = it->next;
}
cur->next = it;
it_last->next = cur;
return ls;
}
static gboolean
smiley_is_unique(GSList *list, GtkIMHtmlSmiley *smiley)
{
GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
while (list) {
GtkIMHtmlSmiley *cur = (GtkIMHtmlSmiley *) list->data;
if (!strcmp(cur->file, smiley->file))
return FALSE;
list = list->next;
}
return TRUE;
}
static gboolean
smiley_dialog_input_cb(GtkWidget *dialog, GdkEvent *event,
GtkWebViewToolbar *toolbar)
{
if ((event->type == GDK_KEY_PRESS && event->key.keyval == GDK_Escape) ||
(event->type == GDK_BUTTON_PRESS && event->button.button == 1))
{
close_smiley_dialog(toolbar);
return TRUE;
}
return FALSE;
}
static void
add_smiley_list(GtkWidget *container, struct smiley_button_list *list,
int max_width, gboolean custom)
{
GtkWidget *line;
int line_width = 0;
if (!list)
return;
line = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0);
for (; list; list = list->next) {
if (custom != !!(list->smiley->flags & GTK_WEBVIEW_SMILEY_CUSTOM))
continue;
gtk_box_pack_start(GTK_BOX(line), list->button, FALSE, FALSE, 0);
gtk_widget_show(list->button);
line_width += list->width;
if (line_width >= max_width) {
if (list->next) {
line = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0);
}
line_width = 0;
}
}
}
#endif
static
void
insert_smiley_cb
(
GtkWidget
*
smiley
,
GtkWebViewToolbar
*
toolbar
)
{
#if 0
GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
GtkWidget *dialog, *vbox;
GtkWidget *smiley_table = NULL;
GSList *smileys, *unique_smileys = NULL;
const GSList *custom_smileys = NULL;
gboolean supports_custom = FALSE;
GtkRequisition req;
GtkWidget *scrolled, *viewport;
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(smiley))) {
destroy_smiley_dialog(toolbar);
gtk_widget_grab_focus(toolbar->webview);
return;
}
if (priv->sml)
smileys = pidgin_themes_get_proto_smileys(priv->sml);
else
smileys = pidgin_themes_get_proto_smileys(NULL);
/* Note: prepend smileys to list to avoid O(n^2) overhead when there is
a large number of smileys... need to revers the list after for the dialog
work... */
while(smileys) {
GtkIMHtmlSmiley *smiley = (GtkIMHtmlSmiley *) smileys->data;
if(!smiley->hidden) {
if(smiley_is_unique(unique_smileys, smiley)) {
unique_smileys = g_slist_prepend(unique_smileys, smiley);
}
}
smileys = smileys->next;
}
supports_custom = (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_CUSTOM_SMILEY);
if (toolbar->webview && supports_custom) {
const GSList *iterator = NULL;
custom_smileys = pidgin_smileys_get_all();
for (iterator = custom_smileys ; iterator ;
iterator = g_slist_next(iterator)) {
GtkIMHtmlSmiley *smiley = (GtkIMHtmlSmiley *) iterator->data;
unique_smileys = g_slist_prepend(unique_smileys, smiley);
}
}
/* we need to reverse the list to get the smileys in the correct order */
unique_smileys = g_slist_reverse(unique_smileys);
dialog = pidgin_create_dialog(_("Smile!"), 0, "smiley_dialog", FALSE);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(dialog), FALSE, 0);
if (unique_smileys != NULL) {
struct smiley_button_list *ls;
int max_line_width, num_lines, button_width = 0;
/* We use hboxes packed in a vbox */
ls = NULL;
max_line_width = 0;
num_lines = floor(sqrt(g_slist_length(unique_smileys)));
smiley_table = gtk_vbox_new(FALSE, 0);
if (supports_custom) {
GtkWidget *manage = gtk_button_new_with_mnemonic(_("_Manage custom smileys"));
GtkRequisition req;
g_signal_connect(G_OBJECT(manage), "clicked",
G_CALLBACK(pidgin_smiley_manager_show), NULL);
g_signal_connect_swapped(G_OBJECT(manage), "clicked",
G_CALLBACK(gtk_widget_destroy), dialog);
gtk_box_pack_end(GTK_BOX(vbox), manage, FALSE, TRUE, 0);
gtk_widget_size_request(manage, &req);
button_width = req.width;
}
/* create list of smileys sorted by height */
while (unique_smileys) {
GtkIMHtmlSmiley *smiley = (GtkIMHtmlSmiley *) unique_smileys->data;
if (!smiley->hidden) {
ls = sort_smileys(ls, toolbar, &max_line_width, smiley);
}
unique_smileys = g_slist_delete_link(unique_smileys, unique_smileys);
}
/* The window will be at least as wide as the 'Manage ..' button */
max_line_width = MAX(button_width, max_line_width / num_lines);
/* pack buttons of the list */
add_smiley_list(smiley_table, ls, max_line_width, FALSE);
if (supports_custom) {
gtk_box_pack_start(GTK_BOX(smiley_table), gtk_hseparator_new(), TRUE, FALSE, 0);
add_smiley_list(smiley_table, ls, max_line_width, TRUE);
}
while (ls) {
struct smiley_button_list *tmp = ls->next;
g_free(ls);
ls = tmp;
}
gtk_widget_add_events(dialog, GDK_KEY_PRESS_MASK);
}
else {
smiley_table = gtk_label_new(_("This theme has no available smileys."));
gtk_widget_add_events(dialog, GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(dialog), "button-press-event", (GCallback)smiley_dialog_input_cb, toolbar);
}
scrolled = pidgin_make_scrollable(smiley_table, GTK_POLICY_NEVER, GTK_POLICY_NEVER, GTK_SHADOW_NONE, -1, -1);
gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show(smiley_table);
viewport = gtk_widget_get_parent(smiley_table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
/* connect signals */
g_signal_connect_swapped(G_OBJECT(dialog), "destroy", G_CALLBACK(close_smiley_dialog), toolbar);
g_signal_connect(G_OBJECT(dialog), "key-press-event", G_CALLBACK(smiley_dialog_input_cb), toolbar);
gtk_window_set_transient_for(GTK_WINDOW(dialog),
GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(toolbar))));
/* show everything */
gtk_widget_show_all(dialog);
gtk_widget_size_request(viewport, &req);
gtk_widget_set_size_request(scrolled, MIN(300, req.width), MIN(290, req.height));
/* The window has to be made resizable, and the scrollbars in the scrolled window
* enabled only after setting the desired size of the window. If we do either of
* these tasks before now, GTK+ miscalculates the required size, and erronously
* makes one or both scrollbars visible (sometimes).
* I too think this hack is gross. But I couldn't find a better way -- sadrul */
gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE);
g_object_set(G_OBJECT(scrolled),
"hscrollbar-policy", GTK_POLICY_AUTOMATIC,
"vscrollbar-policy", GTK_POLICY_AUTOMATIC,
NULL);
#ifdef _WIN32
winpidgin_ensure_onscreen(dialog);
#endif
priv->smiley_dialog = dialog;
gtk_widget_grab_focus(toolbar->webview);
#endif
}
static
void
send_attention_cb
(
GtkWidget
*
attention
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
PurpleConversation
*
conv
=
priv
->
active_conv
;
const
gchar
*
who
=
purple_conversation_get_name
(
conv
);
PurpleConnection
*
gc
=
purple_conversation_get_connection
(
conv
);
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
attention
),
FALSE
,
toolbar
);
purple_prpl_send_attention
(
gc
,
who
,
0
);
gtk_widget_grab_focus
(
toolbar
->
webview
);
}
static
void
update_buttons_cb
(
GtkWebView
*
webview
,
GtkWebViewButtons
buttons
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
bold
),
buttons
&
GTK_WEBVIEW_BOLD
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
italic
),
buttons
&
GTK_WEBVIEW_ITALIC
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
underline
),
buttons
&
GTK_WEBVIEW_UNDERLINE
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
strike
),
buttons
&
GTK_WEBVIEW_STRIKE
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
larger_size
),
buttons
&
GTK_WEBVIEW_GROW
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
smaller_size
),
buttons
&
GTK_WEBVIEW_SHRINK
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
font
),
buttons
&
GTK_WEBVIEW_FACE
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
fgcolor
),
buttons
&
GTK_WEBVIEW_FORECOLOR
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
bgcolor
),
buttons
&
GTK_WEBVIEW_BACKCOLOR
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
clear
),
(
buttons
&
GTK_WEBVIEW_BOLD
||
buttons
&
GTK_WEBVIEW_ITALIC
||
buttons
&
GTK_WEBVIEW_UNDERLINE
||
buttons
&
GTK_WEBVIEW_STRIKE
||
buttons
&
GTK_WEBVIEW_GROW
||
buttons
&
GTK_WEBVIEW_SHRINK
||
buttons
&
GTK_WEBVIEW_FACE
||
buttons
&
GTK_WEBVIEW_FORECOLOR
||
buttons
&
GTK_WEBVIEW_BACKCOLOR
));
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
image
),
buttons
&
GTK_WEBVIEW_IMAGE
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
link
),
buttons
&
GTK_WEBVIEW_LINK
);
gtk_widget_set_sensitive
(
GTK_WIDGET
(
priv
->
smiley
),
buttons
&
GTK_WEBVIEW_SMILEY
);
}
/* we call this when we want to _set_active the toggle button, it'll
* block the callback thats connected to the button so we don't have to
* do the double toggling hack
*/
static
void
toggle_button_set_active_block
(
GtkToggleButton
*
button
,
gboolean
is_active
,
GtkWebViewToolbar
*
toolbar
)
{
GObject
*
object
;
g_return_if_fail
(
toolbar
);
object
=
g_object_ref
(
button
);
g_signal_handlers_block_matched
(
object
,
G_SIGNAL_MATCH_DATA
,
0
,
0
,
NULL
,
NULL
,
toolbar
);
gtk_toggle_button_set_active
(
button
,
is_active
);
g_signal_handlers_unblock_matched
(
object
,
G_SIGNAL_MATCH_DATA
,
0
,
0
,
NULL
,
NULL
,
toolbar
);
g_object_unref
(
object
);
}
static
void
update_buttons
(
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
gboolean
bold
,
italic
,
underline
,
strike
;
char
*
tmp
;
GtkLabel
*
label
=
GTK_LABEL
(
priv
->
font_label
);
gtk_label_set_label
(
label
,
_
(
"_Font"
));
gtk_webview_get_current_format
(
GTK_WEBVIEW
(
toolbar
->
webview
),
&
bold
,
&
italic
,
&
underline
,
&
strike
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
priv
->
bold
))
!=
bold
)
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
bold
),
bold
,
toolbar
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
priv
->
italic
))
!=
italic
)
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
italic
),
italic
,
toolbar
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
priv
->
underline
))
!=
underline
)
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
underline
),
underline
,
toolbar
);
if
(
gtk_toggle_button_get_active
(
GTK_TOGGLE_BUTTON
(
priv
->
strike
))
!=
strike
)
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
strike
),
strike
,
toolbar
);
/* These buttons aren't ever "active". */
gtk_toggle_button_set_active
(
GTK_TOGGLE_BUTTON
(
priv
->
smaller_size
),
FALSE
);
gtk_toggle_button_set_active
(
GTK_TOGGLE_BUTTON
(
priv
->
larger_size
),
FALSE
);
if
(
bold
)
{
gchar
*
markup
=
g_strdup_printf
(
"<b>%s</b>"
,
gtk_label_get_label
(
label
));
gtk_label_set_markup_with_mnemonic
(
label
,
markup
);
g_free
(
markup
);
}
if
(
italic
)
{
gchar
*
markup
=
g_strdup_printf
(
"<i>%s</i>"
,
gtk_label_get_label
(
label
));
gtk_label_set_markup_with_mnemonic
(
label
,
markup
);
g_free
(
markup
);
}
if
(
underline
)
{
gchar
*
markup
=
g_strdup_printf
(
"<u>%s</u>"
,
gtk_label_get_label
(
label
));
gtk_label_set_markup_with_mnemonic
(
label
,
markup
);
g_free
(
markup
);
}
if
(
strike
)
{
gchar
*
markup
=
g_strdup_printf
(
"<s>%s</s>"
,
gtk_label_get_label
(
label
));
gtk_label_set_markup_with_mnemonic
(
label
,
markup
);
g_free
(
markup
);
}
tmp
=
gtk_webview_get_current_fontface
(
GTK_WEBVIEW
(
toolbar
->
webview
));
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
font
),
(
tmp
!=
NULL
),
toolbar
);
if
(
tmp
!=
NULL
)
{
gchar
*
markup
=
g_strdup_printf
(
"<span font_desc=
\"
%s
\"
>%s</span>"
,
tmp
,
gtk_label_get_label
(
label
));
gtk_label_set_markup_with_mnemonic
(
label
,
markup
);
g_free
(
markup
);
}
g_free
(
tmp
);
tmp
=
gtk_webview_get_current_forecolor
(
GTK_WEBVIEW
(
toolbar
->
webview
));
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
fgcolor
),
(
tmp
!=
NULL
),
toolbar
);
if
(
tmp
!=
NULL
)
{
gchar
*
markup
=
g_strdup_printf
(
"<span foreground=
\"
%s
\"
>%s</span>"
,
tmp
,
gtk_label_get_label
(
label
));
gtk_label_set_markup_with_mnemonic
(
label
,
markup
);
g_free
(
markup
);
}
g_free
(
tmp
);
tmp
=
gtk_webview_get_current_backcolor
(
GTK_WEBVIEW
(
toolbar
->
webview
));
toggle_button_set_active_block
(
GTK_TOGGLE_BUTTON
(
priv
->
bgcolor
),
(
tmp
!=
NULL
),
toolbar
);
if
(
tmp
!=
NULL
)
{
gchar
*
markup
=
g_strdup_printf
(
"<span background=
\"
%s
\"
>%s</span>"
,
tmp
,
gtk_label_get_label
(
label
));
gtk_label_set_markup_with_mnemonic
(
label
,
markup
);
g_free
(
markup
);
}
g_free
(
tmp
);
}
static
void
toggle_button_cb
(
GtkWebView
*
webview
,
GtkWebViewButtons
buttons
,
GtkWebViewToolbar
*
toolbar
)
{
update_buttons
(
toolbar
);
}
static
void
update_format_cb
(
GtkWebView
*
webview
,
GtkWebViewToolbar
*
toolbar
)
{
update_buttons
(
toolbar
);
}
#if 0
static void
mark_set_cb(GtkTextBuffer *buffer, GtkTextIter *location, GtkTextMark *mark,
GtkWebViewToolbar *toolbar)
{
if(mark != gtk_text_buffer_get_insert(buffer))
return;
update_buttons(toolbar);
}
#endif
/* This comes from gtkmenutoolbutton.c from gtk+
* Copyright (C) 2003 Ricardo Fernandez Pascual
* Copyright (C) 2004 Paolo Borelli
*/
static
void
menu_position_func
(
GtkMenu
*
menu
,
int
*
x
,
int
*
y
,
gboolean
*
push_in
,
gpointer
data
)
{
GtkWidget
*
widget
=
GTK_WIDGET
(
data
);
GtkRequisition
menu_req
;
gint
ythickness
=
widget
->
style
->
ythickness
;
int
savy
;
gtk_widget_size_request
(
GTK_WIDGET
(
menu
),
&
menu_req
);
gdk_window_get_origin
(
widget
->
window
,
x
,
y
);
*
x
+=
widget
->
allocation
.
x
;
*
y
+=
widget
->
allocation
.
y
+
widget
->
allocation
.
height
;
savy
=
*
y
;
pidgin_menu_position_func_helper
(
menu
,
x
,
y
,
push_in
,
data
);
if
(
savy
>
*
y
+
ythickness
+
1
)
*
y
-=
widget
->
allocation
.
height
;
}
static
gboolean
button_activate_on_click
(
GtkWidget
*
button
,
GdkEventButton
*
event
,
GtkWebViewToolbar
*
toolbar
)
{
if
(
event
->
button
==
1
&&
GTK_IS_TOGGLE_BUTTON
(
button
))
gtk_widget_activate
(
button
);
else
if
(
event
->
button
==
3
)
return
gtk_webviewtoolbar_popup_menu
(
button
,
event
,
toolbar
);
return
FALSE
;
}
static
void
pidgin_menu_clicked
(
GtkWidget
*
button
,
GtkMenu
*
menu
)
{
gtk_widget_show_all
(
GTK_WIDGET
(
menu
));
gtk_menu_popup
(
menu
,
NULL
,
NULL
,
menu_position_func
,
button
,
0
,
gtk_get_current_event_time
());
}
static
void
pidgin_menu_deactivate
(
GtkWidget
*
menu
,
GtkToggleButton
*
button
)
{
gtk_toggle_button_set_active
(
GTK_TOGGLE_BUTTON
(
button
),
FALSE
);
}
static
void
switch_toolbar_view
(
GtkWidget
*
item
,
GtkWebViewToolbar
*
toolbar
)
{
purple_prefs_set_bool
(
PIDGIN_PREFS_ROOT
"/conversations/toolbar/wide"
,
!
purple_prefs_get_bool
(
PIDGIN_PREFS_ROOT
"/conversations/toolbar/wide"
));
}
static
gboolean
gtk_webviewtoolbar_popup_menu
(
GtkWidget
*
widget
,
GdkEventButton
*
event
,
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkWidget
*
menu
;
GtkWidget
*
item
;
gboolean
wide
;
if
(
event
->
button
!=
3
)
return
FALSE
;
wide
=
gtk_widget_get_visible
(
priv
->
bold
);
menu
=
gtk_menu_new
();
item
=
gtk_menu_item_new_with_mnemonic
(
wide
?
_
(
"Group Items"
)
:
_
(
"Ungroup Items"
));
g_signal_connect
(
G_OBJECT
(
item
),
"activate"
,
G_CALLBACK
(
switch_toolbar_view
),
toolbar
);
gtk_menu_shell_append
(
GTK_MENU_SHELL
(
menu
),
item
);
gtk_widget_show
(
item
);
gtk_menu_popup
(
GTK_MENU
(
menu
),
NULL
,
NULL
,
pidgin_menu_position_func_helper
,
widget
,
event
->
button
,
event
->
time
);
return
TRUE
;
}
static
void
button_visibility_changed
(
GtkWidget
*
button
,
gpointer
dontcare
,
GtkWidget
*
item
)
{
if
(
gtk_widget_get_visible
(
button
))
gtk_widget_hide
(
item
);
else
gtk_widget_show
(
item
);
}
static
void
button_sensitiveness_changed
(
GtkWidget
*
button
,
gpointer
dontcare
,
GtkWidget
*
item
)
{
gtk_widget_set_sensitive
(
item
,
gtk_widget_is_sensitive
(
button
));
}
static
void
update_menuitem
(
GtkToggleButton
*
button
,
GtkCheckMenuItem
*
item
)
{
g_signal_handlers_block_by_func
(
G_OBJECT
(
item
),
G_CALLBACK
(
gtk_button_clicked
),
button
);
gtk_check_menu_item_set_active
(
item
,
gtk_toggle_button_get_active
(
button
));
g_signal_handlers_unblock_by_func
(
G_OBJECT
(
item
),
G_CALLBACK
(
gtk_button_clicked
),
button
);
}
static
void
enable_markup
(
GtkWidget
*
widget
,
gpointer
null
)
{
if
(
GTK_IS_LABEL
(
widget
))
g_object_set
(
G_OBJECT
(
widget
),
"use-markup"
,
TRUE
,
NULL
);
}
static
void
webviewtoolbar_view_pref_changed
(
const
char
*
name
,
PurplePrefType
type
,
gconstpointer
value
,
gpointer
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
value
)
{
gtk_widget_hide_all
(
priv
->
lean_view
);
gtk_widget_show_all
(
priv
->
wide_view
);
}
else
{
gtk_widget_hide_all
(
priv
->
wide_view
);
gtk_widget_show_all
(
priv
->
lean_view
);
}
}
/******************************************************************************
* GObject stuff
*****************************************************************************/
static
void
gtk_webviewtoolbar_finalize
(
GObject
*
object
)
{
GtkWebViewToolbar
*
toolbar
=
GTK_WEBVIEWTOOLBAR
(
object
);
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
if
(
priv
->
image_dialog
!=
NULL
)
{
gtk_widget_destroy
(
priv
->
image_dialog
);
priv
->
image_dialog
=
NULL
;
}
destroy_toolbar_font
(
NULL
,
NULL
,
toolbar
);
if
(
priv
->
smiley_dialog
!=
NULL
)
{
#if 0
g_signal_handlers_disconnect_by_func(G_OBJECT(priv->smiley_dialog), close_smiley_dialog, toolbar);
destroy_smiley_dialog(toolbar);
#endif
}
destroy_toolbar_bgcolor
(
NULL
,
NULL
,
toolbar
);
destroy_toolbar_fgcolor
(
NULL
,
NULL
,
toolbar
);
close_link_dialog
(
toolbar
);
if
(
toolbar
->
webview
)
{
g_signal_handlers_disconnect_matched
(
toolbar
->
webview
,
G_SIGNAL_MATCH_DATA
,
0
,
0
,
NULL
,
NULL
,
toolbar
);
#if 0
g_signal_handlers_disconnect_matched(GTK_WEBVIEW(toolbar->webview)->text_buffer,
G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
toolbar);
#endif
}
g_free
(
priv
->
sml
);
#if !GTK_CHECK_VERSION(2,12,0)
gtk_object_sink
(
GTK_OBJECT
(
priv
->
tooltips
));
#endif
if
(
priv
->
font_menu
)
gtk_widget_destroy
(
priv
->
font_menu
);
if
(
priv
->
insert_menu
)
gtk_widget_destroy
(
priv
->
insert_menu
);
purple_prefs_disconnect_by_handle
(
object
);
G_OBJECT_CLASS
(
parent_class
)
->
finalize
(
object
);
}
static
void
gtk_webviewtoolbar_class_init
(
GtkWebViewToolbarClass
*
class
)
{
GObjectClass
*
gobject_class
;
gobject_class
=
(
GObjectClass
*
)
class
;
parent_class
=
g_type_class_ref
(
GTK_TYPE_HBOX
);
gobject_class
->
finalize
=
gtk_webviewtoolbar_finalize
;
g_type_class_add_private
(
class
,
sizeof
(
GtkWebViewToolbarPriv
));
purple_prefs_add_none
(
PIDGIN_PREFS_ROOT
"/conversations/toolbar"
);
purple_prefs_add_bool
(
PIDGIN_PREFS_ROOT
"/conversations/toolbar/wide"
,
FALSE
);
}
static
void
gtk_webviewtoolbar_create_old_buttons
(
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkWidget
*
hbox
;
GtkWidget
*
button
;
struct
{
char
*
stock
;
gpointer
callback
;
GtkWidget
**
button
;
const
char
*
tooltip
;
}
buttons
[]
=
{
{
GTK_STOCK_BOLD
,
G_CALLBACK
(
do_bold
),
&
priv
->
bold
,
_
(
"Bold"
)},
{
GTK_STOCK_ITALIC
,
do_italic
,
&
priv
->
italic
,
_
(
"Italic"
)},
{
GTK_STOCK_UNDERLINE
,
do_underline
,
&
priv
->
underline
,
_
(
"Underline"
)},
{
GTK_STOCK_STRIKETHROUGH
,
do_strikethrough
,
&
priv
->
strike
,
_
(
"Strikethrough"
)},
{
""
,
NULL
,
NULL
,
NULL
},
{
PIDGIN_STOCK_TOOLBAR_TEXT_LARGER
,
do_big
,
&
priv
->
larger_size
,
_
(
"Increase Font Size"
)},
{
PIDGIN_STOCK_TOOLBAR_TEXT_SMALLER
,
do_small
,
&
priv
->
smaller_size
,
_
(
"Decrease Font Size"
)},
{
""
,
NULL
,
NULL
,
NULL
},
{
PIDGIN_STOCK_TOOLBAR_FONT_FACE
,
toggle_font
,
&
priv
->
font
,
_
(
"Font Face"
)},
{
PIDGIN_STOCK_TOOLBAR_FGCOLOR
,
toggle_fg_color
,
&
priv
->
fgcolor
,
_
(
"Foreground Color"
)},
{
PIDGIN_STOCK_TOOLBAR_BGCOLOR
,
toggle_bg_color
,
&
priv
->
bgcolor
,
_
(
"Background Color"
)},
{
""
,
NULL
,
NULL
,
NULL
},
{
PIDGIN_STOCK_CLEAR
,
clear_formatting_cb
,
&
priv
->
clear
,
_
(
"Reset Formatting"
)},
{
""
,
NULL
,
NULL
,
NULL
},
{
PIDGIN_STOCK_TOOLBAR_INSERT_IMAGE
,
insert_image_cb
,
&
priv
->
image
,
_
(
"Insert IM Image"
)},
{
PIDGIN_STOCK_TOOLBAR_INSERT_LINK
,
insert_link_cb
,
&
priv
->
link
,
_
(
"Insert Link"
)},
{
""
,
NULL
,
NULL
,
NULL
},
{
PIDGIN_STOCK_TOOLBAR_SMILEY
,
insert_smiley_cb
,
&
priv
->
smiley
,
_
(
"Insert Smiley"
)},
{
PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION
,
send_attention_cb
,
&
priv
->
attention
,
_
(
"Send Attention"
)},
{
NULL
,
NULL
,
NULL
,
NULL
}
};
int
iter
;
hbox
=
gtk_hbox_new
(
FALSE
,
0
);
for
(
iter
=
0
;
buttons
[
iter
].
stock
;
iter
++
)
{
if
(
buttons
[
iter
].
stock
[
0
])
{
button
=
pidgin_pixbuf_toolbar_button_from_stock
(
buttons
[
iter
].
stock
);
g_signal_connect
(
G_OBJECT
(
button
),
"button-press-event"
,
G_CALLBACK
(
gtk_webviewtoolbar_popup_menu
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
button
),
"clicked"
,
G_CALLBACK
(
buttons
[
iter
].
callback
),
toolbar
);
*
(
buttons
[
iter
].
button
)
=
button
;
gtk_widget_set_tooltip_text
(
button
,
buttons
[
iter
].
tooltip
);
}
else
button
=
gtk_vseparator_new
();
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
button
,
FALSE
,
FALSE
,
0
);
}
gtk_box_pack_start
(
GTK_BOX
(
toolbar
),
hbox
,
FALSE
,
FALSE
,
0
);
priv
->
wide_view
=
hbox
;
}
static
void
gtk_webviewtoolbar_init
(
GtkWebViewToolbar
*
toolbar
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
GtkWidget
*
hbox
=
GTK_WIDGET
(
toolbar
),
*
event
=
gtk_event_box_new
();
GtkWidget
*
bbox
,
*
box
=
gtk_hbox_new
(
FALSE
,
0
);
GtkWidget
*
image
;
GtkWidget
*
label
;
GtkWidget
*
insert_button
;
GtkWidget
*
font_button
;
GtkWidget
*
smiley_button
;
GtkWidget
*
attention_button
;
GtkWidget
*
font_menu
;
GtkWidget
*
insert_menu
;
GtkWidget
*
menuitem
;
GtkWidget
*
sep
;
int
i
;
struct
{
const
char
*
label
;
GtkWidget
**
button
;
gboolean
check
;
}
buttons
[]
=
{
{
_
(
"<b>_Bold</b>"
),
&
priv
->
bold
,
TRUE
},
{
_
(
"<i>_Italic</i>"
),
&
priv
->
italic
,
TRUE
},
{
_
(
"<u>_Underline</u>"
),
&
priv
->
underline
,
TRUE
},
{
_
(
"<span strikethrough='true'>Strikethrough</span>"
),
&
priv
->
strike
,
TRUE
},
{
_
(
"<span size='larger'>_Larger</span>"
),
&
priv
->
larger_size
,
TRUE
},
#if 0
{_("_Normal"), &priv->normal_size, TRUE},
#endif
{
_
(
"<span size='smaller'>_Smaller</span>"
),
&
priv
->
smaller_size
,
TRUE
},
/* If we want to show the formatting for the following items, we would
* need to update them when formatting changes. The above items don't need
* no updating nor nothin' */
{
_
(
"_Font face"
),
&
priv
->
font
,
TRUE
},
{
_
(
"Foreground _color"
),
&
priv
->
fgcolor
,
TRUE
},
{
_
(
"Bac_kground color"
),
&
priv
->
bgcolor
,
TRUE
},
{
_
(
"_Reset formatting"
),
&
priv
->
clear
,
FALSE
},
{
NULL
,
NULL
,
FALSE
}
};
toolbar
->
webview
=
NULL
;
priv
->
font_dialog
=
NULL
;
priv
->
fgcolor_dialog
=
NULL
;
priv
->
bgcolor_dialog
=
NULL
;
priv
->
link_dialog
=
NULL
;
priv
->
smiley_dialog
=
NULL
;
priv
->
image_dialog
=
NULL
;
#if !GTK_CHECK_VERSION(2,12,0)
priv
->
tooltips
=
gtk_tooltips_new
();
#endif
gtk_box_set_spacing
(
GTK_BOX
(
toolbar
),
3
);
gtk_webviewtoolbar_create_old_buttons
(
toolbar
);
/* Fonts */
font_button
=
gtk_toggle_button_new
();
gtk_button_set_relief
(
GTK_BUTTON
(
font_button
),
GTK_RELIEF_NONE
);
bbox
=
gtk_hbox_new
(
FALSE
,
3
);
gtk_container_add
(
GTK_CONTAINER
(
font_button
),
bbox
);
image
=
gtk_image_new_from_stock
(
GTK_STOCK_BOLD
,
gtk_icon_size_from_name
(
PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL
));
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
image
,
FALSE
,
FALSE
,
0
);
priv
->
font_label
=
label
=
gtk_label_new_with_mnemonic
(
_
(
"_Font"
));
gtk_label_set_use_markup
(
GTK_LABEL
(
label
),
TRUE
);
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
label
,
FALSE
,
FALSE
,
0
);
gtk_box_pack_start
(
GTK_BOX
(
box
),
font_button
,
FALSE
,
FALSE
,
0
);
gtk_widget_show_all
(
font_button
);
priv
->
font_menu
=
font_menu
=
gtk_menu_new
();
for
(
i
=
0
;
buttons
[
i
].
label
;
i
++
)
{
GtkWidget
*
old
=
*
buttons
[
i
].
button
;
if
(
buttons
[
i
].
check
)
{
menuitem
=
gtk_check_menu_item_new_with_mnemonic
(
buttons
[
i
].
label
);
g_signal_connect_after
(
G_OBJECT
(
old
),
"toggled"
,
G_CALLBACK
(
update_menuitem
),
menuitem
);
}
else
{
menuitem
=
gtk_menu_item_new_with_mnemonic
(
buttons
[
i
].
label
);
}
g_signal_connect_swapped
(
G_OBJECT
(
menuitem
),
"activate"
,
G_CALLBACK
(
gtk_button_clicked
),
old
);
gtk_menu_shell_append
(
GTK_MENU_SHELL
(
font_menu
),
menuitem
);
g_signal_connect
(
G_OBJECT
(
old
),
"notify::sensitive"
,
G_CALLBACK
(
button_sensitiveness_changed
),
menuitem
);
g_signal_connect
(
G_OBJECT
(
old
),
"notify::visible"
,
G_CALLBACK
(
button_visibility_changed
),
menuitem
);
gtk_container_foreach
(
GTK_CONTAINER
(
menuitem
),
(
GtkCallback
)
enable_markup
,
NULL
);
}
g_signal_connect
(
G_OBJECT
(
font_button
),
"button-press-event"
,
G_CALLBACK
(
button_activate_on_click
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
font_button
),
"activate"
,
G_CALLBACK
(
pidgin_menu_clicked
),
font_menu
);
g_signal_connect
(
G_OBJECT
(
font_menu
),
"deactivate"
,
G_CALLBACK
(
pidgin_menu_deactivate
),
font_button
);
/* Sep */
sep
=
gtk_vseparator_new
();
gtk_box_pack_start
(
GTK_BOX
(
box
),
sep
,
FALSE
,
FALSE
,
0
);
gtk_widget_show_all
(
sep
);
/* Insert */
insert_button
=
gtk_toggle_button_new
();
gtk_button_set_relief
(
GTK_BUTTON
(
insert_button
),
GTK_RELIEF_NONE
);
bbox
=
gtk_hbox_new
(
FALSE
,
3
);
gtk_container_add
(
GTK_CONTAINER
(
insert_button
),
bbox
);
image
=
gtk_image_new_from_stock
(
PIDGIN_STOCK_TOOLBAR_INSERT
,
gtk_icon_size_from_name
(
PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL
));
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
image
,
FALSE
,
FALSE
,
0
);
label
=
gtk_label_new_with_mnemonic
(
_
(
"_Insert"
));
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
label
,
FALSE
,
FALSE
,
0
);
gtk_box_pack_start
(
GTK_BOX
(
box
),
insert_button
,
FALSE
,
FALSE
,
0
);
gtk_widget_show_all
(
insert_button
);
priv
->
insert_menu
=
insert_menu
=
gtk_menu_new
();
menuitem
=
gtk_menu_item_new_with_mnemonic
(
_
(
"_Image"
));
g_signal_connect_swapped
(
G_OBJECT
(
menuitem
),
"activate"
,
G_CALLBACK
(
gtk_button_clicked
),
priv
->
image
);
gtk_menu_shell_append
(
GTK_MENU_SHELL
(
insert_menu
),
menuitem
);
g_signal_connect
(
G_OBJECT
(
priv
->
image
),
"notify::sensitive"
,
G_CALLBACK
(
button_sensitiveness_changed
),
menuitem
);
g_signal_connect
(
G_OBJECT
(
priv
->
image
),
"notify::visible"
,
G_CALLBACK
(
button_visibility_changed
),
menuitem
);
menuitem
=
gtk_menu_item_new_with_mnemonic
(
_
(
"_Link"
));
g_signal_connect_swapped
(
G_OBJECT
(
menuitem
),
"activate"
,
G_CALLBACK
(
gtk_button_clicked
),
priv
->
link
);
gtk_menu_shell_append
(
GTK_MENU_SHELL
(
insert_menu
),
menuitem
);
g_signal_connect
(
G_OBJECT
(
priv
->
link
),
"notify::sensitive"
,
G_CALLBACK
(
button_sensitiveness_changed
),
menuitem
);
g_signal_connect
(
G_OBJECT
(
priv
->
link
),
"notify::visible"
,
G_CALLBACK
(
button_visibility_changed
),
menuitem
);
menuitem
=
gtk_menu_item_new_with_mnemonic
(
_
(
"_Horizontal rule"
));
g_signal_connect
(
G_OBJECT
(
menuitem
),
"activate"
,
G_CALLBACK
(
insert_hr_cb
),
toolbar
);
gtk_menu_shell_append
(
GTK_MENU_SHELL
(
insert_menu
),
menuitem
);
priv
->
insert_hr
=
menuitem
;
g_signal_connect
(
G_OBJECT
(
insert_button
),
"button-press-event"
,
G_CALLBACK
(
button_activate_on_click
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
insert_button
),
"activate"
,
G_CALLBACK
(
pidgin_menu_clicked
),
insert_menu
);
g_signal_connect
(
G_OBJECT
(
insert_menu
),
"deactivate"
,
G_CALLBACK
(
pidgin_menu_deactivate
),
insert_button
);
priv
->
sml
=
NULL
;
/* Sep */
sep
=
gtk_vseparator_new
();
gtk_box_pack_start
(
GTK_BOX
(
box
),
sep
,
FALSE
,
FALSE
,
0
);
gtk_widget_show_all
(
sep
);
/* Smiley */
smiley_button
=
gtk_button_new
();
gtk_button_set_relief
(
GTK_BUTTON
(
smiley_button
),
GTK_RELIEF_NONE
);
bbox
=
gtk_hbox_new
(
FALSE
,
3
);
gtk_container_add
(
GTK_CONTAINER
(
smiley_button
),
bbox
);
image
=
gtk_image_new_from_stock
(
PIDGIN_STOCK_TOOLBAR_SMILEY
,
gtk_icon_size_from_name
(
PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL
));
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
image
,
FALSE
,
FALSE
,
0
);
label
=
gtk_label_new_with_mnemonic
(
_
(
"_Smile!"
));
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
label
,
FALSE
,
FALSE
,
0
);
gtk_box_pack_start
(
GTK_BOX
(
box
),
smiley_button
,
FALSE
,
FALSE
,
0
);
g_signal_connect
(
G_OBJECT
(
smiley_button
),
"button-press-event"
,
G_CALLBACK
(
gtk_webviewtoolbar_popup_menu
),
toolbar
);
g_signal_connect_swapped
(
G_OBJECT
(
smiley_button
),
"clicked"
,
G_CALLBACK
(
gtk_button_clicked
),
priv
->
smiley
);
gtk_widget_show_all
(
smiley_button
);
/* Sep */
sep
=
gtk_vseparator_new
();
gtk_box_pack_start
(
GTK_BOX
(
box
),
sep
,
FALSE
,
FALSE
,
0
);
gtk_widget_show_all
(
sep
);
/* Attention */
attention_button
=
gtk_button_new
();
gtk_button_set_relief
(
GTK_BUTTON
(
attention_button
),
GTK_RELIEF_NONE
);
bbox
=
gtk_hbox_new
(
FALSE
,
3
);
gtk_container_add
(
GTK_CONTAINER
(
attention_button
),
bbox
);
image
=
gtk_image_new_from_stock
(
PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION
,
gtk_icon_size_from_name
(
PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL
));
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
image
,
FALSE
,
FALSE
,
0
);
label
=
gtk_label_new_with_mnemonic
(
_
(
"_Attention!"
));
gtk_box_pack_start
(
GTK_BOX
(
bbox
),
label
,
FALSE
,
FALSE
,
0
);
gtk_box_pack_start
(
GTK_BOX
(
box
),
attention_button
,
FALSE
,
FALSE
,
0
);
g_signal_connect_swapped
(
G_OBJECT
(
attention_button
),
"clicked"
,
G_CALLBACK
(
gtk_button_clicked
),
priv
->
attention
);
gtk_widget_show_all
(
attention_button
);
g_signal_connect
(
G_OBJECT
(
priv
->
attention
),
"notify::sensitive"
,
G_CALLBACK
(
button_sensitiveness_changed
),
attention_button
);
g_signal_connect
(
G_OBJECT
(
priv
->
attention
),
"notify::visible"
,
G_CALLBACK
(
button_visibility_changed
),
attention_button
);
/* set attention button to be greyed out until we get a conversation */
gtk_widget_set_sensitive
(
priv
->
attention
,
FALSE
);
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
box
,
FALSE
,
FALSE
,
0
);
priv
->
lean_view
=
box
;
gtk_widget_show
(
box
);
purple_prefs_connect_callback
(
toolbar
,
PIDGIN_PREFS_ROOT
"/conversations/toolbar/wide"
,
webviewtoolbar_view_pref_changed
,
toolbar
);
g_signal_connect_data
(
G_OBJECT
(
toolbar
),
"realize"
,
G_CALLBACK
(
purple_prefs_trigger_callback
),
PIDGIN_PREFS_ROOT
"/conversations/toolbar/wide"
,
NULL
,
G_CONNECT_AFTER
|
G_CONNECT_SWAPPED
);
gtk_event_box_set_visible_window
(
GTK_EVENT_BOX
(
event
),
FALSE
);
gtk_widget_add_events
(
event
,
GDK_BUTTON_PRESS_MASK
);
gtk_box_pack_start
(
GTK_BOX
(
hbox
),
event
,
TRUE
,
TRUE
,
0
);
g_signal_connect
(
G_OBJECT
(
event
),
"button-press-event"
,
G_CALLBACK
(
gtk_webviewtoolbar_popup_menu
),
toolbar
);
gtk_widget_show
(
event
);
}
/******************************************************************************
* Public API
*****************************************************************************/
GtkWidget
*
gtk_webviewtoolbar_new
(
void
)
{
return
GTK_WIDGET
(
g_object_new
(
gtk_webviewtoolbar_get_type
(),
NULL
));
}
GType
gtk_webviewtoolbar_get_type
(
void
)
{
static
GType
webviewtoolbar_type
=
0
;
if
(
!
webviewtoolbar_type
)
{
static
const
GTypeInfo
webviewtoolbar_info
=
{
sizeof
(
GtkWebViewToolbarClass
),
NULL
,
NULL
,
(
GClassInitFunc
)
gtk_webviewtoolbar_class_init
,
NULL
,
NULL
,
sizeof
(
GtkWebViewToolbar
),
0
,
(
GInstanceInitFunc
)
gtk_webviewtoolbar_init
,
NULL
};
webviewtoolbar_type
=
g_type_register_static
(
GTK_TYPE_HBOX
,
"GtkWebViewToolbar"
,
&
webviewtoolbar_info
,
0
);
}
return
webviewtoolbar_type
;
}
void
gtk_webviewtoolbar_attach
(
GtkWebViewToolbar
*
toolbar
,
GtkWidget
*
webview
)
{
GtkWebViewButtons
buttons
;
g_return_if_fail
(
toolbar
!=
NULL
);
g_return_if_fail
(
GTK_IS_WEBVIEWTOOLBAR
(
toolbar
));
g_return_if_fail
(
webview
!=
NULL
);
g_return_if_fail
(
GTK_IS_WEBVIEW
(
webview
));
toolbar
->
webview
=
webview
;
g_signal_connect
(
G_OBJECT
(
webview
),
"allowed-formats-updated"
,
G_CALLBACK
(
update_buttons_cb
),
toolbar
);
g_signal_connect_after
(
G_OBJECT
(
webview
),
"format-toggled"
,
G_CALLBACK
(
toggle_button_cb
),
toolbar
);
g_signal_connect_after
(
G_OBJECT
(
webview
),
"format-cleared"
,
G_CALLBACK
(
update_format_cb
),
toolbar
);
g_signal_connect
(
G_OBJECT
(
webview
),
"format-updated"
,
G_CALLBACK
(
update_format_cb
),
toolbar
);
#if 0
g_signal_connect_after(G_OBJECT(GTK_WEBVIEW(webview)->text_buffer), "mark-set", G_CALLBACK(mark_set_cb), toolbar);
#endif
buttons
=
gtk_webview_get_format_functions
(
GTK_WEBVIEW
(
webview
));
update_buttons_cb
(
GTK_WEBVIEW
(
webview
),
buttons
,
toolbar
);
update_buttons
(
toolbar
);
}
void
gtk_webviewtoolbar_associate_smileys
(
GtkWebViewToolbar
*
toolbar
,
const
char
*
proto_id
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
g_free
(
priv
->
sml
);
priv
->
sml
=
g_strdup
(
proto_id
);
}
void
gtk_webviewtoolbar_switch_active_conversation
(
GtkWebViewToolbar
*
toolbar
,
PurpleConversation
*
conv
)
{
GtkWebViewToolbarPriv
*
priv
=
GTK_WEBVIEWTOOLBAR_GET_PRIVATE
(
toolbar
);
PurpleConnection
*
gc
=
purple_conversation_get_connection
(
conv
);
PurplePlugin
*
prpl
=
purple_connection_get_prpl
(
gc
);
priv
->
active_conv
=
conv
;
/* gray out attention button on protocols that don't support it
for the time being it is always disabled for chats */
gtk_widget_set_sensitive
(
priv
->
attention
,
conv
&&
prpl
&&
purple_conversation_get_type
(
conv
)
==
PURPLE_CONV_TYPE_IM
&&
PURPLE_PLUGIN_PROTOCOL_INFO
(
prpl
)
->
send_attention
!=
NULL
);
}