src/Builder4/Editor.bjs
[app.Builder.js] / src / Builder4 / Editor.vala
1 static Editor  _Editor;
2
3 public class Editor : Object
4 {
5     public Gtk.VBox el;
6     private Editor  _this;
7
8     public static Editor singleton()
9     {
10         if (_Editor == null) {
11             _Editor= new Editor();
12         }
13         return _Editor;
14     }
15     public Xcls_save_button save_button;
16     public Xcls_key_edit key_edit;
17     public Xcls_RightEditor RightEditor;
18     public Xcls_view view;
19     public Xcls_buffer buffer;
20
21         // my vars (def)
22     public Xcls_MainWindow window;
23     public string activeEditor;
24     public int pos_root_x;
25     public int pos_root_y;
26     public string ptype;
27     public string key;
28     public JsRender.JsRender file;
29     public bool pos;
30     public bool dirty;
31     public signal void save ();
32     public JsRender.Node node;
33
34     // ctor
35     public Editor()
36     {
37         _this = this;
38         this.el = new Gtk.VBox( false, 0 );
39
40         // my vars (dec)
41         this.window = null;
42         this.activeEditor = "";
43         this.ptype = "";
44         this.key = "";
45         this.file = null;
46         this.pos = false;
47         this.dirty = false;
48         this.node = null;
49
50         // set gobject values
51         var child_0 = new Xcls_HBox2( _this );
52         child_0.ref();
53         this.el.pack_start (  child_0.el , false,true );
54         var child_1 = new Xcls_RightEditor( _this );
55         child_1.ref();
56         this.el.add (  child_1.el  );
57     }
58
59     // user defined functions
60     public   bool saveContents ()  {
61         
62         
63         
64         
65         
66         
67         
68        
69          
70          var str = _this.buffer.toString();
71          
72           
73          
74          
75          if (!_this.buffer.checkSyntax()) {
76              print("check syntax failed");
77              //this.get('/StandardErrorDialog').show("Fix errors in code and save.."); 
78              //return false;
79          }
80          
81          // LeftPanel.model.changed(  str , false);
82          _this.dirty = false;
83          _this.save_button.el.sensitive = false;
84          
85          
86             
87          
88         // find the text for the node..
89         if (ptype == "listener") {
90             this.node.listeners.set(key,str);
91         
92         } else {
93              this.node.props.set(key,str);
94         }
95     
96          
97         
98         // call the signal..
99         this.save();
100         
101         return true;
102     
103     }
104     public   void show (JsRender.JsRender file, JsRender.Node node, string ptype, string key)
105     {
106         this.ptype = ptype;
107         this.key  = key;
108         this.node = node;
109         this.file = file;
110         
111        string val = "";
112         // find the text for the node..
113         if (ptype == "listener") {
114             val = node.listeners.get(key);
115         
116         } else {
117             val = node.props.get(key);
118         }
119         this.view.load(val);
120         this.key_edit.el.text = key;    
121     
122     }
123     public class Xcls_HBox2 : Object
124     {
125         public Gtk.HBox el;
126         private Editor  _this;
127
128
129             // my vars (def)
130
131         // ctor
132         public Xcls_HBox2(Editor _owner )
133         {
134             _this = _owner;
135             this.el = new Gtk.HBox( false, 0 );
136
137             // my vars (dec)
138
139             // set gobject values
140             var child_0 = new Xcls_save_button( _this );
141             child_0.ref();
142             this.el.pack_start (  child_0.el , false,false );
143             var child_1 = new Xcls_key_edit( _this );
144             child_1.ref();
145             this.el.pack_end (  child_1.el , true,true );
146         }
147
148         // user defined functions
149     }
150     public class Xcls_save_button : Object
151     {
152         public Gtk.Button el;
153         private Editor  _this;
154
155
156             // my vars (def)
157
158         // ctor
159         public Xcls_save_button(Editor _owner )
160         {
161             _this = _owner;
162             _this.save_button = this;
163             this.el = new Gtk.Button();
164
165             // my vars (dec)
166
167             // set gobject values
168             this.el.label = "Save";
169
170             //listeners
171             this.el.clicked.connect( () => { 
172                 _this.saveContents();
173             });
174         }
175
176         // user defined functions
177     }
178
179     public class Xcls_key_edit : Object
180     {
181         public Gtk.Entry el;
182         private Editor  _this;
183
184
185             // my vars (def)
186
187         // ctor
188         public Xcls_key_edit(Editor _owner )
189         {
190             _this = _owner;
191             _this.key_edit = this;
192             this.el = new Gtk.Entry();
193
194             // my vars (dec)
195
196             // set gobject values
197         }
198
199         // user defined functions
200     }
201
202
203     public class Xcls_RightEditor : Object
204     {
205         public Gtk.ScrolledWindow el;
206         private Editor  _this;
207
208
209             // my vars (def)
210
211         // ctor
212         public Xcls_RightEditor(Editor _owner )
213         {
214             _this = _owner;
215             _this.RightEditor = this;
216             this.el = new Gtk.ScrolledWindow( null, null );
217
218             // my vars (dec)
219
220             // set gobject values
221             var child_0 = new Xcls_view( _this );
222             child_0.ref();
223             this.el.add (  child_0.el  );
224
225             // init method
226
227             this.el.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
228         }
229
230         // user defined functions
231     }
232     public class Xcls_view : Object
233     {
234         public Gtk.SourceView el;
235         private Editor  _this;
236
237
238             // my vars (def)
239
240         // ctor
241         public Xcls_view(Editor _owner )
242         {
243             _this = _owner;
244             _this.view = this;
245             this.el = new Gtk.SourceView();
246
247             // my vars (dec)
248
249             // set gobject values
250             this.el.auto_indent = true;
251             this.el.indent_width = 4;
252             this.el.show_line_marks = true;
253             this.el.insert_spaces_instead_of_tabs = true;
254             this.el.show_line_numbers = true;
255             this.el.highlight_current_line = true;
256             var child_0 = new Xcls_buffer( _this );
257             child_0.ref();
258             this.el.set_buffer (  child_0.el  );
259
260             // init method
261
262             var description =   Pango.FontDescription.from_string("monospace");
263                 description.set_size(8000);
264                 this.el.override_font(description);
265             
266             
267               
268                 var attrs = new Gtk.SourceMarkAttributes();
269                 var  pink = new Gdk.RGBA();
270                 pink.parse ( "pink");
271                 attrs.set_background ( pink);
272                 attrs.set_icon_name ( "process-stop");    
273                 attrs.query_tooltip_text.connect(( mark) => {
274                     //print("tooltip query? %s\n", mark.name);
275                     return mark.name;
276                 });
277                 
278                 this.el.set_mark_attributes ("ERR", attrs, 1);
279                 
280                  var wattrs = new Gtk.SourceMarkAttributes();
281                 var  blue = new Gdk.RGBA();
282                 blue.parse ( "#ABF4EB");
283                 wattrs.set_background ( blue);
284                 wattrs.set_icon_name ( "process-stop");    
285                 wattrs.query_tooltip_text.connect(( mark) => {
286                     //print("tooltip query? %s\n", mark.name);
287                     return mark.name;
288                 });
289                 
290                 this.el.set_mark_attributes ("WARN", wattrs, 1);
291                 
292              
293                 
294                  var dattrs = new Gtk.SourceMarkAttributes();
295                 var  purple = new Gdk.RGBA();
296                 purple.parse ( "#EEA9FF");
297                 dattrs.set_background ( purple);
298                 dattrs.set_icon_name ( "process-stop");    
299                 dattrs.query_tooltip_text.connect(( mark) => {
300                     //print("tooltip query? %s\n", mark.name);
301                     return mark.name;
302                 });
303                 
304                 this.el.set_mark_attributes ("DEPR", dattrs, 1);
305
306             //listeners
307             this.el.key_release_event.connect( (event) => {
308                 
309                 if (event.keyval == 115 && (event.state & Gdk.ModifierType.CONTROL_MASK ) > 0 ) {
310                     print("SAVE: ctrl-S  pressed");
311                     _this.saveContents();
312                     return false;
313                 }
314                // print(event.key.keyval)
315                 
316                 return false;
317             
318             });
319         }
320
321         // user defined functions
322         public   void load (string str) {
323         
324         // show the help page for the active node..
325            //this.get('/Help').show();
326         
327         
328           // this.get('/BottomPane').el.set_current_page(0);
329           var buf = (Gtk.SourceBuffer)this.el.get_buffer();
330             buf.set_text(str, str.length);
331             buf.set_undo_manager(null);
332             
333             var lm = Gtk.SourceLanguageManager.get_default();
334             
335             var lang = _this.file.language;
336             //?? is javascript going to work as js?
337             
338             ((Gtk.SourceBuffer)(this.el.get_buffer())) .set_language(lm.get_language(lang));
339             var buf = this.el.get_buffer();
340              
341             _this.dirty = false;
342             this.el.grab_focus();
343             _this.save_button.el.sensitive = false;
344         }
345     }
346     public class Xcls_buffer : Object
347     {
348         public Gtk.SourceBuffer el;
349         private Editor  _this;
350
351
352             // my vars (def)
353         public bool check_queued;
354         public int error_line;
355         public bool check_running;
356
357         // ctor
358         public Xcls_buffer(Editor _owner )
359         {
360             _this = _owner;
361             _this.buffer = this;
362             this.el = new Gtk.SourceBuffer( null );
363
364             // my vars (dec)
365             this.check_queued = false;
366             this.error_line = -1;
367             this.check_running = false;
368
369             // set gobject values
370
371             //listeners
372             this.el.changed.connect( () => {
373                 // check syntax??
374                 // ??needed..??
375                 _this.save_button.el.sensitive = true;
376                 print("EDITOR CHANGED");
377                 this.checkSyntax();
378                
379                 _this.dirty = true;
380             
381                 // this.get('/LeftPanel.model').changed(  str , false);
382                 return ;
383             });
384         }
385
386         // user defined functions
387         public bool highlightErrors ( Gee.HashMap<int,string> validate_res) {
388                 this.error_line = validate_res.size;
389         
390                 if (this.error_line < 1) {
391                       return true;
392                 }
393                 var tlines = this.el.get_line_count ();
394                 Gtk.TextIter iter;
395                 var valiter = validate_res.map_iterator();
396                 while (valiter.next()) {
397                 
398             //        print("get inter\n");
399                     var eline = valiter.get_key();
400                     if (eline > tlines) {
401                         continue;
402                     }
403                     this.el.get_iter_at_line( out iter, eline);
404                     //print("mark line\n");
405                     this.el.create_source_mark(valiter.get_value(), "error", iter);
406                 }   
407                 return false;
408             }
409         public   string toString () {
410             
411             Gtk.TextIter s;
412             Gtk.TextIter e;
413             this.el.get_start_iter(out s);
414             this.el.get_end_iter(out e);
415             var ret = this.el.get_text(s,e,true);
416             //print("TO STRING? " + ret);
417             return ret;
418         }
419         public   bool checkSyntax () {
420          
421             if (this.check_running) {
422                 print("Check is running\n");
423                 if (this.check_queued) { 
424                     print("Check is already queued");
425                     return true;
426                 }
427                 this.check_queued = true;
428                 print("Adding queued Check ");
429                 GLib.Timeout.add_seconds(1, () => {
430                     this.check_queued = false;
431                     
432                     this.checkSyntax();
433                     return false;
434                 });
435             
436         
437                 return true;
438             }
439            
440            
441             var p = Palete.factory(_this.file.xtype);   
442             
443             var str = this.toString();
444             
445              
446             if (this.error_line > 0) {
447                  Gtk.TextIter start;
448                  Gtk.TextIter end;     
449                 this.el.get_bounds (out start, out end);
450         
451                 this.el.remove_source_marks (start, end, null);
452             }
453             
454             if (str.length < 1) {
455                 print("checkSyntax - empty string?\n");
456                 return true;
457             }
458             this.check_running = true;
459             
460             
461             if (_this.file.language == "js") {
462                 this.check_running = false;
463                 print("calling validate javascript\n"); 
464                 return this.highlightErrors(p.validateJavascript(
465                     str, 
466                      _this.key, 
467                     _this.ptype,
468                     _this.file,
469                     _this.node
470                 ));    
471                 
472             }
473                 
474                 
475             print("calling validate vala\n");    
476             // clear the buttons.
477          
478             
479             p.validateVala(
480                 _this.window.windowstate,
481                 str, 
482                  _this.key, 
483                 _this.ptype,
484                 _this.file,
485                 _this.node 
486                 
487                 
488             );
489              
490             
491             
492             //print("done mark line\n");
493              
494             return true; // at present allow saving - even if it's invalid..
495         }
496         public bool highlightErrorsJson (string type, Json.Object obj) {
497               Gtk.TextIter start;
498              Gtk.TextIter end;     
499                 this.el.get_bounds (out start, out end);
500                 
501                 this.el.remove_source_marks (start, end, type);
502                          
503              
504              // we should highlight other types of errors..
505             
506             if (!obj.has_member(type)) {
507                 print("Return has no errors\n");
508                 return true;
509             }
510             var err = obj.get_object_member(type);
511             
512             
513             var valafn = "";
514               try {             
515                    var  regex = new Regex("\\.bjs$");
516                 
517                  
518                     valafn = regex.replace(_this.file.path,_this.file.path.length , 0 , ".vala");
519                  } catch (GLib.RegexError e) {
520                     return true;
521                 }   
522         
523            if (!err.has_member(valafn)) {
524                 print("File path has no errors\n");
525                 return  true;
526             }
527         
528             var lines = err.get_object_member(valafn);
529             
530             var offset = 1;
531             if (obj.has_member("line_offset")) {
532                 offset = (int)obj.get_int_member("line_offset") + 1;
533             }
534              
535             
536             var tlines = this.el.get_line_count () +1;
537             
538             lines.foreach_member((obj, line, node) => {
539                 
540                      Gtk.TextIter iter;
541             //        print("get inter\n");
542                     var eline = int.parse(line) - offset;
543                     print("GOT ERROR on line %s -- converted to %d\n", line,eline);
544                     
545                     
546                     if (eline > tlines || eline < 0) {
547                         return;
548                     }
549                     this.el.get_iter_at_line( out iter, eline);
550                     //print("mark line\n");
551                     var msg  = "Line: %d".printf(eline+1);
552                     var ar = lines.get_array_member(line);
553                     for (var i = 0 ; i < ar.get_length(); i++) {
554                             msg += (msg.length > 0) ? "\n" : "";
555                             msg += ar.get_string_element(i);
556                     }
557                     
558                     
559                     this.el.create_source_mark(msg, type, iter);
560                 } );
561                 return false;
562             
563         
564         
565         
566         
567         }
568     }
569
570
571
572 }