← Back to branch summary

~ubuntu-branches/ubuntu/utopic/d4x/utopic

« back to all changes in this revision

Viewing changes to main/face/mywidget.cc

  • Committer: Bazaar Package Importer
  • Author(s): Michael Ablassmeier
  • Date: 2006-10-04 10:37:26 UTC
  • mfrom: (2.1.5 edgy)
  • Revision ID: james.westby@ubuntu.com-20061004103726-hgy0n1ujphwdapsf
Tags: 2.5.7.1-4
http://bugs.debian.org/39094
* QA upload.
* Add Replaces: d4x <= 2.5.0rel-4 for d4x-common in order to
  allow upgrade from old sarge version. (Closes: #39094)

Show diffs side-by-side

added added

removed removed

Lines of Context:
main/face/mywidget.cc
303
303
static void d4x_rule_edit_destroy(GtkObject *widget){
304
304
        g_return_if_fail(widget!=NULL);
305
305
 
 
306
        d4xRuleEdit *edit=(d4xRuleEdit *)widget;
 
307
        if (edit->rule){
 
308
                delete (edit->rule);
 
309
                edit->rule=0;
 
310
        };
 
311
        if (edit->iter){
 
312
                gtk_tree_iter_free(edit->iter);
 
313
                edit->iter=0;
 
314
        };
 
315
 
306
316
        if (GTK_OBJECT_CLASS (rule_parent_class)->destroy)
307
317
                (* GTK_OBJECT_CLASS (rule_parent_class)->destroy) (widget);
308
318
};
315
325
};
316
326
 
317
327
void d4x_rule_edit_apply(d4xRuleEdit *edit){
318
 
        if (edit && edit->rule){
319
 
                if (*(text_from_combo(edit->host))){
320
 
                        edit->rule->host.set(text_from_combo(edit->host));
321
 
                }else
322
 
                        edit->rule->host.set((char*)NULL);
323
 
                if (*(text_from_combo(edit->path))){
324
 
                        edit->rule->path.set(text_from_combo(edit->path));
325
 
                }else
326
 
                        edit->rule->path.set((char*)NULL);
327
 
                if (*(text_from_combo(edit->file))){
328
 
                        edit->rule->file.set(text_from_combo(edit->file));
329
 
                }else
330
 
                        edit->rule->file.set((char*)NULL);
331
 
                if (*(text_from_combo(edit->params))){
332
 
                        edit->rule->params.set(text_from_combo(edit->params));
333
 
                }else
334
 
                        edit->rule->params.set((char*)NULL);
335
 
                if (*(text_from_combo(edit->tag))){
336
 
                        edit->rule->tag.set(text_from_combo(edit->tag));
337
 
                }else
338
 
                        edit->rule->tag.set((char*)NULL);
 
328
        if (edit){
 
329
                edit->rule->host=text_from_combo(edit->host);
 
330
                edit->rule->path=text_from_combo(edit->path);
 
331
                edit->rule->file=text_from_combo(edit->file);
 
332
                edit->rule->params=text_from_combo(edit->params);
 
333
                edit->rule->tag=text_from_combo(edit->tag);
339
334
                edit->rule->proto=get_proto_by_name(text_from_combo(edit->proto));
340
335
                edit->rule->include=GTK_TOGGLE_BUTTON(edit->include)->active;
341
336
        };
344
339
static void d4x_rule_edit_ok(GtkWidget *widget,d4xRuleEdit *edit) {
345
340
        g_return_if_fail(edit!=NULL);
346
341
        d4x_rule_edit_apply(edit);
 
342
        
347
343
        gtk_widget_destroy(GTK_WIDGET(edit));
348
344
};
349
345
 
352
348
};
353
349
 
354
350
static void d4x_rule_edit_init(d4xRuleEdit *edit){
 
351
        edit->rule=0;
 
352
        edit->iter=0;
355
353
        gtk_window_set_title(GTK_WINDOW (edit),_("Edit properties of Rule"));
356
354
        gtk_window_set_resizable(GTK_WINDOW(edit), FALSE);
357
355
 
520
518
        return d4x_rule_edit_type;
521
519
};
522
520
 
523
 
GtkWidget *d4x_rule_edit_new(d4xRule *rule){
 
521
GtkWidget *d4x_rule_edit_new(const d4x::Filter::Rule &rule){
524
522
        d4xRuleEdit *edit=(d4xRuleEdit *)g_object_new(d4x_rule_edit_get_type(),NULL);
525
 
        edit->rule=rule;
526
 
        if (rule){
527
 
                if (rule->host.get())
528
 
                        text_to_combo(edit->host,rule->host.get());
529
 
                if (rule->proto)
530
 
                        text_to_combo(edit->proto,get_name_by_proto(rule->proto));
531
 
                if (rule->path.get())
532
 
                        text_to_combo(edit->path,rule->path.get());
533
 
                if (rule->file.get())
534
 
                        text_to_combo(edit->file,rule->file.get());
535
 
                if (rule->params.get())
536
 
                        text_to_combo(edit->params,rule->params.get());
537
 
                if (rule->tag.get())
538
 
                        text_to_combo(edit->tag,rule->tag.get());
539
 
                GTK_TOGGLE_BUTTON(edit->include)->active=rule->include;
540
 
                GTK_TOGGLE_BUTTON(edit->exclude)->active=!rule->include;
541
 
        };
 
523
        edit->rule=new d4x::Filter::Rule(rule);
 
524
        text_to_combo(edit->host,rule.host.c_str());
 
525
        if (rule.proto)
 
526
                text_to_combo(edit->proto,get_name_by_proto(rule.proto));
 
527
        text_to_combo(edit->path,rule.path.c_str());
 
528
        text_to_combo(edit->file,rule.file.c_str());
 
529
        text_to_combo(edit->params,rule.params.c_str());
 
530
        text_to_combo(edit->tag,rule.tag.c_str());
 
531
        GTK_TOGGLE_BUTTON(edit->include)->active=rule.include;
 
532
        GTK_TOGGLE_BUTTON(edit->exclude)->active=!rule.include;
542
533
        return GTK_WIDGET(edit);
543
534
};
544
535
 
546
537
        gtk_widget_destroy(edit);
547
538
};
548
539
 
549
 
GtkWidget *d4x_rule_edit_new_full(d4xRule *rule){
550
 
        d4xRuleEdit *edit=(d4xRuleEdit *)d4x_rule_edit_new(rule);
551
 
        g_signal_connect(G_OBJECT(edit->ok_button),"clicked",
552
 
                           G_CALLBACK(d4x_rule_edit_ok),edit);
553
 
        g_signal_connect(G_OBJECT(edit->cancel_button),"clicked",
554
 
                           G_CALLBACK(d4x_rule_edit_cancel),edit);
555
 
        g_signal_connect(G_OBJECT(edit),"delete_event",
556
 
                           G_CALLBACK(d4x_rule_edit_delete), edit);
557
 
        d4x_eschandler_init(GTK_WIDGET(edit),edit);
558
 
 
559
 
        return GTK_WIDGET(edit);
560
 
};
561
 
 
562
540
/************************************************************/
563
541
 
564
542
enum {
569
547
        FE_COL_FILE,
570
548
        FE_COL_PARAMS,
571
549
        FE_COL_TAG,
572
 
        FE_COL_RULE,
 
550
        FE_COL_RULE_ITER,
573
551
        FE_COL_LAST
574
552
};
575
553
 
 
554
static gboolean destroy_filter_iterators(GtkTreeModel *model,GtkTreePath *path,
 
555
                                         GtkTreeIter *iter,gpointer data){
 
556
        
 
557
        GValue val={0,};
 
558
        gtk_tree_model_get_value(model,iter,FE_COL_RULE_ITER,&val);
 
559
        d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
 
560
        delete it;
 
561
        g_value_unset(&val);
 
562
        
 
563
        return FALSE;
 
564
};
 
565
 
576
566
static void d4x_filter_edit_destroy(GtkObject *widget){
577
567
        g_return_if_fail(widget!=NULL);
578
568
 
 
569
        d4xFilterEdit *edit=(d4xFilterEdit *)widget;
 
570
        if (edit->filter){
 
571
                delete(edit->filter);
 
572
                edit->filter=0;
 
573
        };
 
574
        if (edit->iter){
 
575
                gtk_tree_iter_free(edit->iter);
 
576
                edit->iter=0;
 
577
        };
 
578
 
 
579
        if (edit->view){
 
580
                gtk_tree_model_foreach(gtk_tree_view_get_model(edit->view),destroy_filter_iterators,0);
 
581
                gtk_list_store_clear(edit->store);
 
582
                edit->view=0;
 
583
        };
 
584
 
579
585
        if (GTK_OBJECT_CLASS (filter_parent_class)->destroy)
580
586
                (* GTK_OBJECT_CLASS (filter_parent_class)->destroy) (widget);
581
587
};
582
588
 
583
589
 
584
 
void d4x_filter_edit_add_rule(d4xFilterEdit *edit,d4xRule *rule){
585
 
        gtk_list_store_append(edit->store,&(rule->iter));
586
 
        gtk_list_store_set(edit->store,&(rule->iter),
587
 
                           FE_COL_INC,rule->include?(char*)"+":(char*)("-"),
588
 
                           FE_COL_PROTO,rule->proto?get_name_by_proto(rule->proto):(char*)(""),
589
 
                           FE_COL_HOST,rule->host.get()?rule->host.get():(char*)(""),
590
 
                           FE_COL_PATH,rule->path.get()?rule->path.get():(char*)(""),
591
 
                           FE_COL_FILE,rule->file.get()?rule->file.get():(char*)(""),
592
 
                           FE_COL_PARAMS,rule->params.get()?rule->params.get():(char*)(""),
593
 
                           FE_COL_TAG,rule->tag.get()?rule->tag.get():(char*)(""),
594
 
                           FE_COL_RULE,rule,
 
590
void d4x_filter_edit_add_rule(d4xFilterEdit *edit,const d4x::Filter::Rule &rule,d4x::Filter::iterator *it){
 
591
        GtkTreeIter iter;
 
592
        gtk_list_store_append(edit->store,&iter);
 
593
        gtk_list_store_set(edit->store,&(iter),
 
594
                           FE_COL_INC,rule.include?(char*)"+":(char*)("-"),
 
595
                           FE_COL_PROTO,rule.proto?get_name_by_proto(rule.proto):(char*)(""),
 
596
                           FE_COL_HOST,rule.host.c_str(),
 
597
                           FE_COL_PATH,rule.path.c_str(),
 
598
                           FE_COL_FILE,rule.file.c_str(),
 
599
                           FE_COL_PARAMS,rule.params.c_str(),
 
600
                           FE_COL_TAG,rule.tag.c_str(),
 
601
                           FE_COL_RULE_ITER,it,
595
602
                           -1);
596
603
};
597
604
 
 
605
 
598
606
static void d4x_filter_edit_add_ok(GtkWidget *widget,d4xRuleEdit *edit){
599
 
        ((d4xFilterEdit *)(edit->filter_edit))->node->filter->insert(edit->rule);
600
607
        d4x_rule_edit_apply(edit);
601
 
        d4x_filter_edit_add_rule((d4xFilterEdit *)(edit->filter_edit),
602
 
                                 edit->rule);
 
608
        d4x::Filter::iterator *it=new d4x::Filter::iterator(((d4xFilterEdit *)(edit->filter_edit))->filter->append(*(edit->rule)));
 
609
        d4x_filter_edit_add_rule((d4xFilterEdit *)(edit->filter_edit),*(edit->rule),it);
603
610
        gtk_widget_destroy(GTK_WIDGET(edit));
604
611
};
605
612
 
606
613
static void d4x_filter_edit_add_cancel(GtkWidget *widget,d4xRuleEdit *edit){
607
 
        delete(edit->rule);
608
614
        gtk_widget_destroy(GTK_WIDGET(edit));
609
615
};
610
616
 
611
617
static void d4x_filter_edit_add_delete(GtkWidget *widget,
612
618
                                  GdkEvent *event,
613
619
                                  d4xRuleEdit *edit){
614
 
        delete(edit->rule);
615
620
        gtk_widget_destroy(GTK_WIDGET(edit));
616
621
};
617
622
 
618
623
void d4x_filter_edit_add(GtkWidget *widget,d4xFilterEdit *edit){
619
 
        d4xRule *rule=new d4xRule;
620
 
        d4xRuleEdit *ruleedit=(d4xRuleEdit *)d4x_rule_edit_new(rule);
 
624
        d4xRuleEdit *ruleedit=(d4xRuleEdit *)d4x_rule_edit_new(d4x::Filter::Rule());
 
625
        ruleedit->iter=0;
621
626
        gtk_widget_show_all(GTK_WIDGET(ruleedit));
622
627
        gtk_window_set_modal (GTK_WINDOW(ruleedit),TRUE);
623
628
        gtk_window_set_transient_for (GTK_WINDOW (ruleedit),
638
643
static void d4x_filter_edit_edit_ok(GtkWidget *widget,d4xRuleEdit *edit){
639
644
        d4xFilterEdit *filtedit=(d4xFilterEdit *)(edit->filter_edit);
640
645
        d4x_rule_edit_apply(edit);
641
 
        d4xRule *rule=edit->rule;
642
 
        gtk_list_store_set(filtedit->store,&(rule->iter),
 
646
        d4x::Filter::Rule *rule=edit->rule;
 
647
        gtk_list_store_set(filtedit->store,edit->iter,
643
648
                           FE_COL_INC,rule->include?"+":"-",
644
649
                           FE_COL_PROTO,rule->proto?get_name_by_proto(rule->proto):"",
645
 
                           FE_COL_HOST,rule->host.get()?rule->host.get():"",
646
 
                           FE_COL_PATH,rule->path.get()?rule->path.get():"",
647
 
                           FE_COL_FILE,rule->file.get()?rule->file.get():"",
648
 
                           FE_COL_PARAMS,rule->params.get()?rule->params.get():"",
649
 
                           FE_COL_TAG,rule->tag.get()?rule->tag.get():"",
 
650
                           FE_COL_HOST,rule->host.c_str(),
 
651
                           FE_COL_PATH,rule->path.c_str(),
 
652
                           FE_COL_FILE,rule->file.c_str(),
 
653
                           FE_COL_PARAMS,rule->params.c_str(),
 
654
                           FE_COL_TAG,rule->tag.c_str(),
650
655
                           -1);
 
656
        GValue val={0,};
 
657
        gtk_tree_model_get_value(gtk_tree_view_get_model(filtedit->view),edit->iter,FE_COL_RULE_ITER,&val);
 
658
        d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
 
659
        g_value_unset(&val);
651
660
        gtk_widget_destroy(GTK_WIDGET(edit));
652
661
};
653
662
 
657
666
        GtkTreeIter iter;
658
667
        if (gtk_tree_selection_get_selected(sel,&model,&iter)){
659
668
                GValue val={0,};
660
 
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE,&val);
661
 
                d4xRule *rule=(d4xRule *)g_value_get_pointer(&val);
 
669
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
 
670
                d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
662
671
                g_value_unset(&val);
663
 
                d4xRuleEdit *ruleedit=(d4xRuleEdit *)d4x_rule_edit_new(rule);
 
672
                d4xRuleEdit *ruleedit=(d4xRuleEdit *)d4x_rule_edit_new(**it);
664
673
                ruleedit->filter_edit=(GtkWidget *)edit;
 
674
                ruleedit->iter=gtk_tree_iter_copy(&iter);
665
675
                g_signal_connect(G_OBJECT(ruleedit->ok_button),"clicked",
666
676
                                   G_CALLBACK(d4x_filter_edit_edit_ok),
667
677
                                   ruleedit);
685
695
        GtkTreeIter iter;
686
696
        if (gtk_tree_selection_get_selected(sel,&model,&iter)){
687
697
                GValue val={0,};
688
 
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE,&val);
689
 
                d4xRule *rule=(d4xRule *)g_value_get_pointer(&val);
 
698
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
 
699
                d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
690
700
                g_value_unset(&val);
691
 
                gtk_list_store_remove(edit->store,&(rule->iter));
692
 
                edit->node->filter->del(rule);
693
 
                delete(rule);
 
701
                gtk_list_store_remove(edit->store,&iter);
 
702
                edit->filter->remove(*it);
 
703
                delete(it);
694
704
        };
695
705
};
696
706
 
700
710
        GtkTreeIter iter;
701
711
        if (gtk_tree_selection_get_selected(sel,&model,&iter)){
702
712
                GValue val={0,};
703
 
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE,&val);
704
 
                d4xRule *rule=(d4xRule *)g_value_get_pointer(&val);
 
713
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
 
714
                d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
705
715
                g_value_unset(&val);
706
 
                if (rule->prev){
707
 
                        tNode *next=rule->prev;
708
 
                        gtk_tree_model_swap_rows_l(GTK_TREE_MODEL(edit->store),
709
 
                                                   &(rule->iter),&(((d4xRule*)next)->iter));
710
 
                        d4xFilter *filter=edit->node->filter;
711
 
                        filter->del(next);
712
 
                        filter->insert_before(next,rule);
713
 
                        GtkTreeIter iter_tmp;
714
 
                        memcpy(&iter_tmp,&(((d4xRule*)next)->iter),sizeof(rule->iter));
715
 
                        memcpy(&(((d4xRule*)next)->iter),&(rule->iter),sizeof(rule->iter));
716
 
                        memcpy(&(rule->iter),&iter_tmp,sizeof(rule->iter));
717
 
                        gtk_tree_selection_select_iter(sel,&(rule->iter));
 
716
 
 
717
                GtkTreeIter *prev=gtk_tree_iter_copy(&iter);
 
718
                if (gtk_tree_model_iter_next(model,&iter)){
 
719
                        gtk_list_store_swap(edit->store,prev,&iter);
 
720
                        
 
721
                        gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
 
722
                        d4x::Filter::iterator *it2=(d4x::Filter::iterator *)g_value_get_pointer(&val);
 
723
                        std::iter_swap(*it,*it2);
 
724
                        g_value_unset(&val);
718
725
                };
 
726
                gtk_tree_iter_free(prev);
719
727
        };
720
728
};
721
729
 
725
733
        GtkTreeIter iter;
726
734
        if (gtk_tree_selection_get_selected(sel,&model,&iter)){
727
735
                GValue val={0,};
728
 
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE,&val);
729
 
                d4xRule *rule=(d4xRule *)g_value_get_pointer(&val);
 
736
                gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
 
737
                d4x::Filter::iterator *it=(d4x::Filter::iterator *)g_value_get_pointer(&val);
730
738
                g_value_unset(&val);
731
 
                if (rule->next){
732
 
                        tNode *next=rule->next;
733
 
                        gtk_tree_model_swap_rows_l(GTK_TREE_MODEL(edit->store),
734
 
                                                   &(rule->iter),&(((d4xRule*)next)->iter));
735
 
                        d4xFilter *filter=edit->node->filter;
736
 
                        filter->del(rule);
737
 
                        filter->insert_before(rule,next);
738
 
                        GtkTreeIter iter_tmp;
739
 
                        memcpy(&iter_tmp,&(((d4xRule*)next)->iter),sizeof(rule->iter));
740
 
                        memcpy(&(((d4xRule*)next)->iter),&(rule->iter),sizeof(rule->iter));
741
 
                        memcpy(&(rule->iter),&iter_tmp,sizeof(rule->iter));
742
 
                        gtk_tree_selection_select_iter(sel,&(rule->iter));
 
739
 
 
740
                GtkTreePath *path=gtk_tree_model_get_path(model,&iter);
 
741
                GtkTreeIter *next=gtk_tree_iter_copy(&iter);
 
742
                if (gtk_tree_path_prev (path) && gtk_tree_model_get_iter(model,next,path)){
 
743
                        gtk_list_store_swap(edit->store,next,&iter);
 
744
                        
 
745
                        gtk_tree_model_get_value(model,&iter,FE_COL_RULE_ITER,&val);
 
746
                        d4x::Filter::iterator *it2=(d4x::Filter::iterator *)g_value_get_pointer(&val);
 
747
                        std::iter_swap(*it,*it2);
 
748
                        g_value_unset(&val);
 
749
                        
743
750
                };
 
751
                gtk_tree_path_free(path);
 
752
                gtk_tree_iter_free(next);
744
753
        };
745
754
};
746
755
 
 
756
static void d4x_filter_edit_cancel(GtkWidget *widget,d4xFilterEdit *edit){
 
757
        gtk_widget_destroy(GTK_WIDGET(edit));
 
758
};
 
759
 
747
760
static gboolean d4x_filter_edit_select(GtkTreeView *view,GdkEventButton *event,d4xFilterEdit *edit) {
748
761
        if (event && event->type==GDK_2BUTTON_PRESS && event->button==1){
749
762
                d4x_filter_edit_edit(GTK_WIDGET(view),edit);
753
766
};
754
767
 
755
768
static void d4x_filter_edit_init(d4xFilterEdit *edit){
 
769
        edit->filter=0;
 
770
        edit->iter=0;
756
771
        gtk_window_set_title(GTK_WINDOW (edit),_("Modify filter"));
757
772
        gtk_window_set_resizable(GTK_WINDOW(edit),FALSE);
758
773
        gtk_widget_set_size_request(GTK_WIDGET (edit),-1,400);
774
789
        edit->view=GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(edit->store)));
775
790
        GtkCellRenderer *renderer;
776
791
        GtkTreeViewColumn *col;
777
 
        for (int i=0;i<FE_COL_RULE;i++){
 
792
        for (int i=0;i<FE_COL_RULE_ITER;i++){
778
793
                        renderer = gtk_cell_renderer_text_new ();
779
794
                        col=gtk_tree_view_column_new_with_attributes (titles[i],
780
795
                                                                      renderer,
808
823
        gtk_box_pack_start_defaults(GTK_BOX(hbox),edit->name);
809
824
        gtk_box_pack_start(GTK_BOX(edit->vbox),hbox,FALSE,FALSE,3);
810
825
 
811
 
        GtkWidget *table=gtk_table_new(2,3,TRUE);
812
 
        gtk_table_set_row_spacings(GTK_TABLE(table),3);
813
 
        gtk_table_set_col_spacings(GTK_TABLE(table),5);
814
 
        gtk_box_pack_start(GTK_BOX(edit->vbox),table, FALSE,FALSE,0);
 
826
        GtkWidget *bbox1=gtk_hbutton_box_new();
 
827
        gtk_box_set_spacing(GTK_BOX(bbox1),5);
 
828
        gtk_box_pack_start(GTK_BOX(edit->vbox),bbox1,FALSE,FALSE,3);
815
829
        
816
830
        GtkWidget *up=gtk_button_new_from_stock(GTK_STOCK_GO_UP);
817
 
        gtk_table_attach_defaults(GTK_TABLE(table),up,0,1,0,1);
 
831
        gtk_box_pack_start(GTK_BOX(bbox1),up,FALSE,FALSE,0);
818
832
        g_signal_connect(G_OBJECT(up),"clicked",
819
833
                           G_CALLBACK(d4x_filter_edit_up),edit);
820
834
        
821
835
        GtkWidget *down=gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
822
 
        gtk_table_attach_defaults(GTK_TABLE(table),down,0,1,1,2);
 
836
        gtk_box_pack_start(GTK_BOX(bbox1),down,FALSE,FALSE,0);
 
837
        g_signal_connect(G_OBJECT(down),"clicked",
 
838
                           G_CALLBACK(d4x_filter_edit_down),edit);
823
839
        
824
840
        GtkWidget *add=gtk_button_new_from_stock(GTK_STOCK_ADD);
825
 
        gtk_table_attach_defaults(GTK_TABLE(table),add,1,2,0,1);
 
841
        gtk_box_pack_start(GTK_BOX(bbox1),add,FALSE,FALSE,0);
826
842
        g_signal_connect(G_OBJECT(add),"clicked",
827
843
                           G_CALLBACK(d4x_filter_edit_add),edit);
828
844
 
829
845
        GtkWidget *del=gtk_button_new_from_stock(GTK_STOCK_REMOVE);
830
 
        gtk_table_attach_defaults(GTK_TABLE(table),del,1,2,1,2);
 
846
        gtk_box_pack_start(GTK_BOX(bbox1),del,FALSE,FALSE,0);
831
847
        g_signal_connect(G_OBJECT(del),"clicked",
832
848
                           G_CALLBACK(d4x_filter_edit_del),edit);
833
849
        
 
850
        
834
851
        edit->edit=gtk_button_new_from_stock(GTK_STOCK_PROPERTIES);
835
 
        gtk_table_attach_defaults(GTK_TABLE(table),edit->edit,2,3,0,1);
 
852
        gtk_box_pack_start(GTK_BOX(bbox1),edit->edit,FALSE,FALSE,0);
836
853
        g_signal_connect(G_OBJECT(edit->edit),"clicked",
837
854
                           G_CALLBACK(d4x_filter_edit_edit),edit);
838
855
        
 
856
        GtkWidget *bbox2=gtk_hbutton_box_new();
 
857
        gtk_box_set_spacing(GTK_BOX(bbox2),5);
 
858
        gtk_box_pack_start(GTK_BOX(edit->vbox),bbox2, FALSE,FALSE,0);
 
859
 
 
860
        GtkWidget *cancel=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
 
861
        gtk_box_pack_start(GTK_BOX(bbox2),cancel,FALSE,FALSE,0);
 
862
        g_signal_connect(G_OBJECT(cancel),"clicked",
 
863
                           G_CALLBACK(d4x_filter_edit_cancel),edit);
 
864
        
839
865
        edit->ok=gtk_button_new_from_stock(GTK_STOCK_OK);
840
 
        gtk_table_attach_defaults(GTK_TABLE(table),edit->ok,2,3,1,2);
841
 
        g_signal_connect(G_OBJECT(down),"clicked",
842
 
                           G_CALLBACK(d4x_filter_edit_down),edit);
 
866
        gtk_box_pack_start(GTK_BOX(bbox2),edit->ok,FALSE,FALSE,0);
843
867
        
844
868
        GTK_WIDGET_SET_FLAGS(edit->ok,GTK_CAN_DEFAULT);
845
869
        GTK_WIDGET_SET_FLAGS(del,GTK_CAN_DEFAULT);
846
870
        GTK_WIDGET_SET_FLAGS(edit->edit,GTK_CAN_DEFAULT);
 
871
        GTK_WIDGET_SET_FLAGS(cancel,GTK_CAN_DEFAULT);
847
872
        
848
873
        gtk_window_set_default(GTK_WINDOW(edit),edit->ok);
849
874
 
873
898
        return d4x_filter_edit_type;
874
899
};
875
900
 
876
 
GtkWidget *d4x_filter_edit_new(d4xFNode *node){
 
901
struct PopulateFilter{
 
902
        d4xFilterEdit *edit;
 
903
        PopulateFilter(d4xFilterEdit *e):edit(e){};
 
904
        void operator()(d4x::Filter::iterator it){
 
905
                d4x_filter_edit_add_rule(edit,*it,new d4x::Filter::iterator(it));
 
906
        };
 
907
};
 
908
 
 
909
GtkWidget *d4x_filter_edit_new(const d4x::Filter &filter){
877
910
        d4xFilterEdit *edit=(d4xFilterEdit *)g_object_new(d4x_filter_edit_get_type(),NULL);
878
 
        edit->node=node;
879
 
        node->filter->print(edit);
880
 
        if (node->filter->name.get())
881
 
                text_to_combo(edit->name,node->filter->name.get());
882
 
        GTK_TOGGLE_BUTTON(edit->include)->active=node->filter->default_inc;
883
 
        GTK_TOGGLE_BUTTON(edit->exclude)->active=!node->filter->default_inc;
 
911
        edit->filter=new d4x::Filter(filter);
 
912
        edit->filter->each_iter(PopulateFilter(edit));
 
913
        text_to_combo(edit->name,filter.name.c_str());
 
914
        GTK_TOGGLE_BUTTON(edit->include)->active=filter.include;
 
915
        GTK_TOGGLE_BUTTON(edit->exclude)->active=!filter.include;
884
916
        return GTK_WIDGET(edit);
885
917
};
886
918
 
931
963
        gtk_box_pack_end(GTK_BOX(hbox),sel->cancel,FALSE,FALSE,0);
932
964
        gtk_container_add(GTK_CONTAINER(sel),vbox);
933
965
        gtk_window_set_default(GTK_WINDOW(sel),sel->ok);
934
 
        FILTERS_DB->print(sel);
 
966
        // adding empty line to select no filter
 
967
        GtkTreeIter iter;
 
968
        gtk_list_store_append(list_store, &iter);
 
969
        gtk_list_store_set(list_store, &iter,
 
970
                           0,"",
 
971
                           1,NULL,
 
972
                           -1);
 
973
//      FILTERS_DB.each(sel);
935
974
};
936
975
 
937
976
static void d4x_filter_sel_class_init(d4xFilterSelClass *klass){
960
999
 
961
1000
GtkWidget *d4x_filter_sel_new(){
962
1001
        d4xFilterSel *sel=(d4xFilterSel *)g_object_new(d4x_filter_sel_get_type(),NULL);
 
1002
        //FIXME: what about fill list?
 
1003
        FILTERS_DB.each_name(PopulateFilters(GTK_LIST_STORE(gtk_tree_view_get_model(sel->view))));
963
1004
        gtk_widget_show_all(GTK_WIDGET(sel));
964
1005
        return GTK_WIDGET(sel);
965
1006
};
966
1007
 
967
 
void d4x_filter_sel_add(d4xFilterSel *sel,d4xFNode *node){
968
 
        GtkListStore *list_store=GTK_LIST_STORE(gtk_tree_view_get_model(sel->view));
969
 
        GtkTreeIter iter;
970
 
        gtk_list_store_append(list_store, &iter);
971
 
        gtk_list_store_set(list_store, &iter,
972
 
                           0,node->filter->name.get(),
973
 
                           1,node,
974
 
                           -1);
975
 
};
976
 
 
977
1008
void d4x_filter_sel_to_combo(d4xFilterSel *sel,GtkWidget *combo){
978
1009
        GtkTreeSelection *s=gtk_tree_view_get_selection(sel->view);
979
1010
        GtkTreeIter iter;
1016
1047
        };
1017
1048
};
1018
1049
 
1019
 
void d4x_links_sel_set(d4xLinksSel *sel,GtkTreeIter *iter,char *url,gpointer p){
 
1050
void d4x_links_sel_set(d4xLinksSel *sel,GtkTreeIter *iter,const char *url,gpointer p){
1020
1051
        GtkListStore *list_store=GTK_LIST_STORE(gtk_tree_view_get_model(sel->view));
1021
1052
        gtk_list_store_set(list_store, iter,
1022
1053
                           0,url,
1100
1131
        GTK_WIDGET_SET_FLAGS(sel->ok,GTK_CAN_DEFAULT);
1101
1132
        GTK_WIDGET_SET_FLAGS(sel->remove,GTK_CAN_DEFAULT);
1102
1133
        GTK_WIDGET_SET_FLAGS(sel->cancel,GTK_CAN_DEFAULT);
1103
 
        GtkWidget *vbox=gtk_vbox_new(FALSE,5);
 
1134
        GtkWidget *vbox=sel->vbox=gtk_vbox_new(FALSE,5);
1104
1135
        sel->hbbox=gtk_hbutton_box_new();
1105
1136
        gtk_box_set_spacing(GTK_BOX(sel->hbbox),5);
1106
1137
        gtk_box_pack_start(GTK_BOX(vbox),scroll_window,TRUE,TRUE,0);
1146
1177
        return GTK_WIDGET(sel);
1147
1178
};
1148
1179
 
 
1180
GtkWidget *d4x_links_sel_new_with_referer(const char *ref){
 
1181
        d4xLinksSel *sel=(d4xLinksSel *)d4x_links_sel_new();
 
1182
        sel->referer=gtk_entry_new();
 
1183
        sel->directory=gtk_entry_new();
 
1184
        gtk_entry_set_text(GTK_ENTRY(sel->referer),ref);
 
1185
        GtkWidget *lab=gtk_label_new(_("Referer:"));
 
1186
        gtk_box_pack_start(GTK_BOX(sel->vbox),lab,FALSE,FALSE,0);
 
1187
        gtk_box_pack_start(GTK_BOX(sel->vbox),sel->referer,FALSE,FALSE,0);
 
1188
        gtk_box_reorder_child(GTK_BOX(sel->vbox),lab,1);
 
1189
        gtk_box_reorder_child(GTK_BOX(sel->vbox),sel->referer,2);
 
1190
        lab=gtk_label_new(_("Store into directory:"));
 
1191
        gtk_box_pack_start(GTK_BOX(sel->vbox),lab,FALSE,FALSE,0);
 
1192
        gtk_box_pack_start(GTK_BOX(sel->vbox),sel->directory,FALSE,FALSE,0);
 
1193
        gtk_widget_set_sensitive(sel->directory,FALSE);
 
1194
        gtk_box_reorder_child(GTK_BOX(sel->vbox),lab,3);
 
1195
        gtk_box_reorder_child(GTK_BOX(sel->vbox),sel->directory,4);
 
1196
        gtk_widget_show_all(GTK_WIDGET(sel));
 
1197
        return GTK_WIDGET(sel);
 
1198
};
 
1199
 
1149
1200
GtkWidget *d4x_links_sel_new(){
1150
1201
        d4xLinksSel *sel=(d4xLinksSel *)g_object_new(d4x_links_sel_get_type(),NULL);
1151
1202
        gtk_box_pack_end(GTK_BOX(sel->hbbox),sel->cancel,FALSE,FALSE,0);
1161
1212
        return GTK_WIDGET(sel);
1162
1213
};
1163
1214
 
1164
 
void d4x_links_sel_add(d4xLinksSel *sel,char *url,gpointer p){
 
1215
void d4x_links_sel_add(d4xLinksSel *sel,const char *url,gpointer p){
1165
1216
        GtkListStore *list_store=GTK_LIST_STORE(gtk_tree_view_get_model(sel->view));
1166
1217
        GtkTreeIter iter;
1167
1218
        gtk_list_store_append(list_store, &iter);
1440
1491
        return GTK_WIDGET(edit);
1441
1492
};
1442
1493
 
1443
 
void d4x_alt_edit_set(d4xAltEdit *sel,tAddr *info){
1444
 
        if (info->host.notempty()){
1445
 
                if (info->proto==D_PROTO_FTP)
 
1494
void d4x_alt_edit_set(d4xAltEdit *sel,const d4x::URL &info){
 
1495
        if (!info.host.empty()){
 
1496
                if (info.proto==D_PROTO_FTP)
1446
1497
                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_type_ftp),TRUE);
1447
1498
                else
1448
1499
                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_type_http),TRUE);
1449
1500
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_use_check),TRUE);
1450
1501
                gtk_widget_set_sensitive(sel->proxy_view,TRUE);
1451
 
                text_to_combo(sel->proxy_host,info->host.get());
 
1502
                text_to_combo(sel->proxy_host,info.host.c_str());
1452
1503
                char data[100];
1453
 
                sprintf(data,"%i",info->port);
 
1504
                sprintf(data,"%i",info.port);
1454
1505
                text_to_combo(sel->proxy_port,data);
1455
 
                if (info->username.notempty() && info->pass.notempty()){
 
1506
                if (!info.user.empty() && !info.pass.empty()){
1456
1507
                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_user_check),TRUE);
1457
 
                        text_to_combo(sel->proxy_user,info->username.get());
1458
 
                        text_to_combo(sel->proxy_pass,info->pass.get());
1459
 
                        ALL_HISTORIES[USER_HISTORY]->add(info->username.get());
 
1508
                        text_to_combo(sel->proxy_user,info.user.c_str());
 
1509
                        text_to_combo(sel->proxy_pass,info.pass.c_str());
 
1510
                        ALL_HISTORIES[USER_HISTORY]->add(info.user.c_str());
1460
1511
                }else{
1461
1512
                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sel->proxy_user_check),FALSE);
1462
1513
                };
1466
1517
        };
1467
1518
};
1468
1519
 
1469
 
void d4x_alt_edit_get(d4xAltEdit *sel,tAddr *info){
 
1520
void d4x_alt_edit_get(d4xAltEdit *sel,d4x::URL &info){
1470
1521
        if (GTK_TOGGLE_BUTTON(sel->proxy_use_check)->active && strlen(text_from_combo(sel->proxy_host))){
1471
1522
                if (GTK_TOGGLE_BUTTON(sel->proxy_type_ftp)->active)
1472
 
                        info->proto=D_PROTO_FTP;
 
1523
                        info.proto=D_PROTO_FTP;
1473
1524
                else
1474
 
                        info->proto=D_PROTO_HTTP;
1475
 
                info->host.set(text_from_combo(sel->proxy_host));
1476
 
                REMOVE_SC_FROM_HOST(info->host.get());
1477
 
                sscanf(text_from_combo(sel->proxy_port),"%i",&info->port);
1478
 
                info->path.set("");
1479
 
                info->file.set("");
 
1525
                        info.proto=D_PROTO_HTTP;
 
1526
                info.host=text_from_combo(sel->proxy_host);
 
1527
                info.host=info.host.substr(0,info.host.find(':'));
 
1528
                sscanf(text_from_combo(sel->proxy_port),"%i",&(info.port));
 
1529
                info.path.clear();
 
1530
                info.file.clear();
1480
1531
                if (GTK_TOGGLE_BUTTON(sel->proxy_user_check)->active
1481
1532
                    && strlen(text_from_combo(sel->proxy_user))
1482
1533
                    && strlen(text_from_combo(sel->proxy_pass))){
1483
 
                        info->username.set(text_from_combo(sel->proxy_user));
1484
 
                        info->pass.set(text_from_combo(sel->proxy_pass));
 
1534
                        info.user=text_from_combo(sel->proxy_user);
 
1535
                        info.pass=text_from_combo(sel->proxy_pass);
1485
1536
                }else{
1486
 
                        info->username.set(NULL);
1487
 
                        info->pass.set(NULL);
 
1537
                        info.user.clear();
 
1538
                        info.pass.clear();
1488
1539
                };
1489
 
                make_proxy_host(info->host.get(),info->port);
 
1540
                make_proxy_host(info.host.c_str(),info.port);
1490
1541
        }else{
1491
 
                info->clear();
 
1542
                info.clear();
1492
1543
        };
1493
1544
};
1494
1545