/***************************************************************************
* optionswindow.cpp
*
* Fri Jul 29 20:01:44 2005
* Copyright 2005 User
* Email
****************************************************************************/
#include "optionswindow.h"
#define OW_CREATE_MAINVBOX(w) \
w = gtk_vbox_new(FALSE, 2); \
gtk_container_set_border_width(GTK_CONTAINER(w), 10);
#define OW_CREATE_SECTION(caption, vbox) \
fstr = g_strdup_printf("%s", caption); \
label = gtk_label_new(fstr); \
g_free(fstr); \
gtk_label_set_use_markup(GTK_LABEL(label), TRUE); \
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f); \
\
vbox = gtk_vbox_new(FALSE, 2); \
alignment = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f); \
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 12, 20, 0); \
gtk_container_add(GTK_CONTAINER(alignment), vbox);
#define OW_CREATE_SECTION_T(caption, t, c, r) \
fstr = g_strdup_printf("%s", caption); \
label = gtk_label_new(fstr); \
g_free(fstr); \
gtk_label_set_use_markup(GTK_LABEL(label), TRUE); \
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f); \
\
t = gtk_table_new(r, c, FALSE); \
alignment = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f); \
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 8, 20, 0); \
gtk_container_add(GTK_CONTAINER(alignment), t);
typedef struct toolbarElement
{
guint num;
gchar *title;
gboolean oneTime;
};
toolbarElement toolbarElements[] =
{
{1, tr_NOOP("User status"), TRUE},
{2, tr_NOOP("User time"), TRUE},
{0, "-", FALSE},
{3, tr_NOOP("Set encoding"), FALSE},
{4, tr_NOOP("Encrypt connection"), FALSE},
{5, tr_NOOP("Show History"), FALSE},
{6, tr_NOOP("Show user info"), FALSE},
{7, tr_NOOP("Insert smileys"), FALSE},
{8, tr_NOOP("Send Files"), FALSE},
{9, tr_NOOP("Send URLs"), FALSE},
{10, tr_NOOP("Start a Chat"), FALSE},
{11, tr_NOOP("Set Text Color"), FALSE},
{12, tr_NOOP("Set Background"), FALSE},
{21, tr_NOOP("Show smileys on/off"), TRUE},
{22, tr_NOOP("Show URLs on/off"), TRUE},
{0, "-", FALSE},
{13, tr_NOOP("Send via Server"), TRUE},
{14, tr_NOOP("Send urgent"), TRUE},
{15, tr_NOOP("Send the message"), TRUE},
{16, tr_NOOP("Send to multiple"), TRUE},
{0, "-", FALSE},
{17, tr_NOOP("Send Animation"), TRUE},
{18, tr_NOOP("Separator"), FALSE},
{19, tr_NOOP("<- (Align left)"), FALSE},
{20, tr_NOOP("-> (Align right)"), FALSE},
{0, NULL, FALSE}
};
struct _responseCat
{
gchar *name;
gulong status;
} categories[] =
{
{tr_NOOP("Away"), BUDDY_STATUS_AWAY},
{tr_NOOP("Not Available"), BUDDY_STATUS_NA},
{tr_NOOP("Occupied"), BUDDY_STATUS_OCC},
{tr_NOOP("Do Not Disturb"), BUDDY_STATUS_DND},
{tr_NOOP("Free For Chat"), BUDDY_STATUS_FFC}
};
optionsWindow::optionsWindow()
{
wType = UE_OPTIONS;
}
optionsWindow::~optionsWindow()
{
}
GtkWidget* optionsWindow::createWindowContent()
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *scrolled,
*hbox,
*vbox;
GtkTreeIter iter;
GList *search;
optionsWindowItem *currentItem;
// initialize the items
optionsItems = NULL;
optionsItems = g_list_append(optionsItems, new optionsWindowItem_contactList());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_mainWindow());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_msgWindow());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_extensions());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_onEvent());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_connections());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_plugins());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_start());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_aresponse());
optionsItems = g_list_append(optionsItems, new optionsWindowItem_themes());
// create the notebook
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
// create the store for the options items
itemsStore = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
search = optionsItems;
while(search)
{
currentItem = (optionsWindowItem*)search->data;
gtk_list_store_append(itemsStore, &iter);
gtk_list_store_set(itemsStore, &iter,
0, currentItem->titleImage,
1, currentItem->titleString,
-1);
currentItem->parentContainer = gtk_vbox_new(FALSE, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), currentItem->parentContainer, NULL);
search = search->next;
}
// create a view for the store
itemsView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(itemsStore));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(itemsView), FALSE);
g_signal_connect_swapped(gtk_tree_view_get_selection(GTK_TREE_VIEW(itemsView)), "changed", G_CALLBACK(this->cb_optionsItemSelected), this);
// create the cell renderers
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"pixbuf", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(itemsView), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"text", 1,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(itemsView), column);
// create a scrolled window around the view
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scrolled), itemsView);
gtk_widget_set_size_request(scrolled, 120, -1);
// add the item view + notebook in a hbox
hbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox), scrolled, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 0);
// create a vbox containing the hbox and the button bar
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), createButtonbar(), FALSE, TRUE, 0);
setWindowSize(600, 600);
setWindowTitle(tr("IcQnD Options"));
return vbox;
}
void optionsWindow::destroyWindowContent()
{
GList *search;
search = optionsItems;
while(search)
{
delete (optionsWindowItem*)search->data;
search = search->next;
}
g_list_free(optionsItems);
}
GtkWidget *optionsWindow::createButtonbar()
{
GtkWidget *hbox,
*closeButton;
applyButton = gtk_button_new_from_stock(GTK_STOCK_APPLY);
g_signal_connect_swapped(applyButton, "clicked", G_CALLBACK(this->cb_applyButtonClicked), this);
closeButton = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect_swapped(closeButton, "clicked", G_CALLBACK(this->cb_destroyWindow), this);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 2);
gtk_box_pack_start(GTK_BOX(hbox), applyButton, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), closeButton, FALSE, TRUE, 0);
return hbox;
}
void optionsWindow::cb_optionsItemSelected(optionsWindow* self)
{
GtkTreePath *path;
gint pos;
optionsWindowItem *currentItem;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(self->itemsView), &path, NULL);
if (!path)
return;
pos = gtk_tree_path_get_indices(path)[0];
currentItem = (optionsWindowItem*)g_list_nth_data(self->optionsItems, pos);
if (!currentItem->tabWidget)
{
currentItem->tabWidget = currentItem->createTab();
gtk_widget_show_all(currentItem->tabWidget);
gtk_box_pack_start(GTK_BOX(currentItem->parentContainer), currentItem->tabWidget, TRUE, TRUE, 0);
}
currentItem->window = self->window;
gtk_notebook_set_show_border(GTK_NOTEBOOK(self->notebook), !currentItem->hasOwnNotebook);
gtk_notebook_set_current_page(GTK_NOTEBOOK(self->notebook), pos);
gtk_tree_path_free(path);
}
void optionsWindow::cb_applyButtonClicked(optionsWindow* self)
{
GList *search;
optionsWindowItem *currentItem;
search = self->optionsItems;
while(search)
{
currentItem = (optionsWindowItem*)search->data;
if (currentItem->tabWidget)
currentItem->applyChanges();
search = search->next;
}
getLicqDaemon()->SaveConf();
}
// -----------------------------------------------------------------------------
optionsWindowItem::optionsWindowItem()
{
titleImage = NULL;
titleString = "dummy";
tabWidget = NULL;
parentContainer = NULL;
hasOwnNotebook = FALSE;
}
optionsWindowItem::~optionsWindowItem()
{
}
GtkWidget *optionsWindowItem::createTab()
{
GtkWidget *label;
label = gtk_label_new("This tab isn't finished yet. Work is in progress. If you are looking for a specific option and you do not find it in the other dialogs, please take a look at ~/.licq/licq_qnd-gui.conf. Stay patient!");
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
return label;
}
void optionsWindowItem::destroyTab()
{
}
gboolean optionsWindowItem::applyChanges()
{
return TRUE;
}
// -----------------------------------------------------------------------------
optionsWindowItem_contactList::optionsWindowItem_contactList()
{
titleImage = NULL;
titleString = tr_NOOP("Contact list");
hasOwnNotebook = TRUE;
}
optionsWindowItem_contactList::~optionsWindowItem_contactList()
{
}
GtkWidget* optionsWindowItem_contactList::createTab()
{
GtkWidget *notebook;
notebook = gtk_notebook_new();
//gtk_notebook_append_page(GTK_NOTEBOOK(notebook), createMainWindowTab(), gtk_label_new(tr("Main Window")));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), createGeneralTab(), gtk_label_new(tr("General")));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), createColorsLookTab(), gtk_label_new(tr("View Modes, Colors and Look")));
return notebook;
}
gboolean optionsWindowItem_contactList::applyChanges()
{
gulong tooltipsMask,
extendedIconsMask;
gchar *orderListStr,
*enabledListStr;
GList *orderList,
*enabledList;
gulong sortListID;
gboolean sortListEnabled;
GtkTreeIter iter;
GdkColor vlistColor,
noMsgColor,
idleColor;
// create new tooltips mask
tooltipsMask = 0;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipStatusCheckbox)))
tooltipsMask|= TT_STATUS;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipRealnameCheckbox)))
tooltipsMask|= TT_REALNAME;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipIPCheckbox)))
tooltipsMask|= TT_IP;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipARCheckbox)))
tooltipsMask|= TT_AUTORESPONSE;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipProtocolCheckbox)))
tooltipsMask|= TT_PROTOCOL;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipIDCheckbox)))
tooltipsMask|= TT_ID;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipEmailCheckbox)))
tooltipsMask|= TT_EMAIL;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipOnlineSinceCheckbox)))
tooltipsMask|= TT_ONLINETIME;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipIDLETimeCheckbox)))
tooltipsMask|= TT_IDLETIME;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tipClientNameCheckbox)))
tooltipsMask|= TT_CLIENTNAME;
// create new sort order list
orderList = NULL;
enabledList = NULL;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(sortStore), &iter);
do
{
gtk_tree_model_get(GTK_TREE_MODEL(sortStore), &iter,
1, &sortListID,
2, &sortListEnabled,
-1);
orderList = g_list_append(orderList, GUINT_TO_POINTER(sortListID));
enabledList = g_list_append(enabledList, GUINT_TO_POINTER(sortListEnabled? 1: 0));
} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(sortStore), &iter));
orderListStr = u_getStringFromNumbers(orderList);
enabledListStr = u_getStringFromNumbers(enabledList);
// get the new contact list colors
gtk_color_button_get_color(GTK_COLOR_BUTTON(vlistColorButton), &vlistColor);
gtk_color_button_get_color(GTK_COLOR_BUTTON(noMsgColorButton), &noMsgColor);
gtk_color_button_get_color(GTK_COLOR_BUTTON(idleColorButton), &idleColor);
// create the new extended icons mask
extendedIconsMask = 0;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(extendedAResponseCheckbox)))
extendedIconsMask|=IET_ARESPONSE;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(extendedBirthdayCheckbox)))
extendedIconsMask|=IET_BIRTHDAY;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(extendedCellCheckbox)))
extendedIconsMask|=IET_CELL;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(extendedPhoneCheckbox)))
extendedIconsMask|=IET_PHONE;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(extendedTypingCheckbox)))
extendedIconsMask|=IET_TYPING;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(extendedEncryptCheckbox)))
extendedIconsMask|=IET_ENCRYPTED;
// apply all settings
settings_getSettings()->setProperties(TRUE, "contactlist",
"showTooltips", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showTipsCheckbox)),
"tooltipsMask", tooltipsMask,
"showRealNames", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(useRealNamesCheckbox)),
"showExtendedIcons", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showExtendedCheckbox)),
"extendedIconsMask", extendedIconsMask,
"sortRulesOrder", orderListStr,
"sortRulesEnabled", enabledListStr,
"showColors", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(useColorsCheckbox)),
"contactVListColor", &vlistColor,
"contactNoMsgColor", &noMsgColor,
"contactIDLEColor", &idleColor,
"blinkEvents", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(blinkEventsCheckbox)),
"highlightARChecked", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(blinkByARCheckbox)),
"highlightOnline", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(blinkByOnlineCheckbox)),
"contactsFont", gtk_font_button_get_font_name(GTK_FONT_BUTTON(contactsFontButton)),
"contactsUseOwnFont", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(useOwnFontCheckbox)),
NULL);
g_free(orderListStr);
g_free(enabledListStr);
g_list_free(orderList);
g_list_free(enabledList);
return TRUE;
}
GtkWidget* optionsWindowItem_contactList::createGeneralTab()
{
GtkWidget *mainVBox,
*vbox,
*vbox2,
*hbox,
*label,
*label2,
*alignment,
*table2,
*scrolled;
gboolean showTooltips,
sortElementEnabled,
blinkEvents,
highlightOnline,
highlightARChecked;
gulong tooltipsMask;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
struct cSortElement
{
gchar *name;
gulong id;
gboolean enabled;
} cSortElements[5] =
{
{"Status", 0, FALSE},
{"Last received event", 1, FALSE},
{"Last sent event", 2, FALSE},
{"Alphabetical", 3, FALSE},
{"IDLE Time", 4, FALSE}
};
guint i, num;
GtkTreeIter iter;
gchar *sortRulesOrder,
*sortRulesEnabled,
*fstr;
GList *orderList,
*enabledList,
*searchOrder,
*searchEnabled;
settings_getSettings()->getProperties("contactlist",
"showTooltips", &showTooltips,
"tooltipsMask", &tooltipsMask,
"sortRulesOrder", &sortRulesOrder,
"sortRulesEnabled", &sortRulesEnabled,
"blinkEvents", &blinkEvents,
"highlightOnline", &highlightOnline,
"highlightARChecked", &highlightARChecked,
NULL);
orderList = u_getUNumbersFromString(sortRulesOrder);
enabledList = u_getUNumbersFromString(sortRulesEnabled);
OW_CREATE_MAINVBOX(mainVBox);
// contact list sorting
OW_CREATE_SECTION(tr("Sort order"), vbox);
// create the store and the view for the sort order
searchOrder = orderList;
searchEnabled = enabledList;
sortStore = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_ULONG, G_TYPE_BOOLEAN);
for (i=0; i<5; i++)
{
if (searchOrder)
num = GPOINTER_TO_UINT(searchOrder->data);
else
break;
if (searchEnabled)
sortElementEnabled = GPOINTER_TO_UINT(searchEnabled->data);
else
break;
gtk_list_store_append(sortStore, &iter);
gtk_list_store_set(sortStore, &iter,
0, cSortElements[num].name,
1, cSortElements[num].id,
2, sortElementEnabled,
-1);
if (searchOrder)
searchOrder = searchOrder->next;
if (searchEnabled)
searchEnabled = searchEnabled->next;
}
g_list_free(orderList);
g_list_free(enabledList);
sortOrderList = gtk_tree_view_new_with_model(GTK_TREE_MODEL(sortStore));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(sortOrderList), TRUE);
g_signal_connect_swapped(gtk_tree_view_get_selection(GTK_TREE_VIEW(sortOrderList)), "changed", G_CALLBACK(this->cb_sortListCursorChanged), this);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(sortOrderList)), GTK_SELECTION_MULTIPLE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(tr("Sort criterion"), renderer,
"text", 0, NULL);
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(sortOrderList), column);
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(renderer, "toggled", G_CALLBACK(this->cb_sortListEnabledToggled), this);
column = gtk_tree_view_column_new_with_attributes(tr("Enabled"), renderer,
"active", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(sortOrderList), column);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scrolled), sortOrderList);
// create the sort buttons
sortUpButton = u_createStockImageButton(GTK_STOCK_GO_UP);
g_signal_connect_swapped(sortUpButton, "clicked", G_CALLBACK(this->cb_sortUpButtonClicked), this);
sortDownButton = u_createStockImageButton(GTK_STOCK_GO_DOWN);
g_signal_connect_swapped(sortDownButton, "clicked", G_CALLBACK(this->cb_sortDownButtonClicked), this);
vbox2 = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox2), sortUpButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), sortDownButton, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 0);
// create the hint label
fstr = g_strdup_printf("%s", tr("You can set the sorting rules by moving elements or enabling/disabling them. "
"For example \"1. Status, 2. Alphabetical\" means: Sort the status. If the status of two elements equal "
"then sort these two entries alphabetical, and so on ..."));
label2 = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(label2), TRUE);
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.0f);
gtk_widget_set_size_request(label2, 400, -1);
gtk_box_pack_start(GTK_BOX(vbox), label2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
// events
OW_CREATE_SECTION(tr("Events"), vbox);
blinkByOnlineCheckbox = gtk_check_button_new_with_mnemonic(tr("Highlight user when he goes online"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(blinkByOnlineCheckbox), highlightOnline);
blinkByARCheckbox = gtk_check_button_new_with_mnemonic(tr("Highlight user when he checks your _auto response"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(blinkByARCheckbox), highlightARChecked);
blinkEventsCheckbox = gtk_check_button_new_with_mnemonic(tr("Blink events"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(blinkEventsCheckbox), blinkEvents);
gtk_box_pack_start(GTK_BOX(vbox), blinkByOnlineCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), blinkByARCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), blinkEventsCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// tool tips
OW_CREATE_SECTION(tr("Tooltips"), vbox);
// create the tooltip fields
tipStatusCheckbox = gtk_check_button_new_with_mnemonic(tr("Status"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipStatusCheckbox), tooltipsMask & TT_STATUS);
tipProtocolCheckbox = gtk_check_button_new_with_mnemonic(tr("Protocol"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipProtocolCheckbox), tooltipsMask & TT_PROTOCOL);
tipRealnameCheckbox = gtk_check_button_new_with_mnemonic(tr("Real name"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipRealnameCheckbox), tooltipsMask & TT_REALNAME);
tipEmailCheckbox = gtk_check_button_new_with_mnemonic(tr("E-Mail"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipEmailCheckbox), tooltipsMask & TT_EMAIL);
tipIPCheckbox = gtk_check_button_new_with_mnemonic(tr("IP Address"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipIPCheckbox), tooltipsMask & TT_IP);
tipOnlineSinceCheckbox = gtk_check_button_new_with_mnemonic(tr("Online time"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipOnlineSinceCheckbox), tooltipsMask& TT_ONLINETIME);
tipIDLETimeCheckbox = gtk_check_button_new_with_mnemonic(tr("Idle time"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipIDLETimeCheckbox), tooltipsMask & TT_IDLETIME);
tipARCheckbox = gtk_check_button_new_with_mnemonic(tr("Auto response"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipARCheckbox), tooltipsMask & TT_AUTORESPONSE);
tipIDCheckbox = gtk_check_button_new_with_mnemonic(tr("User ID"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipIDCheckbox), tooltipsMask & TT_ID);
tipClientNameCheckbox = gtk_check_button_new_with_mnemonic(tr("Client Name"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tipClientNameCheckbox), tooltipsMask & TT_CLIENTNAME);
// pack them into a table
table2 = gtk_table_new(5, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table2), 2);
gtk_table_attach_defaults(GTK_TABLE(table2), tipRealnameCheckbox, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table2), tipIDCheckbox, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table2), tipStatusCheckbox, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table2), tipProtocolCheckbox, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table2), tipIPCheckbox, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(table2), tipEmailCheckbox, 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(table2), tipOnlineSinceCheckbox, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(table2), tipIDLETimeCheckbox, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(table2), tipARCheckbox, 0, 1, 4, 5);
gtk_table_attach_defaults(GTK_TABLE(table2), tipClientNameCheckbox, 1, 2, 4, 5);
gtk_widget_set_sensitive(table2, showTooltips);
// create the "enable tooltips button" and pack everything into the vbox
showTipsCheckbox = gtk_check_button_new_with_mnemonic(tr("Show tool tips"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showTipsCheckbox), showTooltips);
g_signal_connect(showTipsCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), table2);
gtk_box_set_spacing(GTK_BOX(vbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), showTipsCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), table2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
cb_sortListCursorChanged(this);
return mainVBox;
}
GtkWidget* optionsWindowItem_contactList::createColorsLookTab()
{
GtkWidget *mainVBox,
*vbox,
*hbox,
*label,
*label2,
*alignment,
*alignment2,
*colorsSubbox,
*extendedSubbox;
gboolean useColors,
useRealNames,
showExtendedIcons,
useOwnFont;
GdkColor vlistColor,
noMsgColor,
idleColor;
gulong extendedIconsMask;
gchar *font,
*fstr;
settings_getSettings()->getProperties("contactlist",
"showColors", &useColors,
"showRealNames", &useRealNames,
"showExtendedIcons", &showExtendedIcons,
"extendedIconsMask", &extendedIconsMask,
"contactVListColor", &vlistColor,
"contactNoMsgColor", &noMsgColor,
"contactIDLEColor", &idleColor,
"contactsFont", &font,
"contactsUseOwnFont", &useOwnFont,
NULL);
OW_CREATE_MAINVBOX(mainVBox);
// view modes
OW_CREATE_SECTION(tr("View modes"), vbox);
detailledModeCheckbox = gtk_check_button_new_with_mnemonic(tr("Show detailled information in contact list"));
gtk_widget_set_sensitive(detailledModeCheckbox, FALSE);
useRealNamesCheckbox = gtk_check_button_new_with_mnemonic(tr("Show real names when possible"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(useRealNamesCheckbox), useRealNames);
gtk_box_pack_start(GTK_BOX(vbox), detailledModeCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), useRealNamesCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// fonts
OW_CREATE_SECTION(tr("Fonts"), vbox);
useOwnFontCheckbox = gtk_check_button_new_with_mnemonic(tr("Use user defined font"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(useOwnFontCheckbox), useOwnFont);
contactsFontButton = gtk_font_button_new();
gtk_font_button_set_font_name(GTK_FONT_BUTTON(contactsFontButton), font);
g_free(font);
hbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox), useOwnFontCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), contactsFontButton, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// colors
OW_CREATE_SECTION(tr("Colors"), vbox);
useColorsCheckbox = gtk_check_button_new_with_mnemonic(tr("Enable colors for different states / modes"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(useColorsCheckbox), useColors);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 0, 10, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment2), useColorsCheckbox);
// create the colors subbox
colorsSubbox = gtk_table_new(3, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(colorsSubbox), 10);
gtk_table_set_row_spacings(GTK_TABLE(colorsSubbox), 2);
label2 = gtk_label_new(tr("The user is on the visible list"));
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.5f);
vlistColorButton = gtk_color_button_new();
gtk_color_button_set_color(GTK_COLOR_BUTTON(vlistColorButton), &vlistColor);
gtk_table_attach(GTK_TABLE(colorsSubbox), vlistColorButton, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(colorsSubbox), label2, 1, 2, 0, 1);
label2 = gtk_label_new(tr("The user has not sent any messages yet"));
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.5f);
noMsgColorButton = gtk_color_button_new();
gtk_color_button_set_color(GTK_COLOR_BUTTON(noMsgColorButton), &noMsgColor);
gtk_table_attach(GTK_TABLE(colorsSubbox), noMsgColorButton, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(colorsSubbox), label2, 1, 2, 1, 2);
label2 = gtk_label_new(tr("The user is inactive (IDLE)"));
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.5f);
idleColorButton = gtk_color_button_new();
gtk_color_button_set_color(GTK_COLOR_BUTTON(idleColorButton), &idleColor);
gtk_table_attach(GTK_TABLE(colorsSubbox), idleColorButton, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(colorsSubbox), label2, 1, 2, 2, 3);
// add the subbox and the togglebutton into the vbox
gtk_box_pack_start(GTK_BOX(vbox), alignment2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), colorsSubbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// extended icons
OW_CREATE_SECTION(tr("Extended Icons"), vbox);
showExtendedCheckbox = gtk_check_button_new_with_mnemonic(tr("Show extended icons next to the name"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showExtendedCheckbox), showExtendedIcons);
extendedAResponseCheckbox = gtk_check_button_new_with_mnemonic(tr("Special auto response set"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(extendedAResponseCheckbox), extendedIconsMask & IET_ARESPONSE);
extendedBirthdayCheckbox = gtk_check_button_new_with_mnemonic(tr("User has a birthday"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(extendedBirthdayCheckbox), extendedIconsMask & IET_BIRTHDAY);
extendedCellCheckbox = gtk_check_button_new_with_mnemonic(tr("User entered his mobile number"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(extendedCellCheckbox), extendedIconsMask & IET_CELL);
extendedPhoneCheckbox = gtk_check_button_new_with_mnemonic(tr("User entered a phone number"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(extendedPhoneCheckbox), extendedIconsMask & IET_PHONE);
extendedTypingCheckbox = gtk_check_button_new_with_mnemonic(tr("User is currently typing"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(extendedTypingCheckbox), extendedIconsMask & IET_TYPING);
extendedEncryptCheckbox = gtk_check_button_new_with_mnemonic(tr("Connection to user is encrypted"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(extendedEncryptCheckbox), extendedIconsMask & IET_ENCRYPTED);
extendedSubbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(extendedSubbox), extendedAResponseCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extendedSubbox), extendedBirthdayCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extendedSubbox), extendedCellCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extendedSubbox), extendedPhoneCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extendedSubbox), extendedTypingCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(extendedSubbox), extendedEncryptCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), showExtendedCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), extendedSubbox, FALSE, TRUE, 10);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// add all sensitivity callbacks
g_signal_connect(useColorsCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), colorsSubbox);
g_signal_connect(showExtendedCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), extendedSubbox);
g_signal_connect(useOwnFontCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), contactsFontButton);
// set sensitivity
gtk_widget_set_sensitive(colorsSubbox, useColors);
gtk_widget_set_sensitive(extendedSubbox, showExtendedIcons);
gtk_widget_set_sensitive(contactsFontButton, useOwnFont);
return mainVBox;
}
void optionsWindowItem_contactList::moveSelectedCriteria(gboolean moveUp)
{
GtkTreeIter iter1, iter2;
GtkTreeSelection *ts;
GList *sels,
*search;
// get our selection
ts = gtk_tree_view_get_selection(GTK_TREE_VIEW(sortOrderList));
sels = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(ts), NULL);
if (moveUp)
search = sels;
else
search = g_list_last(sels);
while(search)
{
gtk_tree_model_get_iter(GTK_TREE_MODEL(sortStore), &iter1,
(GtkTreePath*)search->data);
if (moveUp)
gtk_tree_path_prev((GtkTreePath*)search->data);
else
gtk_tree_path_next((GtkTreePath*)search->data);
gtk_tree_model_get_iter(GTK_TREE_MODEL(sortStore), &iter2,
(GtkTreePath*)search->data);
gtk_list_store_swap(sortStore, &iter1, &iter2);
if (moveUp)
search = search->next;
else
search = search->prev;
}
g_list_foreach(sels, (GFunc)gtk_tree_path_free, NULL);
g_list_free(sels);
}
void optionsWindowItem_contactList::cb_sortUpButtonClicked(optionsWindowItem_contactList* self)
{
self->moveSelectedCriteria(TRUE);
self->cb_sortListCursorChanged(self);
}
void optionsWindowItem_contactList::cb_sortDownButtonClicked(optionsWindowItem_contactList* self)
{
self->moveSelectedCriteria(FALSE);
self->cb_sortListCursorChanged(self);
}
void optionsWindowItem_contactList::cb_sortListCursorChanged(optionsWindowItem_contactList* self)
{
GtkTreeSelection *ts;
GList *sels;
ts = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->sortOrderList));
sels = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(ts), NULL);
if (!sels)
{
gtk_widget_set_sensitive(self->sortUpButton, FALSE);
gtk_widget_set_sensitive(self->sortDownButton, FALSE);
return;
}
if (gtk_tree_path_get_indices((GtkTreePath*)sels->data)[0] == 0)
gtk_widget_set_sensitive(self->sortUpButton, FALSE);
else
gtk_widget_set_sensitive(self->sortUpButton, TRUE);
if (gtk_tree_path_get_indices((GtkTreePath*)g_list_last(sels)->data)[0] ==
gtk_tree_model_iter_n_children(GTK_TREE_MODEL(self->sortStore), NULL)-1)
gtk_widget_set_sensitive(self->sortDownButton, FALSE);
else
gtk_widget_set_sensitive(self->sortDownButton, TRUE);
g_list_foreach(sels, (GFunc)gtk_tree_path_free, NULL);
g_list_free(sels);
}
void optionsWindowItem_contactList::cb_sortListEnabledToggled(GtkCellRendererToggle* t, gchar* pathStr, optionsWindowItem_contactList* self)
{
GtkTreePath *path;
GtkTreeIter iter;
gboolean state;
path = gtk_tree_path_new_from_string(pathStr);
gtk_tree_model_get_iter(GTK_TREE_MODEL(self->sortStore), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(self->sortStore), &iter, 2, &state, -1);
state = !state;
gtk_list_store_set(GTK_LIST_STORE(self->sortStore), &iter, 2, state, -1);
gtk_tree_path_free(path);
}
// -----------------------------------------------------------------------------
optionsWindowItem_mainWindow::optionsWindowItem_mainWindow()
{
titleImage = NULL;
titleString = tr_NOOP("Main Window");
hasOwnNotebook = FALSE;
}
optionsWindowItem_mainWindow::~optionsWindowItem_mainWindow()
{
}
GtkWidget* optionsWindowItem_mainWindow::createTab()
{
GtkWidget *mainVBox,
*alignment,
*alignment2,
*label,
*label2,
*label3,
*vbox;
gboolean showMainMenu,
showNotifyBox,
showStatusButtons,
showWindowBorders,
alwaysOnTop,
inTaskbarOnMin,
inTaskbarOnMax,
inPager,
showStarInTitle,
showOwnersInTitle,
showWindowOnAll,
useDoubleClick;
gchar *fstr;
settings_getSettings()->getProperties("mainwindow",
"showMainMenu", &showMainMenu,
"showNotifyBox", &showNotifyBox,
"showStatusButtons", &showStatusButtons,
"showWindowBorders", &showWindowBorders,
"alwaysOnTop", &alwaysOnTop,
/* "dockWindow", &dockWindow,
"dockMode", &dockMode, */
"inTaskbarWhenMinimized", &inTaskbarOnMin,
"inTaskbarWhenMaximized", &inTaskbarOnMax,
"inPager", &inPager,
"showStarInTitle", &showStarInTitle,
"showOwnersInTitle", &showOwnersInTitle,
"showWindowOnAll", &showWindowOnAll,
"useDoubleClick", &useDoubleClick,
NULL);
OW_CREATE_MAINVBOX(mainVBox);
// Window elements
OW_CREATE_SECTION(tr("Window Elements"), vbox);
showMainMenuCheckbox = gtk_check_button_new_with_mnemonic(tr("Show main menu"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showMainMenuCheckbox), showMainMenu);
showNotifyBoxCheckbox = gtk_check_button_new_with_mnemonic(tr("Show event notify box"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showNotifyBoxCheckbox), showNotifyBox);
showStatusButtonsCheckbox = gtk_check_button_new_with_mnemonic(tr("Show status button(s)"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showStatusButtonsCheckbox), showStatusButtons);
createWindowBorderCheckbox = gtk_check_button_new_with_mnemonic(tr("Show the window title / border"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(createWindowBorderCheckbox), showWindowBorders);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 5, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment2), createWindowBorderCheckbox);
fstr = g_strdup_printf("%s", tr("If you disable the main menu it will still be available by right clickiing on a contact (the menus will then be at the bottom of the popup) or by clicking on groups or empty space."));
label2 = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(label2), TRUE);
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.0f);
gtk_misc_set_padding(GTK_MISC(label2), 20, 0);
fstr = g_strdup_printf("%s", tr("If you disable the window title and borders you probably disable a place of the window where you normally move/resize it. Moving is then possible by clicking the middle (or left + right) mouse button. Resizing will be available soon."));
label3 = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_use_markup(GTK_LABEL(label3), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(label3), TRUE);
gtk_misc_set_alignment(GTK_MISC(label3), 0.0f, 0.0f);
gtk_misc_set_padding(GTK_MISC(label3), 20, 0);
gtk_box_pack_start(GTK_BOX(vbox), showMainMenuCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), label2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), showNotifyBoxCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), showStatusButtonsCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), label3, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// Window positioning
OW_CREATE_SECTION(tr("Window Positioning"), vbox);
alwaysOnTopCheckbox = gtk_check_button_new_with_mnemonic(tr("Always stay on top"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(alwaysOnTopCheckbox), alwaysOnTop);
showWindowOnAllCheckbox = gtk_check_button_new_with_mnemonic(tr("Show main window on all desktops"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showWindowOnAllCheckbox), showWindowOnAll);
/* dockWindowCheckbox = gtk_check_button_new_with_mnemonic(tr("Dock the window on a screen side"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dockWindowCheckbox), dockWindow);
dockLeftRadiobox = gtk_radio_button_new_with_mnemonic(NULL, tr("Left side"));
dockRightRadiobox = gtk_radio_button_new_with_mnemonic(gtk_radio_button_get_group(GTK_RADIO_BUTTON(dockLeftRadiobox)),
tr("Right side"));
if (dockMode)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dockRightRadiobox), TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dockLeftRadiobox), TRUE);
hbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox), dockLeftRadiobox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), dockRightRadiobox, FALSE, FALSE, 0);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 0.0f, 0.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 0, 0, 20, 0);
gtk_container_add(GTK_CONTAINER(alignment2), hbox);
*/
gtk_box_pack_start(GTK_BOX(vbox), alwaysOnTopCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), showWindowOnAllCheckbox, FALSE, TRUE, 0);
/* gtk_box_pack_start(GTK_BOX(vbox), dockWindowCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment2, FALSE, TRUE, 0);
*/
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
OW_CREATE_SECTION(tr("Visibility Options"), vbox);
inTaskbarMaximizedCheckbox = gtk_check_button_new_with_mnemonic(tr("Show the window in the task bar when it is not minimized"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(inTaskbarMaximizedCheckbox), inTaskbarOnMax);
inTaskbarMinimizedCheckbox = gtk_check_button_new_with_mnemonic(tr("Show the window in the task bar when it is minimized"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(inTaskbarMinimizedCheckbox), inTaskbarOnMin);
inPagerCheckbox = gtk_check_button_new_with_mnemonic(tr("Show the window in the pager"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(inPagerCheckbox), inPager);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 0.0f, 0.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 5, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment2), inPagerCheckbox);
gtk_box_pack_start(GTK_BOX(vbox), inTaskbarMaximizedCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), inTaskbarMinimizedCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// Title bar options
OW_CREATE_SECTION(tr("Title Bar Options"), vbox);
titleShowStarCheckbox = gtk_check_button_new_with_mnemonic(tr("Show a \"*\" in the title on new events"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(titleShowStarCheckbox), showStarInTitle);
titleShowOwnersCheckbox = gtk_check_button_new_with_mnemonic(tr("Show the names of the owners in the title"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(titleShowOwnersCheckbox), showOwnersInTitle);
gtk_box_pack_start(GTK_BOX(vbox), titleShowStarCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), titleShowOwnersCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// Dock options
OW_CREATE_SECTION(tr("Dock Options"), vbox);
dockDoubleClickCheckbox = gtk_check_button_new_with_mnemonic(tr("Use double-click"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dockDoubleClickCheckbox), useDoubleClick);
gtk_box_pack_start(GTK_BOX(vbox), dockDoubleClickCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
/*
// set sensitivity
gtk_widget_set_sensitive(dockLeftRadiobox, dockWindow);
gtk_widget_set_sensitive(dockRightRadiobox, dockWindow);
// set sensitivity functions
g_signal_connect(dockWindowCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), dockLeftRadiobox);
g_signal_connect(dockWindowCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), dockRightRadiobox);
*/
return mainVBox;
}
gboolean optionsWindowItem_mainWindow::applyChanges()
{
/* gulong dockMode;
dockMode = 0;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dockRightRadiobox)))
dockMode = 1;
*/
settings_getSettings()->setProperties(TRUE, "mainwindow",
"showMainMenu", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showMainMenuCheckbox)),
"showNotifyBox", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showNotifyBoxCheckbox)),
"showStatusButtons", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showStatusButtonsCheckbox)),
"showWindowBorders", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(createWindowBorderCheckbox)),
"alwaysOnTop", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(alwaysOnTopCheckbox)),
/* "dockWindow", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dockWindowCheckbox)),
"dockMode", dockMode, */
"inTaskbarWhenMinimized", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(inTaskbarMinimizedCheckbox)),
"inTaskbarWhenMaximized", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(inTaskbarMaximizedCheckbox)),
"inPager", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(inPagerCheckbox)),
"showStarInTitle", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(titleShowStarCheckbox)),
"showOwnersInTitle", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(titleShowOwnersCheckbox)),
"showWindowOnAll", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showWindowOnAllCheckbox)),
"useDoubleClick", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dockDoubleClickCheckbox)),
NULL);
return TRUE;
}
// -----------------------------------------------------------------------------
optionsWindowItem_msgWindow::optionsWindowItem_msgWindow()
{
titleImage = NULL;
titleString = tr_NOOP("Conversation");
hasOwnNotebook = TRUE;
currentbar = &remotebar;
}
optionsWindowItem_msgWindow::~optionsWindowItem_msgWindow()
{
}
GtkWidget *optionsWindowItem_msgWindow::createTab()
{
GtkWidget *notebook,
*previewNotebook,
*vbox,
*preview,
*alignment,
*label;
gchar *fstr;
// create the tool bars
settings_getSettings()->getProperties("conversations",
"remoteToolbarRules", &remotebar.rules,
"localToolbarRules", &localbar.rules,
"buttonbarRules", &buttonbar.rules,
"remoteToolbarSpacing", &remotebar.spacing,
"localToolbarSpacing", &localbar.spacing,
"buttonbarSpacing", &buttonbar.spacing,
"showRemoteToolbar", &remotebar.visible,
"showLocalToolbar", &localbar.visible,
"showButtonbar", &buttonbar.visible,
"messageTag", &messageTag,
"dontApplyColors", &dontApplyColors,
"standardEncoding", &standardEncoding,
"sendTyping", &sendTyping,
"showSmileys", &showSmileys,
"showURIs", &showURIs,
"showHistory", &showHistory,
"historyCount", &historyCount,
"alwaysViaServer", &sendViaServer,
"sendByReturn", &sendByReturn,
NULL);
// cut the messagetag
u_stripStringByNeedle(messageTag, "|||");
settings_getSettings()->getProperties("appearance",
"colorReceive", &incomingCol,
"colorSend", &outgoingCol,
"tabMessageColor", &msgCol,
"tabTypingColor", &typeCol,
NULL);
// create the preview container
preview = createPreview();
// create the three toolbars
createPreviewToolbar(&remotebar);
createPreviewToolbar(&localbar);
createPreviewToolbar(&buttonbar);
gtk_container_set_border_width(GTK_CONTAINER(preview), 5);
previewNotebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(previewNotebook), preview, NULL);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(previewNotebook), FALSE);
notebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), createGeneralTab(), gtk_label_new("General"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), createColorsTab(), gtk_label_new("Colors / Format"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), createToolbarsTab(), gtk_label_new("Toolbars"));
fstr = g_strdup_printf("%s", tr("Preview of the message window"));
label = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
alignment = gtk_alignment_new(0.0f, 0.0f, 0.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 5, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), label);
vbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox), notebook, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), previewNotebook, TRUE, TRUE, 0);
return vbox;
}
GtkWidget *optionsWindowItem_msgWindow::createPreview()
{
GtkWidget *paned,
*vbox1,
*vbox2,
*frame1,
*frame2;
GtkTextBuffer *buf;
GtkTextTagTable *textTags;
GtkTextTag *atag;
// create the toolbar containers
localbar.container = gtk_event_box_new();
remotebar.container = gtk_event_box_new();
buttonbar.container = gtk_event_box_new();
localbar.list = NULL;
remotebar.list = NULL;
buttonbar.list = NULL;
// create the preview text views
frame1 = u_createTextView(&remotePreviewView);
gtk_widget_set_size_request(frame1, -1, 20);
// we need to copy the contents of the text tag table, because the tags
// are shared by all open windows. Changing a tag for the preview would
// change every tag before clicking the "apply" button
textTags = gtk_text_tag_table_new();
atag = gtk_text_tag_new("HL");
g_object_set(atag, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_tag_table_add(textTags, atag);
atag = gtk_text_tag_new("newline");
g_object_set(atag, "size", 3*PANGO_SCALE, NULL);
gtk_text_tag_table_add(textTags, atag);
atag = gtk_text_tag_new("timestamp");
g_object_set(atag, "size", 8*PANGO_SCALE,
"weight", PANGO_WEIGHT_LIGHT,
NULL);
gtk_text_tag_table_add(textTags, atag);
atag = gtk_text_tag_new("incoming");
g_object_set(atag, "foreground-gdk", &incomingCol,
NULL);
gtk_text_tag_table_add(textTags, atag);
atag = gtk_text_tag_new("outgoing");
g_object_set(atag, "foreground-gdk", &outgoingCol,
NULL);
gtk_text_tag_table_add(textTags, atag);
buf = gtk_text_buffer_new(textTags);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(remotePreviewView), buf);
g_object_unref(buf);
g_object_unref(textTags);
refreshRemoteViewPreview();
frame2 = u_createTextView(&localPreviewView);
gtk_widget_set_size_request(frame2, -1, 20);
// create the box for the menu + entry
vbox1 = gtk_vbox_new(FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox1), localbar.container, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), frame2, TRUE, TRUE, 0);
// create divider
paned = gtk_vpaned_new();
gtk_paned_pack1(GTK_PANED(paned), frame1, TRUE, TRUE);
gtk_paned_pack2(GTK_PANED(paned), vbox1, FALSE, TRUE);
// create the main vertical box
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), remotebar.container, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), paned, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), buttonbar.container, FALSE, FALSE, 0);
return vbox2;
}
void optionsWindowItem_msgWindow::createPreviewToolbar(editToolbarElements* tb)
{
conversationWindow *cwnd;
GList *children;
GtkWidget *bar,
*alignment;
children = gtk_container_get_children(GTK_CONTAINER(tb->container));
if (children)
gtk_widget_destroy(GTK_WIDGET(children->data));
g_list_free(children);
if (tb->list)
{
g_list_free(tb->list);
tb->list = NULL;
}
if (tb->visible)
{
cwnd = new conversationWindow();
bar = cwnd->createToolbar(tb->rules, tb->spacing, TRUE, &tb->list);
delete cwnd;
if (tb == &remotebar)
{
alignment = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 5, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), bar);
gtk_container_add(GTK_CONTAINER(tb->container), alignment);
} else
if (tb == &localbar)
{
gtk_container_set_border_width(GTK_CONTAINER(bar), 2);
gtk_container_add(GTK_CONTAINER(tb->container), bar);
} else
{
alignment = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 3,0,0,0);
gtk_container_add(GTK_CONTAINER(alignment), bar);
gtk_container_add(GTK_CONTAINER(tb->container), alignment);
}
} else
tb->list = u_getUNumbersFromString(tb->rules);
}
GtkWidget* optionsWindowItem_msgWindow::createColorsTab()
{
GtkWidget *vbox,
*mainVBox,
*label,
*label2,
*alignment,
*alignment2,
*hbox2,
*hbox3,
*hbox4,
*table,
*msgHintsButton,
*msgRefreshButton;
gchar *fstr;
OW_CREATE_MAINVBOX(mainVBox);
OW_CREATE_SECTION(tr("Colors"), vbox);
// color for sent messages
label2 = gtk_label_new(tr("Color for sent messages"));
sentColorButton = gtk_color_button_new();
gtk_color_button_set_color(GTK_COLOR_BUTTON(sentColorButton), &outgoingCol);
g_signal_connect(sentColorButton, "color-set", G_CALLBACK(this->cb_msgColorSelected), this);
hbox2 = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox2), sentColorButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox2), label2, FALSE, FALSE, 0);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 5, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment2), hbox2);
// color for received messages
label2 = gtk_label_new(tr("Color for received messages"));
recColorButton = gtk_color_button_new();
gtk_color_button_set_color(GTK_COLOR_BUTTON(recColorButton), &incomingCol);
g_signal_connect(recColorButton, "color-set", G_CALLBACK(this->cb_msgColorSelected), this);
hbox2 = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox2), recColorButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox2), label2, FALSE, FALSE, 0);
// color for received messages
label2 = gtk_label_new(tr("Color for received messages (in another tab)"));
msgColorButton = gtk_color_button_new();
gtk_color_button_set_color(GTK_COLOR_BUTTON(msgColorButton), &msgCol);
hbox3 = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox3), msgColorButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox3), label2, FALSE, FALSE, 0);
// color when typing
label2 = gtk_label_new(tr("Tab color when a user is typing"));
typeColorButton = gtk_color_button_new();
gtk_color_button_set_color(GTK_COLOR_BUTTON(typeColorButton), &typeCol);
hbox4 = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(hbox4), typeColorButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox4), label2, FALSE, FALSE, 0);
// don't apply colors button
dontApplyColorsButton = gtk_check_button_new_with_mnemonic(tr("Do not apply colors to the messages"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dontApplyColorsButton), dontApplyColors);
g_signal_connect_swapped(dontApplyColorsButton, "clicked", G_CALLBACK(this->cb_dontApplyColorsButtonClicked), this);
gtk_box_pack_start(GTK_BOX(vbox), alignment2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox4, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), dontApplyColorsButton, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
OW_CREATE_SECTION_T(tr("Font / Format"), table, 4, 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 2);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
// message format
label2 = gtk_label_new(tr("Message format:"));
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.5f);
msgFormatEntry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(msgFormatEntry), messageTag);
msgHintsButton = u_createStockImageButton(GTK_STOCK_HELP);
g_signal_connect_swapped(msgHintsButton, "clicked", G_CALLBACK(this->cb_msgHelpButtonClicked), this);
msgRefreshButton = u_createStockImageButton(GTK_STOCK_REFRESH);
g_signal_connect_swapped(msgRefreshButton, "clicked", G_CALLBACK(this->cb_msgRefreshButtonClicked), this);
gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), msgFormatEntry, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(table), msgRefreshButton, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), msgHintsButton, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
// font
label2 = gtk_label_new(tr("Message font:"));
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.5f);
msgFontButton = gtk_font_button_new();
gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), msgFontButton, 1, 4, 1, 2);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
return mainVBox;
}
void optionsWindowItem_msgWindow::refreshRemoteViewPreview()
{
GtkTextIter iter1,
iter2;
GtkTextBuffer *buf;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(remotePreviewView));
// clear the old content
gtk_text_buffer_get_bounds(buf, &iter1, &iter2);
gtk_text_buffer_delete(buf, &iter1, &iter2);
refreshMessageFormatList(messageTag, "H-Jay", "Homer", "Simpson", buf, "outgoing");
gtk_text_buffer_get_end_iter(buf, &iter2);
gtk_text_buffer_insert_with_tags_by_name(buf, &iter2, tr("I know I should say something but I'm so unimaginative!\n"), -1, dontApplyColors? NULL : "outgoing", NULL);
gtk_text_buffer_insert_with_tags_by_name(buf, &iter2, "\n", -1, "newline", dontApplyColors ? NULL: "outgoing", NULL);
refreshMessageFormatList(messageTag, "Mutch", "Marge", "Simpson", buf, "incoming");
gtk_text_buffer_get_end_iter(buf, &iter2);
gtk_text_buffer_insert_with_tags_by_name(buf, &iter2, tr("However ...!\n"), -1, dontApplyColors ? NULL: "incoming", NULL);
gtk_text_buffer_insert_with_tags_by_name(buf, &iter2, "\n", -1, "newline", dontApplyColors ? NULL: "incoming", NULL);
}
void optionsWindowItem_msgWindow::refreshMessageFormatList(gchar* tag, gchar* alias, gchar* firstname, gchar* lastname, GtkTextBuffer* buf, gchar* dirTag)
{
gchar *lastPos,
*currentPos,
*toInsert,
*currentTag;
GtkTextIter endIter;
lastPos = tag;
currentPos = tag;
gtk_text_buffer_get_end_iter(buf, &endIter);
while((currentPos = strchr(lastPos, '%')))
{
// insert non-token stuff
if (lastPos != currentPos)
gtk_text_buffer_insert_with_tags_by_name(buf, &endIter, lastPos, currentPos - lastPos, "HL", dirTag, NULL);
toInsert = NULL;
currentTag = "HL";
// insert the appropriate tag
switch(currentPos[1])
{
case 't':
toInsert = g_strdup("(12:00:00)");
currentTag = "timestamp";
break;
case 'a':
toInsert = g_strdup(alias);
break;
case 'f':
toInsert = g_strdup(firstname);
break;
case 'l':
toInsert = g_strdup(lastname);
break;
case 'n':
toInsert = g_strdup_printf("%s %s", firstname, lastname);
break;
case 'b':
toInsert = g_strdup("\n");
break;
default:
fprintf(stderr, "optionsWindowItem_msgWindow::refreshMessageFormatList: Unknown token '%c'\n", currentPos[1]);
break;
}
gtk_text_buffer_insert_with_tags_by_name(buf, &endIter, toInsert, -1, currentTag, dirTag, NULL);
g_free(toInsert);
lastPos = currentPos+2;
}
// insert the rest
gtk_text_buffer_insert_with_tags_by_name(buf, &endIter, lastPos, -1, "HL", dirTag, NULL);
}
GtkWidget* optionsWindowItem_msgWindow::createGeneralTab()
{
GtkWidget *label,
*label2,
*label3,
*alignment,
*vbox,
*hbox,
*mainVBox;
charsetType *charset;
guint i;
gchar *tmp,
*fstr;
OW_CREATE_MAINVBOX(mainVBox)
OW_CREATE_SECTION(tr("Sending / Receiving"), vbox);
sendTypingCheckbox = gtk_check_button_new_with_mnemonic(tr("Inform user when you start _typing"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sendTypingCheckbox), sendTyping);
showSmileysCheckbox = gtk_check_button_new_with_mnemonic(tr("Show _smiley images instead of tokens ;)"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showSmileysCheckbox), showSmileys);
showURIsCheckbox = gtk_check_button_new_with_mnemonic(tr("Look for _URIs in the text"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showURIsCheckbox), showURIs);
sendViaServerCheckbox = gtk_check_button_new_with_mnemonic(tr("Always send messages via the server"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sendViaServerCheckbox), sendViaServer);
sendByReturnCheckbox = gtk_check_button_new_with_mnemonic(tr("Send messages after a RETURN"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sendByReturnCheckbox), sendByReturn);
gtk_box_pack_start(GTK_BOX(vbox), sendTypingCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), showSmileysCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), showURIsCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), sendViaServerCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), sendByReturnCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
OW_CREATE_SECTION(tr("Misc Settings"), vbox);
// history check box / spin button
showHistoryCheckbox = gtk_check_button_new_with_mnemonic(tr("_List the last "));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(showHistoryCheckbox), showHistory);
label2 = gtk_label_new_with_mnemonic(tr(" _history entries when opening a chat window"));
historyCountBox = gtk_spin_button_new_with_range(1, 20, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(historyCountBox), historyCount);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), showHistoryCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), historyCountBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// localization
OW_CREATE_SECTION(tr("Localization"), vbox);
fstr = g_strdup_printf("%s", tr("Different countries use different encodings (a special number is sent for non-latin characters). Some clients do not send the encoding. Please select an encoding to use in this case."));
label2 = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_line_wrap(GTK_LABEL(label2), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.0f);
gtk_widget_set_size_request(label2, 400, -1);
encodingComboBox = gtk_combo_box_new_text();
charset = charset_getCharsetList();
i = 0;
while(charset[i].name)
{
tmp = g_strdup_printf("%s (%s)", charset[i].name, charset[i].id);
gtk_combo_box_append_text(GTK_COMBO_BOX(encodingComboBox), tmp);
if (!strcmp(charset[i].id, standardEncoding))
gtk_combo_box_set_active(GTK_COMBO_BOX(encodingComboBox), i);
g_free(tmp);
i++;
}
label3 = gtk_label_new(tr("Default encoding:"));
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), label3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), encodingComboBox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
return mainVBox;
}
GtkWidget* optionsWindowItem_msgWindow::createToolbarsTab()
{
GtkWidget *hbox,
*alignment,
*mainHBox,
*scrolled,
*scrolledUsed,
*label1,
*label2,
*label3,
*vbox1,
*vbox2,
*vbox3;
guint i;
GtkTreeIter iter;
gchar *numStr;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GList *usedElements,
*search;
gboolean inUse;
label1 = gtk_label_new(tr("Possible Elements"));
gtk_label_set_use_markup(GTK_LABEL(label1), TRUE);
gtk_misc_set_alignment(GTK_MISC(label1), 0.0f, 0.0f);
toolsStore = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);
usedElements = g_list_copy(localbar.list);
usedElements = g_list_concat(usedElements, g_list_copy(remotebar.list));
usedElements = g_list_concat(usedElements, g_list_copy(buttonbar.list));
// set up the tools list
i=0;
while(toolbarElements[i].title)
{
inUse = FALSE;
// look whether this element is already in our list (and don't show it if it's a one time element)
if (toolbarElements[i].oneTime)
{
search = usedElements;
while(search)
{
if (GPOINTER_TO_UINT(search->data) == toolbarElements[i].num)
{
inUse = TRUE;
break;
}
search = search->next;
}
}
gtk_list_store_append(toolsStore, &iter);
if (strlen(toolbarElements[i].title)>1)
{
numStr = g_strdup_printf("%d", toolbarElements[i].num);
gtk_list_store_set(toolsStore, &iter,
0, numStr,
1, toolbarElements[i].title,
2, &toolbarElements[i],
3, inUse,
-1);
g_free(numStr);
}
else
gtk_list_store_set(toolsStore, &iter,
0, "",
1, " ",
2, NULL,
3, TRUE,
-1);
i++;
}
g_list_free(usedElements);
toolsView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(toolsStore));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(toolsView), FALSE);
g_signal_connect_swapped(G_OBJECT(toolsView), "row-activated", G_CALLBACK(this->cb_addElementButtonClicked), this);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(toolsView), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"text", 1,
"strikethrough", 3,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(toolsView), column);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scrolled), toolsView);
vbox1 = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox1), label1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), scrolled, TRUE, TRUE, 0);
label2 = gtk_label_new("Toolbar to Edit");
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.0f);
editToolsSelection = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(editToolsSelection), tr("Remote Bar"));
gtk_combo_box_append_text(GTK_COMBO_BOX(editToolsSelection), tr("Local Bar"));
gtk_combo_box_append_text(GTK_COMBO_BOX(editToolsSelection), tr("Button Bar"));
gtk_combo_box_set_active(GTK_COMBO_BOX(editToolsSelection), 0);
g_signal_connect_swapped(editToolsSelection, "changed", G_CALLBACK(this->cb_toolbarSelected), this);
// create the stores containing the used elements
localbar.store = createToolbarStore(localbar.list);
remotebar.store = createToolbarStore(remotebar.list);
buttonbar.store = createToolbarStore(buttonbar.list);
// set up the view of used elements
editToolsView = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(editToolsView), FALSE);
g_signal_connect_swapped(G_OBJECT(editToolsView), "row-activated", G_CALLBACK(this->cb_removeElementButtonClicked), this);
renderer = gtk_cell_renderer_text_new();
editToolsColumn = gtk_tree_view_column_new_with_attributes("", renderer,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(editToolsView), editToolsColumn);
scrolledUsed = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledUsed), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledUsed), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scrolledUsed), editToolsView);
// create the show toolbar checkbox / spacing spin button
showToolbarCheckbox = gtk_check_button_new_with_mnemonic(tr("Toolbar is visible"));
g_signal_connect_swapped(showToolbarCheckbox, "clicked", G_CALLBACK(this->cb_showToolbarBoxClicked), this);
toolbarSpacingSpinButton = gtk_spin_button_new_with_range(0, 20, 1);
label3 = gtk_label_new(tr("Element spacing: "));
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), label3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), toolbarSpacingSpinButton, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox2), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), editToolsSelection, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), showToolbarCheckbox, FALSE, TRUE, 0);
// gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), scrolledUsed, TRUE, TRUE, 0);
// create the add / remove buttons
addElementButton = u_createStockImageButton(GTK_STOCK_GO_FORWARD);
g_signal_connect_swapped(addElementButton, "clicked", G_CALLBACK(this->cb_addElementButtonClicked), this);
removeElementButton = u_createStockImageButton(GTK_STOCK_GO_BACK);
g_signal_connect_swapped(removeElementButton, "clicked", G_CALLBACK(this->cb_removeElementButtonClicked), this);
vbox3 = gtk_vbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX(vbox3), addElementButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox3), removeElementButton, FALSE, FALSE, 0);
alignment = gtk_alignment_new(0.0f, 0.5f, 0.0f, 0.0f);
gtk_container_add(GTK_CONTAINER(alignment), vbox3);
// add everything into a hbox
mainHBox = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(mainHBox), 10);
gtk_box_pack_start(GTK_BOX(mainHBox), vbox1, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainHBox), alignment, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(mainHBox), vbox2, TRUE, TRUE, 0);
cb_toolbarSelected(this);
return mainHBox;
}
GtkListStore *optionsWindowItem_msgWindow::createToolbarStore(GList *el)
{
GtkListStore *store;
guint i;
GList *search;
GtkTreeIter iter;
toolbarElement *currentElement;
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
currentElement = NULL;
search = el;
while(search)
{
i = 0;
currentElement = NULL;
while(toolbarElements[i].title)
{
if (GPOINTER_TO_UINT(search->data) == toolbarElements[i].num)
{
currentElement = &toolbarElements[i];
break;
}
i++;
}
if (currentElement)
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, currentElement->title,
1, currentElement,
-1);
}
search = search->next;
}
return store;
}
gboolean optionsWindowItem_msgWindow::applyChanges()
{
charsetType *encoding;
encoding = charset_getCharsetList();
g_free(messageTag);
messageTag = g_strdup_printf("%s|||", gtk_entry_get_text(GTK_ENTRY(msgFormatEntry)));
// set all conversation changes and let the connected windows be informed
settings_getSettings()->setProperties(TRUE, "conversations",
"remoteToolbarRules", remotebar.rules,
"localToolbarRules", localbar.rules,
"buttonbarRules", buttonbar.rules,
"remoteToolbarSpacing", remotebar.spacing,
"localToolbarSpacing", localbar.spacing,
"buttonbarSpacing", buttonbar.spacing,
"showRemoteToolbar", remotebar.visible,
"showLocalToolbar", localbar.visible,
"showButtonbar", buttonbar.visible,
"messageTag", messageTag,
"dontApplyColors", dontApplyColors,
"standardEncoding", encoding[gtk_combo_box_get_active(GTK_COMBO_BOX(encodingComboBox))].id,
"sendTyping", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sendTypingCheckbox)),
"showSmileys", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showSmileysCheckbox)),
"showURIs", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showURIsCheckbox)),
"showHistory", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(showHistoryCheckbox)),
"historyCount", ( gulong ) gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(historyCountBox)),
"alwaysViaServer", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sendViaServerCheckbox)),
"sendByReturn", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sendByReturnCheckbox)),
NULL);
gtk_color_button_get_color(GTK_COLOR_BUTTON(msgColorButton), &msgCol);
gtk_color_button_get_color(GTK_COLOR_BUTTON(typeColorButton), &typeCol);
settings_getSettings()->setProperties(TRUE, "appearance",
"colorReceive", &incomingCol,
"colorSend", &outgoingCol,
"tabMessageColor", &msgCol,
"tabTypingColor", &typeCol,
NULL);
settings_getSettings()->writeSettings();
// update the preview
u_stripStringByNeedle(messageTag, "|||");
refreshRemoteViewPreview();
return TRUE;
}
void optionsWindowItem_msgWindow::cb_toolbarSelected(optionsWindowItem_msgWindow* self)
{
guint active;
active = gtk_combo_box_get_active(GTK_COMBO_BOX(self->editToolsSelection));
switch(active)
{
case 0: self->currentbar = &(self->remotebar); break;
case 1: self->currentbar = &(self->localbar); break;
case 2: self->currentbar = &(self->buttonbar); break;
}
gtk_tree_view_set_model(GTK_TREE_VIEW(self->editToolsView), GTK_TREE_MODEL(self->currentbar->store));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->showToolbarCheckbox), self->currentbar->visible);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(self->toolbarSpacingSpinButton), (gulong)self->currentbar->spacing);
}
void optionsWindowItem_msgWindow::cb_addElementButtonClicked(optionsWindowItem_msgWindow* self)
{
GtkTreePath *path;
toolbarElement *element;
GtkTreeIter iter;
gboolean inUse;
guint pos;
// get the element that should be added
gtk_tree_view_get_cursor(GTK_TREE_VIEW(self->toolsView), &path, NULL);
if (!path)
return;
gtk_tree_model_get_iter(GTK_TREE_MODEL(self->toolsStore), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(self->toolsStore), &iter,
2, &element,
3, &inUse,
-1);
gtk_tree_path_free(path);
// is this just a separator?
if (!element)
return;
// look whether this element is already in use
if (element->oneTime && inUse)
{
u_showAlertMessage(tr("Could not add element"), tr("The element you selected is cancelled. This means that it can be only used one time and is already in use. Please remove the element from one of the other toolbars in order to insert it here"), GTK_STOCK_DIALOG_WARNING);
return;
}
// mark the element as used if its a one-time element
if (element->oneTime)
gtk_list_store_set(self->toolsStore, &iter,
3, TRUE,
-1);
// get the position of the cursor in the toolbar store
gtk_tree_view_get_cursor(GTK_TREE_VIEW(self->editToolsView), &path, NULL);
if (path)
{
self->currentbar->list = g_list_insert(self->currentbar->list, GUINT_TO_POINTER(element->num), gtk_tree_path_get_indices(path)[0]+1);
pos = gtk_tree_path_get_indices(path)[0];
gtk_tree_model_get_iter(GTK_TREE_MODEL(self->currentbar->store), &iter, path);
gtk_list_store_insert_after(self->currentbar->store, &iter, &iter);
gtk_tree_path_free(path);
} else
{
self->currentbar->list = g_list_prepend(self->currentbar->list, GUINT_TO_POINTER(element->num));
gtk_list_store_prepend(self->currentbar->store, &iter);
}
gtk_list_store_set(self->currentbar->store, &iter, 0, element->title, 1, element, -1);
// recreate the preview
g_free(self->currentbar->rules);
self->currentbar->rules = u_getStringFromNumbers(self->currentbar->list);
self->createPreviewToolbar(self->currentbar);
gtk_widget_show_all(self->currentbar->container);
// highlight the element
path = gtk_tree_model_get_path(GTK_TREE_MODEL(self->currentbar->store), &iter);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(self->editToolsView), path, self->editToolsColumn, FALSE);
gtk_tree_path_free(path);
}
void optionsWindowItem_msgWindow::cb_removeElementButtonClicked(optionsWindowItem_msgWindow* self)
{
GtkTreePath *path;
GtkTreeIter iter,
iter2;
toolbarElement *el1,
*el2;
// get the element that should be removed
gtk_tree_view_get_cursor(GTK_TREE_VIEW(self->editToolsView), &path, NULL);
if (!path)
return;
gtk_tree_model_get_iter(GTK_TREE_MODEL(self->currentbar->store), &iter, path);
gtk_tree_path_free(path);
gtk_tree_model_get(GTK_TREE_MODEL(self->currentbar->store), &iter, 1, &el1, -1);
// check whether its a one time element and activate the element in the
// store of available elements
if (el1->oneTime)
{
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(self->toolsStore), &iter2);
do
{
gtk_tree_model_get(GTK_TREE_MODEL(self->toolsStore), &iter2, 2, &el2, -1);
if (el2 && el2->num == el1->num)
{
gtk_list_store_set(self->toolsStore, &iter2, 3, FALSE, -1);
break;
}
} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(self->toolsStore), &iter2));
}
// remove the element from the store ...
gtk_list_store_remove(self->currentbar->store, &iter);
// ... and from the list
self->currentbar->list = g_list_remove(self->currentbar->list, GUINT_TO_POINTER(el1->num));
// recreate the preview
g_free(self->currentbar->rules);
self->currentbar->rules = u_getStringFromNumbers(self->currentbar->list);
self->createPreviewToolbar(self->currentbar);
gtk_widget_show_all(self->currentbar->container);
}
void optionsWindowItem_msgWindow::cb_showToolbarBoxClicked(optionsWindowItem_msgWindow* self)
{
self->currentbar->visible = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self->showToolbarCheckbox));
self->createPreviewToolbar(self->currentbar);
gtk_widget_show_all(self->currentbar->container);
}
void optionsWindowItem_msgWindow::cb_msgColorSelected(GtkColorButton* but, optionsWindowItem_msgWindow* self)
{
GtkTextTag *tag;
GtkTextBuffer *buf;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->remotePreviewView));
if (but == GTK_COLOR_BUTTON(self->recColorButton))
gtk_color_button_get_color(but, &self->incomingCol);
else
gtk_color_button_get_color(but, &self->outgoingCol);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buf), "incoming");
g_object_set(tag, "foreground-gdk", &self->incomingCol, NULL);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buf), "outgoing");
g_object_set(tag, "foreground-gdk", &self->outgoingCol, NULL);
}
void optionsWindowItem_msgWindow::cb_msgRefreshButtonClicked(optionsWindowItem_msgWindow* self)
{
g_free(self->messageTag);
self->messageTag = g_strdup(gtk_entry_get_text(GTK_ENTRY(self->msgFormatEntry)));
self->refreshRemoteViewPreview();
}
void optionsWindowItem_msgWindow::cb_msgHelpButtonClicked(optionsWindowItem_msgWindow* self)
{
GtkWidget *dialog,
*label,
*hbox,
*icon;
label = gtk_label_new(tr("In the entry field you can set the format of the "
"string that appears at the beginning of the messages "
"that are displayed in the conversation window. It uses "
"tokens, that means short letters are replaced by certain information.\n\n"
"Allowed tokens:\n"
" %a Alias\n"
" %f first name\n"
" %l last name\n"
" %n first and last name\n"
" %t current time\n"
" %b line break\n\n"
"Something like \"%t from %n:%b\" would give\n"
"\"(12:00:00) from First Last:\nHello, this is a message!\"\n\n"
"Any letters that are not tokens will simply be copied to the text"));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_widget_set_size_request(label, 300, -1);
icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment(GTK_MISC(icon), 0.5f, 0.0f);
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 10);
gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 5);
dialog = gtk_dialog_new_with_buttons ( tr("Hints for the message beginning"),
GTK_WINDOW(self->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK,
GTK_RESPONSE_NONE,
NULL);
g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), hbox);
gtk_widget_show_all(dialog);
}
void optionsWindowItem_msgWindow::cb_dontApplyColorsButtonClicked(optionsWindowItem_msgWindow* self)
{
self->dontApplyColors = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(self->dontApplyColorsButton));
self->refreshRemoteViewPreview();
}
// -----------------------------------------------------------------------------
optionsWindowItem_extensions::optionsWindowItem_extensions()
{
titleImage = NULL;
titleString = tr_NOOP("Applications");
}
optionsWindowItem_extensions::~optionsWindowItem_extensions()
{
}
u_browserInfo* optionsWindowItem_extensions::createBrowsersBox(gchar* browserCommand)
{
GList *installed,
*search;
GtkListStore *store;
GtkTreeIter iter;
u_browserInfo *currentBrowser,
*browserToUse;
GtkCellRenderer *renderer;
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
// create the combo box
browserCombobox = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(browserCombobox), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(browserCombobox), renderer, "text", 0, NULL);
browserToUse = NULL;
// insert the list of installed browsers into the store
installed = u_getInstalledBrowsers();
for (search = installed; search; search = search->next)
{
currentBrowser = (u_browserInfo*)search->data;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, currentBrowser->name, 1, currentBrowser, -1);
if (!browserToUse && !strcmp(browserCommand, currentBrowser->command))
{
browserToUse = currentBrowser;
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(browserCombobox), &iter);
}
}
// add "use own browser" entry
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, tr("Use own browser command"), 1, NULL, -1);
if (!browserToUse)
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(browserCombobox), &iter);
return browserToUse;
}
GtkWidget* optionsWindowItem_extensions::createTab()
{
GtkWidget *mainVBox,
*vbox,
*label,
*label2,
*alignment,
*alignment2,
*hbox1;
gchar *browserCommand,
*fstr;
gboolean useGnomeDefaults;
gulong browserMode;
u_browserInfo *usedBrowser;
settings_getSettings()->getProperties("applications",
"useGnomeDefaults", &useGnomeDefaults,
"browserCommand", &browserCommand,
"browserMode", &browserMode,
NULL);
OW_CREATE_MAINVBOX(mainVBox);
// default programs
OW_CREATE_SECTION(tr("General"), vbox);
fstr = g_strdup_printf("%s", tr("IcQnD can use standard programs defined in the gnome environment for opening files/URIs. This works only if the program is started under Gnome. Otherwise the applications defined below are used."));
label2 = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(label2), TRUE);
gtk_misc_set_alignment(GTK_MISC(label2), 0, 0);
useGnomeCheckbox = gtk_check_button_new_with_label(tr("Use Gnome applications when possible"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(useGnomeCheckbox), useGnomeDefaults);
gtk_box_pack_start(GTK_BOX(vbox), label2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), useGnomeCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// browser
OW_CREATE_SECTION(tr("Web Browser"), vbox);
label2 = gtk_label_new(tr("Browser to use: "));
usedBrowser = createBrowsersBox(browserCommand);
hbox1 = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox1), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox1), browserCombobox, TRUE, TRUE, 0);
openURLinTabRadiobox = gtk_radio_button_new_with_label(NULL, tr("Open URL in a new tab"));
openURLinCurRadiobox = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(openURLinTabRadiobox), tr("Open URL in the last active window"));
openURLinWndRadiobox = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(openURLinTabRadiobox), tr("Open URL in a new window"));
// check which option was passed
if (usedBrowser)
{
switch (browserMode)
{
case WMODE_CURRENT:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(openURLinCurRadiobox), TRUE);
break;
case WMODE_TAB:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(openURLinTabRadiobox), TRUE);
break;
default:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(openURLinWndRadiobox), TRUE);
break;
}
}
fstr = g_strdup_printf("%s", tr("Here you can define a command to use when clicking a URI. \"%s\" stands for the URI"));
ownBrowserInfoLabel = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_use_markup(GTK_LABEL(ownBrowserInfoLabel), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(ownBrowserInfoLabel), TRUE);
gtk_misc_set_alignment(GTK_MISC(ownBrowserInfoLabel), 0, 0);
alignment2 = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 5, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment2), ownBrowserInfoLabel);
label2 = gtk_label_new(tr("Browser command: "));
ownBrowserEntry = gtk_entry_new();
ownBrowserHBox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(ownBrowserHBox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ownBrowserHBox), ownBrowserEntry, TRUE, TRUE, 0);
if (!usedBrowser)
gtk_entry_set_text(GTK_ENTRY(ownBrowserEntry), browserCommand);
gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), openURLinTabRadiobox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), openURLinWndRadiobox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), openURLinCurRadiobox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), ownBrowserHBox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
g_signal_connect_swapped(browserCombobox, "changed", G_CALLBACK(cb_browserComboboxChanged), this);
cb_browserComboboxChanged(this);
g_free(browserCommand);
return mainVBox;
}
gboolean optionsWindowItem_extensions::applyChanges()
{
u_browserInfo *currentBrowser;
GtkTreeIter iter;
gchar *newBrowser;
gulong newMode;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(browserCombobox), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(browserCombobox)), &iter, 1, ¤tBrowser, -1);
if (currentBrowser)
newBrowser = currentBrowser->command;
else
newBrowser = (gchar*)gtk_entry_get_text(GTK_ENTRY(ownBrowserEntry));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(openURLinTabRadiobox)))
newMode = WMODE_TAB;
else
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(openURLinWndRadiobox)))
newMode = WMODE_WINDOW;
else
newMode = WMODE_CURRENT;
settings_getSettings()->setProperties(FALSE, "applications",
"useGnomeDefaults", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(useGnomeCheckbox)),
"browserCommand", newBrowser,
"browserMode", newMode,
NULL);
return TRUE;
}
void optionsWindowItem_extensions::cb_browserComboboxChanged(optionsWindowItem_extensions* self)
{
gpointer browser;
GtkTreeIter iter;
GtkTreeModel *model;
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->browserCombobox), &iter))
return;
model = gtk_combo_box_get_model(GTK_COMBO_BOX(self->browserCombobox));
gtk_tree_model_get(model, &iter, 1, &browser, -1);
gtk_widget_set_sensitive(self->openURLinTabRadiobox, browser != NULL);
gtk_widget_set_sensitive(self->openURLinWndRadiobox, browser != NULL);
gtk_widget_set_sensitive(self->openURLinCurRadiobox, browser != NULL);
gtk_widget_set_sensitive(self->ownBrowserHBox, browser == NULL);
gtk_widget_set_sensitive(self->ownBrowserInfoLabel, browser == NULL);
if (!browser)
gtk_widget_grab_focus(self->ownBrowserEntry);
}
// -----------------------------------------------------------------------------
optionsWindowItem_onEvent::optionsWindowItem_onEvent()
{
titleImage = NULL;
titleString = tr_NOOP("On Events");
}
optionsWindowItem_onEvent::~optionsWindowItem_onEvent()
{
}
#define OW_CREATE_ONEVENT_PARAM(w, cap, row, pt) \
label2 = gtk_label_new(tr(cap)); \
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.0f); \
w = gtk_entry_new(); \
gtk_entry_set_text(GTK_ENTRY(w), oem->Parameter(pt)); \
gtk_table_attach(GTK_TABLE(table), label2, 0, 1, row, row+1, GTK_FILL, GTK_FILL, 0, 0); \
gtk_table_attach_defaults(GTK_TABLE(table), w, 1, 2, row, row+1);
GtkWidget *optionsWindowItem_onEvent::createTab()
{
GtkWidget *mainVBox,
*vbox,
*label,
*label2,
*alignment,
*table;
COnEventManager *oem; // FIXME: wrap this
gboolean onEventEnabled;
gchar *fstr;
oem = getLicqDaemon()->OnEventManager();
onEventEnabled = oem->CommandType() != ON_EVENT_IGNORE;
OW_CREATE_MAINVBOX(mainVBox);
// general
OW_CREATE_SECTION(tr("General"), vbox);
enableCheckbox = gtk_check_button_new_with_mnemonic(tr("Enable execution of a command on events"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enableCheckbox), onEventEnabled);
oem->Lock();
label2 = gtk_label_new(tr("Command:"));
commandEntry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(commandEntry), oem->Command());
generalBox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(generalBox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(generalBox), commandEntry, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), enableCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), generalBox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// parameters
OW_CREATE_SECTION_T(tr("Command parameters for events"), table, 2, 7);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 4);
OW_CREATE_ONEVENT_PARAM(paramMsgEntry, "Message:", 0, ON_EVENT_MSG);
OW_CREATE_ONEVENT_PARAM(paramURLEntry, "URL:", 1, ON_EVENT_URL);
OW_CREATE_ONEVENT_PARAM(paramChatEntry, "Chat Request:", 2, ON_EVENT_CHAT);
OW_CREATE_ONEVENT_PARAM(paramFTEntry, "File Transfer:", 3, ON_EVENT_FILE);
OW_CREATE_ONEVENT_PARAM(paramONEntry, "Online Notify:", 4, ON_EVENT_NOTIFY);
OW_CREATE_ONEVENT_PARAM(paramSysMsgEntry, "System Message:", 5, ON_EVENT_SYSMSG);
OW_CREATE_ONEVENT_PARAM(paramMsgSentEntry, "Sent Messages:", 6, ON_EVENT_MSGSENT);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
paramBox = alignment;
// also execute
OW_CREATE_SECTION_T(tr("Also accept execution"), table, 2, 3);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
acceptAwayCheckbox = gtk_check_button_new_with_mnemonic(tr("in Away"));
gtk_widget_set_sensitive(acceptAwayCheckbox, FALSE);
acceptNACheckbox = gtk_check_button_new_with_mnemonic(tr("in Not Available"));
gtk_widget_set_sensitive(acceptNACheckbox, FALSE);
acceptOccCheckbox = gtk_check_button_new_with_mnemonic(tr("in Occupied"));
gtk_widget_set_sensitive(acceptOccCheckbox, FALSE);
acceptDnDCheckbox = gtk_check_button_new_with_mnemonic(tr("in Do Not Disturb"));
gtk_widget_set_sensitive(acceptDnDCheckbox, FALSE);
acceptLogonCheckbox = gtk_check_button_new_with_mnemonic(tr("when contact list user status is updated while logging on"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(acceptLogonCheckbox), getLicqDaemon()->AlwaysOnlineNotify());
gtk_table_attach_defaults(GTK_TABLE(table), acceptAwayCheckbox, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), acceptNACheckbox, 1, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), acceptOccCheckbox, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), acceptDnDCheckbox, 1, 2, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), acceptLogonCheckbox, 0, 2, 2, 3);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
acceptBox = alignment;
oem->Unlock();
gtk_widget_set_sensitive(generalBox, onEventEnabled);
gtk_widget_set_sensitive(paramBox, onEventEnabled);
gtk_widget_set_sensitive(acceptBox, onEventEnabled);
g_signal_connect(enableCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), generalBox);
g_signal_connect(enableCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), paramBox);
g_signal_connect(enableCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), acceptBox);
return mainVBox;
}
gboolean optionsWindowItem_onEvent::applyChanges()
{
COnEventManager *oem;
const gchar *paramMsg,
*paramURL,
*paramChat,
*paramFT,
*paramON,
*paramSysMsg,
*paramMsgSent;
paramMsg = gtk_entry_get_text(GTK_ENTRY(paramMsgEntry));
paramURL = gtk_entry_get_text(GTK_ENTRY(paramURLEntry));
paramChat = gtk_entry_get_text(GTK_ENTRY(paramChatEntry));
paramFT = gtk_entry_get_text(GTK_ENTRY(paramFTEntry));
paramON = gtk_entry_get_text(GTK_ENTRY(paramONEntry));
paramSysMsg = gtk_entry_get_text(GTK_ENTRY(paramSysMsgEntry));
paramMsgSent = gtk_entry_get_text(GTK_ENTRY(paramMsgSentEntry));
const gchar* parameters[8] =
{
paramMsg, paramURL, paramChat, paramFT, paramON, paramSysMsg, paramMsgSent
};
oem = getLicqDaemon()->OnEventManager();
// set whether execution is enabled / disabled
oem->SetCommandType(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enableCheckbox))? ON_EVENT_RUN : ON_EVENT_IGNORE);
// set the parameters
oem->SetParameters(gtk_entry_get_text(GTK_ENTRY(commandEntry)), parameters);
// set the rest
getLicqDaemon()->SetAlwaysOnlineNotify(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(acceptLogonCheckbox)));
return TRUE;
}
// -----------------------------------------------------------------------------
optionsWindowItem_connections::optionsWindowItem_connections()
{
titleImage = NULL;
titleString = tr_NOOP("Connections");
serverTabs = NULL;
}
optionsWindowItem_connections::~optionsWindowItem_connections()
{
IO_getGeneralSource()->removeCallback((IMEventCallback)this->cb_eventCallback);
g_list_foreach(serverTabs, (GFunc)g_free, NULL);
}
GtkWidget *optionsWindowItem_connections::createTab()
{
GtkWidget *vbox,
*alignment,
*alignment2,
*label,
*label2,
*label3,
*mainVBox,
*hbox,
*table;
GtkWidget *firewallSubbox,
*proxySubbox,
*authSubbox;
gulong autoOffline;
gboolean autoOfflineEnabled;
gchar *fstr;
settings_getSettings()->getProperties("autoresponses",
"autoOffline", &autoOffline,
"autoOfflineEnabled", &autoOfflineEnabled,
NULL);
OW_CREATE_MAINVBOX(mainVBox);
// firewall
OW_CREATE_SECTION(tr("Firewall"), vbox);
fwEnableCheckbox = gtk_check_button_new_with_mnemonic(tr("I am behind a firewall"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fwEnableCheckbox), getLicqDaemon()->Firewall());
fwDirectConnectionsCheckbox = gtk_check_button_new_with_mnemonic(tr("I can receive direct connections"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fwDirectConnectionsCheckbox), getLicqDaemon()->TCPEnabled());
fwPortsFromSpinButton = gtk_spin_button_new_with_range(0, 0xFFFF, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(fwPortsFromSpinButton), (gushort)getLicqDaemon()->TCPPortsLow());
fwPortsToSpinButton = gtk_spin_button_new_with_range(0, 0xFFFF, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(fwPortsToSpinButton), (gushort)getLicqDaemon()->TCPPortsHigh());
label2 = gtk_label_new(tr("Use port range from "));
label3 = gtk_label_new(tr(" to "));
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), fwPortsFromSpinButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), fwPortsToSpinButton, FALSE, FALSE, 0);
fstr = g_strdup_printf("%s", tr(""0" means that licq will decide which ports to use"));
label2 = gtk_label_new(fstr);
g_free(fstr);
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.0f);
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
// we need another vbox here to disable it if neccessary
firewallSubbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(firewallSubbox), fwDirectConnectionsCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(firewallSubbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(firewallSubbox), label2, FALSE, TRUE, 0);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 0, 0, 20, 0);
gtk_container_add(GTK_CONTAINER(alignment2), firewallSubbox);
gtk_box_pack_start(GTK_BOX(vbox), fwEnableCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// proxy
OW_CREATE_SECTION(tr("Proxy"), vbox);
// the proxy part
pxUseCheckbox = gtk_check_button_new_with_mnemonic(tr("Use HTTPS proxy server"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pxUseCheckbox), getLicqDaemon()->ProxyEnabled());
label2 = gtk_label_new(tr("Proxy server:"));
label3 = gtk_label_new(tr(" Port:"));
pxServerEntry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(pxServerEntry), getLicqDaemon()->ProxyHost());
pxPortSpinButton = gtk_spin_button_new_with_range(0, 0xFFFF, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(pxPortSpinButton), (gushort)getLicqDaemon()->ProxyPort());
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), pxServerEntry, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), pxPortSpinButton, FALSE, FALSE, 0);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 0, 0, 20, 0);
gtk_container_add(GTK_CONTAINER(alignment2), hbox);
// the authorization part
pxUseAuthorizationCheckbox = gtk_check_button_new_with_mnemonic(tr("Use authorization"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pxUseAuthorizationCheckbox), getLicqDaemon()->ProxyAuthEnabled());
label2 = gtk_label_new(tr("Username:"));
label3 = gtk_label_new(tr("Password:"));
pxUsernameEntry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(pxUsernameEntry), getLicqDaemon()->ProxyLogin());
pxPasswordEntry = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(pxPasswordEntry), FALSE);
gtk_entry_set_text(GTK_ENTRY(pxPasswordEntry), getLicqDaemon()->ProxyPasswd());
table = gtk_table_new(2, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 4);
gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), pxUsernameEntry, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(table), label3, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), pxPasswordEntry, 1, 2, 1, 2);
authSubbox = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(authSubbox), 0, 0, 20, 0);
gtk_container_add(GTK_CONTAINER(authSubbox), table);
// now pack everything together.
proxySubbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(proxySubbox), alignment2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(proxySubbox), pxUseAuthorizationCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(proxySubbox), authSubbox, FALSE, TRUE, 0);
// and pack the proxyBox and the label into the main vbox
gtk_box_pack_start(GTK_BOX(vbox), pxUseCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), proxySubbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// keep connection
OW_CREATE_SECTION(tr("Keep connection"), vbox);
kcIDClashCheckbox = gtk_check_button_new_with_mnemonic(tr("Keep the connection after connection clash"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(kcIDClashCheckbox), getLicqDaemon()->ReconnectAfterUinClash());
kcDisconnectCheckbox = gtk_check_button_new_with_mnemonic(tr("Automatic disconnection after"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(kcDisconnectCheckbox), autoOfflineEnabled);
kcDisconnectSpinButton = gtk_spin_button_new_with_range(1, 0xFFFF, 1);
if (autoOffline)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(kcDisconnectSpinButton), autoOffline);
label2 = gtk_label_new(tr("minutes of inactivity"));
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), kcDisconnectCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), kcDisconnectSpinButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), kcIDClashCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// connections
OW_CREATE_SECTION(tr("Server connections"), vbox);
gtk_box_pack_start(GTK_BOX(vbox), createPluginsConnectionTabs(), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
// add a callback to keep the connection tabs updated
IO_getGeneralSource()->addCallback((IMEventCallback)this->cb_eventCallback, this);
// add button callbacks
g_signal_connect(fwEnableCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), firewallSubbox);
g_signal_connect(pxUseCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), proxySubbox);
g_signal_connect(pxUseAuthorizationCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), authSubbox);
g_signal_connect(kcDisconnectCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), kcDisconnectSpinButton);
// set widget sensivity
gtk_widget_set_sensitive(firewallSubbox, getLicqDaemon()->Firewall());
gtk_widget_set_sensitive(proxySubbox, getLicqDaemon()->ProxyEnabled());
gtk_widget_set_sensitive(authSubbox, getLicqDaemon()->ProxyAuthEnabled());
gtk_widget_set_sensitive(kcDisconnectSpinButton, autoOfflineEnabled);
return mainVBox;
}
GtkWidget *optionsWindowItem_connections::createPluginsConnectionTabs()
{
GList *search;
IMPluginDaemon *proto;
notebook = gtk_notebook_new();
search = IO_getPluginsList();
while(search)
{
proto = (IMPluginDaemon*)search->data;
if (proto->isProtoPlugin && proto->isLoaded)
appendPluginsConnectionTab(proto);
search = search->next;
}
return notebook;
}
void optionsWindowItem_connections::appendPluginsConnectionTab(IMPluginDaemon *proto)
{
GtkWidget *vbox,
*label1,
*label2,
*table;
editServerConTab *con;
gchar *fstr;
label1 = gtk_label_new(tr("Server:"));
label2 = gtk_label_new(tr("Port:"));
con = (editServerConTab*)g_malloc0(sizeof(editServerConTab));
con->server = gtk_entry_new();
if (proto->getServerName())
gtk_entry_set_text(GTK_ENTRY(con->server), proto->getServerName());
con->port = gtk_spin_button_new_with_range(0, 0xFFFF, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(con->port), (gushort)proto->getServerPort());
con->proto = proto;
table = gtk_table_new(3, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 4);
gtk_table_attach(GTK_TABLE(table), label1, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), con->server, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), con->port, 1, 2, 1, 2);
if (!proto->getServerName())
{
fstr = g_strdup_printf("%s", tr("The server settings for this plugin cannot be set, because protocol plugin support for licq isn't finished yet. Sorry!"));
label1 = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_line_wrap(GTK_LABEL(label1), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label1), TRUE);
gtk_misc_set_alignment(GTK_MISC(label1), 0.0f, 0.0f);
gtk_table_attach_defaults(GTK_TABLE(table), label1, 0, 2, 2, 3);
gtk_widget_set_sensitive(con->server, FALSE);
gtk_widget_set_sensitive(con->port, FALSE);
}
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, TRUE, 0);
gtk_widget_show_all(vbox);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, gtk_label_new(proto->name));
g_object_set_data(G_OBJECT(vbox), "icqnd-options-con", proto);
serverTabs = g_list_append(serverTabs, con);
}
gboolean optionsWindowItem_connections::applyChanges()
{
GList *search;
editServerConTab *serverTab;
// firewall settings
getLicqDaemon()->SetFirewall(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fwEnableCheckbox)));
getLicqDaemon()->SetTCPEnabled(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fwDirectConnectionsCheckbox)));
getLicqDaemon()->SetTCPPorts(gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(fwPortsFromSpinButton)),
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(fwPortsToSpinButton)));
// proxy settings
getLicqDaemon()->SetProxyEnabled(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pxUseCheckbox)));
getLicqDaemon()->SetProxyHost(gtk_entry_get_text(GTK_ENTRY(pxServerEntry)));
getLicqDaemon()->SetProxyPort(gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pxPortSpinButton)));
getLicqDaemon()->SetProxyAuthEnabled(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pxUseAuthorizationCheckbox)));
getLicqDaemon()->SetProxyLogin(gtk_entry_get_text(GTK_ENTRY(pxUsernameEntry)));
getLicqDaemon()->SetProxyPasswd(gtk_entry_get_text(GTK_ENTRY(pxPasswordEntry)));
// keep connection settings
getLicqDaemon()->setReconnectAfterUinClash(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(kcIDClashCheckbox)));
settings_getSettings()->setProperties(TRUE, "autoresponses",
"autoOfflineEnabled", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(kcDisconnectCheckbox)),
"autoOffline", gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(kcDisconnectSpinButton)),
NULL);
// server settings
search = serverTabs;
while(search)
{
serverTab = (editServerConTab*)search->data;
serverTab->proto->setServerName((gchar*)gtk_entry_get_text(GTK_ENTRY(serverTab->server)));
serverTab->proto->setServerPort(gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(serverTab->port)));
search = search->next;
}
return TRUE;
}
gboolean optionsWindowItem_connections::cb_eventCallback(userEventType type, gint command, gint lastResult, gpointer info, optionsWindowItem_connections* self)
{
GList *search;
gint page;
editServerConTab *tab;
switch(command)
{
case PC_NEWPLUGIN:
self->appendPluginsConnectionTab((IMPluginDaemon*)info);
break;
case PC_REMOVEPLUGIN:
page = 0;
search = self->serverTabs;
while(search)
{
tab = (editServerConTab*)search->data;
if (tab->proto == info)
{
gtk_notebook_remove_page(GTK_NOTEBOOK(self->notebook), page);
self->serverTabs = g_list_remove(self->serverTabs, tab);
g_free(tab);
break;
}
page++;
search = search->next;
}
break;
}
return TRUE;
}
// -----------------------------------------------------------------------------
optionsWindowItem_plugins::optionsWindowItem_plugins()
{
titleImage = NULL;
titleString = tr_NOOP("Plugins");
}
optionsWindowItem_plugins::~optionsWindowItem_plugins()
{
// remove us from the general signal source
IO_getGeneralSource()->removeCallback((IMEventCallback)this->cb_eventCallback);
}
GtkWidget *optionsWindowItem_plugins::createTab()
{
GtkWidget *label,
*vbox,
*alignment,
*mainVBox;
gchar *id,
*fstr;
GtkListStore *store;
GtkTreeIter iter;
IMPluginDaemon *plugin;
GList *search;
OW_CREATE_MAINVBOX(mainVBox);
OW_CREATE_SECTION(tr("Standard Plugins"), vbox);
gtk_box_pack_start(GTK_BOX(vbox), createPluginsList(&standardStore), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
OW_CREATE_SECTION(tr("Protocol Plugins"), vbox);
gtk_box_pack_start(GTK_BOX(vbox), createPluginsList(&protoStore), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
// fill the plugin list
search = IO_getPluginsList();
while(search)
{
plugin = (IMPluginDaemon*)search->data;
if (plugin->pluginID == LICQ_PPID)
{
search = search->next;
continue;
}
if (plugin->isProtoPlugin)
store = protoStore;
else
store = standardStore;
if (plugin->isLoaded)
id = g_strdup_printf("%d", plugin->id);
else
id = g_strdup("*");
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, id,
1, plugin->name,
2, plugin->version,
3, plugin->isLoaded,
4, plugin->isEnabled,
5, plugin->description,
6, plugin,
-1);
g_free(id);
search = search->next;
}
// attach a listener to the general signal source
IO_getGeneralSource()->addCallback((IMEventCallback)this->cb_eventCallback, this);
return mainVBox;
}
GtkWidget *optionsWindowItem_plugins::createPluginsList(GtkListStore **store)
{
GtkCellRenderer *renderer;
GtkWidget *view,
*scrolled;
GtkTreeViewColumn *column;
// id name version loaded enabled descr pointer
*store = gtk_list_store_new(7, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(*store));
// id column
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(tr("id"), renderer,
"text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
// name column
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(tr("Name"), renderer,
"text", 1, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
// version column
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(tr("Version"), renderer,
"text", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
// loaded column
renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(tr("Loaded"), renderer,
"active", 3, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
g_object_set_data(G_OBJECT(renderer), "icqnd-plugins-store", *store);
g_signal_connect(renderer, "toggled", G_CALLBACK(this->cb_loadedCheckboxToggled), this);
// enabled column
renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(tr("Enabled"), renderer,
"active", 4, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
g_object_set_data(G_OBJECT(renderer), "icqnd-plugins-store", *store);
g_signal_connect(renderer, "toggled", G_CALLBACK(this->cb_enabledCheckboxToggled), this);
// description column
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(tr("Description"), renderer,
"text", 5, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scrolled), view);
return scrolled;
}
void optionsWindowItem_plugins::cb_loadedCheckboxToggled(GtkCellRenderer* t, gchar* pathString, optionsWindowItem_plugins* self)
{
GtkTreePath* path;
GtkTreeIter iter;
IMPluginDaemon *plugin;
gboolean checked;
GtkListStore *store;
path = gtk_tree_path_new_from_string(pathString);
store = GTK_LIST_STORE(g_object_get_data(G_OBJECT(t), "icqnd-plugins-store"));
gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
3, &checked,
6, &plugin,
-1);
checked = !checked;
if (checked)
{
if(!plugin->loadPlugin())
u_showAlertMessage(tr("Couldn't load plugin"), tr("The plugin couldn't be loaded. Please check the network log window for more information!"), GTK_STOCK_DIALOG_ERROR);
} else
plugin->unloadPlugin();
gtk_tree_path_free(path);
}
void optionsWindowItem_plugins::cb_enabledCheckboxToggled(GtkCellRenderer* t, gchar* pathString, optionsWindowItem_plugins* self)
{
GtkTreePath* path;
GtkTreeIter iter;
IMPluginDaemon *plugin;
gboolean checked;
GtkListStore *store;
path = gtk_tree_path_new_from_string(pathString);
store = GTK_LIST_STORE(g_object_get_data(G_OBJECT(t), "icqnd-plugins-store"));
gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
4, &checked,
6, &plugin,
-1);
gtk_tree_path_free(path);
}
gboolean optionsWindowItem_plugins::cb_eventCallback(userEventType type, gint command, gint lastResult, gpointer info, optionsWindowItem_plugins* self)
{
GtkTreeIter iter;
GtkListStore *store;
IMPluginDaemon *plugin,
*pluginToUpdate;
gchar *id;
if (command != PC_NEWPLUGIN && command != PC_REMOVEPLUGIN)
return TRUE;
pluginToUpdate = (IMPluginDaemon*)info;
if (pluginToUpdate->isProtoPlugin)
store = self->protoStore;
else
store = self->standardStore;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
do
{
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
6, &plugin,
-1);
if (plugin == pluginToUpdate)
{
if (plugin->isLoaded)
id = g_strdup_printf("%d", plugin->id);
else
id = g_strdup("*");
gtk_list_store_set(store, &iter,
0, id,
1, plugin->name,
2, plugin->version,
3, plugin->isLoaded,
4, plugin->isEnabled,
5, plugin->description,
6, plugin,
-1);
g_free(id);
break;
}
} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
return TRUE;
}
// -----------------------------------------------------------------------------
optionsWindowItem_start::optionsWindowItem_start()
{
titleImage = NULL;
titleString = tr_NOOP("Startup");
}
optionsWindowItem_start::~optionsWindowItem_start()
{
}
gboolean optionsWindowItem_start::applyChanges()
{
gulong autoLogonStatus;
GtkTreeIter iter;
autoLogonStatus = 0;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(autoLogonStatusList), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(autoLogonStatusList)),
&iter, 1, &autoLogonStatus,
-1);
settings_getSettings()->setProperties(TRUE, "startup",
"autoLogonEnabled", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(autoLogonEnabledCheckbox)),
"autoLogonStatus", autoLogonStatus,
"autoLogonInvisible", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(autoLogonInvisibleCheckbox)),
NULL);
return TRUE;
}
GtkWidget* optionsWindowItem_start::createTab()
{
GtkWidget *alignment,
*alignment2,
*label,
*label2,
*vbox,
*vbox2,
*hbox,
*mainVBox;
guint i;
GtkListStore *store;
GtkTreeIter iter;
GtkCellRenderer *renderer;
gulong autoLogonStatus;
gboolean autoLogonEnabled,
autoLogonInvisible;
gchar *fstr;
settings_getSettings()->getProperties("startup",
"autoLogonEnabled", &autoLogonEnabled,
"autoLogonStatus", &autoLogonStatus,
"autoLogonInvisible", &autoLogonInvisible,
NULL);
OW_CREATE_MAINVBOX(mainVBox);
OW_CREATE_SECTION("Automatic logon on startup", vbox);
autoLogonEnabledCheckbox = gtk_check_button_new_with_mnemonic(tr("Enable auto logon"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(autoLogonEnabledCheckbox), autoLogonEnabled);
autoLogonInvisibleCheckbox = gtk_check_button_new_with_mnemonic(tr("Go invisible"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(autoLogonInvisibleCheckbox), autoLogonInvisible);
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_BOOLEAN);
autoLogonStatusList = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(autoLogonStatusList), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(autoLogonStatusList), renderer, "text", 0, NULL);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, tr("Online"), 1, BUDDY_STATUS_ONLINE, -1);
if (autoLogonStatus == BUDDY_STATUS_ONLINE)
gtk_combo_box_set_active(GTK_COMBO_BOX(autoLogonStatusList), 0);
for (i=0; i<5; i++)
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, tr(categories[i].name), 1, categories[i].status, -1);
if (autoLogonStatus == categories[i].status)
gtk_combo_box_set_active(GTK_COMBO_BOX(autoLogonStatusList), i+1);
}
label2 = gtk_label_new(tr("Status to set:"));
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), autoLogonStatusList, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox2), hbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), autoLogonInvisibleCheckbox, FALSE, TRUE, 0);
alignment2 = gtk_alignment_new(0.0f, 0.0f, 1.0f, 1.0f);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment2), 0, 0, 20, 0);
gtk_container_add(GTK_CONTAINER(alignment2), vbox2);
gtk_box_pack_start(GTK_BOX(vbox), autoLogonEnabledCheckbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), alignment2, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// set sensitivity callbacks
g_signal_connect(autoLogonEnabledCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), alignment2);
// set sensivitivityvitiy
gtk_widget_set_sensitive(alignment2, autoLogonEnabled);
return mainVBox;
}
// -----------------------------------------------------------------------------
optionsWindowItem_aresponse::optionsWindowItem_aresponse()
{
titleImage = NULL;
titleString = tr_NOOP("Auto Responses");
}
optionsWindowItem_aresponse::~optionsWindowItem_aresponse()
{
}
GtkWidget *optionsWindowItem_aresponse::createTab()
{
GtkWidget *mainVBox,
*label,
*label2,
*label3,
*label4,
*alignment,
*vbox,
*hbox,
*table,
*paned,
*frame,
*scrolled;
guint i;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkListStore *store;
IMAutoResponseManager *man;
GList *contents,
*names,
*searchc,
*searchn;
gboolean autoAwayEnabled,
autoNAEnabled;
gulong autoAway,
autoNA,
autoAwayMessage,
autoNAMessage;
GtkListStore *awayStore,
*naStore;
gchar *fstr;
lastStore = NULL;
settings_getSettings()->getProperties("autoresponses",
"autoAway", &autoAway,
"autoNA", &autoNA,
"autoAwayEnabled", &autoAwayEnabled,
"autoNAEnabled", &autoNAEnabled,
"autoAwayMessage", &autoAwayMessage,
"autoNAMessage", &autoNAMessage,
NULL);
OW_CREATE_MAINVBOX(mainVBox);
// edit autoresponses
OW_CREATE_SECTION(tr("Edit Auto responses"), vbox);
awayStore = NULL;
naStore = NULL;
man = new IMAutoResponseManager(NULL, TRUE);
// create all neccessary stores
arTypeStore = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_ULONG, G_TYPE_POINTER);
for (i=0; i<5; i++)
{
// create the sub stores
contents = NULL;
names = NULL;
man->fetchTemplates(categories[i].status, &contents, &names);
searchc = contents;
searchn = names;
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
while(searchc)
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, searchn->data,
1, searchc->data,
-1);
searchc = searchc->next;
searchn = searchn->next;
}
// save the stores for later
if (categories[i].status == BUDDY_STATUS_AWAY)
awayStore = store;
else
if (categories[i].status == BUDDY_STATUS_NA)
naStore = store;
g_list_foreach(names, (GFunc)g_free, NULL);
g_list_foreach(contents, (GFunc)g_free, NULL);
g_list_free(names);
g_list_free(contents);
gtk_list_store_append(arTypeStore, &iter);
gtk_list_store_set(arTypeStore, &iter,
0, categories[i].name,
1, categories[i].status,
2, store,
-1);
}
// create the templates view
arTemplatesView = gtk_tree_view_new();
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(arTemplatesView), TRUE);
g_signal_connect_swapped(gtk_tree_view_get_selection(GTK_TREE_VIEW(arTemplatesView)), "changed", G_CALLBACK(this->cb_arTemplateChanged), this);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
g_signal_connect(renderer, "edited", G_CALLBACK(this->cb_arTemplatesViewEdited), this);
col = gtk_tree_view_column_new_with_attributes(tr("Preset Slot"), renderer,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(arTemplatesView), col);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scrolled), arTemplatesView);
gtk_widget_set_size_request(scrolled, 100, -1);
// create the templates entry
frame = u_createTextView(&arTemplateEntryView);
// create the types view
arTypeView = gtk_combo_box_new_with_model(GTK_TREE_MODEL(arTypeStore));
g_signal_connect_swapped(arTypeView, "changed", G_CALLBACK(this->cb_arTypeChanged), this);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(arTypeView), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(arTypeView), renderer,
"text", 0,
NULL);
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(arTypeStore), &iter);
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(arTypeView), &iter);
label2 = gtk_label_new(tr("Status:"));
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbox), label2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), arTypeView, TRUE, TRUE, 0);
// add the templates store and the text entry in a vpaned
paned = gtk_hpaned_new();
gtk_paned_pack1(GTK_PANED(paned), scrolled, FALSE, TRUE);
gtk_paned_pack2(GTK_PANED(paned), frame, TRUE, TRUE);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
// time outs
OW_CREATE_SECTION_T(tr("Automatic set auto response"), table, 4, 3);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacing(GTK_TABLE(table), 1, 10);
fstr = g_strdup_printf("%s", tr("After a while (in minutes) a special status can be set automatically if you are inactive."));
label2 = gtk_label_new(fstr);
g_free(fstr);
gtk_label_set_line_wrap(GTK_LABEL(label2), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label2), TRUE);
gtk_misc_set_alignment(GTK_MISC(label2), 0.0f, 0.0f);
arAutoAwayEnabledCheckbox = gtk_check_button_new_with_mnemonic(tr("Away:"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(arAutoAwayEnabledCheckbox), autoAwayEnabled);
arAutoAwaySpinButton = gtk_spin_button_new_with_range(1, 0xFFFF, 1);
if (autoAway)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(arAutoAwaySpinButton), autoAway);
arAutoAwayTemplatesCombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(awayStore));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(arAutoAwayTemplatesCombo), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(arAutoAwayTemplatesCombo), renderer, "text", 0, NULL);
gtk_combo_box_set_active(GTK_COMBO_BOX(arAutoAwayTemplatesCombo), autoAwayMessage);
label3 = gtk_label_new(tr("Auto Response:"));
arAutoNAEnabledCheckbox = gtk_check_button_new_with_mnemonic(tr("Not Available:"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(arAutoNAEnabledCheckbox), autoNAEnabled);
arAutoNASpinButton = gtk_spin_button_new_with_range(1, 0xFFFF, 1);
if (autoNA)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(arAutoNASpinButton), autoNA);
arAutoNATemplatesCombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(naStore));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(arAutoNATemplatesCombo), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(arAutoNATemplatesCombo), renderer, "text", 0, NULL);
gtk_combo_box_set_active(GTK_COMBO_BOX(arAutoNATemplatesCombo), autoNAMessage);
label4 = gtk_label_new(tr("Auto Response:"));
gtk_table_attach(GTK_TABLE(table), label2, 0, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), arAutoAwayEnabledCheckbox, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), arAutoAwaySpinButton, 1, 2, 1, 2);
gtk_table_attach(GTK_TABLE(table), label3, 2, 3, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), arAutoAwayTemplatesCombo, 3, 4, 1, 2);
gtk_table_attach(GTK_TABLE(table), arAutoNAEnabledCheckbox, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), arAutoNASpinButton, 1, 2, 2, 3);
gtk_table_attach(GTK_TABLE(table), label4, 2, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), arAutoNATemplatesCombo, 3, 4, 2, 3);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, FALSE, TRUE, 0);
// set toggle button callbacks
g_signal_connect(arAutoAwayEnabledCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), arAutoAwaySpinButton);
g_signal_connect(arAutoAwayEnabledCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), label3);
g_signal_connect(arAutoAwayEnabledCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), arAutoAwayTemplatesCombo);
g_signal_connect(arAutoNAEnabledCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), arAutoNASpinButton);
g_signal_connect(arAutoNAEnabledCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), label4);
g_signal_connect(arAutoNAEnabledCheckbox, "toggled", G_CALLBACK(o_cb_sensitivityToggleButtonClicked), arAutoNATemplatesCombo);
// set sensitivity
gtk_widget_set_sensitive(arAutoAwaySpinButton, autoAwayEnabled);
gtk_widget_set_sensitive(label3, autoAwayEnabled);
gtk_widget_set_sensitive(arAutoAwayTemplatesCombo, autoAwayEnabled);
gtk_widget_set_sensitive(arAutoNASpinButton, autoNAEnabled);
gtk_widget_set_sensitive(label4, autoNAEnabled);
gtk_widget_set_sensitive(arAutoNATemplatesCombo, autoNAEnabled);
delete man;
return mainVBox;
}
gboolean optionsWindowItem_aresponse::applyChanges()
{
GtkTreeIter iter1,
iter2;
GList *names,
*contents;
gulong status;
GtkListStore *statusTemplates;
gchar *currentName,
*currentContent;
IMAutoResponseManager *man;
// save all auto responses
// FIXME: is it really neccessary to rewrite ALL responses?
// apply the latest change
cb_arTemplateChanged(this);
man = new IMAutoResponseManager(NULL, TRUE);
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(arTypeStore), &iter1))
{
do
{
gtk_tree_model_get(GTK_TREE_MODEL(arTypeStore),
&iter1,
1, &status,
2, &statusTemplates,
-1);
names = NULL;
contents = NULL;
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(statusTemplates), &iter2))
{
do
{
gtk_tree_model_get(GTK_TREE_MODEL(statusTemplates), &iter2,
0, ¤tName,
1, ¤tContent,
-1);
names = g_list_append(names, currentName);
contents = g_list_append(contents, currentContent);
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(statusTemplates), &iter2));
man->writeTemplates(status, contents, names);
}
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(arTypeStore), &iter1));
}
delete man;
settings_getSettings()->setProperties(TRUE, "autoresponses",
"autoAway", gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(arAutoAwaySpinButton)),
"autoNA", gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(arAutoNASpinButton)),
"autoAwayEnabled", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(arAutoAwayEnabledCheckbox)),
"autoNAEnabled", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(arAutoNAEnabledCheckbox)),
"autoAwayMessage", gtk_combo_box_get_active(GTK_COMBO_BOX(arAutoAwayTemplatesCombo)),
"autoNAMessage", gtk_combo_box_get_active(GTK_COMBO_BOX(arAutoNATemplatesCombo)),
NULL);
return TRUE;
}
void optionsWindowItem_aresponse::cb_arTypeChanged(optionsWindowItem_aresponse* self)
{
GtkTreeIter iter;
GtkListStore *store;
GtkTreePath *path;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->arTypeView), &iter);
gtk_tree_model_get(GTK_TREE_MODEL(self->arTypeStore), &iter,
2, &store,
-1);
gtk_tree_view_set_model(GTK_TREE_VIEW(self->arTemplatesView), GTK_TREE_MODEL(store));
// select the first entry
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(self->arTemplatesView), path, self->col, FALSE);
gtk_tree_path_free(path);
}
void optionsWindowItem_aresponse::cb_arTemplateChanged(optionsWindowItem_aresponse* self)
{
gchar *content;
GtkTreePath *path;
GtkTextIter titer1, titer2;
GtkTextBuffer *buf;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->arTemplateEntryView));
// set the last edited entry
if (self->lastStore)
{
gtk_text_buffer_get_bounds(buf, &titer1, &titer2);
content = gtk_text_buffer_get_text(buf, &titer1, &titer2, FALSE);
gtk_list_store_set(self->lastStore, &self->lastIter, 1, content, -1);
}
gtk_tree_view_get_cursor(GTK_TREE_VIEW(self->arTemplatesView), &path, NULL);
if (!path)
return;
self->lastStore = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->arTemplatesView)));
gtk_tree_model_get_iter(GTK_TREE_MODEL(self->lastStore), &self->lastIter, path);
gtk_tree_path_free(path);
gtk_tree_model_get(GTK_TREE_MODEL(self->lastStore), &self->lastIter, 1, &content, -1);
gtk_text_buffer_set_text(buf,
content,
-1);
}
void optionsWindowItem_aresponse::cb_arTemplatesViewEdited(GtkCellRendererText *cell, gchar *pathStr, gchar *newText, optionsWindowItem_aresponse* self)
{
GtkTreePath *path;
GtkTreeIter iter;
GtkListStore *store;
path = gtk_tree_path_new_from_string(pathStr);
store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(self->arTemplatesView)));
gtk_tree_model_get_iter(GTK_TREE_MODEL(store), &iter, path);
gtk_tree_path_free(path);
gtk_list_store_set(store, &iter, 0, newText, -1);
}
// -----------------------------------------------------------------------------
optionsWindowItem_themes::optionsWindowItem_themes()
{
titleImage = NULL;
titleString = tr_NOOP("Themes");
}
optionsWindowItem_themes::~optionsWindowItem_themes()
{
}
gboolean optionsWindowItem_themes::applyChanges()
{
GtkTreeIter iter;
gchar *eventTheme,
*smileyTheme,
*statusTheme,
*extendedTheme;
// get the status theme
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(statusCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(statusCombo)),
&iter, 2, &statusTheme, -1);
// get the extended theme
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(extendedCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(extendedCombo)),
&iter, 2, &extendedTheme, -1);
// get the events theme
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(eventCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(eventCombo)),
&iter, 2, &eventTheme, -1);
// get the smileys theme
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(smileysCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(smileysCombo)),
&iter, 2, &smileyTheme, -1);
// apply the changes
settings_getSettings()->setProperties(TRUE, "appearance",
"EventTheme", eventTheme,
"SmileyTheme", smileyTheme,
"StatusTheme", statusTheme,
"ExtendedTheme", extendedTheme,
NULL);
return TRUE;
}
GtkWidget *optionsWindowItem_themes::createTab()
{
GtkWidget *mainVBox,
*vbox,
*label,
*alignment;
gchar *fstr;
// build all event boxes
statusBox = gtk_event_box_new();
eventBox = gtk_event_box_new();
extendedBox = gtk_event_box_new();
smileysBox = gtk_event_box_new();
// read all directories
statusIcons = NULL;
eventIcons = NULL;
extendedIcons = NULL;
smileys = NULL;
fillThemeCombos();
OW_CREATE_MAINVBOX(mainVBox);
// build the sub sections
OW_CREATE_SECTION("Status Icons", vbox);
gtk_box_pack_start(GTK_BOX(vbox), statusCombo, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), statusBox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
OW_CREATE_SECTION("Event Icons", vbox);
gtk_box_pack_start(GTK_BOX(vbox), eventCombo, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), eventBox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
OW_CREATE_SECTION("Extended Icons", vbox);
gtk_box_pack_start(GTK_BOX(vbox), extendedCombo, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), extendedBox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
OW_CREATE_SECTION("Smileys", vbox);
gtk_box_pack_start(GTK_BOX(vbox), smileysCombo, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), smileysBox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainVBox), alignment, TRUE, TRUE, 0);
return mainVBox;
}
void optionsWindowItem_themes::fillThemeCombos()
{
GDir *currentDir;
gchar *base,
*themeTitle,
*tmp,
*strStart,
*strEnd;
FILE *authorFile;
gulong authorsSize;
gchar *buf;
const gchar *themeBase;
gchar *themePath;
GtkTreeIter iter;
GtkListStore *store;
gchar *eventTheme,
*smileyTheme,
*statusTheme,
*extendedTheme;
settings_getSettings()->getProperties("appearance",
"EventTheme", &eventTheme,
"SmileyTheme", &smileyTheme,
"StatusTheme", &statusTheme,
"ExtendedTheme", &extendedTheme,
NULL);
// init the combos
statusCombo = createThemeCombo();
g_signal_connect_swapped(statusCombo, "changed", G_CALLBACK(this->cb_statusComboChanged), this);
eventCombo = createThemeCombo();
g_signal_connect_swapped(eventCombo, "changed", G_CALLBACK(this->cb_eventComboChanged), this);
extendedCombo = createThemeCombo();
g_signal_connect_swapped(extendedCombo, "changed", G_CALLBACK(this->cb_extendedComboChanged), this);
smileysCombo = createThemeCombo();
g_signal_connect_swapped(smileysCombo, "changed", G_CALLBACK(this->cb_smileysComboChanged), this);
base = g_strdup_printf("%sicqnd", SHARE_DIR);
// get a list of all theme directories
currentDir = g_dir_open(base, 0, NULL);
while((themeBase = g_dir_read_name(currentDir)))
{
themePath = g_strdup_printf("%s/%s", base, themeBase);
// okay, this should be a theme if it's a directory
if (!g_file_test(themePath, G_FILE_TEST_IS_DIR))
{
g_free(themePath);
continue;
}
themeTitle = NULL;
// try to get the author information
tmp = g_strdup_printf("%s/author", themePath);
authorFile = fopen(tmp, "r");
g_free(tmp);
if (authorFile)
{
fseek(authorFile, 0, SEEK_END);
authorsSize = ftell(authorFile);
rewind(authorFile);
buf = (gchar*)g_malloc0(authorsSize);
fread(buf, 1, authorsSize, authorFile);
if ((strStart = strstr(buf, "theme:")) && (strEnd = strstr(strStart, "\n")))
{
strStart+=6;
strStart = g_strstrip(strStart);
themeTitle = (gchar*)g_malloc0(strEnd - strStart);
memcpy(themeTitle, strStart, strEnd - strStart-1);
}
g_free(buf);
fclose(authorFile);
}
// ** check for existance of theme elements and add them into the combos**
// smileys
tmp = g_strdup_printf("%s/smileys", themePath);
if (g_file_test(tmp, G_FILE_TEST_IS_DIR))
{
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(smileysCombo)));
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, themeTitle? themeTitle: themeBase, 1, tmp, 2, themeBase, -1);
if (!strcmp(themeBase, smileyTheme))
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(smileysCombo), &iter);
}
g_free(tmp);
// status icons
tmp = g_strdup_printf("%s/status", themePath);
if (g_file_test(tmp, G_FILE_TEST_IS_DIR))
{
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(statusCombo)));
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, themeTitle? themeTitle: themeBase, 1, tmp, 2, themeBase, -1);
if (!strcmp(themeBase, statusTheme))
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(statusCombo), &iter);
}
g_free(tmp);
// event icons
tmp = g_strdup_printf("%s/events", themePath);
if (g_file_test(tmp, G_FILE_TEST_IS_DIR))
{
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(eventCombo)));
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, themeTitle? themeTitle: themeBase, 1, tmp, 2, themeBase, -1);
if (!strcmp(themeBase, eventTheme))
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(eventCombo), &iter);
}
g_free(tmp);
// extended icons
tmp = g_strdup_printf("%s/extended", themePath);
if (g_file_test(tmp, G_FILE_TEST_IS_DIR))
{
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(extendedCombo)));
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, themeTitle? themeTitle: themeBase, 1, tmp, 2, themeBase, -1);
if (!strcmp(themeBase, extendedTheme))
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(extendedCombo), &iter);
}
g_free(tmp);
g_free(themePath);
}
g_dir_close(currentDir);
}
GtkWidget *optionsWindowItem_themes::createThemeCombo()
{
GtkWidget *combo;
GtkCellRenderer *renderer;
GtkListStore *store;
store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", 0, NULL);
return combo;
}
void optionsWindowItem_themes::showIcons(GtkWidget *box, GList *list)
{
GList *search;
iconManagerIcon *icon;
guint width;
GtkWidget *img,
*hbox,
*vbox;
// clear all children
gtk_container_foreach(GTK_CONTAINER(box), (GtkCallback)gtk_widget_destroy, NULL);
// draw all children
width = 0;
vbox = gtk_vbox_new(FALSE, 10);
hbox = gtk_hbox_new(FALSE, 10);
for (search = list; search; search = search->next)
{
icon = (iconManagerIcon*)search->data;
img = gtk_image_new_from_pixbuf(icon->pb);
gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
width+= gdk_pixbuf_get_width(icon->pb) + 10;
if (width > 390)
{
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 10);
width = 0;
}
}
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(box), vbox);
gtk_widget_show_all(box);
}
void optionsWindowItem_themes::showSmileys()
{
guint width,
i;
GtkWidget *img,
*hbox,
*vbox;
// clear all children
gtk_container_foreach(GTK_CONTAINER(smileysBox), (GtkCallback)gtk_widget_destroy, NULL);
// draw all children
width = 0;
vbox = gtk_vbox_new(FALSE, 10);
hbox = gtk_hbox_new(FALSE, 10);
if ( smileys != NULL )
for (i=0; smileys[i].token; i++)
{
if (!smileys[i].isFirstIcon)
continue;
img = gtk_image_new_from_pixbuf(smileys[i].icon);
gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0);
width+= gdk_pixbuf_get_width(smileys[i].icon) + 10;
if (width > 390)
{
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 10);
width = 0;
}
}
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(smileysBox), vbox);
gtk_widget_show_all(smileysBox);
}
void optionsWindowItem_themes::cb_statusComboChanged(optionsWindowItem_themes* self)
{
GtkTreeIter iter;
gchar *base;
GList *icons,
*search;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->statusCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(self->statusCombo)), &iter,
1, &base,
-1);
i_getIcons()->loadStatusIcons(base, &self->statusIcons, FALSE);
icons = NULL;
// icons are splitted in categories here, append them into one list
for (search = self->statusIcons; search; search = search->next)
icons = g_list_concat(icons, g_list_copy(((iconManagerCat*)search->data)->icons));
self->showIcons(self->statusBox, icons);
g_list_free(icons);
}
void optionsWindowItem_themes::cb_eventComboChanged(optionsWindowItem_themes* self)
{
GtkTreeIter iter;
gchar *base;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->eventCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(self->eventCombo)), &iter,
1, &base,
-1);
i_getIcons()->loadEventIcons(base, &self->eventIcons);
self->showIcons(self->eventBox, self->eventIcons);
}
void optionsWindowItem_themes::cb_extendedComboChanged(optionsWindowItem_themes* self)
{
GtkTreeIter iter;
gchar *base;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->extendedCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(self->extendedCombo)), &iter,
1, &base,
-1);
i_getIcons()->loadExtendedIcons(base, &self->extendedIcons);
self->showIcons(self->extendedBox, self->extendedIcons);
}
void optionsWindowItem_themes::cb_smileysComboChanged(optionsWindowItem_themes* self)
{
GtkTreeIter iter;
gchar *base;
gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->smileysCombo), &iter);
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(self->smileysCombo)), &iter,
1, &base,
-1);
i_getIcons()->loadSmileys(base, &self->smileys, FALSE);
self->showSmileys();
}
// =============================================================================
void o_cb_sensitivityToggleButtonClicked(GtkWidget* btn, GtkWidget* victim)
{
gtk_widget_set_sensitive(victim, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn)));
}