Mercurial > hg > idav / file comparison

comparison: ui/gtk/text.c

ui/gtk/text.c

changeset 44
473954dc6b74
parent 38
acd8c4a9d3fe
child 45
ab71409644b0
equal deleted inserted replaced
43:ef01d2c90128 44:473954dc6b74
80 text_area, 80 text_area,
81 "destroy", 81 "destroy",
82 G_CALLBACK(ui_textarea_destroy), 82 G_CALLBACK(ui_textarea_destroy),
83 uitext); 83 uitext);
84 84
85 GtkWidget *scroll_area = gtk_scrolled_window_new (NULL, NULL); 85 GtkWidget *scroll_area = SCROLLEDWINDOW_NEW();
86 gtk_scrolled_window_set_policy( 86 gtk_scrolled_window_set_policy(
87 GTK_SCROLLED_WINDOW(scroll_area), 87 GTK_SCROLLED_WINDOW(scroll_area),
88 GTK_POLICY_AUTOMATIC, 88 GTK_POLICY_AUTOMATIC,
89 GTK_POLICY_AUTOMATIC); // GTK_POLICY_ALWAYS 89 GTK_POLICY_AUTOMATIC); // GTK_POLICY_ALWAYS
90 gtk_container_add(GTK_CONTAINER(scroll_area), text_area); 90 SCROLLEDWINDOW_SET_CHILD(scroll_area, text_area);
91 91
92 // font and padding 92 // font and padding
93 PangoFontDescription *font; 93 PangoFontDescription *font;
94 font = pango_font_description_from_string("Monospace"); 94 font = pango_font_description_from_string("Monospace");
95 gtk_widget_modify_font(text_area, font); 95 //gtk_widget_modify_font(text_area, font); // TODO
96 pango_font_description_free(font); 96 pango_font_description_free(font);
97 97
98 gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_area), 2); 98 gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_area), 2);
99 gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text_area), 2); 99 gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text_area), 2);
100 100
178 } 178 }
179 return NULL; 179 return NULL;
180 } 180 }
181 181
182 UIWIDGET ui_textarea_gettextwidget(UIWIDGET textarea) { 182 UIWIDGET ui_textarea_gettextwidget(UIWIDGET textarea) {
183 return gtk_bin_get_child(GTK_BIN(textarea)); 183 return SCROLLEDWINDOW_GET_CHILD(textarea);
184 } 184 }
185 185
186 char* ui_textarea_get(UiText *text) { 186 char* ui_textarea_get(UiText *text) {
187 if(text->value.ptr) { 187 if(text->value.ptr) {
188 text->value.free(text->value.ptr); 188 text->value.free(text->value.ptr);
555 "destroy", 555 "destroy",
556 G_CALLBACK(ui_textfield_destroy), 556 G_CALLBACK(ui_textfield_destroy),
557 uitext); 557 uitext);
558 558
559 if(args.width > 0) { 559 if(args.width > 0) {
560 // TODO: gtk4
561 #if GTK_MAJOR_VERSION <= 3
560 gtk_entry_set_width_chars(GTK_ENTRY(textfield), args.width); 562 gtk_entry_set_width_chars(GTK_ENTRY(textfield), args.width);
563 #endif
561 } 564 }
562 if(frameless) { 565 if(frameless) {
563 // TODO: gtk2legacy workaroud 566 // TODO: gtk2legacy workaroud
564 gtk_entry_set_has_frame(GTK_ENTRY(textfield), FALSE); 567 gtk_entry_set_has_frame(GTK_ENTRY(textfield), FALSE);
565 } 568 }
571 ct->add(ct, textfield, FALSE); 574 ct->add(ct, textfield, FALSE);
572 575
573 if(var) { 576 if(var) {
574 UiString *value = var->value; 577 UiString *value = var->value;
575 if(value->value.ptr) { 578 if(value->value.ptr) {
576 gtk_entry_set_text(GTK_ENTRY(textfield), value->value.ptr); 579 ENTRY_SET_TEXT(textfield, value->value.ptr);
577 value->value.free(value->value.ptr); 580 value->value.free(value->value.ptr);
578 value->value.ptr = NULL; 581 value->value.ptr = NULL;
579 value->value.free = NULL; 582 value->value.free = NULL;
580 } 583 }
581 584
629 632
630 char* ui_textfield_get(UiString *str) { 633 char* ui_textfield_get(UiString *str) {
631 if(str->value.ptr) { 634 if(str->value.ptr) {
632 str->value.free(str->value.ptr); 635 str->value.free(str->value.ptr);
633 } 636 }
634 str->value.ptr = g_strdup(gtk_entry_get_text(str->obj)); 637 str->value.ptr = g_strdup(ENTRY_GET_TEXT(str->obj));
635 str->value.free = (ui_freefunc)g_free; 638 str->value.free = (ui_freefunc)g_free;
636 return str->value.ptr; 639 return str->value.ptr;
637 } 640 }
638 641
639 void ui_textfield_set(UiString *str, const char *value) { 642 void ui_textfield_set(UiString *str, const char *value) {
640 gtk_entry_set_text(str->obj, value); 643 ENTRY_SET_TEXT(str->obj, value);
641 if(str->value.ptr) { 644 if(str->value.ptr) {
642 str->value.free(str->value.ptr); 645 str->value.free(str->value.ptr);
643 str->value.ptr = NULL; 646 str->value.ptr = NULL;
644 str->value.free = NULL; 647 str->value.free = NULL;
645 } 648 }
686 *ret_nelm = n; 689 *ret_nelm = n;
687 690
688 return elms; 691 return elms;
689 } 692 }
690 693
691 static gboolean path_textfield_btn_pressed(GtkWidget *widget, GdkEventButton *event, UiPathTextField *pathtf) {
692 gtk_box_pack_start(GTK_BOX(pathtf->hbox), pathtf->entry, TRUE, TRUE, 0);
693 gtk_container_remove(GTK_CONTAINER(pathtf->hbox), pathtf->buttonbox);
694 pathtf->buttonbox = NULL;
695
696 gtk_widget_show(pathtf->entry);
697 gtk_widget_grab_focus(pathtf->entry);
698
699 return TRUE;
700 }
701
702 static void ui_pathelm_destroy(UiPathElm *elms, size_t nelm) { 694 static void ui_pathelm_destroy(UiPathElm *elms, size_t nelm) {
703 for(int i=0;i<nelm;i++) { 695 for(int i=0;i<nelm;i++) {
704 free(elms[i].name); 696 free(elms[i].name);
705 free(elms[i].path); 697 free(elms[i].path);
706 } 698 }
707 free(elms); 699 free(elms);
708 } 700 }
709 701
710 static void ui_path_textfield_destroy(GtkWidget *object, UiPathTextField *pathtf) { 702 static void ui_path_textfield_destroy(GtkWidget *object, UiPathTextField *pathtf) {
711 free(pathtf->current_path); 703 free(pathtf->hbox);
712 g_object_unref(pathtf->entry); 704 g_object_unref(pathtf->entry);
713 free(pathtf); 705 free(pathtf);
714 } 706 }
715 707
708 void ui_path_button_clicked(GtkWidget *widget, UiEventData *event) {
709 UiPathElm *elm = event->customdata;
710 cxmutstr path = cx_strdup(cx_strn(elm->path, elm->path_len));
711 UiEvent evt;
712 evt.obj = event->obj;
713 evt.window = evt.obj->window;
714 evt.document = evt.obj->ctx->document;
715 evt.eventdata = elm->path;
716 evt.intval = event->value;
717 event->callback(&evt, event->userdata);
718 free(path.ptr);
719 }
720
721 int ui_pathtextfield_update(UiPathTextField* pathtf, const char *full_path) {
722 size_t full_path_len = strlen(full_path);
723 if(full_path_len == 0) {
724 return 1;
725 }
726
727 size_t nelm = 0;
728 UiPathElm* path_elm = pathtf->getpathelm(full_path, full_path_len, &nelm, pathtf->getpathelmdata);
729 if (!path_elm) {
730 return 1;
731 }
732
733 free(pathtf->current_path);
734 pathtf->current_path = strdup(full_path);
735
736 ui_pathelm_destroy(pathtf->current_pathelms, pathtf->current_nelm);
737 pathtf->current_pathelms = path_elm;
738 pathtf->current_nelm = nelm;
739
740 return ui_pathtextfield_update_widget(pathtf);
741 }
742
743 static GtkWidget* ui_path_elm_button(UiPathTextField *pathtf, UiPathElm *elm, int i) {
744 cxmutstr name = cx_strdup(cx_strn(elm->name, elm->name_len));
745 GtkWidget *button = gtk_button_new_with_label(name.ptr);
746 free(name.ptr);
747
748 if(pathtf->onactivate) {
749 UiEventData *eventdata = malloc(sizeof(UiEventData));
750 eventdata->callback = pathtf->onactivate;
751 eventdata->userdata = pathtf->onactivatedata;
752 eventdata->obj = pathtf->obj;
753 eventdata->customdata = elm;
754 eventdata->value = i;
755
756 g_signal_connect(
757 button,
758 "clicked",
759 G_CALLBACK(ui_path_button_clicked),
760 eventdata);
761
762 g_signal_connect(
763 button,
764 "destroy",
765 G_CALLBACK(ui_destroy_userdata),
766 eventdata);
767 }
768
769 return button;
770 }
771
716 static void ui_path_textfield_activate(GtkWidget *entry, UiPathTextField *pathtf) { 772 static void ui_path_textfield_activate(GtkWidget *entry, UiPathTextField *pathtf) {
717 const gchar *text = gtk_entry_get_text(GTK_ENTRY(pathtf->entry)); 773 const gchar *text = ENTRY_GET_TEXT(pathtf->entry);
718 if(strlen(text) == 0) { 774 if(strlen(text) == 0) {
719 return; 775 return;
720 } 776 }
721 777
722 UiObject *obj = pathtf->obj; 778 UiObject *obj = pathtf->obj;
734 evt.intval = -1; 790 evt.intval = -1;
735 pathtf->onactivate(&evt, pathtf->onactivatedata); 791 pathtf->onactivate(&evt, pathtf->onactivatedata);
736 } 792 }
737 } 793 }
738 794
739 static gboolean ui_path_textfield_key_press(GtkWidget *self, GdkEventKey *event, UiPathTextField *pathtf) { 795 #if GTK_MAJOR_VERSION >= 4
740 if (event->keyval == GDK_KEY_Escape) { 796
741 // reset GtkEntry value 797 static void pathbar_show_hbox(GtkWidget *widget, UiPathTextField *pathtf) {
742 gtk_entry_set_text(GTK_ENTRY(self), pathtf->current_path); 798 if(pathtf->current_path) {
743 const gchar *text = gtk_entry_get_text(GTK_ENTRY(self)); 799 gtk_stack_set_visible_child(GTK_STACK(pathtf->stack), pathtf->hbox);
744 ui_pathtextfield_update(pathtf, text); 800 ENTRY_SET_TEXT(pathtf->entry, pathtf->current_path);
745 return TRUE; 801 }
802 }
803
804 static gboolean ui_path_textfield_key_controller(
805 GtkEventControllerKey* self,
806 guint keyval,
807 guint keycode,
808 GdkModifierType state,
809 UiPathTextField *pathtf)
810 {
811 if(keyval == GDK_KEY_Escape) {
812 pathbar_show_hbox(NULL, pathtf);
746 } 813 }
747 return FALSE; 814 return FALSE;
748 }
749
750 static GtkWidget* create_path_button_box() {
751 GtkWidget *bb = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
752 gtk_button_box_set_layout(GTK_BUTTON_BOX(bb), GTK_BUTTONBOX_EXPAND); // linked style
753 gtk_box_set_homogeneous(GTK_BOX(bb), FALSE);
754 gtk_box_set_spacing(GTK_BOX(bb), 0);
755 return bb;
756 } 815 }
757 816
758 UIWIDGET ui_path_textfield_create(UiObject* obj, UiPathTextFieldArgs args) { 817 UIWIDGET ui_path_textfield_create(UiObject* obj, UiPathTextFieldArgs args) {
759 UiObject* current = uic_current_obj(obj); 818 UiObject* current = uic_current_obj(obj);
760 819
775 if(!pathtf->getpathelm) { 834 if(!pathtf->getpathelm) {
776 pathtf->getpathelm = default_pathelm_func; 835 pathtf->getpathelm = default_pathelm_func;
777 pathtf->getpathelmdata = NULL; 836 pathtf->getpathelmdata = NULL;
778 } 837 }
779 838
839 pathtf->stack = gtk_stack_new();
840 gtk_widget_set_name(pathtf->stack, "path-textfield-box");
841
842 UI_APPLY_LAYOUT1(current, args);
843 current->container->add(current->container, pathtf->stack, FALSE);
844
845 pathtf->entry_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
846 pathtf->entry = gtk_entry_new();
847 gtk_box_append(GTK_BOX(pathtf->entry_box), pathtf->entry);
848 gtk_widget_set_hexpand(pathtf->entry, TRUE);
849
850 GtkWidget *cancel_button = gtk_button_new_from_icon_name("window-close-symbolic");
851 gtk_widget_add_css_class(cancel_button, "flat");
852 gtk_widget_add_css_class(cancel_button, "pathbar-extra-button");
853 gtk_box_append(GTK_BOX(pathtf->entry_box), cancel_button);
854 g_signal_connect(
855 cancel_button,
856 "clicked",
857 G_CALLBACK(pathbar_show_hbox),
858 pathtf);
859
860 gtk_stack_add_child(GTK_STACK(pathtf->stack), pathtf->entry_box);
861 g_object_ref(pathtf->entry); // for compatibility with older pathbar version
862 g_signal_connect(
863 pathtf->entry,
864 "activate",
865 G_CALLBACK(ui_path_textfield_activate),
866 pathtf);
867
868 GtkEventController *entry_cancel = gtk_event_controller_key_new();
869 gtk_widget_add_controller(pathtf->entry, entry_cancel);
870 g_signal_connect(entry_cancel, "key-pressed", G_CALLBACK(ui_path_textfield_key_controller), pathtf);
871
872 gtk_stack_set_visible_child(GTK_STACK(pathtf->stack), pathtf->entry_box);
873
874
875 UiVar* var = uic_widget_var(obj->ctx, current->ctx, args.value, args.varname, UI_VAR_STRING);
876 if (var) {
877 UiString* value = (UiString*)var->value;
878 value->obj = pathtf;
879 value->get = ui_path_textfield_get;
880 value->set = ui_path_textfield_set;
881
882 if(value->value.ptr) {
883 char *str = strdup(value->value.ptr);
884 ui_string_set(value, str);
885 free(str);
886 }
887 }
888
889 return pathtf->stack;
890 }
891
892 static void pathbar_pressed(
893 GtkGestureClick* self,
894 gint n_press,
895 gdouble x,
896 gdouble y,
897 UiPathTextField *pathtf)
898 {
899 gtk_stack_set_visible_child(GTK_STACK(pathtf->stack), pathtf->entry_box);
900 gtk_widget_grab_focus(pathtf->entry);
901 }
902
903 int ui_pathtextfield_update_widget(UiPathTextField* pathtf) {
904 // recreate button hbox
905 if(pathtf->hbox) {
906 gtk_stack_remove(GTK_STACK(pathtf->stack), pathtf->hbox);
907 }
908 pathtf->hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
909 gtk_box_set_homogeneous(GTK_BOX(pathtf->hbox), FALSE);
910 gtk_stack_add_child(GTK_STACK(pathtf->stack), pathtf->hbox);
911 gtk_widget_set_name(pathtf->hbox, "pathbar");
912
913 // add buttons for path elements
914 for (int i=0;i<pathtf->current_nelm;i++) {
915 UiPathElm *elm = &pathtf->current_pathelms[i];
916
917 GtkWidget *button = ui_path_elm_button(pathtf, elm, i);
918 gtk_widget_add_css_class(button, "flat");
919
920 gtk_box_append(GTK_BOX(pathtf->hbox), button);
921
922 if(i+1 < pathtf->current_nelm && cx_strcmp(cx_strn(elm->name, elm->name_len), CX_STR("/"))) {
923 gtk_box_append(GTK_BOX(pathtf->hbox), gtk_label_new("/"));
924 }
925 }
926 gtk_stack_set_visible_child(GTK_STACK(pathtf->stack), pathtf->hbox);
927
928 // create a widget for receiving button press events
929 GtkWidget *event_area = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
930 GtkGesture *handler = gtk_gesture_click_new();
931 gtk_widget_add_controller(event_area, GTK_EVENT_CONTROLLER(handler));
932 g_signal_connect(
933 handler,
934 "pressed",
935 G_CALLBACK(pathbar_pressed),
936 pathtf);
937 gtk_widget_set_hexpand(event_area, TRUE);
938 gtk_widget_set_vexpand(event_area, TRUE);
939 gtk_box_append(GTK_BOX(pathtf->hbox), event_area);
940
941 return 0;
942 }
943
944 #else
945
946 static gboolean path_textfield_btn_pressed(GtkWidget *widget, GdkEventButton *event, UiPathTextField *pathtf) {
947 gtk_box_pack_start(GTK_BOX(pathtf->hbox), pathtf->entry, TRUE, TRUE, 0);
948 gtk_container_remove(GTK_CONTAINER(pathtf->hbox), pathtf->buttonbox);
949 pathtf->buttonbox = NULL;
950
951 gtk_widget_show(pathtf->entry);
952 gtk_widget_grab_focus(pathtf->entry);
953
954 return TRUE;
955 }
956
957 static gboolean ui_path_textfield_key_press(GtkWidget *self, GdkEventKey *event, UiPathTextField *pathtf) {
958 if (event->keyval == GDK_KEY_Escape) {
959 // reset GtkEntry value
960 gtk_entry_set_text(GTK_ENTRY(self), pathtf->current_path);
961 const gchar *text = gtk_entry_get_text(GTK_ENTRY(self));
962 ui_pathtextfield_update(pathtf, text);
963 return TRUE;
964 }
965 return FALSE;
966 }
967
968 static GtkWidget* create_path_button_box() {
969 GtkWidget *bb = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
970 gtk_button_box_set_layout(GTK_BUTTON_BOX(bb), GTK_BUTTONBOX_EXPAND); // linked style
971 gtk_box_set_homogeneous(GTK_BOX(bb), FALSE);
972 gtk_box_set_spacing(GTK_BOX(bb), 0);
973 return bb;
974 }
975
976 UIWIDGET ui_path_textfield_create(UiObject* obj, UiPathTextFieldArgs args) {
977 UiObject* current = uic_current_obj(obj);
978
979 UiPathTextField *pathtf = malloc(sizeof(UiPathTextField));
980 memset(pathtf, 0, sizeof(UiPathTextField));
981 pathtf->obj = obj;
982 pathtf->getpathelm = args.getpathelm;
983 pathtf->getpathelmdata = args.getpathelmdata;
984 pathtf->onactivate = args.onactivate;
985 pathtf->onactivatedata = args.onactivatedata;
986 pathtf->ondragcomplete = args.ondragcomplete;
987 pathtf->ondragcompletedata = args.ondragcompletedata;
988 pathtf->ondragstart = args.ondragstart;
989 pathtf->ondragstartdata = args.ondragstartdata;
990 pathtf->ondrop = args.ondrop;
991 pathtf->ondropdata = args.ondropsdata;
992
993 if(!pathtf->getpathelm) {
994 pathtf->getpathelm = default_pathelm_func;
995 pathtf->getpathelmdata = NULL;
996 }
997
780 // top level container for the path textfield is a GtkEventBox 998 // top level container for the path textfield is a GtkEventBox
781 // the event box is needed to handle background button presses 999 // the event box is needed to handle background button presses
782 GtkWidget *eventbox = gtk_event_box_new(); 1000 GtkWidget *eventbox = gtk_event_box_new();
783 g_signal_connect( 1001 g_signal_connect(
784 eventbox, 1002 eventbox,
831 } 1049 }
832 1050
833 return hbox; 1051 return hbox;
834 } 1052 }
835 1053
836 void ui_path_button_clicked(GtkWidget *widget, UiEventData *event) { 1054 int ui_pathtextfield_update_widget(UiPathTextField* pathtf) {
837 UiPathElm *elm = event->customdata;
838 cxmutstr path = cx_strdup(cx_strn(elm->path, elm->path_len));
839 UiEvent evt;
840 evt.obj = event->obj;
841 evt.window = evt.obj->window;
842 evt.document = evt.obj->ctx->document;
843 evt.eventdata = elm->path;
844 evt.intval = event->value;
845 event->callback(&evt, event->userdata);
846 free(path.ptr);
847 }
848
849 int ui_pathtextfield_update(UiPathTextField* pathtf, const char *full_path) {
850 size_t full_path_len = strlen(full_path);
851 if(full_path_len == 0) {
852 return 1;
853 }
854
855 size_t nelm = 0;
856 UiPathElm* path_elm = pathtf->getpathelm(full_path, full_path_len, &nelm, pathtf->getpathelmdata);
857 if (!path_elm) {
858 return 1;
859 }
860
861 free(pathtf->current_path);
862 pathtf->current_path = strdup(full_path);
863
864 ui_pathelm_destroy(pathtf->current_pathelms, pathtf->current_nelm);
865 pathtf->current_pathelms = path_elm;
866 pathtf->current_nelm = nelm;
867
868 GtkWidget *buttonbox = create_path_button_box(); 1055 GtkWidget *buttonbox = create_path_button_box();
869 1056
870 // switch from entry to buttonbox or remove current buttonbox 1057 // switch from entry to buttonbox or remove current buttonbox
871 if(pathtf->buttonbox) { 1058 if(pathtf->buttonbox) {
872 gtk_container_remove(GTK_CONTAINER(pathtf->hbox), pathtf->buttonbox); 1059 gtk_container_remove(GTK_CONTAINER(pathtf->hbox), pathtf->buttonbox);
874 gtk_container_remove(GTK_CONTAINER(pathtf->hbox), pathtf->entry); 1061 gtk_container_remove(GTK_CONTAINER(pathtf->hbox), pathtf->entry);
875 } 1062 }
876 gtk_box_pack_start(GTK_BOX(pathtf->hbox), buttonbox, FALSE, FALSE, 0); 1063 gtk_box_pack_start(GTK_BOX(pathtf->hbox), buttonbox, FALSE, FALSE, 0);
877 pathtf->buttonbox = buttonbox; 1064 pathtf->buttonbox = buttonbox;
878 1065
879 for (int i=0;i<nelm;i++) { 1066 for (int i=0;i<pathtf->current_nelm;i++) {
880 UiPathElm *elm = &path_elm[i]; 1067 UiPathElm *elm = &pathtf->current_pathelms[i];
881 1068 GtkWidget *button = ui_path_elm_button(pathtf, elm, i);
882 cxmutstr name = cx_strdup(cx_strn(elm->name, elm->name_len));
883 GtkWidget *button = gtk_button_new_with_label(name.ptr);
884 free(name.ptr);
885
886 if(pathtf->onactivate) {
887 UiEventData *eventdata = malloc(sizeof(UiEventData));
888 eventdata->callback = pathtf->onactivate;
889 eventdata->userdata = pathtf->onactivatedata;
890 eventdata->obj = pathtf->obj;
891 eventdata->customdata = elm;
892 eventdata->value = i;
893
894 g_signal_connect(
895 button,
896 "clicked",
897 G_CALLBACK(ui_path_button_clicked),
898 eventdata);
899
900 g_signal_connect(
901 button,
902 "destroy",
903 G_CALLBACK(ui_destroy_userdata),
904 eventdata);
905 }
906
907 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); 1069 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
908 } 1070 }
909 1071
910 gtk_widget_show_all(buttonbox); 1072 gtk_widget_show_all(buttonbox);
911 1073
912 return 0; 1074 return 0;
913 } 1075 }
1076
1077 #endif
914 1078
915 char* ui_path_textfield_get(UiString *str) { 1079 char* ui_path_textfield_get(UiString *str) {
916 if(str->value.ptr) { 1080 if(str->value.ptr) {
917 str->value.free(str->value.ptr); 1081 str->value.free(str->value.ptr);
918 } 1082 }
919 UiPathTextField *tf = str->obj; 1083 UiPathTextField *tf = str->obj;
920 str->value.ptr = g_strdup(gtk_entry_get_text(GTK_ENTRY(tf->entry))); 1084 str->value.ptr = g_strdup(ENTRY_GET_TEXT(tf->entry));
921 str->value.free = (ui_freefunc)g_free; 1085 str->value.free = (ui_freefunc)g_free;
922 return str->value.ptr; 1086 return str->value.ptr;
923 } 1087 }
924 1088
925 void ui_path_textfield_set(UiString *str, const char *value) { 1089 void ui_path_textfield_set(UiString *str, const char *value) {
926 UiPathTextField *tf = str->obj; 1090 UiPathTextField *tf = str->obj;
927 gtk_entry_set_text(GTK_ENTRY(tf->entry), value); 1091 ENTRY_SET_TEXT(tf->entry, value);
928 ui_pathtextfield_update(tf, value); 1092 ui_pathtextfield_update(tf, value);
929 if(str->value.ptr) { 1093 if(str->value.ptr) {
930 str->value.free(str->value.ptr); 1094 str->value.free(str->value.ptr);
931 str->value.ptr = NULL; 1095 str->value.ptr = NULL;
932 str->value.free = NULL; 1096 str->value.free = NULL;

Mercurial Repository: idav

mercurial