/* WebDownloader for X-Window
* Copyright (C) 1999-2002 Koshelev Maxim
* This Program is free but not GPL!!! You can't modify it
* without agreement with author. You can't distribute modified
* program but you can distribute unmodified program.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
#include "mywidget.h"
#include "edit.h"
#include "misc.h"
#include "../ntlocale.h"
#include "../filter.h"
#include "../history.h"
#include "../var.h"
static GtkWidgetClass *parent_class1 = (GtkWidgetClass *)NULL;
static GtkWidgetClass *color_parent_class = (GtkWidgetClass *)NULL;
static GtkWidgetClass *rule_parent_class = (GtkWidgetClass *)NULL;
static GtkWidgetClass *filter_parent_class = (GtkWidgetClass *)NULL;
static GtkWidgetClass *filtersel_parent_class = (GtkWidgetClass *)NULL;
static GtkWidgetClass *linkssel_parent_class = (GtkWidgetClass *)NULL;
static GtkWidgetClass *stringedit_parent_class = (GtkWidgetClass *)NULL;
static GtkWidgetClass *altedit_parent_class = (GtkWidgetClass *)NULL;
static void my_gtk_filesel_destroy_browser(MyGtkFilesel *filesel){
if (filesel->browser){
gtk_widget_destroy(filesel->browser);
filesel->browser=(GtkWidget *)NULL;
};
};
static gint my_gtk_filesel_ok(GtkButton *button,MyGtkFilesel *filesel){
g_return_val_if_fail(filesel!=NULL,FALSE);
if (filesel->browser){
text_to_combo(filesel->combo,
gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel->browser)));
my_gtk_filesel_destroy_browser(filesel);
};
return TRUE;
};
static gint my_gtk_filesel_cancel(GtkButton *button,MyGtkFilesel *filesel){
g_return_val_if_fail(filesel!=NULL,FALSE);
my_gtk_filesel_destroy_browser(filesel);
return TRUE;
};
static gint my_gtk_filesel_delete(GtkWidget *window,GdkEvent *event, MyGtkFilesel *filesel) {
my_gtk_filesel_cancel((GtkButton *)NULL,filesel);
return TRUE;
};
static gint my_gtk_filesel_init_browser(GtkButton *button, MyGtkFilesel *filesel){
g_return_val_if_fail(filesel!=NULL,FALSE);
if (filesel->browser){
gdk_window_show(filesel->browser->window);
}else{
if (filesel->only_dirs){
filesel->browser=gtk_file_selection_new((gchar*)_("Select directory"));
gtk_widget_set_sensitive(GTK_FILE_SELECTION(filesel->browser)->file_list,FALSE);
}else
filesel->browser=gtk_file_selection_new((gchar*)_("Select file"));
gtk_window_set_wmclass(GTK_WINDOW(filesel->browser),
"D4X_FileSel","D4X");
char *tmp=text_from_combo(filesel->combo);
if (tmp && *tmp)
gtk_file_selection_set_filename(GTK_FILE_SELECTION(filesel->browser),tmp);
g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(filesel->browser)->ok_button),
"clicked",G_CALLBACK(my_gtk_filesel_ok),filesel);
g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(filesel->browser)->cancel_button),
"clicked",G_CALLBACK(my_gtk_filesel_cancel),filesel);
g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(filesel->browser)),
"delete_event",G_CALLBACK(my_gtk_filesel_delete),filesel);
gtk_widget_show(filesel->browser);
d4x_eschandler_init(filesel->browser,filesel);
if (filesel->modal){
gtk_window_set_modal (GTK_WINDOW(filesel->browser),TRUE);
gtk_window_set_transient_for (GTK_WINDOW (filesel->browser), filesel->modal);
};
};
return TRUE;
};
static void my_gtk_filsel_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
MyGtkFilesel *filesel=(MyGtkFilesel *)widget;
my_gtk_filesel_destroy_browser(filesel);
if (GTK_OBJECT_CLASS (parent_class1)->destroy)
(* GTK_OBJECT_CLASS (parent_class1)->destroy) (widget);
};
static void my_gtk_filesel_class_init(MyGtkFileselClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=my_gtk_filsel_destroy;
parent_class1=(GtkWidgetClass *)gtk_type_class(gtk_box_get_type());
};
static void my_gtk_filesel_init(MyGtkFilesel *filesel){
filesel->browser=(GtkWidget *)NULL;
filesel->combo=gtk_combo_box_entry_new_text();
filesel->only_dirs=0;
filesel->modal=(GtkWindow *)NULL;
GtkWidget *button=gtk_button_new_with_label(_("Browse"));
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(my_gtk_filesel_init_browser),filesel);
// gtk_combo_set_case_sensitive(GTK_COMBO(filesel->combo),TRUE);
gtk_box_set_spacing(GTK_BOX(filesel),5);
gtk_box_pack_start(GTK_BOX(filesel),filesel->combo,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(filesel),button,FALSE,FALSE,0);
};
guint my_gtk_filesel_get_type(){
static guint my_filesel_type=0;
if (!my_filesel_type){
GTypeInfo my_filesel_info={
sizeof(MyGtkFileselClass),
NULL,NULL,
(GClassInitFunc)my_gtk_filesel_class_init,
NULL,NULL,
sizeof(MyGtkFilesel),
0,
(GInstanceInitFunc)my_gtk_filesel_init
};
my_filesel_type = g_type_register_static (GTK_TYPE_HBOX,"MyGtkFilesel",&my_filesel_info,(GTypeFlags)0);
};
return my_filesel_type;
};
GtkWidget *my_gtk_filesel_new(tHistory *history){
MyGtkFilesel *filesel=(MyGtkFilesel *)g_object_new(my_gtk_filesel_get_type(),NULL);
history_to_combo_box_entry(history,filesel->combo);
/*
GList *list=make_glist_from_mylist(history);
if (list){
gtk_combo_set_popdown_strings (GTK_COMBO (filesel->combo), list);
g_list_free(list);
};
*/
return GTK_WIDGET(filesel);
};
/* ------------------ Color selection widget --------------------*/
static void my_gtk_colorsel_destroy_browser(MyGtkColorsel *colsel){
if (colsel->browser){
gtk_widget_destroy(colsel->browser);
colsel->browser=(GtkWidget *)NULL;
};
};
static void my_gtk_colorsel_expose(GtkWidget *widget,GdkEventExpose *event,MyGtkColorsel *colsel){
gint w=widget->allocation.width,h=widget->allocation.height;
guchar *buf=g_new(guchar,3*w*h);
gint i=0;
for (int y=0;y<h;y++){
for (int x=0;x<w;x++){
buf[i]=0;
buf[i++]=colsel->color.red>>8;
buf[i++]=colsel->color.green>>8;
buf[i++]=colsel->color.blue>>8;
};
};
gdk_draw_rgb_image(widget->window,widget->style->black_gc,
0,0,w,h,
GDK_RGB_DITHER_NORMAL,
buf,3*w);
g_free(buf);
};
static gint my_gtk_colorsel_ok(GtkButton *button,MyGtkColorsel *colsel){
g_return_val_if_fail(colsel!=NULL,FALSE);
if (colsel->browser){
gtk_color_selection_get_current_color(GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colsel->browser)->colorsel),
&(colsel->color));
gtk_widget_queue_draw (colsel->preview);
my_gtk_colorsel_destroy_browser(colsel);
};
return TRUE;
};
static gint my_gtk_colorsel_cancel(GtkButton *button,MyGtkColorsel *colsel){
g_return_val_if_fail(colsel!=NULL,FALSE);
my_gtk_colorsel_destroy_browser(colsel);
return TRUE;
};
static gint my_gtk_colorsel_delete(GtkWidget *window,GdkEvent *event, MyGtkColorsel *colsel) {
my_gtk_colorsel_cancel((GtkButton *)NULL,colsel);
return TRUE;
};
static gint my_gtk_colorsel_init_browser(GtkButton *button, MyGtkColorsel *colsel){
g_return_val_if_fail(colsel!=NULL,FALSE);
if (colsel->browser){
gdk_window_show(colsel->browser->window);
}else{
colsel->browser=gtk_color_selection_dialog_new(_("Select color"));
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colsel->browser)->colorsel),
&(colsel->color));
g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(colsel->browser)->ok_button),
"clicked",G_CALLBACK(my_gtk_colorsel_ok),colsel);
g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(colsel->browser)->cancel_button),
"clicked",G_CALLBACK(my_gtk_colorsel_cancel),colsel);
g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(colsel->browser)),
"delete_event",G_CALLBACK(my_gtk_colorsel_delete),colsel);
d4x_eschandler_init(GTK_WIDGET(GTK_COLOR_SELECTION_DIALOG(colsel->browser)),colsel);
gtk_widget_destroy(GTK_COLOR_SELECTION_DIALOG(colsel->browser)->help_button);
gtk_widget_show(colsel->browser);
if (colsel->modal){
gtk_window_set_modal (GTK_WINDOW(colsel->browser),TRUE);
gtk_window_set_transient_for (GTK_WINDOW (colsel->browser), colsel->modal);
};
};
return TRUE;
};
static void my_gtk_colorsel_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
MyGtkColorsel *colsel=(MyGtkColorsel *)widget;
my_gtk_colorsel_destroy_browser(colsel);
if (GTK_OBJECT_CLASS (color_parent_class)->destroy)
(* GTK_OBJECT_CLASS (color_parent_class)->destroy) (widget);
};
static void my_gtk_colorsel_class_init(MyGtkColorselClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=my_gtk_colorsel_destroy;
color_parent_class=(GtkWidgetClass *)gtk_type_class(gtk_box_get_type());
};
static void my_gtk_colorsel_init(MyGtkColorsel *colsel){
colsel->browser=(GtkWidget *)NULL;
colsel->modal=(GtkWindow *)NULL;
colsel->preview=gtk_drawing_area_new();
g_signal_connect(G_OBJECT(colsel->preview),"expose_event",G_CALLBACK(my_gtk_colorsel_expose),colsel);
GtkWidget *button=gtk_button_new_with_label(_("Select"));
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(my_gtk_colorsel_init_browser),colsel);
gtk_box_set_spacing(GTK_BOX(colsel),5);
gtk_widget_set_size_request(colsel->preview,50,50);
gtk_box_pack_start(GTK_BOX(colsel),colsel->preview,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(colsel),button,FALSE,FALSE,0);
};
guint my_gtk_colorsel_get_type(){
static guint my_filesel_type=0;
if (!my_filesel_type){
GTypeInfo my_filesel_info={
sizeof(MyGtkColorselClass),
NULL,NULL,
(GClassInitFunc) my_gtk_colorsel_class_init,
NULL,NULL,
sizeof(MyGtkColorsel),
0,
(GInstanceInitFunc)my_gtk_colorsel_init
};
my_filesel_type = g_type_register_static (GTK_TYPE_HBOX,"MyGtkColorsel",&my_filesel_info,(GTypeFlags)0);
};
return my_filesel_type;
};
gint my_gtk_colorsel_get_color(MyGtkColorsel *colsel){
gint color=0;
color=((gint(colsel->color.blue>>8))&0xff)+
(((gint(colsel->color.green>>8))&0xff)<<8)+
(((gint(colsel->color.red>>8))&0xff)<<16);
return color;
};
void my_gtk_colorsel_set_color(MyGtkColorsel *colsel, gint color){
g_return_if_fail(colsel!=NULL);
colsel->color.blue=((color&0xff)<<8)+(color&0xff);
colsel->color.green=(((color>>8)&0xff)<<8)+((color>>8)&0xff);
colsel->color.red=(((color>>16)&0xff)<<8)+((color>>16)&0xff);
if (GTK_WIDGET_VISIBLE(colsel))
gtk_widget_queue_draw (colsel->preview);
};
GtkWidget *my_gtk_colorsel_new(gint color,gchar *title){
MyGtkColorsel *colsel=(MyGtkColorsel *)g_object_new(my_gtk_colorsel_get_type(),NULL);
if (title){
GtkWidget *label=gtk_label_new(title);
gtk_box_pack_start(GTK_BOX(colsel),label,FALSE,FALSE,0);
};
my_gtk_colorsel_set_color(colsel,color);
return GTK_WIDGET(colsel);
};
/***********************************************************************/
static void d4x_rule_edit_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
d4xRuleEdit *edit=(d4xRuleEdit *)widget;
if (edit->rule){
delete (edit->rule);
edit->rule=0;
};
if (edit->iter){
gtk_tree_iter_free(edit->iter);
edit->iter=0;
};
if (GTK_OBJECT_CLASS (rule_parent_class)->destroy)
(* GTK_OBJECT_CLASS (rule_parent_class)->destroy) (widget);
};
static void d4x_rule_edit_class_init(d4xRuleEditClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=d4x_rule_edit_destroy;
rule_parent_class=(GtkWidgetClass *)gtk_type_class(gtk_window_get_type());
};
void d4x_rule_edit_apply(d4xRuleEdit *edit){
if (edit){
edit->rule->host=text_from_combo(edit->host);
edit->rule->path=text_from_combo(edit->path);
edit->rule->file=text_from_combo(edit->file);
edit->rule->params=text_from_combo(edit->params);
edit->rule->tag=text_from_combo(edit->tag);
edit->rule->proto=get_proto_by_name(text_from_combo(edit->proto));
edit->rule->include=GTK_TOGGLE_BUTTON(edit->include)->active;
};
};
static void d4x_rule_edit_ok(GtkWidget *widget,d4xRuleEdit *edit) {
g_return_if_fail(edit!=NULL);
d4x_rule_edit_apply(edit);
gtk_widget_destroy(GTK_WIDGET(edit));
};
static void d4x_rule_edit_cancel(GtkWidget *widget,d4xRuleEdit *edit) {
gtk_widget_destroy(GTK_WIDGET(edit));
};
static void d4x_rule_edit_init(d4xRuleEdit *edit){
edit->rule=0;
edit->iter=0;
gtk_window_set_title(GTK_WINDOW (edit),_("Edit properties of Rule"));
gtk_window_set_resizable(GTK_WINDOW(edit), FALSE);
edit->vbox=gtk_vbox_new(FALSE,0);
gtk_container_set_border_width(GTK_CONTAINER(edit->vbox),5);
gtk_container_add(GTK_CONTAINER(edit),edit->vbox);
GtkWidget *table=gtk_table_new(6,2,FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table),3);
gtk_table_set_col_spacings(GTK_TABLE(table),5);
gtk_box_pack_start(GTK_BOX(edit->vbox),table, FALSE,FALSE,0);
GtkWidget *label=gtk_label_new(_("Protocol"));
GtkWidget *align=gtk_alignment_new(1,0.5,0,0);
gtk_container_add(GTK_CONTAINER(align),label);
gtk_table_attach(GTK_TABLE(table),align,0,1,0,1,
(GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) 0,0,0);
edit->proto=gtk_combo_box_entry_new_text();
set_editable_for_combo(edit->proto,FALSE);
gtk_combo_box_append_text (GTK_COMBO_BOX (edit->proto),get_name_by_proto(D_PROTO_FTP));
gtk_combo_box_append_text (GTK_COMBO_BOX (edit->proto),get_name_by_proto(D_PROTO_HTTP));
gtk_combo_box_append_text (GTK_COMBO_BOX (edit->proto),"");
/*
edit->proto=gtk_combo_new();
GList *list=(GList*)NULL;
list = g_list_append (list, get_name_by_proto(D_PROTO_FTP));
list = g_list_append (list, get_name_by_proto(D_PROTO_HTTP));
list = g_list_append (list, (void*)"");
gtk_combo_set_popdown_strings (GTK_COMBO (edit->proto), list);
g_list_free(list);
gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(edit->proto)->entry),FALSE);
*/
text_to_combo(edit->proto,"");
gtk_table_attach_defaults(GTK_TABLE(table),edit->proto,1,2,0,1);
label=gtk_label_new(_("Host"));
align=gtk_alignment_new(1,0.5,0,0);
gtk_container_add(GTK_CONTAINER(align),label);
gtk_table_attach(GTK_TABLE(table),align,0,1,1,2,
(GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) 0,0,0);
edit->host=gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table),edit->host,1,2,1,2);
label=gtk_label_new(_("Path"));
align=gtk_alignment_new(1,0.5,0,0);
gtk_container_add(GTK_CONTAINER(align),label);
gtk_table_attach(GTK_TABLE(table),align,0,1,2,3,
(GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) 0,0,0);
edit->path=gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table),edit->path,1,2,2,3);
label=gtk_label_new(_("File"));
align=gtk_alignment_new(1,0.5,0,0);
gtk_container_add(GTK_CONTAINER(align),label);
gtk_table_attach(GTK_TABLE(table),align,0,1,3,4,
(GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) 0,0,0);
edit->file=gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table),edit->file,1,2,3,4);
label=gtk_label_new(_("?"));
align=gtk_alignment_new(1,0.5,0,0);
gtk_container_add(GTK_CONTAINER(align),label);
gtk_table_attach(GTK_TABLE(table),align,0,1,4,5,
(GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) 0,0,0);
edit->params=gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table),edit->params,1,2,4,5);
label=gtk_label_new(_("Tag"));
align=gtk_alignment_new(1,0.5,0,0);
gtk_container_add(GTK_CONTAINER(align),label);
gtk_table_attach(GTK_TABLE(table),align,0,1,5,6,
(GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) 0,0,0);
char *tags[]={"",
"a",
"applet",
"area",
"bgsound",
"blockqute",
"body",
"col",
"del",
"div",
"embed",
"fig",
"frame",
"head",
"iframe",
"img",
"input",
"ins",
"layer",
"link",
"meta",
"object",
"overlay",
"q",
"table",
"tbody",
"td",
"tfoot",
"th",
"thead",
"script",
"sound",
"span"
};
/*
list=(GList*)NULL;
edit->tag=gtk_combo_new();
for (unsigned int i=0;i<sizeof(tags)/sizeof(char*);i++)
list = g_list_append (list, tags[i]);
gtk_combo_set_popdown_strings (GTK_COMBO (edit->tag), list);
g_list_free(list);
gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(edit->tag)->entry),FALSE);
*/
edit->tag=gtk_combo_box_entry_new_text();
for (unsigned int i=0;i<sizeof(tags)/sizeof(char*);i++)
gtk_combo_box_append_text (GTK_COMBO_BOX (edit->tag),tags[i]);
set_editable_for_combo(edit->tag,FALSE);
gtk_table_attach_defaults(GTK_TABLE(table),edit->tag,1,2,5,6);
GtkWidget *hbox=gtk_hbox_new(FALSE,0);
edit->include=gtk_radio_button_new_with_label((GSList *)NULL,
_("include"));
edit->exclude=gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(edit->include)),
_("exclude"));
gtk_box_pack_start(GTK_BOX(hbox),edit->include,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox),edit->exclude,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(edit->vbox),hbox,FALSE,FALSE,0);
edit->ok_button=gtk_button_new_from_stock(GTK_STOCK_OK);
edit->cancel_button=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(edit->ok_button,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(edit->cancel_button,GTK_CAN_DEFAULT);
hbox=gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(hbox),5);
gtk_box_pack_start(GTK_BOX(hbox),edit->ok_button,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(hbox),edit->cancel_button,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(edit->vbox),hbox,TRUE,FALSE,0);
gtk_window_set_default(GTK_WINDOW(edit),edit->cancel_button);
};
guint d4x_rule_edit_get_type(){
static guint d4x_rule_edit_type=0;
if (!d4x_rule_edit_type){
GTypeInfo info={
sizeof(d4xRuleEditClass),
NULL,NULL,
(GClassInitFunc) d4x_rule_edit_class_init,
NULL,NULL,
sizeof(d4xRuleEdit),
0,
(GInstanceInitFunc)d4x_rule_edit_init
};
d4x_rule_edit_type=g_type_register_static(GTK_TYPE_WINDOW,"d4xRuleEdit",&info,(GTypeFlags)0);
};
return d4x_rule_edit_type;
};
GtkWidget *d4x_rule_edit_new(const d4x::Filter::Rule &rule){
d4xRuleEdit *edit=(d4xRuleEdit *)g_object_new(d4x_rule_edit_get_type(),NULL);
edit->rule=new d4x::Filter::Rule(rule);
text_to_combo(edit->host,rule.host.c_str());
if (rule.proto)
text_to_combo(edit->proto,get_name_by_proto(rule.proto));
text_to_combo(edit->path,rule.path.c_str());
text_to_combo(edit->file,rule.file.c_str());
text_to_combo(edit->params,rule.params.c_str());
text_to_combo(edit->tag,rule.tag.c_str());
GTK_TOGGLE_BUTTON(edit->include)->active=rule.include;
GTK_TOGGLE_BUTTON(edit->exclude)->active=!rule.include;
return GTK_WIDGET(edit);
};
void d4x_rule_edit_delete(GtkWidget *widget, GdkEvent *event,GtkWidget *edit){
gtk_widget_destroy(edit);
};
/************************************************************/
enum {
FE_COL_INC,
FE_COL_PROTO,
FE_COL_HOST,
FE_COL_PATH,
FE_COL_FILE,
FE_COL_PARAMS,
FE_COL_TAG,
FE_COL_RULE_ITER,
FE_COL_LAST
};
static gboolean destroy_filter_iterators(GtkTreeModel *model,GtkTreePath *path,
GtkTreeIter *iter,gpointer data){
GValue val={0,};
gtk_tree_model_get_value(model,iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
delete it;
g_value_unset(&val);
return FALSE;
};
static void d4x_filter_edit_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
d4xFilterEdit *edit=(d4xFilterEdit *)widget;
if (edit->filter){
delete(edit->filter);
edit->filter=0;
};
if (edit->iter){
gtk_tree_iter_free(edit->iter);
edit->iter=0;
};
if (edit->view){
gtk_tree_model_foreach(gtk_tree_view_get_model(edit->view),destroy_filter_iterators,0);
gtk_list_store_clear(edit->store);
edit->view=0;
};
if (GTK_OBJECT_CLASS (filter_parent_class)->destroy)
(* GTK_OBJECT_CLASS (filter_parent_class)->destroy) (widget);
};
void d4x_filter_edit_add_rule(d4xFilterEdit *edit,const d4x::Filter::Rule &rule,d4x::Filter::iterator *it){
GtkTreeIter iter;
gtk_list_store_append(edit->store,&iter);
gtk_list_store_set(edit->store,&(iter),
FE_COL_INC,rule.include?(char*)"+":(char*)("-"),
FE_COL_PROTO,rule.proto?get_name_by_proto(rule.proto):(char*)(""),
FE_COL_HOST,rule.host.c_str(),
FE_COL_PATH,rule.path.c_str(),
FE_COL_FILE,rule.file.c_str(),
FE_COL_PARAMS,rule.params.c_str(),
FE_COL_TAG,rule.tag.c_str(),
FE_COL_RULE_ITER,it,
-1);
};
static void d4x_filter_edit_add_ok(GtkWidget *widget,d4xRuleEdit *edit){
d4x_rule_edit_apply(edit);
d4x::Filter::iterator *it=new d4x::Filter::iterator(((d4xFilterEdit *)(edit->filter_edit))->filter->append(*(edit->rule)));
d4x_filter_edit_add_rule((d4xFilterEdit *)(edit->filter_edit),*(edit->rule),it);
gtk_widget_destroy(GTK_WIDGET(edit));
};
static void d4x_filter_edit_add_cancel(GtkWidget *widget,d4xRuleEdit *edit){
gtk_widget_destroy(GTK_WIDGET(edit));
};
static void d4x_filter_edit_add_delete(GtkWidget *widget,
GdkEvent *event,
d4xRuleEdit *edit){
gtk_widget_destroy(GTK_WIDGET(edit));
};
void d4x_filter_edit_add(GtkWidget *widget,d4xFilterEdit *edit){
d4xRuleEdit *ruleedit=(d4xRuleEdit *)d4x_rule_edit_new(d4x::Filter::Rule());
ruleedit->iter=0;
gtk_widget_show_all(GTK_WIDGET(ruleedit));
gtk_window_set_modal (GTK_WINDOW(ruleedit),TRUE);
gtk_window_set_transient_for (GTK_WINDOW (ruleedit),
GTK_WINDOW (edit));
ruleedit->filter_edit=(GtkWidget *)edit;
g_signal_connect(G_OBJECT(ruleedit->ok_button),"clicked",
G_CALLBACK(d4x_filter_edit_add_ok),
ruleedit);
g_signal_connect(G_OBJECT(ruleedit->cancel_button),"clicked",
G_CALLBACK(d4x_filter_edit_add_cancel),
ruleedit);
g_signal_connect(G_OBJECT(ruleedit),"delete_event",
G_CALLBACK(d4x_filter_edit_add_delete),
ruleedit);
d4x_eschandler_init(GTK_WIDGET(ruleedit),ruleedit);
};
static void d4x_filter_edit_edit_ok(GtkWidget *widget,d4xRuleEdit *edit){
d4xFilterEdit *filtedit=(d4xFilterEdit *)(edit->filter_edit);
d4x_rule_edit_apply(edit);
d4x::Filter::Rule *rule=edit->rule;
gtk_list_store_set(filtedit->store,edit->iter,
FE_COL_INC,rule->include?"+":"-",
FE_COL_PROTO,rule->proto?get_name_by_proto(rule->proto):"",
FE_COL_HOST,rule->host.c_str(),
FE_COL_PATH,rule->path.c_str(),
FE_COL_FILE,rule->file.c_str(),
FE_COL_PARAMS,rule->params.c_str(),
FE_COL_TAG,rule->tag.c_str(),
-1);
GValue val={0,};
gtk_tree_model_get_value(gtk_tree_view_get_model(filtedit->view),edit->iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
g_value_unset(&val);
gtk_widget_destroy(GTK_WIDGET(edit));
};
static void d4x_filter_edit_edit(GtkWidget *widget,d4xFilterEdit *edit){
GtkTreeSelection *sel=gtk_tree_view_get_selection(edit->view);
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(sel,&model,&iter)){
GValue val={0,};
gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
g_value_unset(&val);
d4xRuleEdit *ruleedit=(d4xRuleEdit *)d4x_rule_edit_new(**it);
ruleedit->filter_edit=(GtkWidget *)edit;
ruleedit->iter=gtk_tree_iter_copy(&iter);
g_signal_connect(G_OBJECT(ruleedit->ok_button),"clicked",
G_CALLBACK(d4x_filter_edit_edit_ok),
ruleedit);
g_signal_connect(G_OBJECT(ruleedit->cancel_button),"clicked",
G_CALLBACK(d4x_rule_edit_cancel),
ruleedit);
g_signal_connect(G_OBJECT(ruleedit),"delete_event",
G_CALLBACK(d4x_rule_edit_delete),
ruleedit);
d4x_eschandler_init(GTK_WIDGET(ruleedit),ruleedit);
gtk_widget_show_all(GTK_WIDGET(ruleedit));
gtk_window_set_modal (GTK_WINDOW(ruleedit),TRUE);
gtk_window_set_transient_for (GTK_WINDOW (ruleedit),
GTK_WINDOW (edit));
};
};
static void d4x_filter_edit_del(GtkWidget *widget,d4xFilterEdit *edit){
GtkTreeSelection *sel=gtk_tree_view_get_selection(edit->view);
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(sel,&model,&iter)){
GValue val={0,};
gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
g_value_unset(&val);
gtk_list_store_remove(edit->store,&iter);
edit->filter->remove(*it);
delete(it);
};
};
static void d4x_filter_edit_down(GtkWidget *widget,d4xFilterEdit *edit){
GtkTreeSelection *sel=gtk_tree_view_get_selection(edit->view);
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(sel,&model,&iter)){
GValue val={0,};
gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
g_value_unset(&val);
GtkTreeIter *prev=gtk_tree_iter_copy(&iter);
if (gtk_tree_model_iter_next(model,&iter)){
gtk_list_store_swap(edit->store,prev,&iter);
gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it2=(d4x::Filter::iterator *)g_value_get_pointer(&val);
std::iter_swap(*it,*it2);
g_value_unset(&val);
};
gtk_tree_iter_free(prev);
};
};
static void d4x_filter_edit_up(GtkWidget *widget,d4xFilterEdit *edit){
GtkTreeSelection *sel=gtk_tree_view_get_selection(edit->view);
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(sel,&model,&iter)){
GValue val={0,};
gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
g_value_unset(&val);
GtkTreePath *path=gtk_tree_model_get_path(model,&iter);
GtkTreeIter *next=gtk_tree_iter_copy(&iter);
if (gtk_tree_path_prev (path) && gtk_tree_model_get_iter(model,next,path)){
gtk_list_store_swap(edit->store,next,&iter);
gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
d4x::Filter::iterator *it2=(d4x::Filter::iterator *)g_value_get_pointer(&val);
std::iter_swap(*it,*it2);
g_value_unset(&val);
};
gtk_tree_path_free(path);
gtk_tree_iter_free(next);
};
};
static void d4x_filter_edit_cancel(GtkWidget *widget,d4xFilterEdit *edit){
gtk_widget_destroy(GTK_WIDGET(edit));
};
static gboolean d4x_filter_edit_select(GtkTreeView *view,GdkEventButton *event,d4xFilterEdit *edit) {
if (event && event->type==GDK_2BUTTON_PRESS && event->button==1){
d4x_filter_edit_edit(GTK_WIDGET(view),edit);
return TRUE;
};
return FALSE;
};
static void d4x_filter_edit_init(d4xFilterEdit *edit){
edit->filter=0;
edit->iter=0;
gtk_window_set_title(GTK_WINDOW (edit),_("Modify filter"));
gtk_window_set_resizable(GTK_WINDOW(edit),FALSE);
gtk_widget_set_size_request(GTK_WIDGET (edit),-1,400);
edit->vbox=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(edit),edit->vbox);
gtk_container_set_border_width(GTK_CONTAINER(edit->vbox),5);
gchar *titles[]={"",_("Protocol"),_("Host"),_("Path"),_("File"),"?",_("Tag")};
edit->store=gtk_list_store_new(FE_COL_LAST,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_POINTER);
edit->view=GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(edit->store)));
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
for (int i=0;i<FE_COL_RULE_ITER;i++){
renderer = gtk_cell_renderer_text_new ();
col=gtk_tree_view_column_new_with_attributes (titles[i],
renderer,
"text",i,
NULL);
gtk_tree_view_append_column (edit->view, col);
};
g_signal_connect(G_OBJECT(edit->view),
"event",
G_CALLBACK(d4x_filter_edit_select),
edit);
GtkWidget *scroll_window=gtk_scrolled_window_new((GtkAdjustment *)NULL,(GtkAdjustment *)NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(scroll_window),GTK_WIDGET(edit->view));
gtk_box_pack_start(GTK_BOX(edit->vbox),scroll_window,TRUE,TRUE,0);
edit->include=gtk_radio_button_new_with_label((GSList *)NULL,
_("include by default"));
edit->exclude=gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(edit->include)),
_("exclude by default"));
gtk_box_pack_start(GTK_BOX(edit->vbox),edit->include,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(edit->vbox),edit->exclude,FALSE,FALSE,0);
GtkWidget *hbox=gtk_hbox_new(FALSE,5);
GtkWidget *label=gtk_label_new(_("Name of filter"));
edit->name=gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
gtk_box_pack_start_defaults(GTK_BOX(hbox),edit->name);
gtk_box_pack_start(GTK_BOX(edit->vbox),hbox,FALSE,FALSE,3);
GtkWidget *bbox1=gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(bbox1),5);
gtk_box_pack_start(GTK_BOX(edit->vbox),bbox1,FALSE,FALSE,3);
GtkWidget *up=gtk_button_new_from_stock(GTK_STOCK_GO_UP);
gtk_box_pack_start(GTK_BOX(bbox1),up,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(up),"clicked",
G_CALLBACK(d4x_filter_edit_up),edit);
GtkWidget *down=gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
gtk_box_pack_start(GTK_BOX(bbox1),down,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(down),"clicked",
G_CALLBACK(d4x_filter_edit_down),edit);
GtkWidget *add=gtk_button_new_from_stock(GTK_STOCK_ADD);
gtk_box_pack_start(GTK_BOX(bbox1),add,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(add),"clicked",
G_CALLBACK(d4x_filter_edit_add),edit);
GtkWidget *del=gtk_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_box_pack_start(GTK_BOX(bbox1),del,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(del),"clicked",
G_CALLBACK(d4x_filter_edit_del),edit);
edit->edit=gtk_button_new_from_stock(GTK_STOCK_PROPERTIES);
gtk_box_pack_start(GTK_BOX(bbox1),edit->edit,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(edit->edit),"clicked",
G_CALLBACK(d4x_filter_edit_edit),edit);
GtkWidget *bbox2=gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(bbox2),5);
gtk_box_pack_start(GTK_BOX(edit->vbox),bbox2, FALSE,FALSE,0);
GtkWidget *cancel=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_box_pack_start(GTK_BOX(bbox2),cancel,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(cancel),"clicked",
G_CALLBACK(d4x_filter_edit_cancel),edit);
edit->ok=gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_box_pack_start(GTK_BOX(bbox2),edit->ok,FALSE,FALSE,0);
GTK_WIDGET_SET_FLAGS(edit->ok,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(del,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(edit->edit,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(cancel,GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(edit),edit->ok);
};
static void d4x_filter_edit_class_init(d4xFilterEditClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=d4x_filter_edit_destroy;
filter_parent_class=(GtkWidgetClass *)gtk_type_class(gtk_window_get_type());
};
guint d4x_filter_edit_get_type(){
static guint d4x_filter_edit_type=0;
if (!d4x_filter_edit_type){
GTypeInfo info={
sizeof(d4xFilterEditClass),
NULL,NULL,
(GClassInitFunc) d4x_filter_edit_class_init,
NULL,NULL,
sizeof(d4xFilterEdit),
0,
(GInstanceInitFunc)d4x_filter_edit_init
};
d4x_filter_edit_type=g_type_register_static(GTK_TYPE_WINDOW,"d4xFilterEdit",&info,(GTypeFlags)0);
};
return d4x_filter_edit_type;
};
struct PopulateFilter{
d4xFilterEdit *edit;
PopulateFilter(d4xFilterEdit *e):edit(e){};
void operator()(d4x::Filter::iterator it){
d4x_filter_edit_add_rule(edit,*it,new d4x::Filter::iterator(it));
};
};
GtkWidget *d4x_filter_edit_new(const d4x::Filter &filter){
d4xFilterEdit *edit=(d4xFilterEdit *)g_object_new(d4x_filter_edit_get_type(),NULL);
edit->filter=new d4x::Filter(filter);
edit->filter->each_iter(PopulateFilter(edit));
text_to_combo(edit->name,filter.name.c_str());
GTK_TOGGLE_BUTTON(edit->include)->active=filter.include;
GTK_TOGGLE_BUTTON(edit->exclude)->active=!filter.include;
return GTK_WIDGET(edit);
};
/**********************************************************/
static void d4x_filter_sel_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
if (GTK_OBJECT_CLASS (filtersel_parent_class)->destroy)
(* GTK_OBJECT_CLASS (filtersel_parent_class)->destroy) (widget);
};
static void d4x_filter_sel_init(d4xFilterSel *sel){
gtk_window_set_wmclass(GTK_WINDOW(sel),
"D4X_FilterSel","D4X");
gtk_widget_set_size_request(GTK_WIDGET(sel),-1,300);
gtk_window_set_title(GTK_WINDOW(sel),_("Select filter"));
GtkListStore *list_store = gtk_list_store_new(2,
G_TYPE_STRING,
G_TYPE_POINTER);
sel->view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)));
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
renderer = gtk_cell_renderer_text_new();
col=gtk_tree_view_column_new_with_attributes(_("filter name"),
renderer,
"text",0,
NULL);
gtk_tree_view_set_headers_visible(sel->view,TRUE);
gtk_tree_view_column_set_visible(col,TRUE);
gtk_tree_view_append_column(sel->view,col);
GtkWidget *scroll_window=gtk_scrolled_window_new((GtkAdjustment*)NULL,(GtkAdjustment*)NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scroll_window),GTK_WIDGET(sel->view));
sel->ok=gtk_button_new_from_stock(GTK_STOCK_OK);
sel->cancel=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(sel->ok,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(sel->cancel,GTK_CAN_DEFAULT);
GtkWidget *vbox=gtk_vbox_new(FALSE,5);
GtkWidget *hbox=gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(hbox),5);
gtk_box_pack_start(GTK_BOX(vbox),scroll_window,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(hbox),sel->ok,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(hbox),sel->cancel,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(sel),vbox);
gtk_window_set_default(GTK_WINDOW(sel),sel->ok);
// adding empty line to select no filter
GtkTreeIter iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter,
0,"",
1,NULL,
-1);
// FILTERS_DB.each(sel);
};
static void d4x_filter_sel_class_init(d4xFilterSelClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=d4x_filter_sel_destroy;
filtersel_parent_class=(GtkWidgetClass *)gtk_type_class(gtk_window_get_type());
};
guint d4x_filter_sel_get_type(){
static guint d4x_filter_sel_type=0;
if (!d4x_filter_sel_type){
GTypeInfo info={
sizeof(d4xFilterSelClass),
NULL,NULL,
(GClassInitFunc) d4x_filter_sel_class_init,
NULL,NULL,
sizeof(d4xFilterSel),
0,
(GInstanceInitFunc)d4x_filter_sel_init
};
d4x_filter_sel_type=g_type_register_static (GTK_TYPE_WINDOW,"d4xFilterSel",&info,(GTypeFlags)0);
};
return d4x_filter_sel_type;
};
GtkWidget *d4x_filter_sel_new(){
d4xFilterSel *sel=(d4xFilterSel *)g_object_new(d4x_filter_sel_get_type(),NULL);
//FIXME: what about fill list?
FILTERS_DB.each_name(PopulateFilters(GTK_LIST_STORE(gtk_tree_view_get_model(sel->view))));
gtk_widget_show_all(GTK_WIDGET(sel));
return GTK_WIDGET(sel);
};
void d4x_filter_sel_to_combo(d4xFilterSel *sel,GtkWidget *combo){
GtkTreeSelection *s=gtk_tree_view_get_selection(sel->view);
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_selection_get_selected(s,&model,&iter)){
GValue val={0,};
gtk_tree_model_get_value(model,&iter,0,&val);
const char *name=g_value_get_string(&val);
text_to_combo(combo,(char*)name);
g_value_unset(&val);
}else
text_to_combo(combo,"");
};
/********************************************************/
static void d4x_links_sel_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
if (GTK_OBJECT_CLASS (linkssel_parent_class)->destroy)
(* GTK_OBJECT_CLASS (linkssel_parent_class)->destroy) (widget);
};
void d4x_links_sel_del(d4xLinksSel *sel,GtkTreeIter *iter){
GtkListStore *store=GTK_LIST_STORE(gtk_tree_view_get_model(sel->view));
gtk_list_store_remove(store,iter);
};
static void d4x_links_sel_remove(GtkWidget *button,d4xLinksSel *sel){
GtkTreeSelection *s=gtk_tree_view_get_selection(sel->view);
tQueue q;
gtk_tree_selection_selected_foreach(s,
_foreach_remove_prepare_,
&q);
tNode *t=q.last();
while(t){
d4x_links_sel_del(sel,((tmpIterNode*)t)->iter);
t=t->next;
};
};
void d4x_links_sel_set(d4xLinksSel *sel,GtkTreeIter *iter,const char *url,gpointer p){
GtkListStore *list_store=GTK_LIST_STORE(gtk_tree_view_get_model(sel->view));
gtk_list_store_set(list_store, iter,
0,url,
1,p,
-1);
};
gpointer d4x_links_sel_get_data(d4xLinksSel *sel,GtkTreeIter *iter){
GtkTreeModel *model=gtk_tree_view_get_model(sel->view);
GValue val={0,};
gtk_tree_model_get_value(model,iter,1,&val);
gpointer p=g_value_get_pointer(&val);
g_value_unset(&val);
return(p);
};
void d4x_links_sel_selected_foreach(d4xLinksSel *sel,d4xLinksSelForeachFunc func,gpointer data){
GtkTreeSelection *s=gtk_tree_view_get_selection(sel->view);
GtkTreeModel *model=gtk_tree_view_get_model(sel->view);
tQueue q;
gtk_tree_selection_selected_foreach(s,
_foreach_remove_prepare_,
&q);
tNode *t=q.last();
while(t){
GValue val={0,};
gtk_tree_model_get_value(model,((tmpIterNode*)t)->iter,1,&val);
gpointer p=g_value_get_pointer(&val);
g_value_unset(&val);
gtk_tree_model_get_value(model,((tmpIterNode*)t)->iter,0,&val);
const gchar *s=g_value_get_string(&val);
func(sel,((tmpIterNode*)t)->iter,s,p,data);
g_value_unset(&val);
t=t->next;
};
};
static void d4x_links_sel_cancel(GtkWidget *button,d4xLinksSel *sel){
gtk_widget_destroy(GTK_WIDGET(sel));
}
static void d4x_links_sel_delete(GtkWindow *window,
GdkEvent *event,
d4xLinksSel *sel){
gtk_widget_destroy(GTK_WIDGET(sel));
};
static void d4x_links_sel_init(d4xLinksSel *sel){
gtk_window_set_wmclass(GTK_WINDOW(sel),
"D4X_LinksSel","D4X");
d4x_eschandler_init(GTK_WIDGET(sel),sel);
gtk_widget_set_size_request(GTK_WIDGET(sel),-1,300);
gtk_window_set_title(GTK_WINDOW(sel),_("List of links"));
GtkListStore *list_store = gtk_list_store_new(2,
G_TYPE_STRING,
G_TYPE_POINTER);
sel->view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)));
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
renderer = gtk_cell_renderer_text_new();
col=gtk_tree_view_column_new_with_attributes(_("URL"),
renderer,
"text",0,
NULL);
gtk_tree_view_set_headers_visible(sel->view,TRUE);
gtk_tree_view_column_set_visible(col,TRUE);
gtk_tree_view_append_column(sel->view,col);
col=gtk_tree_view_get_column(sel->view,0);
GtkWidget *scroll_window=gtk_scrolled_window_new((GtkAdjustment*)NULL,(GtkAdjustment*)NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scroll_window),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scroll_window),GTK_WIDGET(sel->view));
sel->ok=gtk_button_new_from_stock(GTK_STOCK_OK);
sel->remove=gtk_button_new_from_stock(GTK_STOCK_REMOVE);
sel->cancel=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(sel->ok,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(sel->remove,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(sel->cancel,GTK_CAN_DEFAULT);
GtkWidget *vbox=sel->vbox=gtk_vbox_new(FALSE,5);
sel->hbbox=gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(sel->hbbox),5);
gtk_box_pack_start(GTK_BOX(vbox),scroll_window,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(vbox),sel->hbbox,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(sel->hbbox),sel->ok,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(sel->hbbox),sel->remove,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(sel),vbox);
gtk_window_set_default(GTK_WINDOW(sel),sel->ok);
};
static void d4x_links_sel_class_init(d4xLinksSelClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=d4x_links_sel_destroy;
linkssel_parent_class=(GtkWidgetClass *)gtk_type_class(gtk_window_get_type());
};
guint d4x_links_sel_get_type(){
static guint d4x_links_sel_type=0;
if (!d4x_links_sel_type){
GTypeInfo info={
sizeof(d4xLinksSelClass),
NULL,NULL,
(GClassInitFunc) d4x_links_sel_class_init,
NULL,NULL,
sizeof(d4xLinksSel),
0,
(GInstanceInitFunc)d4x_links_sel_init
};
d4x_links_sel_type = g_type_register_static (GTK_TYPE_WINDOW,"d4xLinksSel",&info,(GTypeFlags)0);
};
return d4x_links_sel_type;
};
GtkWidget *d4x_links_sel_new_with_add(){
d4xLinksSel *sel=(d4xLinksSel *)g_object_new(d4x_links_sel_get_type(),NULL);
sel->find=gtk_button_new_from_stock(GTK_STOCK_FIND);
GTK_WIDGET_SET_FLAGS(sel->find,GTK_CAN_DEFAULT);
gtk_box_pack_end(GTK_BOX(sel->hbbox),sel->find,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(sel->hbbox),sel->cancel,FALSE,FALSE,0);
gtk_button_set_label(GTK_BUTTON(sel->cancel),_("Add"));
gtk_widget_show_all(GTK_WIDGET(sel));
return GTK_WIDGET(sel);
};
GtkWidget *d4x_links_sel_new_with_referer(const char *ref){
d4xLinksSel *sel=(d4xLinksSel *)d4x_links_sel_new();
sel->referer=gtk_entry_new();
sel->directory=gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(sel->referer),ref);
GtkWidget *lab=gtk_label_new(_("Referer:"));
gtk_box_pack_start(GTK_BOX(sel->vbox),lab,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(sel->vbox),sel->referer,FALSE,FALSE,0);
gtk_box_reorder_child(GTK_BOX(sel->vbox),lab,1);
gtk_box_reorder_child(GTK_BOX(sel->vbox),sel->referer,2);
lab=gtk_label_new(_("Store into directory:"));
gtk_box_pack_start(GTK_BOX(sel->vbox),lab,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(sel->vbox),sel->directory,FALSE,FALSE,0);
gtk_widget_set_sensitive(sel->directory,FALSE);
gtk_box_reorder_child(GTK_BOX(sel->vbox),lab,3);
gtk_box_reorder_child(GTK_BOX(sel->vbox),sel->directory,4);
gtk_widget_show_all(GTK_WIDGET(sel));
return GTK_WIDGET(sel);
};
GtkWidget *d4x_links_sel_new(){
d4xLinksSel *sel=(d4xLinksSel *)g_object_new(d4x_links_sel_get_type(),NULL);
gtk_box_pack_end(GTK_BOX(sel->hbbox),sel->cancel,FALSE,FALSE,0);
g_signal_connect(G_OBJECT(sel),"delete_event",
G_CALLBACK(d4x_links_sel_delete), sel);
g_signal_connect(G_OBJECT(sel->remove),"clicked",
G_CALLBACK(d4x_links_sel_remove),
sel);
g_signal_connect(G_OBJECT(sel->cancel),"clicked",
G_CALLBACK(d4x_links_sel_cancel),
sel);
gtk_widget_show_all(GTK_WIDGET(sel));
return GTK_WIDGET(sel);
};
void d4x_links_sel_add(d4xLinksSel *sel,const char *url,gpointer p){
GtkListStore *list_store=GTK_LIST_STORE(gtk_tree_view_get_model(sel->view));
GtkTreeIter iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter,
0,url,
1,p,
-1);
};
struct d4xSelTmp{
gpointer data;
d4xLinksSelForeachFunc func;
d4xLinksSel *sel;
};
static gboolean _tmp_sel_foreach_(GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data){
d4xSelTmp *tmp=(d4xSelTmp *)data;
GValue val={0,};
gtk_tree_model_get_value(model,iter,1,&val);
gpointer p=g_value_get_pointer(&val);
g_value_unset(&val);
gtk_tree_model_get_value(model,iter,0,&val);
const gchar *s=g_value_get_string(&val);
tmp->func(tmp->sel,iter,s,p,tmp->data);
g_value_unset(&val);
return FALSE;
};
void d4x_links_sel_foreach(d4xLinksSel *sel,d4xLinksSelForeachFunc func,gpointer data){
GtkTreeModel *store=gtk_tree_view_get_model(sel->view);
d4xSelTmp a={data,func,sel};
gtk_tree_model_foreach(store,_tmp_sel_foreach_,&a);
};
void d4x_links_sel_clear(d4xLinksSel *sel){
GtkListStore *store=GTK_LIST_STORE(gtk_tree_view_get_model(sel->view));
gtk_list_store_clear(store);
};
/********************************************************/
static void d4x_string_edit_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
if (GTK_OBJECT_CLASS (stringedit_parent_class)->destroy)
(* GTK_OBJECT_CLASS (stringedit_parent_class)->destroy) (widget);
};
static void d4x_string_edit_class_init(d4xStringEditClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=d4x_string_edit_destroy;
stringedit_parent_class=(GtkWidgetClass *)gtk_type_class(gtk_window_get_type());
};
static void d4x_string_edit_init(d4xStringEdit *sel){
gtk_window_set_wmclass(GTK_WINDOW(sel),
"D4X_EditString","D4X");
d4x_eschandler_init(GTK_WIDGET(sel),sel);
gtk_widget_set_size_request(GTK_WIDGET(sel),400,-1);
GtkWidget *vbox=gtk_vbox_new(FALSE,5);
GtkWidget *hbbox=gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(hbbox),5);
sel->ok=gtk_button_new_from_stock(GTK_STOCK_OK);
sel->cancel=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(sel->ok,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(sel->cancel,GTK_CAN_DEFAULT);
sel->entry=(GtkEntry*)gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(sel->entry),TRUE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbbox,TRUE,FALSE,0);
gtk_box_pack_end(GTK_BOX(hbbox),sel->ok,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(hbbox),sel->cancel,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(sel),vbox);
gtk_window_set_default(GTK_WINDOW(sel),sel->cancel);
};
guint d4x_string_edit_get_type(){
static guint d4x_string_edit_type=0;
if (!d4x_string_edit_type){
GTypeInfo info={
sizeof(d4xStringEditClass),
NULL,NULL,
(GClassInitFunc) d4x_string_edit_class_init,
NULL,NULL,
sizeof(d4xStringEdit),
0,
(GInstanceInitFunc)d4x_string_edit_init
};
d4x_string_edit_type = g_type_register_static (GTK_TYPE_WINDOW,"d4xStringEdit",&info,(GTypeFlags)0);
};
return d4x_string_edit_type;
};
GtkWidget *d4x_string_edit_new(){
d4xStringEdit *edit=(d4xStringEdit *)g_object_new(d4x_string_edit_get_type(),NULL);
gtk_widget_show_all(GTK_WIDGET(edit));
return GTK_WIDGET(edit);
};
/********************************************************/
static void d4x_alt_edit_destroy(GtkObject *widget){
g_return_if_fail(widget!=NULL);
if (GTK_OBJECT_CLASS (altedit_parent_class)->destroy)
(* GTK_OBJECT_CLASS (altedit_parent_class)->destroy) (widget);
};
static void d4x_alt_edit_class_init(d4xAltEditClass *klass){
GtkObjectClass *object_class=(GtkObjectClass *)klass;
object_class->destroy=d4x_alt_edit_destroy;
altedit_parent_class=(GtkWidgetClass *)gtk_type_class(gtk_window_get_type());
};
static void _alt_proxy_host_changed_(GtkEntry *entry,d4xAltEdit *parent){
const char *tmp=gtk_entry_get_text(entry);
tmp=index(tmp,':');
if (tmp){
int a=0;
if (sscanf(tmp+1,"%i",&a)==1){
char str[100];
sprintf(str,"%i",a);
gtk_entry_set_text(GTK_ENTRY(parent->proxy_port),str);
};
};
};
static void _alt_proxy_toggle_(GtkWidget *parent,d4xAltEdit *where) {
gtk_widget_set_sensitive(where->proxy_view,GTK_TOGGLE_BUTTON(parent)->active);
/*
if (GTK_TOGGLE_BUTTON(parent)->active)
gtk_widget_show(where->proxy_view);
else
gtk_widget_hide(where->proxy_view);
gtk_widget_set_size_request(GTK_WIDGET(where),-1,-1);
*/
// gtk_window_reshow_with_initial_size (GTK_WINDOW(where));
};
static void _alt_proxy_toggle_pass_(GtkWidget *parent,d4xAltEdit *where) {
set_editable_for_combo(where->proxy_pass,GTK_TOGGLE_BUTTON(parent)->active);
set_editable_for_combo(where->proxy_user,GTK_TOGGLE_BUTTON(parent)->active);
gtk_widget_set_sensitive(where->proxy_user,GTK_TOGGLE_BUTTON(parent)->active);
gtk_widget_set_sensitive(where->proxy_pass,GTK_TOGGLE_BUTTON(parent)->active);
};
static void d4x_alt_edit_size_request(GtkWidget *widget,GtkAllocation *a,gpointer p){
printf("A:%ix%i\n",a->width,a->height);
};
static void d4x_alt_edit_init(d4xAltEdit *sel){
gtk_window_set_wmclass(GTK_WINDOW(sel),
"D4X_AltEdit","D4X");
d4x_eschandler_init(GTK_WIDGET(sel),sel);
gtk_window_set_resizable (GTK_WINDOW(sel),FALSE);
gtk_window_set_default_size(GTK_WINDOW(sel),0,0);
// gtk_widget_set_size_request(GTK_WIDGET(sel),400,-1);
// g_signal_connect(G_OBJECT(sel),"size_request",
// G_CALLBACK(d4x_alt_edit_size_request), NULL);
// g_signal_connect(G_OBJECT(sel),"size_allocate",
// G_CALLBACK(d4x_alt_edit_size_request), NULL);
GtkWidget *vbox=gtk_vbox_new(FALSE,5);
GtkWidget *hbbox=gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(hbbox),5);
sel->ok=gtk_button_new_from_stock(GTK_STOCK_OK);
sel->cancel=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(sel->ok,GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(sel->cancel,GTK_CAN_DEFAULT);
sel->entry=(GtkEntry*)gtk_entry_new();
GtkWidget *hbox=gtk_hbox_new(FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox),GTK_WIDGET(sel->entry),TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(hbox),gtk_label_new(_("URL")),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
GtkWidget *proxy_frame=gtk_frame_new(_("proxy type"));
sel->proxy_type_http=gtk_radio_button_new_with_label(NULL,"HTTP");
GSList *proxy_group1=gtk_radio_button_get_group(GTK_RADIO_BUTTON(sel->proxy_type_http));
sel->proxy_type_ftp=gtk_radio_button_new_with_label(proxy_group1,_("FTP (wingate)"));
// GtkWidget *table=gtk_table_new(2,1,FALSE);
// gtk_container_add(GTK_CONTAINER(proxy_frame),table);
// gtk_table_attach_defaults(GTK_TABLE(table),sel->proxy_type_ftp,0,1,0,1);
// gtk_table_attach_defaults(GTK_TABLE(table),sel->proxy_type_http,0,1,1,2);
GtkWidget *vbox1=gtk_vbox_new(FALSE,5);
gtk_box_pack_start(GTK_BOX(vbox1),sel->proxy_type_http,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox1),sel->proxy_type_ftp,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(proxy_frame),vbox1);
GtkWidget *hboxproxy=gtk_hbox_new(FALSE,0);
GtkWidget *vboxproxy=gtk_vbox_new(FALSE,0);
sel->proxy_use_check=gtk_check_button_new_with_label(_("Use different proxy for this alternate"));
g_signal_connect(G_OBJECT(sel->proxy_use_check),"clicked",G_CALLBACK(_alt_proxy_toggle_),sel);
gtk_box_pack_start(GTK_BOX(vbox),sel->proxy_use_check,FALSE,FALSE,0);
sel->proxy_host=my_gtk_combo_new(ALL_HISTORIES[PROXY_HISTORY]);
text_to_combo(sel->proxy_host,"");
sel->proxy_port=my_gtk_entry_new_with_max_length(5,0);
g_signal_connect (G_OBJECT (GTK_BIN(sel->proxy_host)->child),
"changed",
G_CALLBACK(_alt_proxy_host_changed_), sel);
gtk_box_pack_start(GTK_BOX(vboxproxy),sel->proxy_host,TRUE,FALSE,0);
GtkWidget *label=gtk_label_new(_("port"));
GtkWidget *hbox1=gtk_hbox_new(FALSE,3);
gtk_box_pack_start(GTK_BOX(hbox1),sel->proxy_port,FALSE,0,0);
gtk_box_pack_start(GTK_BOX(hbox1),label,FALSE,0,0);
gtk_box_pack_start(GTK_BOX(vboxproxy),hbox1,TRUE,FALSE,0);
sel->proxy_user_check=gtk_check_button_new_with_label(_("need password"));
g_signal_connect(G_OBJECT(sel->proxy_user_check),"clicked",G_CALLBACK(_alt_proxy_toggle_pass_),sel);
gtk_box_pack_start(GTK_BOX(vboxproxy),sel->proxy_user_check,FALSE,0,0);
sel->proxy_user=my_gtk_combo_new(ALL_HISTORIES[USER_HISTORY]);
gtk_widget_set_size_request(sel->proxy_user,100,-1);
label=gtk_label_new(_("username"));
hbox1=gtk_hbox_new(FALSE,3);
gtk_box_pack_start(GTK_BOX(hbox1),sel->proxy_user,FALSE,0,0);
gtk_box_pack_start(GTK_BOX(hbox1),label,FALSE,0,0);
gtk_box_pack_start(GTK_BOX(vboxproxy),hbox1,TRUE,FALSE,0);
if (CFG.REMEMBER_PASS)
sel->proxy_pass=my_gtk_combo_new(ALL_HISTORIES[PASS_HISTORY]);
else{
sel->proxy_pass=gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(sel->proxy_pass),FALSE);
};
gtk_widget_set_size_request(sel->proxy_pass,100,-1);
label=gtk_label_new(_("password"));
hbox1=gtk_hbox_new(FALSE,3);
gtk_box_pack_start(GTK_BOX(hbox1),sel->proxy_pass,FALSE,0,0);
gtk_box_pack_start(GTK_BOX(hbox1),label,FALSE,0,0);
gtk_box_pack_start(GTK_BOX(vboxproxy),hbox1,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(hboxproxy),vboxproxy,FALSE,FALSE,0);
vbox1=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox1),proxy_frame,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox1),gtk_hbox_new(FALSE,0),TRUE,FALSE,0);
gtk_box_pack_start(GTK_BOX(hboxproxy),vbox1,FALSE,FALSE,0);
sel->proxy_view=hboxproxy;
gtk_box_pack_start(GTK_BOX(vbox),hboxproxy,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbbox,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(hbbox),sel->ok,FALSE,FALSE,0);
gtk_box_pack_end(GTK_BOX(hbbox),sel->cancel,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(sel),vbox);
gtk_window_set_default(GTK_WINDOW(sel),sel->cancel);
};
guint d4x_alt_edit_get_type(){
static guint d4x_alt_edit_type=0;
if (!d4x_alt_edit_type){
GTypeInfo info={
sizeof(d4xAltEditClass),
NULL,NULL,
(GClassInitFunc) d4x_alt_edit_class_init,
NULL,NULL,
sizeof(d4xAltEdit),
0,
(GInstanceInitFunc)d4x_alt_edit_init
};
d4x_alt_edit_type = g_type_register_static (GTK_TYPE_WINDOW,"d4xAltEdit",&info,(GTypeFlags)0);
};
return d4x_alt_edit_type;
};
GtkWidget *d4x_alt_edit_new(){
d4xAltEdit *edit=(d4xAltEdit *)g_object_new(d4x_alt_edit_get_type(),NULL);
gtk_widget_show_all(GTK_WIDGET(edit));
gtk_widget_set_sensitive(edit->proxy_view,FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit->proxy_user_check),FALSE);
gtk_widget_set_sensitive(edit->proxy_user,FALSE);
gtk_widget_set_sensitive(edit->proxy_pass,FALSE);
return GTK_WIDGET(edit);
};
void d4x_alt_edit_set(d4xAltEdit *sel,const d4x::URL &info){
if (!info.host.empty()){
if (info.proto==D_PROTO_FTP)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_type_ftp),TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_type_http),TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_use_check),TRUE);
gtk_widget_set_sensitive(sel->proxy_view,TRUE);
text_to_combo(sel->proxy_host,info.host.c_str());
char data[100];
sprintf(data,"%i",info.port);
text_to_combo(sel->proxy_port,data);
if (!info.user.empty() && !info.pass.empty()){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_user_check),TRUE);
text_to_combo(sel->proxy_user,info.user.c_str());
text_to_combo(sel->proxy_pass,info.pass.c_str());
ALL_HISTORIES[USER_HISTORY]->add(info.user.c_str());
}else{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_user_check),FALSE);
};
}else{
gtk_widget_set_sensitive(sel->proxy_view,FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_use_check),FALSE);
};
};
void d4x_alt_edit_get(d4xAltEdit *sel,d4x::URL &info){
if (GTK_TOGGLE_BUTTON(sel->proxy_use_check)->active && strlen(text_from_combo(sel->proxy_host))){
if (GTK_TOGGLE_BUTTON(sel->proxy_type_ftp)->active)
info.proto=D_PROTO_FTP;
else
info.proto=D_PROTO_HTTP;
info.host=text_from_combo(sel->proxy_host);
info.host=info.host.substr(0,info.host.find(':'));
sscanf(text_from_combo(sel->proxy_port),"%i",&(info.port));
info.path.clear();
info.file.clear();
if (GTK_TOGGLE_BUTTON(sel->proxy_user_check)->active
&& strlen(text_from_combo(sel->proxy_user))
&& strlen(text_from_combo(sel->proxy_pass))){
info.user=text_from_combo(sel->proxy_user);
info.pass=text_from_combo(sel->proxy_pass);
}else{
info.user.clear();
info.pass.clear();
};
make_proxy_host(info.host.c_str(),info.port);
}else{
info.clear();
};
};
/********************************************************/
static GtkRadioButtonClass *vbookmark_parent_class=NULL;
static GtkButtonClass *vbookmark_parent_class1=NULL;
static GtkBinClass *vbookmark_parent_class2=NULL;
static gint my_gtk_vbookmark_expose (GtkWidget *widget, GdkEventExpose *event){
if (GTK_WIDGET_DRAWABLE (widget)){
gint x=widget->allocation.x;
gint y=widget->allocation.y;
gint w=widget->allocation.width;
gint h=widget->allocation.height;
GtkStateType state_type=GtkStateType(GTK_WIDGET_STATE(widget));
if (!GTK_TOGGLE_BUTTON(widget)->active)
x+=2;
if (state_type==GTK_STATE_ACTIVE || state_type==GTK_STATE_PRELIGHT){
state_type=GTK_STATE_NORMAL;
}else{
state_type=GTK_STATE_ACTIVE;
};
gtk_paint_extension(widget->style, widget->window,
state_type, GTK_SHADOW_OUT,
&(event->area), widget, "tab",
x, y,
w,h,
GTK_POS_RIGHT);
((GtkWidgetClass *)(vbookmark_parent_class2))->expose_event (widget, event);
};
return(FALSE);
};
static void my_gtk_vbookmark_size_request (GtkWidget *widget,
GtkRequisition *requisition){
((GtkWidgetClass *)(vbookmark_parent_class1))->size_request(widget,requisition);
};
static void my_gtk_vbookmark_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
((GtkWidgetClass *)(vbookmark_parent_class1))->size_allocate(widget,allocation);
};
static void my_gtk_vbookmark_init(MyGtkVbookmark *graph){
};
static void my_gtk_vbookmark_class_init(MyGtkVbookmarkClass *klass){
GtkWidgetClass *widget_class=(GtkWidgetClass *)klass;
widget_class->expose_event = my_gtk_vbookmark_expose;
widget_class->size_request = my_gtk_vbookmark_size_request;
widget_class->size_allocate = my_gtk_vbookmark_size_allocate;
vbookmark_parent_class=(GtkRadioButtonClass *)gtk_type_class(gtk_radio_button_get_type());
vbookmark_parent_class1=(GtkButtonClass *)gtk_type_class(gtk_button_get_type());
vbookmark_parent_class2=(GtkBinClass *)gtk_type_class(gtk_bin_get_type());
};
GtkType my_gtk_vbookmark_get_type (void){
static GtkType vbookmark_type = 0;
if (!vbookmark_type) {
static const GTypeInfo vbookmark_info={
sizeof (MyGtkVbookmarkClass),
NULL,NULL,
(GClassInitFunc) my_gtk_vbookmark_class_init,
NULL,NULL,
sizeof (MyGtkVbookmark),
0,
(GInstanceInitFunc)my_gtk_vbookmark_init
};
vbookmark_type = g_type_register_static (GTK_TYPE_RADIO_BUTTON,"MyGtkVbookmark",&vbookmark_info,(GTypeFlags)0);
}
return vbookmark_type;
}
GtkWidget *my_gtk_vbookmark_new(GSList *group){
MyGtkVbookmark *vb=(MyGtkVbookmark *)g_object_new(my_gtk_vbookmark_get_type(),NULL);
if (group) gtk_radio_button_set_group (GTK_RADIO_BUTTON(vb), group);
return GTK_WIDGET(vb);
};
GtkWidget *my_gtk_vbookmark_new_with_label(GSList *group,const gchar *label){
MyGtkVbookmark *vb=(MyGtkVbookmark *)g_object_new(my_gtk_vbookmark_get_type(),
"label",label,NULL);
if (group) gtk_radio_button_set_group (GTK_RADIO_BUTTON(vb), group);
return GTK_WIDGET(vb);
};
syntax highlighted by Code2HTML, v. 0.9.1