/*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with the program; if not, see <http://www.gnu.org/licenses/>
*
* Authors:
* Dan Vratil <dvratil@redhat.com>
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "e-port-entry.h"
#include <stddef.h>
#include <string.h>
struct _EPortEntryPrivate {
guint port;
gboolean is_valid;
CamelNetworkSecurityMethod method;
};
enum {
PORT_NUM_COLUMN,
PORT_DESC_COLUMN,
PORT_IS_SSL_COLUMN
};
enum {
PROP_0,
PROP_IS_VALID,
PROP_PORT,
PROP_SECURITY_METHOD
};
G_DEFINE_TYPE (
EPortEntry,
e_port_entry,
GTK_TYPE_COMBO_BOX)
static void
port_entry_set_is_valid (EPortEntry *port_entry,
gboolean is_valid)
{
g_return_if_fail (E_IS_PORT_ENTRY (port_entry));
port_entry->priv->is_valid = is_valid;
g_object_notify (G_OBJECT (port_entry), "is-valid");
}
/**
* Returns number of port currently selected in the widget, no matter
* what value is in the PORT property
*/
static gint
port_entry_get_model_active_port (EPortEntry *port_entry)
{
const gchar *port;
port = gtk_combo_box_get_active_id (GTK_COMBO_BOX (port_entry));
if (!port) {
GtkWidget *entry = gtk_bin_get_child (GTK_BIN (port_entry));
port = gtk_entry_get_text (GTK_ENTRY (entry));
}
return atoi (port);
}
static void
port_entry_port_changed (EPortEntry *port_entry)
{
GtkTreeModel *model;
GtkTreeIter iter;
const gchar *port;
const gchar *tooltip;
g_return_if_fail (E_IS_PORT_ENTRY (port_entry));
model = gtk_combo_box_get_model (GTK_COMBO_BOX (port_entry));
g_return_if_fail (model);
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (port_entry), &iter)) {
GtkWidget *entry = gtk_bin_get_child (GTK_BIN (port_entry));
port = gtk_entry_get_text (GTK_ENTRY (entry));
/* Try if user just haven't happened to enter a default port */
gtk_combo_box_set_active_id (GTK_COMBO_BOX (port_entry), port);
} else {
gtk_tree_model_get (model, &iter, PORT_NUM_COLUMN, &port, -1);
}
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (port_entry), &iter)) {
gtk_tree_model_get (model, &iter, PORT_DESC_COLUMN, &tooltip, -1);
gtk_widget_set_tooltip_text (GTK_WIDGET (port_entry), tooltip);
} else {
gtk_widget_set_has_tooltip (GTK_WIDGET (port_entry), FALSE);
}
if (port == NULL || *port == '\0') {
port_entry->priv->port = 0;
port_entry_set_is_valid (port_entry, FALSE);
} else {
port_entry->priv->port = atoi (port);
if ((port_entry->priv->port <= 0) ||
(port_entry->priv->port > G_MAXUINT16)) {
port_entry->priv->port = 0;
port_entry_set_is_valid (port_entry, FALSE);
} else {
port_entry_set_is_valid (port_entry, TRUE);
}
}
g_object_notify (G_OBJECT (port_entry), "port");
}
static void
port_entry_method_changed (EPortEntry *port_entry)
{
CamelNetworkSecurityMethod method;
method = e_port_entry_get_security_method (port_entry);
switch (method) {
case CAMEL_NETWORK_SECURITY_METHOD_SSL_ON_ALTERNATE_PORT:
e_port_entry_activate_secured_port (port_entry, 0);
break;
default:
e_port_entry_activate_nonsecured_port (port_entry, 0);
break;
}
}
static void
port_entry_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_IS_VALID:
port_entry_set_is_valid (
E_PORT_ENTRY (object),
g_value_get_boolean (value));
return;
case PROP_PORT:
e_port_entry_set_port (
E_PORT_ENTRY (object),
g_value_get_uint (value));
return;
case PROP_SECURITY_METHOD:
e_port_entry_set_security_method (
E_PORT_ENTRY (object),
g_value_get_enum (value));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
port_entry_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_IS_VALID:
g_value_set_boolean (
value, e_port_entry_is_valid (
E_PORT_ENTRY (object)));
return;
case PROP_PORT:
g_value_set_uint (
value, e_port_entry_get_port (
E_PORT_ENTRY (object)));
return;
case PROP_SECURITY_METHOD:
g_value_set_enum (
value, e_port_entry_get_security_method (
E_PORT_ENTRY (object)));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
port_entry_get_preferred_width (GtkWidget *widget,
gint *minimum_size,
gint *natural_size)
{
PangoContext *context;
PangoFontMetrics *metrics;
PangoFontDescription *font_desc;
GtkStyleContext *style_context;
GtkStateFlags state;
gint digit_width;
gint parent_entry_width_min;
gint parent_width_min;
GtkWidget *entry;
style_context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
gtk_style_context_get (
style_context, state, "font", &font_desc, NULL);
context = gtk_widget_get_pango_context (GTK_WIDGET (widget));
metrics = pango_context_get_metrics (
context, font_desc, pango_context_get_language (context));
digit_width = PANGO_PIXELS (
pango_font_metrics_get_approximate_digit_width (metrics));
/* Preferred width of the entry */
entry = gtk_bin_get_child (GTK_BIN (widget));
gtk_widget_get_preferred_width (entry, NULL, &parent_entry_width_min);
/* Preferred width of a standard combobox */
GTK_WIDGET_CLASS (e_port_entry_parent_class)->
get_preferred_width (widget, &parent_width_min, NULL);
/* 6 * digit_width - port number has max 5
* digits + extra free space for better look */
if (minimum_size != NULL)
*minimum_size =
parent_width_min - parent_entry_width_min +
6 * digit_width;
if (natural_size != NULL)
*natural_size =
parent_width_min - parent_entry_width_min +
6 * digit_width;
pango_font_metrics_unref (metrics);
pango_font_description_free (font_desc);
}
static void
e_port_entry_class_init (EPortEntryClass *class)
{
GObjectClass *object_class;
GtkWidgetClass *widget_class;
g_type_class_add_private (class, sizeof (EPortEntryPrivate));
object_class = G_OBJECT_CLASS (class);
object_class->set_property = port_entry_set_property;
object_class->get_property = port_entry_get_property;
widget_class = GTK_WIDGET_CLASS (class);
widget_class->get_preferred_width = port_entry_get_preferred_width;
g_object_class_install_property (
object_class,
PROP_IS_VALID,
g_param_spec_boolean (
"is-valid",
NULL,
NULL,
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (
object_class,
PROP_PORT,
g_param_spec_uint (
"port",
NULL,
NULL,
0, /* Min port, 0 = invalid port */
G_MAXUINT16, /* Max port */
0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (
object_class,
PROP_SECURITY_METHOD,
g_param_spec_enum (
"security-method",
"Security Method",
"Method used to establish a network connection",
CAMEL_TYPE_NETWORK_SECURITY_METHOD,
CAMEL_NETWORK_SECURITY_METHOD_NONE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
}
static void
e_port_entry_init (EPortEntry *port_entry)
{
GtkCellRenderer *renderer;
GtkListStore *store;
port_entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (
port_entry, E_TYPE_PORT_ENTRY, EPortEntryPrivate);
port_entry->priv->port = 0;
port_entry->priv->is_valid = FALSE;
store = gtk_list_store_new (
3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
gtk_combo_box_set_model (
GTK_COMBO_BOX (port_entry), GTK_TREE_MODEL (store));
gtk_combo_box_set_entry_text_column (
GTK_COMBO_BOX (port_entry), PORT_NUM_COLUMN);
gtk_combo_box_set_id_column (
GTK_COMBO_BOX (port_entry), PORT_NUM_COLUMN);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_sensitive (renderer, TRUE);
gtk_cell_layout_pack_start (
GTK_CELL_LAYOUT (port_entry), renderer, FALSE);
gtk_cell_layout_add_attribute (
GTK_CELL_LAYOUT (port_entry),
renderer, "text", PORT_NUM_COLUMN);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_sensitive (renderer, FALSE);
gtk_cell_layout_pack_start (
GTK_CELL_LAYOUT (port_entry), renderer, TRUE);
gtk_cell_layout_add_attribute (
GTK_CELL_LAYOUT (port_entry),
renderer, "text", PORT_DESC_COLUMN);
/* Update the port property when port is changed */
g_signal_connect (
port_entry, "changed",
G_CALLBACK (port_entry_port_changed), NULL);
g_signal_connect (
port_entry, "notify::security-method",
G_CALLBACK (port_entry_method_changed), NULL);
}
GtkWidget *
e_port_entry_new (void)
{
return g_object_new (
E_TYPE_PORT_ENTRY, "has-entry", TRUE, NULL);
}
void
e_port_entry_set_camel_entries (EPortEntry *port_entry,
CamelProviderPortEntry *entries)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkListStore *store;
gint i = 0;
g_return_if_fail (E_IS_PORT_ENTRY (port_entry));
g_return_if_fail (entries);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (port_entry));
store = GTK_LIST_STORE (model);
gtk_list_store_clear (store);
while (entries[i].port > 0) {
gchar *port_string;
port_string = g_strdup_printf ("%i", entries[i].port);
gtk_list_store_append (store, &iter);
gtk_list_store_set (
store, &iter,
PORT_NUM_COLUMN, port_string,
PORT_DESC_COLUMN, entries[i].desc,
PORT_IS_SSL_COLUMN, entries[i].is_ssl,
-1);
i++;
g_free (port_string);
}
/* Activate the first port */
if (i > 0)
e_port_entry_set_port (port_entry, entries[0].port);
}
gint
e_port_entry_get_port (EPortEntry *port_entry)
{
g_return_val_if_fail (E_IS_PORT_ENTRY (port_entry), 0);
return port_entry->priv->port;
}
void
e_port_entry_set_port (EPortEntry *port_entry,
gint port)
{
g_return_if_fail (E_IS_PORT_ENTRY (port_entry));
port_entry->priv->port = port;
if ((port <= 0) || (port > G_MAXUINT16))
port_entry_set_is_valid (port_entry, FALSE);
else {
gchar *port_string;
port_string = g_strdup_printf ("%i", port);
gtk_combo_box_set_active_id (
GTK_COMBO_BOX (port_entry), port_string);
if (port_entry_get_model_active_port (port_entry) != port) {
GtkWidget *entry;
entry = gtk_bin_get_child (GTK_BIN (port_entry));
gtk_entry_set_text (GTK_ENTRY (entry), port_string);
}
port_entry_set_is_valid (port_entry, TRUE);
g_free (port_string);
}
g_object_notify (G_OBJECT (port_entry), "port");
}
gboolean
e_port_entry_is_valid (EPortEntry *port_entry)
{
g_return_val_if_fail (E_IS_PORT_ENTRY (port_entry), FALSE);
return port_entry->priv->is_valid;
}
CamelNetworkSecurityMethod
e_port_entry_get_security_method (EPortEntry *port_entry)
{
g_return_val_if_fail (
E_IS_PORT_ENTRY (port_entry),
CAMEL_NETWORK_SECURITY_METHOD_NONE);
return port_entry->priv->method;
}
void
e_port_entry_set_security_method (EPortEntry *port_entry,
CamelNetworkSecurityMethod method)
{
g_return_if_fail (E_IS_PORT_ENTRY (port_entry));
port_entry->priv->method = method;
g_object_notify (G_OBJECT (port_entry), "security-method");
}
/**
* If there are more then one secured port in the model, you can specify
* which of the secured ports should be activated by specifying the index.
* The index counts only for secured ports, so if you have 5 ports of which
* ports 1, 3 and 5 are secured, the association is 0=>1, 1=>3, 2=>5
*/
void
e_port_entry_activate_secured_port (EPortEntry *port_entry,
gint index)
{
GtkTreeModel *model;
GtkTreeIter iter;
gboolean is_ssl;
gint iters = 0;
g_return_if_fail (E_IS_PORT_ENTRY (port_entry));
model = gtk_combo_box_get_model (GTK_COMBO_BOX (port_entry));
if (!gtk_tree_model_get_iter_first (model, &iter))
return;
do {
gtk_tree_model_get (
model, &iter, PORT_IS_SSL_COLUMN, &is_ssl, -1);
if (is_ssl && (iters == index)) {
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX (port_entry), &iter);
return;
}
if (is_ssl)
iters++;
} while (gtk_tree_model_iter_next (model, &iter));
}
/**
* If there are more then one unsecured port in the model, you can specify
* which of the unsecured ports should be activated by specifiying the index.
* The index counts only for unsecured ports, so if you have 5 ports, of which
* ports 2 and 4 are unsecured, the associtation is 0=>2, 1=>4
*/
void
e_port_entry_activate_nonsecured_port (EPortEntry *port_entry,
gint index)
{
GtkTreeModel *model;
GtkTreeIter iter;
gboolean is_ssl;
gint iters = 0;
g_return_if_fail (E_IS_PORT_ENTRY (port_entry));
model = gtk_combo_box_get_model (GTK_COMBO_BOX (port_entry));
if (!gtk_tree_model_get_iter_first (model, &iter))
return;
do {
gtk_tree_model_get (model, &iter, PORT_IS_SSL_COLUMN, &is_ssl, -1);
if (!is_ssl && (iters == index)) {
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX (port_entry), &iter);
return;
}
if (!is_ssl)
iters++;
} while (gtk_tree_model_iter_next (model, &iter));
}
