~ubuntu-branches/ubuntu/natty/bluefish/natty-proposed

pd->ftd.lstore = gtk_list_store_new (8,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_POINTER);

624

pd->ftd.lview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pd->ftd.lstore));

625

pref_create_column(GTK_TREE_VIEW(pd->ftd.lview), 1, G_CALLBACK(filetype_0_edited_lcb), pd, _("Label"), 0);

626

pref_create_column(GTK_TREE_VIEW(pd->ftd.lview), 1, G_CALLBACK(filetype_1_edited_lcb), pd, _("Extensions"), 1);

627

pref_create_column(GTK_TREE_VIEW(pd->ftd.lview), 1, G_CALLBACK(filetype_2_edited_lcb), pd, _("Update chars"), 2);

628

pref_create_column(GTK_TREE_VIEW(pd->ftd.lview), 1, G_CALLBACK(filetype_3_edited_lcb), pd, _("Icon"), 3);

629

pref_create_column(GTK_TREE_VIEW(pd->ftd.lview), 2, G_CALLBACK(filetype_4_toggled_lcb), pd, _("Editable"), 4);

630

pref_create_column(GTK_TREE_VIEW(pd->ftd.lview), 1, G_CALLBACK(filetype_5_edited_lcb), pd, _("Content regex"), 5);

631

pref_create_column(GTK_TREE_VIEW(pd->ftd.lview), 1, G_CALLBACK(filetype_6_edited_lcb), pd, _("Auto close tags mode"), 6);

632

633

scrolwin = gtk_scrolled_window_new(NULL, NULL);

634

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);

635

gtk_container_add(GTK_CONTAINER(scrolwin), pd->ftd.lview);

636

gtk_widget_set_size_request(scrolwin, 150, 190);

637

gtk_box_pack_start(GTK_BOX(vbox1), scrolwin, TRUE, TRUE, 2);

638

639

/* select = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->ftd.lview));

640

gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);

641

g_signal_connect(G_OBJECT(select), "changed",G_CALLBACK(filetype_selection_changed_cb),pd);*/

642

{

643

GList *tmplist = g_list_first(pd->lists[filetypes]);

644

while (tmplist) {

645

gint arrcount;

646

gchar **strarr = (gchar **)tmplist->data;

647

arrcount = count_array(strarr);

648

if (arrcount==7) {

649

GtkTreeIter iter;

650

gtk_list_store_append(GTK_LIST_STORE(pd->ftd.lstore), &iter);

651

set_filetype_strarr_in_list(&iter, strarr,pd);

652

}

653

tmplist = g_list_next(tmplist);

654

}

655

}

656

gtk_tree_view_set_reorderable(GTK_TREE_VIEW(pd->ftd.lview), TRUE);

657

pd->ftd.thelist = &pd->lists[filetypes];

658

pd->ftd.insertloc = -1;

659

g_signal_connect(G_OBJECT(pd->ftd.lstore), "row-inserted", G_CALLBACK(listpref_row_inserted), &pd->ftd);

660

g_signal_connect(G_OBJECT(pd->ftd.lstore), "row-deleted", G_CALLBACK(listpref_row_deleted), &pd->ftd);

661

662

hbox = gtk_hbox_new(FALSE, 0);

663

gtk_box_pack_start(GTK_BOX(vbox1),hbox, TRUE, TRUE, 2);

664

but = bf_gtkstock_button(GTK_STOCK_ADD, G_CALLBACK(add_new_filetype_lcb), pd);

665

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

666

but = bf_gtkstock_button(GTK_STOCK_DELETE, G_CALLBACK(delete_filetype_lcb), pd);

667

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

668

}

669

670

static gchar **filefilter_create_strarr(Tprefdialog *pd) {

671

gchar **strarr = g_malloc(4*sizeof(gchar *));

672

strarr[0] = gtk_editable_get_chars(GTK_EDITABLE(pd->ffd.entry[0]), 0, -1);

673

if (GTK_TOGGLE_BUTTON(pd->ffd.check)->active){

674

strarr[1] = g_strdup("0");

675

} else {

676

strarr[1] = g_strdup("1");

677

}

678

strarr[2] = gtk_editable_get_chars(GTK_EDITABLE(pd->ffd.entry[1]), 0, -1);

679

strarr[3] = NULL;

680

return strarr;

681

}

682

683

static void filefilter_apply_changes(Tprefdialog *pd) {

684

DEBUG_MSG("filefilters_apply_changes, started\n");

685

if (pd->ffd.curstrarr) {

686

gchar **strarr;

687

strarr = filefilter_create_strarr(pd);

688

if (strarr) {

689

GList *tmplist;

690

GtkTreeIter iter;

691

gboolean retval = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pd->ffd.lstore),&iter);

692

while (retval) {

693

gchar *curval;

694

gtk_tree_model_get(GTK_TREE_MODEL(pd->ffd.lstore),&iter,0,&curval,-1);

695

if (strcmp(curval,pd->ffd.curstrarr[0])==0) {

696

gtk_list_store_set(GTK_LIST_STORE(pd->ffd.lstore), &iter

697

,0,strarr[0]

698

,1,(strarr[1][0] == '0')

699

,2,strarr[2]

700

,-1);

701

DEBUG_MSG("filefilters_apply_changes, changed in tree model\n");

702

break;

703

}

704

retval = gtk_tree_model_iter_next(GTK_TREE_MODEL(pd->ffd.lstore),&iter);

705

}

706

707

tmplist = g_list_first(pd->lists[filefilters]);

708

while (tmplist) {

709

if (tmplist->data == pd->ffd.curstrarr) {

710

g_strfreev(pd->ffd.curstrarr);

711

tmplist->data = strarr;

712

pd->ffd.curstrarr = strarr;

713

DEBUG_MSG("filefilters_apply_changes, changed custrarr\n");

714

break;

715

}

716

tmplist = g_list_next(tmplist);

717

}

718

} else {

719

DEBUG_MSG("filefilters_apply_changes, NO strarr!!\n");

720

}

721

} else {

722

DEBUG_MSG("filefilters_apply_changes, NO curstrarr!!\n");

723

}

724

}

725

726

static void add_new_filefilter_lcb(GtkWidget *wid, Tprefdialog *pd) {

727

gchar **strarr;

728

strarr = filefilter_create_strarr(pd);

729

if (strarr) {

730

GtkTreeIter iter;

731

pd->lists[filefilters] = g_list_append(pd->lists[filefilters], strarr);

732

gtk_list_store_append(GTK_LIST_STORE(pd->ffd.lstore), &iter);

733

gtk_list_store_set(GTK_LIST_STORE(pd->ffd.lstore), &iter

734

,0,strarr[0]

735

,1,(strarr[1][0]=='0')

736

,2,strarr[2]

737

,-1);

738

}

739

}

740

static void filefilter_selection_changed_cb(GtkTreeSelection *selection, Tprefdialog *pd) {

741

GtkTreeIter iter;

742

GtkTreeModel *model;

743

DEBUG_MSG("filefilter_selection_changed_cb, curstrarr=%p, &curstrarr=%p\n", pd->ftd.curstrarr, &pd->ffd.curstrarr);

744

if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

745

gchar *filefilter;

746

GList *tmplist = g_list_first(pd->lists[filefilters]);

747

gtk_tree_model_get(model, &iter, 0, &filefilter, -1);

748

filefilter_apply_changes(pd);

749

while (tmplist) {

750

gchar **strarr =(gchar **)tmplist->data;

751

if (strcmp(strarr[0],filefilter)==0) {

752

gtk_entry_set_text(GTK_ENTRY(pd->ffd.entry[0]), strarr[0]);

753

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->ffd.check), (strarr[1][0] == '0'));

754

gtk_entry_set_text(GTK_ENTRY(pd->ffd.entry[1]), strarr[2]);

755

pd->ffd.curstrarr = strarr;

756

DEBUG_MSG("filefilter_selection_changed_cb, found %s, curstrarr=%p\n", filefilter, strarr);

757

return;

758

}

759

tmplist = g_list_next(tmplist);

760

}

761

DEBUG_MSG("filefilter_selection_changed_cb, could not find the selected text %s\n", filefilter);

762

} else {

763

DEBUG_MSG("filefilter_selection_changed_cb, no selection ?!?!\n");

764

}

765

}*/

766

static void set_filefilter_strarr_in_list(GtkTreeIter *iter, gchar **strarr, Tprefdialog *pd) {

767

gint arrcount;

768

arrcount = count_array(strarr);

769

if (arrcount==3) {

770

gtk_list_store_set(GTK_LIST_STORE(pd->ffd.lstore), iter

771

,0,strarr[0],1,(strarr[1][0] != '0'),2,strarr[2],3,strarr,-1);

772

} else {

773

DEBUG_MSG("ERROR: set_filefilter_strarr_in_list, arraycount != 3 !!!!!!\n");

774

}

775

}

776

static void filefilter_apply_change(Tprefdialog *pd, gint type, gchar *path, gchar *newval, gint index) {

777

DEBUG_MSG("filefilter_apply_change,lstore=%p,path=%s,newval=%s,index=%d\n",pd->ffd.lstore,path,newval,index);

778

pref_apply_change(pd->ffd.lstore,3,type,path,newval,index);

779

}

780

static void filefilter_0_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

781

filefilter_apply_change(pd, 1, path, newtext, 0);

782

}

783

static void filefilter_1_toggled_lcb(GtkCellRendererToggle *cellrenderertoggle,gchar *path,Tprefdialog *pd) {

784

gchar *val = g_strdup(cellrenderertoggle->active ? "0" : "1");

785

filefilter_apply_change(pd, 2, path, val, 1);

786

g_free(val);

787

}

788

static void filefilter_2_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

789

filefilter_apply_change(pd, 1, path, newtext, 2);

790

}

791

static void add_new_filefilter_lcb(GtkWidget *wid, Tprefdialog *pd) {

792

gchar **strarr;

793

GtkTreeIter iter;

794

strarr = pref_create_empty_strarr(3);

795

gtk_list_store_append(GTK_LIST_STORE(pd->ffd.lstore), &iter);

796

set_filefilter_strarr_in_list(&iter, strarr,pd);

797

pd->lists[filefilters] = g_list_append(pd->lists[filefilters], strarr);

798

pd->ffd.insertloc = -1;

799

}

800

801

static void delete_filefilter_lcb(GtkWidget *wid, Tprefdialog *pd) {

802

pref_delete_strarr(pd, &pd->ffd, 3);

803

}

804

static void create_filefilter_gui(Tprefdialog *pd, GtkWidget *vbox1) {

805

GtkWidget *hbox, *but, *scrolwin;

806

pd->lists[filefilters] = duplicate_arraylist(main_v->props.filefilters);

807

pd->ffd.lstore = gtk_list_store_new (4,G_TYPE_STRING,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_POINTER);

808

pd->ffd.lview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pd->ffd.lstore));

809

pref_create_column(GTK_TREE_VIEW(pd->ffd.lview), 1, G_CALLBACK(filefilter_0_edited_lcb), pd, _("Label"), 0);

810

pref_create_column(GTK_TREE_VIEW(pd->ffd.lview), 2, G_CALLBACK(filefilter_1_toggled_lcb), pd, _("Inverse filter"), 1);

811

pref_create_column(GTK_TREE_VIEW(pd->ffd.lview), 1, G_CALLBACK(filefilter_2_edited_lcb), pd, _("Filetypes in filter"), 2);

812

scrolwin = gtk_scrolled_window_new(NULL, NULL);

813

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);

814

gtk_container_add(GTK_CONTAINER(scrolwin), pd->ffd.lview);

815

gtk_widget_set_size_request(scrolwin, 150, 190);

816

gtk_box_pack_start(GTK_BOX(vbox1), scrolwin, TRUE, TRUE, 2);

817

{

818

GList *tmplist = g_list_first(pd->lists[filefilters]);

819

while (tmplist) {

820

gchar **strarr = (gchar **)tmplist->data;

821

if (count_array(strarr)==3) {

822

GtkTreeIter iter;

823

gtk_list_store_append(GTK_LIST_STORE(pd->ffd.lstore), &iter);

824

set_filefilter_strarr_in_list(&iter, strarr,pd);

825

}

826

tmplist = g_list_next(tmplist);

827

}

828

}

829

gtk_tree_view_set_reorderable(GTK_TREE_VIEW(pd->ffd.lview), TRUE);

830

pd->ffd.thelist = &pd->lists[filefilters];

831

pd->ffd.insertloc = -1;

832

g_signal_connect(G_OBJECT(pd->ffd.lstore), "row-inserted", G_CALLBACK(listpref_row_inserted), &pd->ffd);

833

g_signal_connect(G_OBJECT(pd->ffd.lstore), "row-deleted", G_CALLBACK(listpref_row_deleted), &pd->ffd);

834

835

hbox = gtk_hbox_new(FALSE, 0);

836

gtk_box_pack_start(GTK_BOX(vbox1),hbox, TRUE, TRUE, 2);

837

but = bf_gtkstock_button(GTK_STOCK_ADD, G_CALLBACK(add_new_filefilter_lcb), pd);

838

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

839

but = bf_gtkstock_button(GTK_STOCK_DELETE, G_CALLBACK(delete_filefilter_lcb), pd);

840

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

841

}

842

843

static gchar **highlightpattern_create_strarr(Tprefdialog *pd) {

844

gchar **strarr;

845

strarr = g_malloc(12*sizeof(gchar *));

846

strarr[0] = g_strdup(pd->hpd.selected_filetype);

847

strarr[1] = gtk_editable_get_chars(GTK_EDITABLE(pd->hpd.entry[0]),0,-1);

848

DEBUG_MSG("highlightpattern_create_strarr for %s-%s at %p\n",strarr[0],strarr[1],strarr);

849

if (GTK_TOGGLE_BUTTON(pd->hpd.check)->active){

850

strarr[2] = g_strdup("0");

851

} else {

852

strarr[2] = g_strdup("1");

853

}

854

strarr[3] = gtk_editable_get_chars(GTK_EDITABLE(pd->hpd.entry[1]),0,-1);

855

strarr[4] = gtk_editable_get_chars(GTK_EDITABLE(pd->hpd.entry[2]),0,-1);

856

if (GTK_TOGGLE_BUTTON(pd->hpd.radio[0])->active){

857

strarr[5] = g_strdup("1");

858

} else if (GTK_TOGGLE_BUTTON(pd->hpd.radio[1])->active) {

859

strarr[5] = g_strdup("2");

860

} else {

861

strarr[5] = g_strdup("3");

862

}

863

strarr[6] = gtk_editable_get_chars(GTK_EDITABLE(pd->hpd.entry[3]),0,-1);

864

strarr[7] = gtk_editable_get_chars(GTK_EDITABLE(pd->hpd.entry[4]),0,-1);

865

strarr[8] = gtk_editable_get_chars(GTK_EDITABLE(pd->hpd.entry[5]),0,-1);

866

if (GTK_TOGGLE_BUTTON(pd->hpd.radio[3])->active){

867

strarr[9] = g_strdup("0");

868

} else if (GTK_TOGGLE_BUTTON(pd->hpd.radio[4])->active) {

869

strarr[9] = g_strdup("1");

870

} else {

871

strarr[9] = g_strdup("2");

872

}

873

if (GTK_TOGGLE_BUTTON(pd->hpd.radio[6])->active){

874

strarr[10] = g_strdup("0");

875

} else if (GTK_TOGGLE_BUTTON(pd->hpd.radio[7])->active) {

876

strarr[10] = g_strdup("1");

877

} else {

878

strarr[10] = g_strdup("2");

879

}

880

strarr[11] = NULL;

881

DEBUG_MSG("highlightpattern_create_strarr, strarr at %p with count %d\n", strarr, count_array(strarr));

882

return strarr;

883

}

884

885

static void highlightpattern_apply_changes(Tprefdialog *pd) {

886

DEBUG_MSG("highlightpattern_apply_changes, started\n");

887

if (pd->hpd.curstrarr) {

888

GList *tmplist;

889

tmplist = g_list_first(pd->lists[highlight_patterns]);

890

while (tmplist) {

891

if (tmplist->data == pd->hpd.curstrarr) {

892

DEBUG_MSG("highlightpattern_apply_changes, curstrarr==tmplist->data==%p\n", tmplist->data);

893

g_strfreev(tmplist->data);

894

tmplist->data = highlightpattern_create_strarr(pd);

895

pd->hpd.curstrarr = tmplist->data;

896

DEBUG_MSG("highlightpattern_apply_changes, new strarr for %s-%s\n",pd->hpd.curstrarr[0],pd->hpd.curstrarr[1]);

897

return;

898

}

899

tmplist = g_list_next(tmplist);

900

}

901

DEBUG_MSG("highlightpattern_apply_changes, nothing found for curstrarr %p?!?\n", pd->hpd.curstrarr);

902

}

903

DEBUG_MSG("highlightpattern_apply_changes, no curstrarr, nothing to apply\n");

904

}

905

906

static void highlightpattern_fill_from_selected_filetype(Tprefdialog *pd) {

907

DEBUG_MSG("highlightpattern_popmenu_activate, applied changes, about to clear liststore\n");

908

gtk_list_store_clear(GTK_LIST_STORE(pd->hpd.lstore));

909

if (pd->hpd.selected_filetype) {

910

GList *tmplist;

911

tmplist = g_list_first(pd->lists[highlight_patterns]);

912

DEBUG_MSG("highlightpattern_popmenu_activate, about to fill for filetype %s (tmplist=%p)\n",pd->hpd.selected_filetype,tmplist);

913

/* fill list model here */

914

while (tmplist) {

915

gchar **strarr =(gchar **)tmplist->data;

916

if (count_array(strarr) ==11 && strarr[0]) {

917

DEBUG_MSG("found entry with filetype %s\n",strarr[0]);

918

if (strcmp(strarr[0], pd->hpd.selected_filetype)==0) {

919

GtkTreeIter iter;

920

DEBUG_MSG("highlightpattern_popmenu_activate, appending pattern %s with filetype %s\n",strarr[1],strarr[0]);

921

gtk_list_store_append(GTK_LIST_STORE(pd->hpd.lstore), &iter);

922

gtk_list_store_set(GTK_LIST_STORE(pd->hpd.lstore), &iter, 0, strarr[1], -1);

923

}

924

}

925

tmplist = g_list_next(tmplist);

926

}

927

}

928

pd->hpd.curstrarr = NULL;

929

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[0]), "");

930

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[1]), "");

931

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[2]), "");

932

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[3]), "");

933

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[4]), "");

934

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[5]), "");

935

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.check), FALSE);

936

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[0]),TRUE);

937

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[3]),TRUE);

938

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[6]),TRUE);

939

}

940

941

static void highlightpattern_popmenu_activate(GtkMenuItem *menuitem,Tprefdialog *pd) {

942

DEBUG_MSG("highlightpattern_popmenu_activate, pd=%p, menuitem=%p\n", pd, menuitem);

943

highlightpattern_apply_changes(pd);

944

pd->hpd.curstrarr = NULL;

945

if (menuitem) {

946

pd->hpd.selected_filetype = gtk_label_get_text(GTK_LABEL(GTK_BIN(menuitem)->child));

947

}

948

highlightpattern_fill_from_selected_filetype(pd);

949

}

950

951

static void add_new_highlightpattern_lcb(GtkWidget *wid, Tprefdialog *pd) {

952

gchar *pattern = gtk_editable_get_chars(GTK_EDITABLE(pd->hpd.entry[0]),0,-1);

953

if (pattern && pd->hpd.selected_filetype && strlen(pattern) && strlen(pd->hpd.selected_filetype)) {

954

gchar **strarr = highlightpattern_create_strarr(pd);

955

DEBUG_MSG("add_new_highlightpattern_lcb, appending strarr %p to list\n", strarr);

956

pd->lists[highlight_patterns] = g_list_append(pd->lists[highlight_patterns], strarr);

957

pd->hpd.curstrarr = NULL;

958

{

959

GtkTreeIter iter;

960

GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->hpd.lview));

961

DEBUG_MSG("add_new_highlightpattern_lcb, appending to lview\n");

962

gtk_list_store_append(GTK_LIST_STORE(pd->hpd.lstore), &iter);

963

gtk_list_store_set(GTK_LIST_STORE(pd->hpd.lstore), &iter, 0, strarr[1], -1);

964

gtk_tree_selection_select_iter(selection,&iter);

965

}

966

/* gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[0]), "");*/

967

} else {

968

g_free(pattern);

969

}

970

}

971

972

static void highlightpattern_selection_changed_cb(GtkTreeSelection *selection, Tprefdialog *pd) {

973

GtkTreeIter iter;

974

GtkTreeModel *model;

975

DEBUG_MSG("highlightpattern_selection_changed_cb, started\n");

976

if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

977

gchar *pattern;

978

GList *tmplist = g_list_first(pd->lists[highlight_patterns]);

979

/* GtkWidget *menuitem = gtk_menu_get_active(GTK_MENU( gtk_option_menu_get_menu(GTK_OPTION_MENU(pd->hpd.popmenu)) ));*/

980

gtk_tree_model_get(model, &iter, 0, &pattern, -1);

981

DEBUG_MSG("highlightpattern_selection_changed_cb, selected=%s\n",pattern);

982

highlightpattern_apply_changes(pd);

983

pd->hpd.curstrarr = NULL;

984

DEBUG_MSG("changed applied, searching for the data of the new selection\n");

985

while (tmplist) {

986

gchar **strarr =(gchar **)tmplist->data;

987

#ifdef DEBUG

988

if (strarr == NULL){

989

DEBUG_MSG("strarr== NULL !!!!!!!!!!!!!!!\n");

990

}

991

#endif

992

if (strcmp(strarr[1], pattern)==0 && strcmp(strarr[0], pd->hpd.selected_filetype)==0) {

993

DEBUG_MSG("highlightpattern_selection_changed_cb, found strarr=%p\n", strarr);

994

DEBUG_MSG("0=%s, 1=%s, 2=%s, 3=%s, 4=%s\n",strarr[0],strarr[1],strarr[2],strarr[3],strarr[4]);

995

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.check), (strarr[2][0] == '0'));

996

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[0]), strarr[1]);

997

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[1]), strarr[3]);

998

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[2]), strarr[4]);

999

if (strarr[5][0] == '3') {

1000

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[2]),TRUE);

1001

} else if (strarr[5][0] == '2') {

1002

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[1]),TRUE);

1003

} else {

1004

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[0]),TRUE);

1005

}

1006

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[3]), strarr[6]);

1007

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[4]), strarr[7]);

1008

gtk_entry_set_text(GTK_ENTRY(pd->hpd.entry[5]), strarr[8]);

1009

if (strarr[9][0] == '2') {

1010

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[5]),TRUE);

1011

} else if (strarr[9][0] == '1') {

1012

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[4]),TRUE);

1013

} else {

1014

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[3]),TRUE);

1015

}

1016

DEBUG_MSG("strarr[10]=%s, \n",strarr[10]);

1017

if (strarr[10][0] == '2') {

1018

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[8]),TRUE);

1019

} else if (strarr[10][0] == '1') {

1020

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[7]),TRUE);

1021

} else {

1022

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->hpd.radio[6]),TRUE);

1023

}

1024

pd->hpd.curstrarr = strarr;

1025

break;

1026

}

1027

tmplist = g_list_next(tmplist);

1028

}

1029

g_free(pattern);

1030

} else {

1031

DEBUG_MSG("no selection, returning..\n");

1032

}

1033

}

1034

static void highlightpattern_type_toggled(GtkToggleButton *togglebutton,Tprefdialog *pd){

1035

DEBUG_MSG("highlightpattern_type_toggled, started\n");

1036

if (GTK_TOGGLE_BUTTON(pd->hpd.radio[0])->active) {

1037

gtk_widget_set_sensitive(pd->hpd.entry[2], TRUE);

1038

} else {

1039

gtk_widget_set_sensitive(pd->hpd.entry[2], FALSE);

1040

}

1041

DEBUG_MSG("highlightpattern_type_toggled, done\n");

1042

}

1043

static void highlightpattern_up_clicked_lcb(GtkWidget *wid, Tprefdialog *pd) {

1044

GtkTreeIter iter;

1045

GtkTreeModel *model;

1046

gchar *pattern;

1047

1048

GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->hpd.lview));

1049

if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

1050

GList *previous=NULL, *tmplist = g_list_first(pd->lists[highlight_patterns]);

1051

gtk_tree_model_get(model, &iter, 0, &pattern, -1);

1052

DEBUG_MSG("highlightpattern_up_clicked_lcb, selected=%s\n",pattern);

1053

while (tmplist) {

1054

gchar **strarr =(gchar **)tmplist->data;

1055

if (strcmp(strarr[0], pd->hpd.selected_filetype)==0) {

1056

DEBUG_MSG("highlightpattern_up_clicked_lcb, comparing %s+%s for filetype %s\n",strarr[1], pattern,pd->hpd.selected_filetype);

1057

if (strcmp(strarr[1], pattern)==0) {

1058

DEBUG_MSG("highlightpattern_up_clicked_lcb, found %s, previous=%p, tmplist=%p\n",strarr[1],previous,tmplist);

1059

if (previous) {

1060

DEBUG_MSG("highlightpattern_up_clicked_lcb, switch list order %s <-> %s\n",((gchar **)tmplist->data)[1], ((gchar **)previous->data)[1]);

1061

list_switch_order(tmplist, previous);

1062

highlightpattern_popmenu_activate(NULL, pd);

1063

}

1064

return;

1065

}

1066

previous = tmplist;

1067

}

1068

tmplist = g_list_next(tmplist);

1069

}

1070

}

1071

}

1072

static void highlightpattern_down_clicked_lcb(GtkWidget *wid, Tprefdialog *pd) {

1073

GtkTreeIter iter;

1074

GtkTreeModel *model;

1075

gchar *pattern;

1076

GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->hpd.lview));

1077

if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

1078

GList *tmplist = g_list_first(pd->lists[highlight_patterns]);

1079

gtk_tree_model_get(model, &iter, 0, &pattern, -1);

1080

while (tmplist) {

1081

gchar **strarr =(gchar **)tmplist->data;

1082

if (strcmp(strarr[1], pattern)==0 && strcmp(strarr[0], pd->hpd.selected_filetype)==0) {

1083

if (tmplist->next) {

1084

list_switch_order(tmplist, tmplist->next);

1085

highlightpattern_popmenu_activate(NULL, pd);

1086

return;

1087

}

1088

}

1089

tmplist = g_list_next(tmplist);

1090

}

1091

}

1092

}

1093

static void highlightpattern_delete_clicked_lcb(GtkWidget *wid, Tprefdialog *pd) {

1094

GtkTreeIter iter;

1095

GtkTreeModel *model;

1096

gchar *pattern;

1097

GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->hpd.lview));

1098

if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

1099

GList *tmplist = g_list_first(pd->lists[highlight_patterns]);

1100

gtk_tree_model_get(model, &iter, 0, &pattern, -1);

1101

while (tmplist) {

1102

gchar **strarr =(gchar **)tmplist->data;

1103

if (strcmp(strarr[1], pattern)==0 && strcmp(strarr[0], pd->hpd.selected_filetype)==0) {

1104

pd->hpd.curstrarr = NULL;

1105

pd->lists[highlight_patterns] = g_list_remove(pd->lists[highlight_patterns], strarr);

1106

g_strfreev(strarr);

1107

highlightpattern_popmenu_activate(NULL, pd);

1108

return;

1109

}

1110

tmplist = g_list_next(tmplist);

1111

}

1112

}

1113

}

1114

1115

static void highlightpattern_gui_rebuild_filetype_popup(Tprefdialog *pd) {

1116

GList *tmplist;

1117

GtkWidget *menu, *menuitem;

1118

gtk_option_menu_remove_menu(GTK_OPTION_MENU(pd->hpd.popmenu));

1119

menu = gtk_menu_new();

1120

gtk_option_menu_set_menu(GTK_OPTION_MENU(pd->hpd.popmenu), menu);

1121

gtk_widget_show(menu);

1122

tmplist = g_list_first(pd->lists[filetypes]);

1123

while (tmplist) {

1124

gchar **arr = (gchar **)tmplist->data;

1125

if (count_array(arr)>=3) {

1126

menuitem = gtk_menu_item_new_with_label(arr[0]);

1127

DEBUG_MSG("highlightpattern_gui_rebuild_filetype_popup, menuitem=%p for %s\n", menuitem, arr[0]);

1128

g_signal_connect(GTK_OBJECT(menuitem), "activate",G_CALLBACK(highlightpattern_popmenu_activate),pd);

1129

gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);

1130

gtk_widget_show(menuitem);

1131

}

1132

tmplist = g_list_next(tmplist);

1133

}

1134

}

1135

1136

static void highlightpattern_reset_clicked_lcb(GtkWidget *button, Tprefdialog *pd) {

1137

gchar *defaultfile = return_first_existing_filename(PKGDATADIR"highlighting.default",

1138

"data/highlighting.default",

1139

"../data/highlighting.default",NULL);

1140

if (defaultfile) {

1141

/* get current selected filetype && create array to compare to*/

1142

gchar **compare = array_from_arglist(pd->hpd.selected_filetype, NULL);

1143

DEBUG_MSG("highlightpattern_reset_clicked_lcb, defaultfile=%s\n",defaultfile);

1144

/* delete filetype from arraylist */

1145

pd->lists[highlight_patterns] = arraylist_delete_identical(pd->lists[highlight_patterns], compare, 1, TRUE);

1146

/* load filetype from default file */

1147

pd->lists[highlight_patterns] = arraylist_append_identical_from_file(pd->lists[highlight_patterns], defaultfile, compare, 1, TRUE);

1148

g_strfreev(compare);

1149

/* re-load selected filetype in preferences gui */

1150

DEBUG_MSG("highlightpattern_reset_clicked_lcb, about to rebuild gui\n");

1151

highlightpattern_fill_from_selected_filetype(pd);

1152

g_free (defaultfile);

1153

}

1154

}

1155

1156

static void create_highlightpattern_gui(Tprefdialog *pd, GtkWidget *vbox1) {

1157

GtkWidget *hbox, *but, *vbox3;

1158

pd->lists[highlight_patterns] = duplicate_arraylist(main_v->props.highlight_patterns);

1159

1160

DEBUG_MSG("create_highlightpattern_gui, pd=%p, pd->lists[highlight_patterns]=%p\n", pd, pd->lists[highlight_patterns]);

1161

hbox = gtk_hbox_new(FALSE, 0);

1162

gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 3);

1163

1164

gtk_box_pack_start(GTK_BOX(hbox),gtk_label_new(_("filetype")),FALSE, FALSE, 3);

1165

pd->hpd.popmenu = gtk_option_menu_new();

1166

gtk_option_menu_set_menu(GTK_OPTION_MENU(pd->hpd.popmenu), gtk_menu_new());

1167

highlightpattern_gui_rebuild_filetype_popup(pd);

1168

gtk_box_pack_start(GTK_BOX(hbox),pd->hpd.popmenu,TRUE, TRUE, 3);

1169

but = gtk_button_new_with_label(_("Reset"));

1170

g_signal_connect(G_OBJECT(but), "clicked", G_CALLBACK(highlightpattern_reset_clicked_lcb), pd);

1171

gtk_box_pack_start(GTK_BOX(hbox),but,FALSE, FALSE, 3);

1172

1173

hbox = gtk_hbox_new(FALSE, 0);

1174

gtk_box_pack_start(GTK_BOX(vbox1), hbox, TRUE, TRUE, 3);

1175

pd->hpd.entry[0] = boxed_full_entry(_("Pattern name"), NULL, 500, hbox);

1176

1177

but = bf_gtkstock_button(GTK_STOCK_ADD, G_CALLBACK(add_new_highlightpattern_lcb), pd);

1178

gtk_box_pack_start(GTK_BOX(hbox), but, FALSE, TRUE, 3);

1179

but = bf_gtkstock_button(GTK_STOCK_DELETE, G_CALLBACK(highlightpattern_delete_clicked_lcb), pd);

1180

gtk_box_pack_start(GTK_BOX(hbox), but, FALSE, FALSE, 1);

1181

1182

hbox = gtk_hbox_new(FALSE, 0);

1183

gtk_box_pack_start(GTK_BOX(vbox1), hbox, TRUE, TRUE, 0);

1184

1185

pd->hpd.lstore = gtk_list_store_new (1, G_TYPE_STRING);

1186

pd->hpd.lview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pd->hpd.lstore));

1187

{

1188

GtkTreeViewColumn *column;

1189

GtkWidget *scrolwin;

1190

GtkTreeSelection *select;

1191

GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();

1192

1193

column = gtk_tree_view_column_new_with_attributes (_("Pattern"), renderer,"text", 0,NULL);

1194

gtk_tree_view_append_column (GTK_TREE_VIEW(pd->hpd.lview), column);

1195

scrolwin = gtk_scrolled_window_new(NULL, NULL);

1196

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

1197

gtk_container_add(GTK_CONTAINER(scrolwin), pd->hpd.lview);

1198

gtk_box_pack_start(GTK_BOX(hbox), scrolwin, FALSE, TRUE, 2);

1199

1200

select = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->hpd.lview));

1201

g_signal_connect(G_OBJECT(select), "changed",G_CALLBACK(highlightpattern_selection_changed_cb),pd);

1202

}

1203

1204

vbox3 = gtk_vbox_new(FALSE, 2);

1205

gtk_box_pack_start(GTK_BOX(hbox), vbox3, FALSE, FALSE, 2);

1206

/* pack up and down buttons here */

1207

1208

but = bf_gtkstock_button(GTK_STOCK_GO_UP, G_CALLBACK(highlightpattern_up_clicked_lcb), pd);

1209

gtk_box_pack_start(GTK_BOX(vbox3), but, FALSE, FALSE, 1);

1210

but = bf_gtkstock_button(GTK_STOCK_GO_DOWN, G_CALLBACK(highlightpattern_down_clicked_lcb), pd);

1211

gtk_box_pack_start(GTK_BOX(vbox3), but, FALSE, FALSE, 1);

1212

1213

vbox3 = gtk_vbox_new(FALSE, 0);

1214

gtk_box_pack_start(GTK_BOX(hbox), vbox3, TRUE, TRUE, 2);

1215

1216

pd->hpd.radio[0] = gtk_radio_button_new_with_label(NULL, _("Start pattern and end pattern"));

1217

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[0], TRUE, TRUE, 0);

1218

pd->hpd.radio[1] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(pd->hpd.radio[0]), _("Only start pattern"));

1219

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[1], TRUE, TRUE, 0);

1220

pd->hpd.radio[2] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(pd->hpd.radio[0]), _("Subpattern from parent"));

1221

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[2], TRUE, TRUE, 0);

1222

g_signal_connect(G_OBJECT(pd->hpd.radio[0]), "toggled", G_CALLBACK(highlightpattern_type_toggled), pd);

1223

g_signal_connect(G_OBJECT(pd->hpd.radio[1]), "toggled", G_CALLBACK(highlightpattern_type_toggled), pd);

1224

g_signal_connect(G_OBJECT(pd->hpd.radio[2]), "toggled", G_CALLBACK(highlightpattern_type_toggled), pd);

1225

1226

pd->hpd.entry[1] = boxed_full_entry(_("Start pattern"), NULL, 4000, vbox3);

1227

pd->hpd.entry[2] = boxed_full_entry(_("End pattern"), NULL, 4000, vbox3);

1228

pd->hpd.check = boxed_checkbut_with_value(_("Case sensitive matching"), FALSE, vbox3);

1229

pd->hpd.entry[3] = boxed_full_entry(_("Parentmatch"), NULL, 300, vbox3);

1230

pd->hpd.entry[4] = prefs_string(_("Foreground color"), "", vbox3, pd, string_color);

1231

pd->hpd.entry[5] = prefs_string(_("Background color"), "", vbox3, pd, string_color);

1232

1233

hbox = gtk_hbox_new(FALSE, 0);

1234

gtk_box_pack_start(GTK_BOX(vbox1), hbox, TRUE, TRUE, 0);

1235

1236

vbox3 = gtk_vbox_new(FALSE, 0);

1237

gtk_box_pack_start(GTK_BOX(hbox), vbox3, TRUE, TRUE, 0);

1238

1239

pd->hpd.radio[3] = gtk_radio_button_new_with_label(NULL, _("don't change weight"));

1240

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[3], TRUE, TRUE, 0);

1241

pd->hpd.radio[4] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(pd->hpd.radio[3]), _("force non-bold weight"));

1242

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[4], TRUE, TRUE, 0);

1243

pd->hpd.radio[5] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(pd->hpd.radio[3]), _("force bold weight"));

1244

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[5], TRUE, TRUE, 0);

1245

1246

vbox3 = gtk_vbox_new(FALSE, 0);

1247

gtk_box_pack_start(GTK_BOX(hbox), vbox3, TRUE, TRUE, 0);

1248

1249

pd->hpd.radio[6] = gtk_radio_button_new_with_label(NULL, _("don't change style"));

1250

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[6], TRUE, TRUE, 0);

1251

pd->hpd.radio[7] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(pd->hpd.radio[6]), _("force non-italic style"));

1252

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[7], TRUE, TRUE, 0);

1253

pd->hpd.radio[8] = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(pd->hpd.radio[6]), _("force italic style"));

1254

gtk_box_pack_start(GTK_BOX(vbox3),pd->hpd.radio[8], TRUE, TRUE, 0);

1255

}

1256

1257

static gchar **browser_create_strarr(Tprefdialog *pd) {

1258

return generic_create_strarr(2, pd->bd.entry, TRUE);

1259

}

1260

1261

static void browsers_apply_changes(Tprefdialog *pd) {

1262

DEBUG_MSG("browsers_apply_changes, started\n");

1263

if (pd->bd.curstrarr) {

1264

gchar **strarr;

1265

strarr = browser_create_strarr(pd);

1266

if (strarr) {

1267

GList *tmplist;

1268

GtkTreeIter iter;

1269

gboolean retval = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pd->bd.lstore),&iter);

1270

while (retval) {

1271

gchar *curval;

1272

gtk_tree_model_get(GTK_TREE_MODEL(pd->bd.lstore),&iter,0,&curval,-1);

1273

if (strcmp(curval,pd->bd.curstrarr[0])==0) {

1274

gtk_list_store_set(GTK_LIST_STORE(pd->bd.lstore), &iter

1275

,0,strarr[0]

1276

,1,strarr[1]

1277

,-1);

1278

DEBUG_MSG("browsers_apply_changes, changed in tree model\n");

1279

break;

1280

}

1281

retval = gtk_tree_model_iter_next(GTK_TREE_MODEL(pd->bd.lstore),&iter);

1282

}

1283

1284

tmplist = g_list_first(pd->lists[browsers]);

1285

while (tmplist) {

1286

if (tmplist->data == pd->bd.curstrarr) {

1287

g_strfreev(pd->bd.curstrarr);

1288

tmplist->data = strarr;

1289

pd->bd.curstrarr = strarr;

1290

DEBUG_MSG("browsers_apply_changes, changed custrarr\n");

1291

break;

1292

}

1293

tmplist = g_list_next(tmplist);

1294

}

1295

} else {

1296

DEBUG_MSG("browsers_apply_changes, strarr=NULL!!\n");

1297

}

1298

} else {

1299

DEBUG_MSG("browsers_apply_changes, NO curstrarr!!\n");

1300

}

1301

}

1302

1303

static void add_new_browser_lcb(GtkWidget *wid, Tprefdialog *pd) {

1304

gchar **strarr;

1305

strarr = browser_create_strarr(pd);

1306

if (strarr) {

1307

GtkTreeIter iter;

1308

pd->lists[browsers] = g_list_append(pd->lists[browsers], strarr);

1309

gtk_list_store_append(GTK_LIST_STORE(pd->bd.lstore), &iter);

1310

gtk_list_store_set(GTK_LIST_STORE(pd->bd.lstore), &iter

1311

,0,strarr[0]

1312

,1,strarr[1]

1313

,-1);

1314

}

1315

}

1316

1317

static void delete_browser_lcb(GtkWidget *wid, Tprefdialog *pd) {

1318

if (pd->bd.curstrarr) {

1319

GtkTreeIter iter;

1320

gboolean retval= gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pd->bd.lstore),&iter);

1321

while (retval) {

1322

gchar *curval;

1323

gtk_tree_model_get(GTK_TREE_MODEL(pd->bd.lstore),&iter,0,&curval,-1);

1324

if (strcmp(curval,pd->bd.curstrarr[0])==0) {

1325

gtk_list_store_remove(GTK_LIST_STORE(pd->bd.lstore),&iter);

1326

break;

1327

}

1328

retval = gtk_tree_model_iter_next(GTK_TREE_MODEL(pd->bd.lstore),&iter);

1329

}

1330

pd->lists[browsers] = g_list_remove(pd->lists[browsers],pd->bd.curstrarr);

1331

}

1332

}

1333

1334

static void set_default_browser_lcb(GtkWidget *wid, Tprefdialog *pd) {

1335

if (pd->bd.curstrarr) {

1336

GtkTreeIter iter;

1337

gboolean retval=gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pd->bd.lstore),&iter);

1338

while (retval) {

1339

gchar *curval;

1340

gtk_tree_model_get(GTK_TREE_MODEL(pd->bd.lstore),&iter,0,&curval,-1);

1341

if (strcmp((char *)curval,pd->bd.curstrarr[0])==0) {

1342

gtk_list_store_remove((pd->bd.lstore),&iter);

1343

break;

1344

}

1345

retval = gtk_tree_model_iter_next(GTK_TREE_MODEL(pd->bd.lstore),&iter);

1346

}

1347

gtk_list_store_insert((pd->bd.lstore),&iter,0);

1348

gtk_list_store_set(GTK_LIST_STORE(pd->bd.lstore), &iter

1349

,0,pd->bd.curstrarr[0]

1350

,1,pd->bd.curstrarr[1]

1351

,-1);

1352

pd->lists[browsers] = g_list_remove(pd->lists[browsers],pd->bd.curstrarr);

1353

pd->lists[browsers] = g_list_insert(pd->lists[browsers],pd->bd.curstrarr,0);

1354

}

1355

}

1356

static void browser_selection_changed_cb(GtkTreeSelection *selection, Tprefdialog *pd) {

1357

DEBUG_MSG("browser_selection_changed_cb, curstrarr=%p, &curstrarr=%p\n", pd->ftd.curstrarr, &pd->bd.curstrarr);

1358

generic_selection_changed_cb(selection,pd->bd.entry,browsers_apply_changes,pd,browsers,2,&pd->bd.curstrarr);

1359

DEBUG_MSG("browser_selection_changed_cb, curstrarr=%p, &curstrarr=%p\n", pd->ftd.curstrarr, &pd->bd.curstrarr);

1360

}*/

1361

static void set_browser_strarr_in_list(GtkTreeIter *iter, gchar **strarr, Tprefdialog *pd) {

1362

gint arrcount = count_array(strarr);

1363

if (arrcount==2) {

1364

gtk_list_store_set(GTK_LIST_STORE(pd->bd.lstore), iter

1365

,0,strarr[0],1,strarr[1],2,strarr,-1);

1366

} else {

1367

DEBUG_MSG("ERROR: set_browser_strarr_in_list, arraycount != 2 !!!!!!\n");

1368

}

1369

}

1370

static void browser_apply_change(Tprefdialog *pd, gint type, gchar *path, gchar *newval, gint index) {

1371

pref_apply_change(pd->bd.lstore,2,type,path,newval,index);

1372

}

1373

static void browser_0_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1374

browser_apply_change(pd, 1, path, newtext, 0);

1375

}

1376

static void browser_1_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1377

browser_apply_change(pd, 1, path, newtext, 1);

1378

}

1379

static void add_new_browser_lcb(GtkWidget *wid, Tprefdialog *pd) {

1380

gchar **strarr;

1381

GtkTreeIter iter;

1382

strarr = pref_create_empty_strarr(2);

1383

gtk_list_store_append(GTK_LIST_STORE(pd->bd.lstore), &iter);

1384

set_browser_strarr_in_list(&iter, strarr,pd);

1385

pd->lists[browsers] = g_list_append(pd->lists[browsers], strarr);

1386

pd->bd.insertloc = -1;

1387

}

1388

static void delete_browser_lcb(GtkWidget *wid, Tprefdialog *pd) {

1389

pref_delete_strarr(pd, &pd->bd, 2);

1390

}

1391

static void create_browsers_gui(Tprefdialog *pd, GtkWidget *vbox1) {

1392

GtkWidget *hbox, *but, *scrolwin;

1393

pd->lists[browsers] = duplicate_arraylist(main_v->props.browsers);

1394

pd->bd.lstore = gtk_list_store_new (3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_POINTER);

1395

pd->bd.lview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pd->bd.lstore));

1396

pref_create_column(GTK_TREE_VIEW(pd->bd.lview), 1, G_CALLBACK(browser_0_edited_lcb), pd, _("Label"), 0);

1397

pref_create_column(GTK_TREE_VIEW(pd->bd.lview), 1, G_CALLBACK(browser_1_edited_lcb), pd, _("Command"), 1);

1398

scrolwin = gtk_scrolled_window_new(NULL, NULL);

1399

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);

1400

gtk_container_add(GTK_CONTAINER(scrolwin), pd->bd.lview);

1401

gtk_widget_set_size_request(scrolwin, 150, 190);

1402

gtk_box_pack_start(GTK_BOX(vbox1), scrolwin, TRUE, TRUE, 2);

1403

{

1404

GList *tmplist = g_list_first(pd->lists[browsers]);

1405

while (tmplist) {

1406

gchar **strarr = (gchar **)tmplist->data;

1407

GtkTreeIter iter;

1408

gtk_list_store_append(GTK_LIST_STORE(pd->bd.lstore), &iter);

1409

set_browser_strarr_in_list(&iter, strarr,pd);

1410

tmplist = g_list_next(tmplist);

1411

}

1412

}

1413

gtk_tree_view_set_reorderable(GTK_TREE_VIEW(pd->bd.lview), TRUE);

1414

pd->bd.thelist = &pd->lists[browsers];

1415

pd->bd.insertloc = -1;

1416

g_signal_connect(G_OBJECT(pd->bd.lstore), "row-inserted", G_CALLBACK(listpref_row_inserted), &pd->bd);

1417

g_signal_connect(G_OBJECT(pd->bd.lstore), "row-deleted", G_CALLBACK(listpref_row_deleted), &pd->bd);

1418

1419

hbox = gtk_hbox_new(FALSE, 0);

1420

gtk_box_pack_start(GTK_BOX(vbox1),hbox, TRUE, TRUE, 2);

1421

but = bf_gtkstock_button(GTK_STOCK_ADD, G_CALLBACK(add_new_browser_lcb), pd);

1422

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

1423

but = bf_gtkstock_button(GTK_STOCK_DELETE, G_CALLBACK(delete_browser_lcb), pd);

1424

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

1425

}

1426

1427

static gchar **external_create_strarr(Tprefdialog *pd) {

1428

return generic_create_strarr(2, pd->ed.entry, TRUE);

1429

}

1430

1431

static void externals_apply_changes(Tprefdialog *pd) {

1432

DEBUG_MSG("externals_apply_changes, started\n");

1433

if (pd->ed.curstrarr) {

1434

gchar **strarr;

1435

strarr = external_create_strarr(pd);

1436

if (strarr) {

1437

GList *tmplist;

1438

GtkTreeIter iter;

1439

gboolean retval = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pd->ed.lstore),&iter);

1440

while (retval) {

1441

gchar *curval;

1442

gtk_tree_model_get(GTK_TREE_MODEL(pd->ed.lstore),&iter,0,&curval,-1);

1443

if (strcmp(curval,pd->ed.curstrarr[0])==0) {

1444

gtk_list_store_set(GTK_LIST_STORE(pd->ed.lstore), &iter

1445

,0,strarr[0]

1446

,1,strarr[1]

1447

,-1);

1448

DEBUG_MSG("externals_apply_changes, changed in tree model\n");

1449

break;

1450

}

1451

retval = gtk_tree_model_iter_next(GTK_TREE_MODEL(pd->ed.lstore),&iter);

1452

}

1453

1454

tmplist = g_list_first(pd->lists[external_commands]);

1455

while (tmplist) {

1456

if (tmplist->data == pd->ed.curstrarr) {

1457

g_strfreev(pd->ed.curstrarr);

1458

tmplist->data = strarr;

1459

pd->ed.curstrarr = strarr;

1460

DEBUG_MSG("externals_apply_changes, changed custrarr\n");

1461

break;

1462

}

1463

tmplist = g_list_next(tmplist);

1464

}

1465

} else {

1466

DEBUG_MSG("externals_apply_changes, NO strarr!!\n");

1467

}

1468

} else {

1469

DEBUG_MSG("externals_apply_changes, NO curstrarr!!\n");

1470

}

1471

}

1472

1473

static void external_selection_changed_cb(GtkTreeSelection *selection, Tprefdialog *pd) {

1474

DEBUG_MSG("external_selection_changed_cb, started\n");

1475

generic_selection_changed_cb(selection,pd->ed.entry,externals_apply_changes,pd,external_commands,2,&pd->ed.curstrarr);

1476

}

1477

1478

static void add_new_external_lcb(GtkWidget *wid, Tprefdialog *pd) {

1479

gchar **strarr;

1480

strarr = external_create_strarr(pd);

1481

if (strarr) {

1482

GtkTreeIter iter;

1483

pd->lists[external_commands] = g_list_append(pd->lists[external_commands], strarr);

1484

gtk_list_store_append(GTK_LIST_STORE(pd->ed.lstore), &iter);

1485

gtk_list_store_set(GTK_LIST_STORE(pd->ed.lstore), &iter

1486

,0,strarr[0]

1487

,1,strarr[1]

1488

,-1);

1489

}

1490

}

1491

1492

static void delete_external_commands_lcb(GtkWidget *wid, Tprefdialog *pd) {

1493

GtkTreeSelection *select;

1494

GtkTreeIter iter;

1495

gboolean retval;

1496

1497

select = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->ed.lview));

1498

retval = gtk_tree_selection_get_selected (select,NULL,&iter);

1499

if(retval) {

1500

gchar *curval;

1501

GList *work = NULL;

1502

gchar **curstrarr;

1503

1504

gtk_tree_model_get(GTK_TREE_MODEL(pd->ed.lstore),&iter,0,&curval,-1);

1505

gtk_list_store_remove(pd->ed.lstore,&iter);

1506

work = pd->lists[external_commands];

1507

while(work) {

1508

curstrarr = work->data;

1509

if (strcmp(curval,curstrarr[0])==0) {

1510

pd->lists[external_commands] = g_list_remove(pd->lists[external_commands],curstrarr);

1511

break;

1512

}

1513

work = g_list_next(work);

1514

}

1515

g_free(curval);

1516

}

1517

}*/

1518

1519

static void set_external_commands_strarr_in_list(GtkTreeIter *iter, gchar **strarr, Tprefdialog *pd) {

1520

gint arrcount = count_array(strarr);

1521

if (arrcount==2) {

1522

gtk_list_store_set(GTK_LIST_STORE(pd->ed.lstore), iter

1523

,0,strarr[0],1,strarr[1],2,strarr,-1);

1524

} else {

1525

DEBUG_MSG("ERROR: set_external_command_strarr_in_list, arraycount != 2 !!!!!!\n");

1526

}

1527

}

1528

static void external_commands_apply_change(Tprefdialog *pd, gint type, gchar *path, gchar *newval, gint index) {

1529

pref_apply_change(pd->ed.lstore,2,type,path,newval,index);

1530

}

1531

static void external_commands_0_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1532

external_commands_apply_change(pd, 1, path, newtext, 0);

1533

}

1534

static void external_commands_1_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1535

external_commands_apply_change(pd, 1, path, newtext, 1);

1536

}

1537

static void add_new_external_commands_lcb(GtkWidget *wid, Tprefdialog *pd) {

1538

gchar **strarr;

1539

GtkTreeIter iter;

1540

strarr = pref_create_empty_strarr(2);

1541

gtk_list_store_append(GTK_LIST_STORE(pd->ed.lstore), &iter);

1542

set_external_commands_strarr_in_list(&iter, strarr,pd);

1543

pd->lists[external_commands] = g_list_append(pd->lists[external_commands], strarr);

1544

pd->ed.insertloc = -1;

1545

}

1546

static void delete_external_commands_lcb(GtkWidget *wid, Tprefdialog *pd) {

1547

pref_delete_strarr(pd, &pd->ed, 2);

1548

}

1549

static void create_externals_gui(Tprefdialog *pd, GtkWidget *vbox1) {

1550

GtkWidget *hbox, *but, *scrolwin;

1551

pd->lists[external_commands] = duplicate_arraylist(main_v->props.external_commands);

1552

pd->ed.lstore = gtk_list_store_new (3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_POINTER);

1553

pd->ed.lview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pd->ed.lstore));

1554

pref_create_column(GTK_TREE_VIEW(pd->ed.lview), 1, G_CALLBACK(external_commands_0_edited_lcb), pd, _("Label"), 0);

1555

pref_create_column(GTK_TREE_VIEW(pd->ed.lview), 1, G_CALLBACK(external_commands_1_edited_lcb), pd, _("Command"), 1);

1556

scrolwin = gtk_scrolled_window_new(NULL, NULL);

1557

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);

1558

gtk_container_add(GTK_CONTAINER(scrolwin), pd->ed.lview);

1559

gtk_widget_set_size_request(scrolwin, 120, 190);

1560

gtk_box_pack_start(GTK_BOX(vbox1), scrolwin, TRUE, TRUE, 2);

1561

{

1562

GList *tmplist = g_list_first(pd->lists[external_commands]);

1563

while (tmplist) {

1564

gchar **strarr = (gchar **)tmplist->data;

1565

GtkTreeIter iter;

1566

gtk_list_store_append(GTK_LIST_STORE(pd->ed.lstore), &iter);

1567

set_external_commands_strarr_in_list(&iter, strarr,pd);

1568

tmplist = g_list_next(tmplist);

1569

}

1570

}

1571

gtk_tree_view_set_reorderable(GTK_TREE_VIEW(pd->ed.lview), TRUE);

1572

pd->ed.thelist = &pd->lists[external_commands];

1573

pd->ed.insertloc = -1;

1574

g_signal_connect(G_OBJECT(pd->ed.lstore), "row-inserted", G_CALLBACK(listpref_row_inserted), &pd->ed);

1575

g_signal_connect(G_OBJECT(pd->ed.lstore), "row-deleted", G_CALLBACK(listpref_row_deleted), &pd->ed);

1576

gtk_box_pack_start(GTK_BOX(vbox1),gtk_label_new(_("%s for current filename (any command)\n%i for input and %f for output filename (filters)")), TRUE, TRUE, 2);

1577

hbox = gtk_hbox_new(FALSE, 0);

1578

gtk_box_pack_start(GTK_BOX(vbox1),hbox, TRUE, TRUE, 2);

1579

but = bf_gtkstock_button(GTK_STOCK_ADD, G_CALLBACK(add_new_external_commands_lcb), pd);

1580

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

1581

but = bf_gtkstock_button(GTK_STOCK_DELETE, G_CALLBACK(delete_external_commands_lcb), pd);

1582

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

1583

}

1584

1585

static gchar **outputbox_create_strarr(Tprefdialog *pd) {

1586

gchar **strarr = g_malloc(8*sizeof(gchar *));

1587

strarr[0] = gtk_editable_get_chars(GTK_EDITABLE(pd->od.entry[0]), 0, -1);

1588

strarr[1] = gtk_editable_get_chars(GTK_EDITABLE(pd->od.entry[1]), 0, -1);

1589

strarr[2] = gtk_editable_get_chars(GTK_EDITABLE(pd->od.entry[2]), 0, -1);

1590

strarr[3] = gtk_editable_get_chars(GTK_EDITABLE(pd->od.entry[3]), 0, -1);

1591

strarr[4] = gtk_editable_get_chars(GTK_EDITABLE(pd->od.entry[4]), 0, -1);

1592

strarr[5] = gtk_editable_get_chars(GTK_EDITABLE(pd->od.entry[5]), 0, -1);

1593

strarr[6] = g_strdup((GTK_TOGGLE_BUTTON(pd->od.check)->active) ? "1" : "0");

1594

strarr[7] = NULL;

1595

return strarr;

1596

}

1597

static void outputbox_apply_changes(Tprefdialog *pd) {

1598

if (pd->od.curstrarr) {

1599

gchar **strarr;

1600

strarr = outputbox_create_strarr(pd);

1601

if (strarr) {

1602

GList *tmplist;

1603

GtkTreeIter iter;

1604

gboolean retval = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pd->od.lstore),&iter);

1605

while (retval) {

1606

gchar *curval;

1607

gtk_tree_model_get(GTK_TREE_MODEL(pd->od.lstore),&iter,0,&curval,-1);

1608

if (strcmp(curval,pd->od.curstrarr[0])==0) {

1609

gtk_list_store_set(GTK_LIST_STORE(pd->od.lstore), &iter

1610

,0,strarr[0]

1611

,1,strarr[1]

1612

,2,strarr[2]

1613

,3,strarr[3]

1614

,4,strarr[4]

1615

,5,strarr[5]

1616

,6,strarr[6]

1617

,-1);

1618

break;

1619

}

1620

retval = gtk_tree_model_iter_next(GTK_TREE_MODEL(pd->od.lstore),&iter);

1621

}

1622

1623

tmplist = g_list_first(pd->lists[outputbox]);

1624

while (tmplist) {

1625

if (tmplist->data == pd->od.curstrarr) {

1626

g_strfreev(pd->od.curstrarr);

1627

tmplist->data = strarr;

1628

pd->od.curstrarr = strarr;

1629

break;

1630

}

1631

tmplist = g_list_next(tmplist);

1632

}

1633

} else {

1634

DEBUG_MSG("outputbox_apply_changes, NO strarr!!\n");

1635

}

1636

} else {

1637

DEBUG_MSG("outputbox_apply_changes, NO curstrarr!!\n");

1638

}

1639

}

1640

static void add_new_outputbox_lcb(GtkWidget *wid, Tprefdialog *pd) {

1641

gchar **strarr;

1642

strarr = outputbox_create_strarr(pd);

1643

if (strarr) {

1644

GtkTreeIter iter;

1645

pd->lists[outputbox] = g_list_append(pd->lists[outputbox], strarr);

1646

gtk_list_store_append(GTK_LIST_STORE(pd->od.lstore), &iter);

1647

gtk_list_store_set(GTK_LIST_STORE(pd->od.lstore), &iter

1648

,0,strarr[0]

1649

,1,strarr[1]

1650

,2,strarr[2]

1651

,3,strarr[3]

1652

,4,strarr[4]

1653

,5,strarr[5]

1654

,6,strarr[6]

1655

,-1);

1656

}

1657

}

1658

1659

static void outputbox_selection_changed_cb(GtkTreeSelection *selection, Tprefdialog *pd) {

1660

GtkTreeIter iter;

1661

GtkTreeModel *model;

1662

if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

1663

gchar *name;

1664

GList *tmplist = g_list_first(pd->lists[outputbox]);

1665

gtk_tree_model_get(model, &iter, 0, &name, -1);

1666

outputbox_apply_changes(pd);

1667

while (tmplist) {

1668

gchar **strarr =(gchar **)tmplist->data;

1669

if (strcmp(strarr[0],name)==0) {

1670

gtk_entry_set_text(GTK_ENTRY(pd->od.entry[0]), strarr[0]);

1671

gtk_entry_set_text(GTK_ENTRY(pd->od.entry[1]), strarr[1]);

1672

gtk_entry_set_text(GTK_ENTRY(pd->od.entry[2]), strarr[2]);

1673

gtk_entry_set_text(GTK_ENTRY(pd->od.entry[3]), strarr[3]);

1674

gtk_entry_set_text(GTK_ENTRY(pd->od.entry[4]), strarr[4]);

1675

gtk_entry_set_text(GTK_ENTRY(pd->od.entry[5]), strarr[5]);

1676

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->od.check), (strarr[6][0] == '1'));

1677

pd->od.curstrarr = strarr;

1678

return;

1679

}

1680

tmplist = g_list_next(tmplist);

1681

}

1682

} else {

1683

DEBUG_MSG("outputbox_selection_changed_cb, no selection ?!?!\n");

1684

}

1685

}

1686

1687

static void set_outputbox_strarr_in_list(GtkTreeIter *iter, gchar **strarr, Tprefdialog *pd) {

1688

gint arrcount;

1689

arrcount = count_array(strarr);

1690

if (arrcount==7) {

1691

gtk_list_store_set(GTK_LIST_STORE(pd->od.lstore), iter

1692

,0,strarr[0],1,strarr[1],2,strarr[2],3,strarr[3]

1693

,4,strarr[4],5,strarr[5],6,(strarr[6][0] != '0')

1694

,7,strarr,-1);

1695

}

1696

}

1697

static void outputbox_apply_change(Tprefdialog *pd, gint type, gchar *path, gchar *newval, gint index) {

1698

pref_apply_change(pd->od.lstore,7,type,path,newval,index);

1699

}

1700

static void outputbox_0_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1701

outputbox_apply_change(pd, 1, path, newtext, 0);

1702

}

1703

static void outputbox_1_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1704

outputbox_apply_change(pd, 1, path, newtext, 1);

1705

}

1706

static void outputbox_2_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1707

outputbox_apply_change(pd, 1, path, newtext, 2);

1708

}

1709

static void outputbox_3_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1710

outputbox_apply_change(pd, 1, path, newtext, 3);

1711

}

1712

static void outputbox_4_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1713

outputbox_apply_change(pd, 1, path, newtext, 4);

1714

}

1715

static void outputbox_5_edited_lcb(GtkCellRendererText *cellrenderertext,gchar *path,gchar *newtext,Tprefdialog *pd) {

1716

outputbox_apply_change(pd, 1, path, newtext, 5);

1717

}

1718

static void outputbox_6_toggled_lcb(GtkCellRendererToggle *cellrenderertoggle,gchar *path,Tprefdialog *pd) {

1719

gchar *val = g_strdup(cellrenderertoggle->active ? "0" : "1");

1720

outputbox_apply_change(pd, 2, path, val, 6);

1721

g_free(val);

1722

}

1723

static void add_new_outputbox_lcb(GtkWidget *wid, Tprefdialog *pd) {

1724

gchar **strarr;

1725

GtkTreeIter iter;

1726

strarr = pref_create_empty_strarr(7);

1727

gtk_list_store_append(GTK_LIST_STORE(pd->od.lstore), &iter);

1728

set_outputbox_strarr_in_list(&iter, strarr,pd);

1729

pd->lists[outputbox] = g_list_append(pd->lists[outputbox], strarr);

1730

pd->od.insertloc = -1;

1731

}

1732

static void delete_outputbox_lcb(GtkWidget *wid, Tprefdialog *pd) {

1733

pref_delete_strarr(pd, &pd->od, 7);

1734

}

1735

1736

static void create_outputbox_gui(Tprefdialog *pd, GtkWidget *vbox1) {

1737

GtkWidget *hbox, *but, *scrolwin;

1738

pd->lists[outputbox] = duplicate_arraylist(main_v->props.outputbox);

1739

pd->od.lstore = gtk_list_store_new (8,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_BOOLEAN,G_TYPE_POINTER);

1740

pd->od.lview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pd->od.lstore));

1741

pref_create_column(GTK_TREE_VIEW(pd->od.lview), 1, G_CALLBACK(outputbox_0_edited_lcb), pd, _("Name"), 0);

1742

pref_create_column(GTK_TREE_VIEW(pd->od.lview), 1, G_CALLBACK(outputbox_1_edited_lcb), pd, _("Pattern"), 1);

1743

pref_create_column(GTK_TREE_VIEW(pd->od.lview), 1, G_CALLBACK(outputbox_2_edited_lcb), pd, _("File #"), 2);

1744

pref_create_column(GTK_TREE_VIEW(pd->od.lview), 1, G_CALLBACK(outputbox_3_edited_lcb), pd, _("Line #"), 3);

1745

pref_create_column(GTK_TREE_VIEW(pd->od.lview), 1, G_CALLBACK(outputbox_4_edited_lcb), pd, _("Output #"), 4);

1746

pref_create_column(GTK_TREE_VIEW(pd->od.lview), 1, G_CALLBACK(outputbox_5_edited_lcb), pd, _("Command"), 5);

1747

pref_create_column(GTK_TREE_VIEW(pd->od.lview), 2, G_CALLBACK(outputbox_6_toggled_lcb), pd, _("Show all output"), 6);

1748

scrolwin = gtk_scrolled_window_new(NULL, NULL);

1749

gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);

1750

gtk_container_add(GTK_CONTAINER(scrolwin), pd->od.lview);

1751

gtk_widget_set_size_request(scrolwin, 150, 190);

1752

gtk_box_pack_start(GTK_BOX(vbox1), scrolwin, TRUE, TRUE, 2);

1753

{

1754

GList *tmplist = g_list_first(pd->lists[outputbox]);

1755

while (tmplist) {

1756

gint arrcount;

1757

gchar **strarr = (gchar **)tmplist->data;

1758

arrcount = count_array(strarr);

1759

if (arrcount==7) {

1760

GtkTreeIter iter;

1761

gtk_list_store_append(GTK_LIST_STORE(pd->od.lstore), &iter);

1762

set_outputbox_strarr_in_list(&iter, strarr,pd);

1763

}

1764

tmplist = g_list_next(tmplist);

1765

}

1766

}

1767

gtk_tree_view_set_reorderable(GTK_TREE_VIEW(pd->od.lview), TRUE);

1768

pd->od.thelist = &pd->lists[outputbox];

1769

pd->od.insertloc = -1;

1770

g_signal_connect(G_OBJECT(pd->od.lstore), "row-inserted", G_CALLBACK(listpref_row_inserted), &pd->od);

1771

g_signal_connect(G_OBJECT(pd->od.lstore), "row-deleted", G_CALLBACK(listpref_row_deleted), &pd->od);

1772

1773

hbox = gtk_hbox_new(FALSE, 0);

1774

gtk_box_pack_start(GTK_BOX(vbox1),hbox, TRUE, TRUE, 2);

1775

but = bf_gtkstock_button(GTK_STOCK_ADD, G_CALLBACK(add_new_outputbox_lcb), pd);

1776

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

1777

but = bf_gtkstock_button(GTK_STOCK_DELETE, G_CALLBACK(delete_outputbox_lcb), pd);

1778

gtk_box_pack_start(GTK_BOX(hbox),but, FALSE, FALSE, 2);

1779

}

1780

1781

/**************************************/

1782

/* MAIN DIALOG FUNCTIONS */

1783

/**************************************/

1784

1785

static void preferences_destroy_lcb(GtkWidget * widget, Tprefdialog *pd) {

1786

GtkTreeSelection *select;

1787

DEBUG_MSG("preferences_destroy_lcb, started\n");

1788

1789

free_arraylist(pd->lists[filetypes]);

1790

free_arraylist(pd->lists[filefilters]);

1791

free_arraylist(pd->lists[highlight_patterns]);

1792

free_arraylist(pd->lists[browsers]);

1793

free_arraylist(pd->lists[external_commands]);

1794

pd->lists[filetypes] = NULL;

1795

pd->lists[filefilters] = NULL;

1796

pd->lists[highlight_patterns] = NULL;

1797

pd->lists[browsers] = NULL;

1798

pd->lists[external_commands] = NULL;

1799

1800

/* select = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->ftd.lview));

1801

g_signal_handlers_destroy(G_OBJECT(select));*/

1802

DEBUG_MSG("preferences_destroy_lcb, destroying handlers for lstore %p\n",pd->ftd.lstore);

1803

g_signal_handlers_destroy(G_OBJECT(pd->ftd.lstore));

1804

1805

select = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->ffd.lview));

1806

g_signal_handlers_destroy(G_OBJECT(select));

1807

1808

g_signal_handlers_destroy(G_OBJECT(pd->hpd.popmenu));

1809

/* g_signal_handlers_destroy(G_OBJECT(GTK_COMBO(pd->bd.combo)->list));*/

1810

select = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->bd.lview));

1811

g_signal_handlers_destroy(G_OBJECT(select));

1812

/* g_signal_handlers_destroy(G_OBJECT(GTK_COMBO(pd->ed.combo)->list));*/

1813

select = gtk_tree_view_get_selection(GTK_TREE_VIEW(pd->ed.lview));

1814

g_signal_handlers_destroy(G_OBJECT(select));

1815

DEBUG_MSG("preferences_destroy_lcb, about to destroy the window\n");

1816

window_destroy(pd->win);

1817

g_free(pd);

1818

}

1819

static void preferences_apply(Tprefdialog *pd) {

1820

string_apply(&main_v->props.editor_font_string, pd->prefs[editor_font_string]);

1821

integer_apply(&main_v->props.editor_tab_width, pd->prefs[editor_tab_width], FALSE);

1822

integer_apply(&main_v->props.editor_indent_wspaces, pd->prefs[editor_indent_wspaces], TRUE);

1823

integer_apply(&main_v->props.word_wrap, pd->prefs[word_wrap], TRUE);

1824

integer_apply(&main_v->props.view_line_numbers, pd->prefs[view_line_numbers], TRUE);

1825

integer_apply(&main_v->props.defaulthighlight, pd->prefs[defaulthighlight], TRUE);

1826

integer_apply(&main_v->props.highlight_num_lines_count, pd->prefs[highlight_num_lines_count], FALSE);

1827

1828

integer_apply(&main_v->props.bookmarks_default_store, pd->prefs[bookmarks_default_store], TRUE);

1829

main_v->props.bookmarks_filename_mode = gtk_option_menu_get_history(GTK_OPTION_MENU(pd->prefs[bookmarks_filename_mode]));

1830

1831

integer_apply(&main_v->props.xhtml, pd->prefs[xhtml], TRUE);

1832

if (main_v->props.xhtml) {

1833

main_v->props.lowercase_tags = 1;

1834

main_v->props.allow_dep = 0;

1835

} else {

1836

integer_apply(&main_v->props.lowercase_tags, pd->prefs[lowercase_tags], TRUE);

1837

integer_apply(&main_v->props.allow_dep, pd->prefs[allow_dep], TRUE);

1838

}

1839

integer_apply(&main_v->props.auto_update_meta, pd->prefs[auto_update_meta], TRUE);

1840

1841

string_apply(&main_v->props.newfile_default_encoding, GTK_COMBO(pd->prefs[newfile_default_encoding])->entry);

1842

integer_apply(&main_v->props.auto_set_encoding_meta, pd->prefs[auto_set_encoding_meta], TRUE);

1843

integer_apply(&main_v->props.backup_file, pd->prefs[backup_file], TRUE);

1844

string_apply(&main_v->props.backup_filestring, pd->prefs[backup_filestring]);

1845

main_v->props.backup_abort_action = gtk_option_menu_get_history(GTK_OPTION_MENU(pd->prefs[backup_abort_action]));

1846

integer_apply(&main_v->props.backup_cleanuponclose, pd->prefs[backup_cleanuponclose], TRUE);

1847

integer_apply(&main_v->props.num_undo_levels, pd->prefs[num_undo_levels], FALSE);

1848

integer_apply(&main_v->props.clear_undo_on_save, pd->prefs[clear_undo_on_save], TRUE);

1849

integer_apply(&main_v->props.allow_multi_instances, pd->prefs[allow_multi_instances], TRUE);

1850

#ifdef WITH_MSG_QUEUE

1851

integer_apply(&main_v->props.open_in_running_bluefish, pd->prefs[open_in_running_bluefish], TRUE);

1852

#endif

1853

main_v->props.modified_check_type = gtk_option_menu_get_history(GTK_OPTION_MENU(pd->prefs[modified_check_type]));

1854

integer_apply(&main_v->props.max_recent_files, pd->prefs[max_recent_files], FALSE);

1855

1856

integer_apply(&main_v->props.restore_dimensions, pd->prefs[restore_dimensions], TRUE);

1857

if (!main_v->props.restore_dimensions) {

1858

integer_apply(&main_v->props.left_panel_width, pd->prefs[left_panel_width], FALSE);

1859

integer_apply(&main_v->globses.main_window_h, pd->prefs[main_window_h], FALSE);

1860

integer_apply(&main_v->globses.main_window_w, pd->prefs[main_window_w], FALSE);

1861

}

1862

string_apply(&main_v->props.tab_font_string, pd->prefs[tab_font_string]);

1863

main_v->props.document_tabposition = gtk_option_menu_get_history(GTK_OPTION_MENU(pd->prefs[document_tabposition]));

1864

main_v->props.leftpanel_tabposition = gtk_option_menu_get_history(GTK_OPTION_MENU(pd->prefs[leftpanel_tabposition]));

1865

main_v->props.left_panel_left = gtk_option_menu_get_history(GTK_OPTION_MENU(pd->prefs[left_panel_left]));

1866

1867

integer_apply(&main_v->props.view_main_toolbar, pd->prefs[view_main_toolbar], TRUE);

1868

integer_apply(&main_v->props.view_left_panel, pd->prefs[view_left_panel], TRUE);

1869

integer_apply(&main_v->props.view_custom_menu, pd->prefs[view_custom_menu], TRUE);

1870

integer_apply(&main_v->props.view_html_toolbar, pd->prefs[view_html_toolbar], TRUE);

1871

integer_apply(&main_v->props.transient_htdialogs, pd->prefs[transient_htdialogs], TRUE);

1872

1873

integer_apply(&main_v->props.ext_browsers_in_submenu, pd->prefs[ext_browsers_in_submenu], TRUE);

1874

integer_apply(&main_v->props.ext_commands_in_submenu, pd->prefs[ext_commands_in_submenu], TRUE);

1875

integer_apply(&main_v->props.ext_outputbox_in_submenu, pd->prefs[ext_outputbox_in_submenu], TRUE);

1876

1877

string_apply(&main_v->props.default_basedir, pd->prefs[default_basedir]);

1878

integer_apply(&main_v->props.filebrowser_two_pane_view, pd->prefs[filebrowser_two_pane_view], TRUE);

1879

string_apply(&main_v->props.filebrowser_unknown_icon, pd->prefs[filebrowser_unknown_icon]);

1880

string_apply(&main_v->props.filebrowser_dir_icon, pd->prefs[filebrowser_dir_icon]);

1881

1882

string_apply(&main_v->props.image_thumbnailstring, pd->prefs[image_thumbnailstring]);

1883

string_apply(&main_v->props.image_thumbnailtype, GTK_COMBO(pd->prefs[image_thumbnailtype])->entry);

1884

1885

#ifdef HAVE_GNOME_VFS

1886

integer_apply(&main_v->props.server_zope_compat, pd->prefs[server_zope_compat], TRUE);

1887

#endif

1888

1889

/*filetype_apply_changes(pd);*/

1890

/*filefilter_apply_changes(pd);*/

1891

highlightpattern_apply_changes(pd);

1892

/*browsers_apply_changes(pd);*/

1893

/*externals_apply_changes(pd);*/

1894

/*outputbox_apply_changes(pd);*/

1895

1896

free_arraylist(main_v->props.filetypes);

1897

main_v->props.filetypes = duplicate_arraylist(pd->lists[filetypes]);

1898

1899

free_arraylist(main_v->props.filefilters);

1900

main_v->props.filefilters = duplicate_arraylist(pd->lists[filefilters]);

1901

1902

free_arraylist(main_v->props.highlight_patterns);

1903

main_v->props.highlight_patterns = duplicate_arraylist(pd->lists[highlight_patterns]);

1904

1905

free_arraylist(main_v->props.browsers);

1906

main_v->props.browsers = duplicate_arraylist(pd->lists[browsers]);

1907

1908

free_arraylist(main_v->props.external_commands);

1909

main_v->props.external_commands = duplicate_arraylist(pd->lists[external_commands]);

1910

1911

free_arraylist(main_v->props.outputbox);

1912

main_v->props.outputbox = duplicate_arraylist(pd->lists[outputbox]);

1913

1914

/* apply the changes to highlighting patterns and filetypes to the running program */

1915

filetype_highlighting_rebuild(TRUE);

1916

filebrowser_filters_rebuild();

1917

1918

all_documents_apply_settings();

1919

{

1920

GList *tmplist = g_list_first(main_v->bfwinlist);

1921

while (tmplist) {

1922

Tbfwin *bfwin = BFWIN(tmplist->data);

1923

DEBUG_MSG("preferences_ok_clicked_lcb, calling encoding_menu_rebuild\n");

1924

encoding_menu_rebuild(bfwin);

1925

external_menu_rebuild(bfwin); /* browsers is also rebuild here! */

1926

filetype_menu_rebuild(bfwin,NULL);

1927

DEBUG_MSG("preferences_ok_clicked_lcb, calling gui_apply_settings\n");

1928

gui_apply_settings(bfwin);

1929

left_panel_rebuild(bfwin);

1930

DEBUG_MSG("preferences_ok_clicked_lcb, calling doc_force_activate\n");

1931

doc_force_activate(bfwin->current_document);

1932

tmplist = g_list_next(tmplist);

1933

}

1934

}

1935

}

1936

1937

static void preferences_cancel_clicked_lcb(GtkWidget *wid, Tprefdialog *pd) {

1938

preferences_destroy_lcb(NULL, pd);

1939

}

1940

static void preferences_apply_clicked_lcb(GtkWidget *wid, Tprefdialog *pd) {

1941

preferences_apply(pd);

1942

}

1943

static void preferences_ok_clicked_lcb(GtkWidget *wid, Tprefdialog *pd) {

1944

preferences_apply(pd);

1945

preferences_destroy_lcb(NULL, pd);

1946

}

1947

1948

static void restore_dimensions_toggled_lcb(GtkToggleButton *togglebutton,Tprefdialog *pd) {

1949

gtk_widget_set_sensitive(pd->prefs[left_panel_width], !togglebutton->active);

1950

gtk_widget_set_sensitive(pd->prefs[main_window_h], !togglebutton->active);

1951

gtk_widget_set_sensitive(pd->prefs[main_window_w], !togglebutton->active);

1952

}

1953

static void create_backup_toggled_lcb(GtkToggleButton *togglebutton,Tprefdialog *pd) {

1954

gtk_widget_set_sensitive(pd->prefs[backup_filestring], togglebutton->active);

1955

gtk_widget_set_sensitive(pd->prefs[backup_abort_action], togglebutton->active);

1956

}

1957

1958

static void preferences_dialog() {

1959

Tprefdialog *pd;

1960

GtkWidget *dvbox, *frame, *vbox1, *vbox2;

1961

gchar *notebooktabpositions[] = {N_("left"), N_("right"), N_("top"), N_("bottom"), NULL};

1962

gchar *panellocations[] = {N_("right"), N_("left"), NULL};

1963

gchar *modified_check_types[] = {N_("no check"), N_("check mtime and size"), N_("check mtime"), N_("check size"), NULL};

1964

1965

pd = g_new0(Tprefdialog,1);

1966

pd->win = window_full(_("Edit preferences"), GTK_WIN_POS_NONE, 0, G_CALLBACK(preferences_destroy_lcb), pd, TRUE);

1967

1968

dvbox = gtk_vbox_new(FALSE, 5);

1969

gtk_container_add(GTK_CONTAINER(pd->win), dvbox);

1970

pd->noteb = gtk_notebook_new();

1971

gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(pd->noteb), TRUE);

1972

gtk_notebook_set_tab_pos(GTK_NOTEBOOK(pd->noteb), GTK_POS_LEFT);

1973

1974

gtk_box_pack_start(GTK_BOX(dvbox), pd->noteb, TRUE, TRUE, 0);

1975

1976

vbox1 = gtk_vbox_new(FALSE, 5);

1977

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("Editor"),150,TRUE));

1978

1979

frame = gtk_frame_new(_("Editor options"));

1980

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

1981

vbox2 = gtk_vbox_new(FALSE, 0);

1982

gtk_container_add(GTK_CONTAINER(frame), vbox2);

1983

1984

pd->prefs[editor_font_string] = prefs_string(_("Font"), main_v->props.editor_font_string, vbox2, pd, string_font);

1985

pd->prefs[editor_tab_width] = prefs_integer(_("Tab width"), main_v->props.editor_tab_width, vbox2, pd, 1, 50);

1986

pd->prefs[editor_indent_wspaces] = boxed_checkbut_with_value(_("Use spaces to indent, not tabs"), main_v->props.editor_indent_wspaces, vbox2);

1987

pd->prefs[word_wrap] = boxed_checkbut_with_value(_("Word wrap default"), main_v->props.word_wrap, vbox2);

1988

pd->prefs[view_line_numbers] = boxed_checkbut_with_value(_("Line numbers by default"), main_v->props.view_line_numbers, vbox2);

1989

pd->prefs[defaulthighlight] = boxed_checkbut_with_value(_("Highlight syntax by default"), main_v->props.defaulthighlight, vbox2);

1990

pd->prefs[highlight_num_lines_count] = prefs_integer(_("Highlight # lines"), main_v->props.highlight_num_lines_count, vbox2, pd, 1, 8);

1991

1992

frame = gtk_frame_new(_("Undo"));

1993

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

1994

vbox2 = gtk_vbox_new(FALSE, 0);

1995

gtk_container_add(GTK_CONTAINER(frame), vbox2);

1996

1997

pd->prefs[num_undo_levels] = prefs_integer(_("Undo history size"), main_v->props.num_undo_levels, vbox2, pd, 50, 10000);

1998

pd->prefs[clear_undo_on_save] = boxed_checkbut_with_value(_("Clear undo history on save"), main_v->props.clear_undo_on_save, vbox2);

1999

2000

frame = gtk_frame_new(_("Bookmark options"));

2001

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2002

vbox2 = gtk_vbox_new(FALSE, 0);

2003

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2004

2005

pd->prefs[bookmarks_default_store] = boxed_checkbut_with_value(_("Make permanent by default"), main_v->props.bookmarks_default_store, vbox2);

2006

{

2007

gchar *actions[] = {N_("full path"), N_("path from basedir"), N_("filename"), NULL};

2008

pd->prefs[bookmarks_filename_mode] = boxed_optionmenu_with_value(_("Bookmarks filename display"), main_v->props.bookmarks_filename_mode, vbox2, actions);

2009

}

2010

2011

vbox1 = gtk_vbox_new(FALSE, 5);

2012

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("HTML"),154,TRUE));

2013

2014

frame = gtk_frame_new(_("HTML options"));

2015

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2016

vbox2 = gtk_vbox_new(FALSE, 0);

2017

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2018

2019

pd->prefs[lowercase_tags] = boxed_checkbut_with_value(_("Lowercase HTML tags"), main_v->props.lowercase_tags, vbox2);

2020

pd->prefs[allow_dep] = boxed_checkbut_with_value(_("Use deprecated tags (e.g. and )"), main_v->props.allow_dep, vbox2);

2021

pd->prefs[xhtml] = boxed_checkbut_with_value(_("Use XHTML style tags ( )"), main_v->props.xhtml, vbox2);

2022

pd->prefs[auto_update_meta] = boxed_checkbut_with_value(_("Automatic update author meta"), main_v->props.auto_update_meta, vbox2);

2023

2024

vbox1 = gtk_vbox_new(FALSE, 5);

2025

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("Files"),152,TRUE));

2026

2027

frame = gtk_frame_new(_("Encoding"));

2028

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2029

vbox2 = gtk_vbox_new(FALSE, 0);

2030

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2031

{

2032

GList *tmplist, *poplist = g_list_append(NULL, "");

2033

tmplist = g_list_first(main_v->props.encodings);

2034

while (tmplist) {

2035

gchar **strarr = (gchar **)tmplist->data;

2036

poplist = g_list_append(poplist, strarr[1]);

2037

tmplist = g_list_next(tmplist);

2038

}

2039

pd->prefs[newfile_default_encoding] = prefs_combo(_("Default character set"),main_v->props.newfile_default_encoding, vbox2, pd, poplist, TRUE);

2040

g_list_free(poplist);

2041

}

2042

pd->prefs[auto_set_encoding_meta] = boxed_checkbut_with_value(_("Auto set <meta> encoding tag on change"), main_v->props.auto_set_encoding_meta, vbox2);

2043

2044

frame = gtk_frame_new(_("Backup"));

2045

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2046

vbox2 = gtk_vbox_new(FALSE, 0);

2047

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2048

pd->prefs[backup_file] = boxed_checkbut_with_value(_("Create backup on save"), main_v->props.backup_file, vbox2);

2049

pd->prefs[backup_filestring] = prefs_string(_("Backup file suffix"), main_v->props.backup_filestring, vbox2, pd, string_none);

2050

{

2051

gchar *failureactions[] = {N_("save"), N_("abort"), N_("ask"), NULL};

2052

pd->prefs[backup_abort_action] = boxed_optionmenu_with_value(_("Action on backup failure"), main_v->props.backup_abort_action, vbox2, failureactions);

2053

}

2054

pd->prefs[backup_cleanuponclose] = boxed_checkbut_with_value(_("Remove backupfile on close"), main_v->props.backup_cleanuponclose, vbox2);

2055

create_backup_toggled_lcb(GTK_TOGGLE_BUTTON(pd->prefs[backup_file]), pd);

2056

g_signal_connect(G_OBJECT(pd->prefs[backup_file]), "toggled", G_CALLBACK(create_backup_toggled_lcb), pd);

2057

2058

frame = gtk_frame_new(_("Misc"));

2059

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2060

vbox2 = gtk_vbox_new(FALSE, 0);

2061

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2062

2063

pd->prefs[allow_multi_instances] = boxed_checkbut_with_value(_("Allow multi instances of a file"), main_v->props.allow_multi_instances, vbox2);

2064

#ifdef WITH_MSG_QUEUE

2065

pd->prefs[open_in_running_bluefish] = boxed_checkbut_with_value(_("Open files in already running bluefish window"),main_v->props.open_in_running_bluefish, vbox2);

2066

#endif /* WITH_MSG_QUEUE */

2067

pd->prefs[modified_check_type] = boxed_optionmenu_with_value(_("File modified on disk check "), main_v->props.modified_check_type, vbox2, modified_check_types);

2068

pd->prefs[max_recent_files] = prefs_integer(_("Number of files in 'Open recent'"), main_v->props.max_recent_files, vbox2, pd, 3, 100);

2069

2070

frame = gtk_frame_new(_("File browser"));

2071

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2072

vbox2 = gtk_vbox_new(FALSE, 0);

2073

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2074

pd->prefs[default_basedir] = prefs_string(_("Default basedir"), main_v->props.default_basedir, vbox2, pd, string_none);

2075

pd->prefs[filebrowser_two_pane_view] = boxed_checkbut_with_value(_("Use separate file and directory view"), main_v->props.filebrowser_two_pane_view, vbox2);

2076

pd->prefs[filebrowser_unknown_icon] = prefs_string(_("Unknown icon"), main_v->props.filebrowser_unknown_icon, vbox2, pd, string_file);

2077

pd->prefs[filebrowser_dir_icon] = prefs_string(_("Directory icon"), main_v->props.filebrowser_dir_icon, vbox2, pd, string_file);

2078

2079

vbox1 = gtk_vbox_new(FALSE, 5);

2080

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("User interface"), 156,TRUE));

2081

2082

frame = gtk_frame_new(_("Dimensions"));

2083

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2084

vbox2 = gtk_vbox_new(FALSE, 0);

2085

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2086

pd->prefs[restore_dimensions] = boxed_checkbut_with_value(_("Restore last used dimensions"), main_v->props.restore_dimensions, vbox2);

2087

pd->prefs[left_panel_width] = prefs_integer(_("Initial sidebar width"), main_v->props.left_panel_width, vbox2, pd, 1, 4000);

2088

pd->prefs[main_window_h] = prefs_integer(_("Initial window height"), main_v->globses.main_window_h, vbox2, pd, 1, 4000);

2089

pd->prefs[main_window_w] = prefs_integer(_("Initial window width"), main_v->globses.main_window_w, vbox2, pd, 1, 4000);

2090

restore_dimensions_toggled_lcb(GTK_TOGGLE_BUTTON(pd->prefs[restore_dimensions]), pd);

2091

g_signal_connect(G_OBJECT(pd->prefs[restore_dimensions]), "toggled", G_CALLBACK(restore_dimensions_toggled_lcb), pd);

2092

2093

frame = gtk_frame_new(_("General"));

2094

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2095

vbox2 = gtk_vbox_new(FALSE, 0);

2096

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2097

2098

pd->prefs[view_main_toolbar] = boxed_checkbut_with_value(_("Show main toolbar by default"), main_v->props.view_main_toolbar, vbox2);

2099

pd->prefs[view_left_panel] = boxed_checkbut_with_value(_("Show sidebar by default"), main_v->props.view_left_panel, vbox2);

2100

pd->prefs[view_custom_menu] = boxed_checkbut_with_value(_("Show custom menu by default"), main_v->props.view_custom_menu, vbox2);

2101

pd->prefs[view_html_toolbar] = boxed_checkbut_with_value(_("Show HTML toolbar by default"), main_v->props.view_html_toolbar, vbox2);

2102

pd->prefs[transient_htdialogs] = boxed_checkbut_with_value(_("Make HTML dialogs transient"), main_v->props.transient_htdialogs, vbox2);

2103

2104

pd->prefs[ext_browsers_in_submenu] = boxed_checkbut_with_value(_("External browsers in submenu"), main_v->props.ext_browsers_in_submenu, vbox2);

2105

pd->prefs[ext_commands_in_submenu] = boxed_checkbut_with_value(_("External commands in submenu"), main_v->props.ext_commands_in_submenu, vbox2);

2106

pd->prefs[ext_outputbox_in_submenu] = boxed_checkbut_with_value(_("External outputbox in submenu"), main_v->props.ext_outputbox_in_submenu, vbox2);

2107

2108

pd->prefs[tab_font_string] = prefs_string(_("Notebook tab font (leave empty for gtk default)"), main_v->props.tab_font_string, vbox2, pd, string_font);

2109

2110

pd->prefs[document_tabposition] = boxed_optionmenu_with_value(_("Document notebook tab position"), main_v->props.document_tabposition, vbox2, notebooktabpositions);

2111

pd->prefs[leftpanel_tabposition] = boxed_optionmenu_with_value(_("Sidebar notebook tab position"), main_v->props.leftpanel_tabposition, vbox2, notebooktabpositions);

2112

pd->prefs[left_panel_left] = boxed_optionmenu_with_value(_("Sidebar location"), main_v->props.left_panel_left, vbox2, panellocations);

2113

2114

vbox1 = gtk_vbox_new(FALSE, 5);

2115

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("Images"), 155,TRUE));

2116

2117

frame = gtk_frame_new(_("Thumbnails"));

2118

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2119

vbox2 = gtk_vbox_new(FALSE, 0);

2120

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2121

pd->prefs[image_thumbnailstring] = prefs_string(_("Thumbnail suffix"), main_v->props.image_thumbnailstring, vbox2, pd, string_none);

2122

{

2123

GList *poplist = g_list_append(NULL, "png");

2124

poplist = g_list_append(poplist, "jpeg");

2125

pd->prefs[image_thumbnailtype] = prefs_combo(_("Thumbnail filetype"),main_v->props.image_thumbnailtype, vbox2, pd, poplist, FALSE);

2126

g_list_free(poplist);

2127

}

2128

2129

vbox1 = gtk_vbox_new(FALSE, 5);

2130

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("Filetypes"), 153,TRUE));

2131

2132

frame = gtk_frame_new(_("Filetypes"));

2133

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2134

vbox2 = gtk_vbox_new(FALSE, 0);

2135

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2136

2137

create_filetype_gui(pd, vbox2);

2138

2139

frame = gtk_frame_new(_("Filefilters"));

2140

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2141

vbox2 = gtk_vbox_new(FALSE, 0);

2142

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2143

2144

create_filefilter_gui(pd, vbox2);

2145

2146

vbox1 = gtk_vbox_new(FALSE, 5);

2147

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("Syntax highlighting"), 158,TRUE));

2148

2149

frame = gtk_frame_new(_("Patterns"));

2150

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2151

vbox2 = gtk_vbox_new(FALSE, 0);

2152

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2153

2154

create_highlightpattern_gui(pd, vbox2);

2155

2156

vbox1 = gtk_vbox_new(FALSE, 5);

2157

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("External programs"), 151,TRUE));

2158

2159

frame = gtk_frame_new(_("Browsers"));

2160

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2161

vbox2 = gtk_vbox_new(FALSE, 0);

2162

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2163

2164

create_browsers_gui(pd, vbox2);

2165

2166

frame = gtk_frame_new(_("Utilities and filters"));

2167

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2168

vbox2 = gtk_vbox_new(FALSE, 0);

2169

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2170

2171

create_externals_gui(pd, vbox2);

2172

2173

vbox1 = gtk_vbox_new(FALSE, 5);

2174

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("Output parsers"), 157,TRUE));

2175

2176

frame = gtk_frame_new(_("Outputbox"));

2177

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2178

vbox2 = gtk_vbox_new(FALSE, 0);

2179

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2180

2181

create_outputbox_gui(pd, vbox2);

2182

2183

#ifdef HAVE_GNOME_VFS

2184

vbox1 = gtk_vbox_new(FALSE, 5);

2185

gtk_notebook_append_page(GTK_NOTEBOOK(pd->noteb), vbox1, hbox_with_pix_and_text(_("Servers"), 0,TRUE));

2186

2187

frame = gtk_frame_new(_("Remote servers"));

2188

gtk_box_pack_start(GTK_BOX(vbox1), frame, FALSE, FALSE, 5);

2189

vbox2 = gtk_vbox_new(FALSE, 0);

2190

gtk_container_add(GTK_CONTAINER(frame), vbox2);

2191

2192

pd->prefs[server_zope_compat] = boxed_checkbut_with_value(_("Zope compatibility mode"), main_v->props.server_zope_compat, vbox2);

2193

#endif

2194

2195

/* end, create buttons for dialog now */

2196

{

2197

GtkWidget *ahbox, *but;

2198

ahbox = gtk_hbutton_box_new();

2199

gtk_hbutton_box_set_layout_default(GTK_BUTTONBOX_END);

2200

gtk_button_box_set_spacing(GTK_BUTTON_BOX(ahbox), 12);

2201

2202

gtk_box_pack_start(GTK_BOX(dvbox), ahbox, FALSE, FALSE, 0);

2203

but = bf_gtkstock_button(GTK_STOCK_APPLY, G_CALLBACK(preferences_apply_clicked_lcb), pd);

2204

gtk_box_pack_start(GTK_BOX(ahbox), but, TRUE, TRUE, 0);

2205

2206

but = bf_stock_cancel_button(G_CALLBACK(preferences_cancel_clicked_lcb), pd);

2207

gtk_box_pack_start(GTK_BOX(ahbox), but, TRUE, TRUE, 0);

2208

2209

but = bf_stock_ok_button(G_CALLBACK(preferences_ok_clicked_lcb), pd);

2210

gtk_box_pack_start(GTK_BOX(ahbox), but, TRUE, TRUE, 0);

2211

gtk_window_set_default(GTK_WINDOW(pd->win), but);

2212

}

2213

gtk_widget_show_all(pd->win);

2214

}

2215

2216

void open_preferences_cb(GtkWidget *wid, gpointer data) {

2217

preferences_dialog();

2218

}

2219

2220

void open_preferences_menu_cb(gpointer callback_data,guint action,GtkWidget *widget) {

2221

preferences_dialog();

2222

}

Older »