git.roojs.org Git - roobuilder/blob - src/Builder4/WindowRooView.vala

   1 static Xcls_WindowRooView  _WindowRooView;
   2
   3 public class Xcls_WindowRooView : Object
   4 {
   5         public Gtk.Box el;
   6         private Xcls_WindowRooView  _this;
   7
   8         public static Xcls_WindowRooView singleton()
   9         {
  10                 if (_WindowRooView == null) {
  11                     _WindowRooView= new Xcls_WindowRooView();
  12                 }
  13                 return _WindowRooView;
  14         }
  15         public Xcls_notebook notebook;
  16         public Xcls_label_preview label_preview;
  17         public Xcls_label_code label_code;
  18         public Xcls_paned paned;
  19         public Xcls_viewbox viewbox;
  20         public Xcls_AutoRedraw AutoRedraw;
  21         public Xcls_view view;
  22         public Xcls_inspectorcontainer inspectorcontainer;
  23         public Xcls_sourceviewscroll sourceviewscroll;
  24         public Xcls_sourceview sourceview;
  25         public Xcls_buffer buffer;
  26         public Xcls_search_entry search_entry;
  27         public Xcls_search_results search_results;
  28         public Xcls_nextBtn nextBtn;
  29         public Xcls_backBtn backBtn;
  30         public Xcls_search_settings search_settings;
  31         public Xcls_case_sensitive case_sensitive;
  32         public Xcls_regex regex;
  33         public Xcls_multiline multiline;
  34
  35                 // my vars (def)
  36         public Gtk.Widget lastObj;
  37         public Xcls_MainWindow main_window;
  38         public int last_error_counter;
  39         public int last_search_end;
  40         public GtkSource.SearchContext searchcontext;
  41         public JsRender.JsRender file;
  42
  43         // ctor
  44         public Xcls_WindowRooView()
  45         {
  46                 _this = this;
  47                 this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
  48
  49                 // my vars (dec)
  50                 this.lastObj = null;
  51                 this.last_error_counter = 0;
  52                 this.last_search_end = 0;
  53                 this.file = null;
  54
  55                 // set gobject values
  56                 this.el.hexpand = true;
  57                 this.el.vexpand = true;
  58                 new Xcls_notebook( _this );
  59                 this.el.append( _this.notebook.el );
  60         }
  61
  62         // user defined functions
  63         public void loadFile (JsRender.JsRender file)
  64         {
  65             this.file = file;
  66             this.view.renderJS(true);
  67             this.notebook.el.page = 0;// gtk preview
  68             this.sourceview.loadFile();
  69             this.last_error_counter = -1;
  70             this.updateErrorMarks();
  71         }
  72         public void highlightNodeAtLine (int ln) {
  73
  74
  75
  76                 // highlight node...
  77
  78
  79             var node = _this.file.lineToNode(ln+1);
  80
  81             if (node == null) {
  82                 //print("can not find node\n");
  83                 return;
  84             }
  85             var prop = node.lineToProp(ln+1);
  86             print("prop : %s", prop == null ? "???" : prop.name);
  87
  88
  89             // ---------- this selects the tree's node...
  90
  91             var ltree = _this.main_window.windowstate.left_tree;
  92            ltree.model.selectNode(node);
  93
  94             //_this.sourceview.allow_node_scroll = false; /// block node scrolling..
  95
  96
  97             //print("changing cursor on tree..\n");
  98
  99
 100
 101             // let's try allowing editing on the methods.
 102             // a little klunky at present..
 103                 _this.sourceview.prop_selected = "";
 104                 /*
 105             if (prop != null) {
 106                         //see if we can find it..
 107                         var kv = prop.split(":");
 108                         if (kv[0] == "p") {
 109
 110                         //var k = prop.get_key(kv[1]);
 111                         // fixme -- need to determine if it's an editable property...
 112                         _this.sourceview.prop_selected = prop;
 113
 114                         } else if (kv[0] == "l") {
 115                                  _this.sourceview.prop_selected = prop;
 116
 117                         }
 118             }
 119             */
 120            // ltree.view.el.set_cursor(new Gtk.TreePath.from_string(tp), null, false);
 121            _this.sourceview.nodeSelected(node,false);
 122
 123                     // scrolling is disabled... as node selection calls scroll 10ms after it changes.
 124               //      GLib.Timeout.add_full(GLib.Priority.DEFAULT,100 , () => {
 125                   //          this.allow_node_scroll = true;
 126                   //          return false;
 127               //      });
 128               //  }
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140         }
 141         public void requestRedraw () {
 142             this.view.renderJS(false);
 143             this.sourceview.loadFile();
 144         }
 145         public void forwardSearch (bool change_focus) {
 146
 147                 if (this.searchcontext == null) {
 148                         return;
 149                 }
 150                 this.notebook.el.page = 1;
 151                 Gtk.TextIter beg, st,en;
 152                 bool has_wrapped_around;
 153                 var buf = this.sourceview.el.get_buffer();
 154                 buf.get_iter_at_offset(out beg, this.last_search_end);
 155                 if (!this.searchcontext.forward(beg, out st, out en, out has_wrapped_around)) {
 156                         this.last_search_end = 0;
 157                         return;
 158                 }
 159                 this.last_search_end = en.get_offset();
 160                 if (change_focus) {
 161                         this.sourceview.el.grab_focus();
 162                 }
 163                 buf.place_cursor(st);
 164
 165
 166
 167                 this.sourceview.el.scroll_to_iter(st,  0.0f, true, 0.0f, 0.5f);
 168
 169
 170                 var ln = st.get_line();
 171
 172                 this.highlightNodeAtLine(ln);
 173         }
 174         public void backSearch (bool change_focus) {
 175
 176                 if (this.searchcontext == null) {
 177                         return;
 178                 }
 179
 180                 Gtk.TextIter beg, st,en;
 181                 bool has_wrapped_around;
 182                 this.buffer.el.get_iter_at_offset(out beg, this.last_search_end -1 );
 183
 184                 if (!this.searchcontext.backward(beg, out st, out en, out has_wrapped_around)) {
 185
 186                         this.last_search_end = 0;
 187                         return;
 188                 }
 189                 this.last_search_end = en.get_offset();
 190                 if (change_focus) {
 191                         this.sourceview.el.grab_focus();
 192                 }
 193                 this.buffer.el.place_cursor(st);
 194                 this.sourceview.el.scroll_to_iter(st,  0.1f, true, 0.0f, 0.5f);
 195                 var ln = st.get_line();
 196                 this.highlightNodeAtLine(ln);
 197
 198
 199         }
 200         public int search (string in_txt) {
 201                 this.notebook.el.page = 1;
 202
 203
 204
 205                 var s = new GtkSource.SearchSettings();
 206                 s.case_sensitive = _this.case_sensitive.el.active;
 207                 s.regex_enabled = _this.regex.el.active;
 208                 s.wrap_around = false;
 209
 210                 this.searchcontext = new GtkSource.SearchContext(this.buffer.el,s);
 211                 this.searchcontext.set_highlight(true);
 212                 var txt = in_txt;
 213
 214                 if (_this.multiline.el.active) {
 215                         txt = in_txt.replace("\\n", "\n");
 216                 }
 217
 218                 s.set_search_text(txt);
 219                 Gtk.TextIter beg, st,en;
 220                 bool has_wrapped_around;
 221                 this.buffer.el.get_start_iter(out beg);
 222                 this.searchcontext.forward(beg, out st, out en, out has_wrapped_around);
 223                 this.last_search_end = 0;
 224
 225                 return this.searchcontext.get_occurrences_count();
 226
 227
 228
 229
 230         }
 231         public void createThumb () {
 232
 233
 234             if (this.file == null) {
 235                 return;
 236             }
 237
 238                 if (this.notebook.el.page > 0 ) {
 239                 return;
 240             }
 241
 242                 this.file.widgetToIcon(this.view.el);
 243
 244
 245
 246
 247
 248         }
 249         public void updateErrorMarks () {
 250
 251
 252
 253                 var buf = _this.buffer.el;
 254                 Gtk.TextIter start;
 255                 Gtk.TextIter end;
 256                 buf.get_bounds (out start, out end);
 257
 258
 259
 260                 GLib.debug("highlight errors");
 261
 262                  // we should highlight other types of errors..
 263
 264
 265
 266
 267                 if (_this.file == null) {
 268                         GLib.debug("file is null?");
 269                         return;
 270
 271                 }
 272                 var ar = this.file.getErrors();
 273                 if (ar.size < 1) {
 274                         buf.remove_tag_by_name ("ERR", start, end);
 275                         buf.remove_tag_by_name ("WARN", start, end);
 276                         buf.remove_tag_by_name ("DEPR", start, end);
 277                         buf.remove_source_marks (start, end, "ERR");
 278                         buf.remove_source_marks (start, end, "WARN");
 279                         buf.remove_source_marks (start, end, "DEPR");
 280                         this.last_error_counter = file.error_counter ;
 281                         GLib.debug("higjlight has no errors");
 282                         return;
 283                 }
 284                 if (this.last_error_counter == file.error_counter) {
 285                         return;
 286                 }
 287
 288                 var tlines = buf.get_line_count () +1;
 289
 290
 291
 292                 buf.remove_source_marks (start, end, "ERR");
 293                 buf.remove_source_marks (start, end, "WARN");
 294                 buf.remove_source_marks (start, end, "DEPR");
 295                 buf.remove_tag_by_name ("ERR", start, end);
 296                 buf.remove_tag_by_name ("WARN", start, end);
 297                 buf.remove_tag_by_name ("DEPR", start, end);
 298                 foreach(var diag in ar) {
 299
 300
 301                      Gtk.TextIter iter;
 302         //        print("get inter\n");
 303                     var eline = (int)diag.range.start.line ;
 304                     var eline_to = (int)diag.range.end.line;
 305                     if (eline > tlines || eline < 0) {
 306                         return;
 307                     }
 308
 309
 310                     buf.get_iter_at_line( out iter, eline);
 311
 312                          buf.get_iter_at_line_offset( out start,
 313                         eline, (int)diag.range.start.character);
 314                     buf.get_iter_at_line_offset( out end,
 315                         eline_to, (int)diag.range.end.character);
 316
 317                     buf.apply_tag_by_name(diag.category, start, end);
 318
 319
 320                         var msg = "Line: %d %s : %s".printf(eline+1, diag.category, diag.message);
 321                     buf.create_source_mark( msg, diag.category, iter);
 322                     GLib.debug("set line %d to %s", eline, msg);
 323                     //this.marks.set(eline, msg);
 324                 }
 325                 this.last_error_counter = file.error_counter ;
 326
 327
 328
 329
 330
 331         }
 332         public void scroll_to_line (int line) {
 333            // code preview...
 334
 335            GLib.Timeout.add(100, () => {
 336
 337                         this.notebook.el.set_current_page( 1 );
 338
 339
 340                           var buf = this.sourceview.el.get_buffer();
 341
 342                         var sbuf = (GtkSource.Buffer) buf;
 343
 344
 345                         Gtk.TextIter iter;
 346                         sbuf.get_iter_at_line(out iter,  line);
 347                         this.sourceview.el.scroll_to_iter(iter,  0.1f, true, 0.0f, 0.5f);
 348                         return false;
 349                 });
 350
 351
 352         }
 353         public class Xcls_notebook : Object
 354         {
 355                 public Gtk.Notebook el;
 356                 private Xcls_WindowRooView  _this;
 357
 358
 359                         // my vars (def)
 360
 361                 // ctor
 362                 public Xcls_notebook(Xcls_WindowRooView _owner )
 363                 {
 364                         _this = _owner;
 365                         _this.notebook = this;
 366                         this.el = new Gtk.Notebook();
 367
 368                         // my vars (dec)
 369
 370                         // set gobject values
 371                         this.el.vexpand = true;
 372                         new Xcls_label_preview( _this );
 373                         new Xcls_label_code( _this );
 374                         new Xcls_paned( _this );
 375                         this.el.append_page ( _this.paned.el , _this.label_preview.el );
 376                         var child_4 = new Xcls_Box12( _this );
 377                         child_4.ref();
 378                         this.el.append_page ( child_4.el , _this.label_code.el );
 379                 }
 380
 381                 // user defined functions
 382         }
 383         public class Xcls_label_preview : Object
 384         {
 385                 public Gtk.Label el;
 386                 private Xcls_WindowRooView  _this;
 387
 388
 389                         // my vars (def)
 390
 391                 // ctor
 392                 public Xcls_label_preview(Xcls_WindowRooView _owner )
 393                 {
 394                         _this = _owner;
 395                         _this.label_preview = this;
 396                         this.el = new Gtk.Label( "Preview" );
 397
 398                         // my vars (dec)
 399
 400                         // set gobject values
 401                 }
 402
 403                 // user defined functions
 404         }
 405
 406         public class Xcls_label_code : Object
 407         {
 408                 public Gtk.Label el;
 409                 private Xcls_WindowRooView  _this;
 410
 411
 412                         // my vars (def)
 413
 414                 // ctor
 415                 public Xcls_label_code(Xcls_WindowRooView _owner )
 416                 {
 417                         _this = _owner;
 418                         _this.label_code = this;
 419                         this.el = new Gtk.Label( "Preview Generated Code" );
 420
 421                         // my vars (dec)
 422
 423                         // set gobject values
 424                 }
 425
 426                 // user defined functions
 427         }
 428
 429         public class Xcls_paned : Object
 430         {
 431                 public Gtk.Paned el;
 432                 private Xcls_WindowRooView  _this;
 433
 434
 435                         // my vars (def)
 436
 437                 // ctor
 438                 public Xcls_paned(Xcls_WindowRooView _owner )
 439                 {
 440                         _this = _owner;
 441                         _this.paned = this;
 442                         this.el = new Gtk.Paned( Gtk.Orientation.VERTICAL );
 443
 444                         // my vars (dec)
 445
 446                         // set gobject values
 447                         this.el.vexpand = true;
 448                         new Xcls_viewbox( _this );
 449                         this.el.set_start_child ( _this.viewbox.el  );
 450                         new Xcls_inspectorcontainer( _this );
 451                         this.el.set_end_child ( _this.inspectorcontainer.el  );
 452                 }
 453
 454                 // user defined functions
 455         }
 456         public class Xcls_viewbox : Object
 457         {
 458                 public Gtk.Box el;
 459                 private Xcls_WindowRooView  _this;
 460
 461
 462                         // my vars (def)
 463
 464                 // ctor
 465                 public Xcls_viewbox(Xcls_WindowRooView _owner )
 466                 {
 467                         _this = _owner;
 468                         _this.viewbox = this;
 469                         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
 470
 471                         // my vars (dec)
 472
 473                         // set gobject values
 474                         this.el.homogeneous = false;
 475                         this.el.vexpand = true;
 476                         var child_1 = new Xcls_Box6( _this );
 477                         child_1.ref();
 478                         this.el.append( child_1.el );
 479                         new Xcls_view( _this );
 480                         this.el.append( _this.view.el );
 481                 }
 482
 483                 // user defined functions
 484         }
 485         public class Xcls_Box6 : Object
 486         {
 487                 public Gtk.Box el;
 488                 private Xcls_WindowRooView  _this;
 489
 490
 491                         // my vars (def)
 492
 493                 // ctor
 494                 public Xcls_Box6(Xcls_WindowRooView _owner )
 495                 {
 496                         _this = _owner;
 497                         this.el = new Gtk.Box( Gtk.Orientation.HORIZONTAL, 0 );
 498
 499                         // my vars (dec)
 500
 501                         // set gobject values
 502                         this.el.homogeneous = true;
 503                         this.el.height_request = 20;
 504                         this.el.vexpand = false;
 505                         var child_1 = new Xcls_Button7( _this );
 506                         child_1.ref();
 507                         this.el.append( child_1.el );
 508                         new Xcls_AutoRedraw( _this );
 509                         this.el.append( _this.AutoRedraw.el );
 510                         var child_3 = new Xcls_Button9( _this );
 511                         child_3.ref();
 512                         this.el.append( child_3.el );
 513                 }
 514
 515                 // user defined functions
 516         }
 517         public class Xcls_Button7 : Object
 518         {
 519                 public Gtk.Button el;
 520                 private Xcls_WindowRooView  _this;
 521
 522
 523                         // my vars (def)
 524
 525                 // ctor
 526                 public Xcls_Button7(Xcls_WindowRooView _owner )
 527                 {
 528                         _this = _owner;
 529                         this.el = new Gtk.Button();
 530
 531                         // my vars (dec)
 532
 533                         // set gobject values
 534                         this.el.label = "Redraw";
 535
 536                         //listeners
 537                         this.el.clicked.connect( ( ) => {
 538                             _this.view.renderJS(  true);
 539                         });
 540                 }
 541
 542                 // user defined functions
 543         }
 544
 545         public class Xcls_AutoRedraw : Object
 546         {
 547                 public Gtk.CheckButton el;
 548                 private Xcls_WindowRooView  _this;
 549
 550
 551                         // my vars (def)
 552
 553                 // ctor
 554                 public Xcls_AutoRedraw(Xcls_WindowRooView _owner )
 555                 {
 556                         _this = _owner;
 557                         _this.AutoRedraw = this;
 558                         this.el = new Gtk.CheckButton();
 559
 560                         // my vars (dec)
 561
 562                         // set gobject values
 563                         this.el.active = true;
 564                         this.el.label = "Auto Redraw On";
 565
 566                         //listeners
 567                         this.el.toggled.connect( (state) => {
 568                             this.el.set_label(this.el.active  ? "Auto Redraw On" : "Auto Redraw Off");
 569                         });
 570                 }
 571
 572                 // user defined functions
 573         }
 574
 575         public class Xcls_Button9 : Object
 576         {
 577                 public Gtk.Button el;
 578                 private Xcls_WindowRooView  _this;
 579
 580
 581                         // my vars (def)
 582
 583                 // ctor
 584                 public Xcls_Button9(Xcls_WindowRooView _owner )
 585                 {
 586                         _this = _owner;
 587                         this.el = new Gtk.Button();
 588
 589                         // my vars (dec)
 590
 591                         // set gobject values
 592                         this.el.label = "Full Redraw";
 593
 594                         //listeners
 595                         this.el.clicked.connect( () => {
 596                           _this.view.redraws = 99;
 597                          //   _this.view.el.web_context.clear_cache();
 598                           //_this.view.renderJS(true);
 599                           FakeServerCache.clear();
 600                           _this.view.reInit();
 601
 602                         });
 603                 }
 604
 605                 // user defined functions
 606         }
 607
 608
 609         public class Xcls_view : Object
 610         {
 611                 public WebKit.WebView el;
 612                 private Xcls_WindowRooView  _this;
 613
 614
 615                         // my vars (def)
 616                 public WebKit.WebInspector inspector;
 617                 public bool pendingRedraw;
 618                 public int redraws;
 619                 public bool refreshRequired;
 620                 public string runjs;
 621                 public string runhtml;
 622                 public string renderedData;
 623                 public GLib.DateTime lastRedraw;
 624
 625                 // ctor
 626                 public Xcls_view(Xcls_WindowRooView _owner )
 627                 {
 628                         _this = _owner;
 629                         _this.view = this;
 630                         this.el = new WebKit.WebView();
 631
 632                         // my vars (dec)
 633                         this.pendingRedraw = false;
 634                         this.redraws = 0;
 635                         this.refreshRequired = false;
 636                         this.runjs = "";
 637                         this.runhtml = "";
 638                         this.renderedData = "";
 639                         this.lastRedraw = null;
 640
 641                         // set gobject values
 642                         this.el.vexpand = true;
 643
 644                         // init method
 645
 646                         {
 647                             // this may not work!?
 648                             var settings =  this.el.get_settings();
 649                             settings.enable_developer_extras = true;
 650
 651
 652                             var fs= new FakeServer(this.el);
 653                             fs.ref();
 654                             // this was an attempt to change the url perms.. did not work..
 655                             // settings.enable_file_access_from_file_uris = true;
 656                             // settings.enable_offline_web_application_cache - true;
 657                             // settings.enable_universal_access_from_file_uris = true;
 658
 659
 660
 661
 662
 663
 664                              // FIXME - base url of script..
 665                              // we need it so some of the database features work.
 666                             this.el.load_html( "Render not ready" ,
 667                                     //fixme - should be a config option!
 668                                     // or should we catch stuff and fix it up..
 669                                     "http://localhost/app.Builder/"
 670                             );
 671
 672
 673                            //this.el.open('file:///' + __script_path__ + '/../builder.html');
 674                             /*
 675                             Gtk.drag_dest_set
 676                             (
 677                                     this.el,              //
 678                                     Gtk.DestDefaults.MOTION  | Gtk.DestDefaults.HIGHLIGHT,
 679                                     null,            // list of targets
 680                                     Gdk.DragAction.COPY         // what to do with data after dropped
 681                             );
 682
 683                            // print("RB: TARGETS : " + LeftTree.atoms["STRING"]);
 684                             Gtk.drag_dest_set_target_list(this.el, this.get('/Window').targetList);
 685                             */
 686                             GLib.Timeout.add_seconds(1,  ()  =>{
 687                                  //print("run refresh?");
 688                                  if (this.el == null) {
 689                                     return false;
 690                                  }
 691                                  this.runRefresh();
 692                                  return true;
 693                              });
 694
 695
 696                         }
 697
 698                         //listeners
 699                         this.el.script_dialog.connect( (dialog) => {
 700
 701
 702                             if (this.el == null) {
 703                                 return true;
 704                             }
 705
 706                              var msg = dialog.get_message();
 707                              if (msg.length < 4) {
 708                                 return false;
 709                              }
 710
 711                              GLib.debug("script dialog got %s", msg);
 712
 713                              if (msg.substring(0,4) != "IPC:") {
 714                                  return false;
 715                              }
 716                              var ar = msg.split(":", 3);
 717                             if (ar.length < 3) {
 718                                 return false;
 719                             }
 720
 721                             switch(ar[1]) {
 722                                 case "SAVEHTML":
 723                                         GLib.debug("GOT saveHTML %d", ar[2].length);
 724                                     _this.file.saveHTML(ar[2]);
 725                                     _this.createThumb();
 726                                     return true;
 727                                 default:
 728                                     return false;
 729                             }
 730
 731                         });
 732                         this.el.ready_to_show.connect( ( ) => {
 733                           this.initInspector();
 734
 735                         });
 736                         this.el.load_changed.connect( (le) => {
 737                             if (le != WebKit.LoadEvent.FINISHED) {
 738                                 return;
 739                             }
 740                             if (this.runjs.length < 1) {
 741                                 return;
 742                             }
 743                           //  this.el.run_javascript(this.runjs, null);
 744                              FakeServerCache.remove(    this.runjs);
 745                             this.runjs = "";
 746                         });
 747                 }
 748
 749                 // user defined functions
 750                 public void initInspector () {
 751
 752
 753
 754                    // this.inspector.open_window.connect(() => {
 755                          this.inspector = this.el.get_inspector();
 756
 757                          this.inspector.open_window.connect(() => {
 758                         print("inspector attach\n");
 759                         var wv = this.inspector.get_web_view();
 760                         if (wv != null) {
 761                             print("got inspector web view\n");
 762
 763                             var cn = _this.inspectorcontainer.el.get_first_child();
 764                             if (cn != null) {
 765                                  _this.inspectorcontainer.el.remove(cn);
 766                              }
 767
 768                             _this.inspectorcontainer.el.append(wv);
 769                             wv.show();
 770                         } else {
 771                                  print("got inspector web view FAILED\n");
 772                             //this.inspector.close();
 773
 774                             //this.inspector = null;
 775
 776
 777                         }
 778                       return true;
 779
 780                    });
 781                      this.inspector.show();
 782
 783
 784
 785                 }
 786                 public void renderJS (bool force) {
 787
 788                     // this is the public redraw call..
 789                     // we refresh in a loop privately..
 790                     var autodraw = _this.AutoRedraw.el.active;
 791                     if (!autodraw && !force) {
 792                         print("Skipping redraw - no force, and autodraw off");
 793                         return;
 794                     }
 795
 796                     this.refreshRequired  = true;
 797                 }
 798                 public void reInit () {
 799                    print("reInit?");
 800                          // if this happens destroy the webkit..
 801                          // recreate it..
 802                      this.el.stop_loading();
 803
 804                      if (_this.viewbox.el.get_parent() == null) {
 805                         return;
 806                      }
 807
 808                          /*
 809                     _this.viewbox.el.remove(_this.viewcontainer.el);
 810                     //_this.paned.el.remove(_this.inspectorcontainer.el);
 811
 812                          // destory seems to cause problems.
 813                          //this.el.destroy();
 814                         //_this.viewcontainer.el.destroy();
 815                          //_this.inspectorcontainer.el.destroy();
 816                      var  inv =new Xcls_inspectorcontainer(_this);
 817
 818                       _this.paned.el.set_end_child(inv.el);
 819                       _this.inspectorcontainer = inv;
 820
 821                      this.el = null;
 822                      var nv =new Xcls_viewcontainer(_this);
 823                     // nv.ref();
 824                      _this.viewbox.el.append(nv.el);
 825
 826                          _this.viewcontainer = nv;
 827                      inv.el.show();
 828                      nv.el.show();
 829                          //while(Gtk.events_pending ()) Gtk.main_iteration ();
 830                          //_this.view.renderJS(true);
 831                      _this.view.refreshRequired  = true;
 832
 833                      */
 834                 }
 835                 public void runRefresh ()
 836                 {
 837                     // this is run every 2 seconds from the init..
 838
 839
 840
 841                     if (!this.refreshRequired) {
 842                        // print("no refresh required");
 843                         return;
 844                     }
 845
 846                     if (this.lastRedraw != null) {
 847                        // do not redraw if last redraw was less that 5 seconds ago.
 848                        if ((int64)(new DateTime.now_local()).difference(this.lastRedraw) < 5000 ) {
 849                             return;
 850                         }
 851                     }
 852
 853                     if (_this.file == null) {
 854                         return;
 855                     }
 856
 857
 858                      this.refreshRequired = false;
 859                    //  print("HTML RENDERING");
 860
 861
 862                      //this.get('/BottomPane').el.show();
 863                      //this.get('/BottomPane').el.set_current_page(2);// webkit inspector
 864                     _this.file.webkit_page_id  = this.el.get_page_id();
 865
 866                     var js = _this.file.toSourcePreview();
 867
 868                     if (js.length < 1) {
 869                         print("no data");
 870                         return;
 871                     }
 872                 //    var  data = js[0];
 873                     this.redraws++;
 874
 875                     var project = (Project.Roo) _this.file.project;
 876
 877                      //print (project.fn);
 878                      // set it to non-empty.
 879
 880                 //     runhtml = runhtml.length ?  runhtml : '<script type="text/javascript"></script>';
 881
 882
 883                 //   this.runhtml  = this.runhtml || '';
 884
 885
 886                     // then we need to reload the browser using
 887                     // load_html_string..
 888
 889                     // then trigger a redraw once it's loaded..
 890                     this.pendingRedraw = true;
 891
 892                     var runhtml = "<script type=\"text/javascript\">\n" ;
 893                     uint8[] builderhtml;
 894
 895                     try {
 896                         GLib. File.new_for_uri("resources:///html/roo.builder.js").load_contents(null,  out   builderhtml, null);
 897                     } catch (Error e) {
 898                         builderhtml = {};
 899                     }
 900
 901                     runhtml += (string) builderhtml + "\n";
 902                     runhtml += "</script>\n" ;
 903
 904                     // fix to make sure they are the same..
 905                     this.runhtml = project.runhtml;
 906                     // need to modify paths
 907
 908                     uint8[] inhtml;
 909                     var base_template = project.base_template;
 910                     var f = GLib. File.new_for_uri("resources:///html/" + base_template);
 911
 912                     if (base_template.length > 0 && !f.query_exists(null)) {
 913
 914                            GLib.debug("invalid base_template name - using default:  %Scanner", base_template);
 915                            f = GLib. File.new_for_uri("resources:///html/roo.builder.html");
 916
 917                     }
 918                     try {
 919                             f.load_contents(null,  out inhtml, null);
 920
 921
 922                     } catch (Error e) {
 923                         inhtml = {};
 924                     }
 925                     this.renderedData = js;
 926
 927
 928                     string js_src = js + "
 929                 Roo.onReady(function() {
 930                 if (" + _this.file.name +".show) {
 931                                 " + _this.file.name +".show({});
 932                                 (function() {
 933                                         Builder.saveHTML.defer(100, Builder);
 934                                 }).defer(100);
 935                 }
 936                 Roo.XComponent.build();
 937                 });\n";
 938
 939                    // print("render js: " + js);
 940                     //if (!this.ready) {
 941                   //      console.log('not loaded yet');
 942                     //}
 943                     this.lastRedraw = new DateTime.now_local();
 944
 945
 946                     //this.runjs = js_src;
 947                     var fc =    FakeServerCache.factory_with_data(js_src);
 948                     this.runjs = fc.fname;
 949                     var html  = (string) inhtml;
 950                         html = html.replace("</head>", runhtml + this.runhtml +
 951                         "<script type=\"text/javascript\" src=\"xhttp://localhost" + fc.fname + "\"></script>" +
 952                           //  "<script type=\"text/javascript\">\n" +
 953                           //  js_src + "\n" +
 954                           //  "</script>" +
 955
 956                     "</head>");
 957                     //print("LOAD HTML " + html);
 958
 959                      var rootURL = project.rootURL;
 960
 961
 962
 963                     this.el.load_html( html ,
 964                         //fixme - should be a config option!
 965                         (rootURL.length > 0 ? rootURL : "xhttp://localhost/roobuilder/")
 966                     );
 967                       this.initInspector();
 968                     // force the inspector...
 969                        //   this.initInspector();
 970
 971                         // - no need for this, the builder javascript will call it when build is complete
 972                         //GLib.Timeout.add_seconds(1, () => {
 973                         //    this.el.run_javascript("Builder.saveHTML()",null);
 974                         //    return false;
 975                         //});
 976                 //     print( "before render" +    this.lastRedraw);
 977                 //    print( "after render" +    (new Date()));
 978
 979                 }
 980         }
 981
 982
 983         public class Xcls_inspectorcontainer : Object
 984         {
 985                 public Gtk.Box el;
 986                 private Xcls_WindowRooView  _this;
 987
 988
 989                         // my vars (def)
 990
 991                 // ctor
 992                 public Xcls_inspectorcontainer(Xcls_WindowRooView _owner )
 993                 {
 994                         _this = _owner;
 995                         _this.inspectorcontainer = this;
 996                         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
 997
 998                         // my vars (dec)
 999
1000                         // set gobject values
1001                         this.el.vexpand = true;
1002                 }
1003
1004                 // user defined functions
1005         }
1006
1007
1008         public class Xcls_Box12 : Object
1009         {
1010                 public Gtk.Box el;
1011                 private Xcls_WindowRooView  _this;
1012
1013
1014                         // my vars (def)
1015
1016                 // ctor
1017                 public Xcls_Box12(Xcls_WindowRooView _owner )
1018                 {
1019                         _this = _owner;
1020                         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
1021
1022                         // my vars (dec)
1023
1024                         // set gobject values
1025                         this.el.vexpand = true;
1026                         new Xcls_sourceviewscroll( _this );
1027                         this.el.append( _this.sourceviewscroll.el );
1028                         var child_2 = new Xcls_Box17( _this );
1029                         child_2.ref();
1030                         this.el.append( child_2.el );
1031                 }
1032
1033                 // user defined functions
1034         }
1035         public class Xcls_sourceviewscroll : Object
1036         {
1037                 public Gtk.ScrolledWindow el;
1038                 private Xcls_WindowRooView  _this;
1039
1040
1041                         // my vars (def)
1042
1043                 // ctor
1044                 public Xcls_sourceviewscroll(Xcls_WindowRooView _owner )
1045                 {
1046                         _this = _owner;
1047                         _this.sourceviewscroll = this;
1048                         this.el = new Gtk.ScrolledWindow();
1049
1050                         // my vars (dec)
1051
1052                         // set gobject values
1053                         this.el.vexpand = true;
1054                         new Xcls_sourceview( _this );
1055                         this.el.set_child ( _this.sourceview.el  );
1056                 }
1057
1058                 // user defined functions
1059         }
1060         public class Xcls_sourceview : Object
1061         {
1062                 public GtkSource.View el;
1063                 private Xcls_WindowRooView  _this;
1064
1065
1066                         // my vars (def)
1067                 public int editable_start_pos;
1068                 public bool loading;
1069                 public bool button_is_pressed;
1070                 public string prop_selected;
1071                 public Gtk.CssProvider? css;
1072                 public bool key_is_pressed;
1073                 public JsRender.Node? node_selected;
1074
1075                 // ctor
1076                 public Xcls_sourceview(Xcls_WindowRooView _owner )
1077                 {
1078                         _this = _owner;
1079                         _this.sourceview = this;
1080                         this.el = new GtkSource.View();
1081
1082                         // my vars (dec)
1083                         this.editable_start_pos = -1;
1084                         this.loading = true;
1085                         this.button_is_pressed = false;
1086                         this.prop_selected = "";
1087                         this.css = null;
1088                         this.key_is_pressed = false;
1089                         this.node_selected = null;
1090
1091                         // set gobject values
1092                         this.el.name = "roo-view";
1093                         this.el.editable = false;
1094                         this.el.show_line_marks = true;
1095                         this.el.show_line_numbers = true;
1096                         this.el.css_classes = { "code-editor" };
1097                         new Xcls_buffer( _this );
1098                         this.el.set_buffer ( _this.buffer.el  );
1099                         var child_2 = new Xcls_EventControllerKey16( _this );
1100                         child_2.ref();
1101                         this.el.add_controller ( child_2.el  );
1102
1103                         // init method
1104
1105                         {
1106
1107
1108
1109                                 this.loading = true;
1110                                 //var buf = this.el.get_buffer();
1111                                 //buf.notify.connect(this.onCursorChanged);
1112
1113
1114                                 var attrs = new GtkSource.MarkAttributes();
1115                                 attrs.set_icon_name ( "process-stop");
1116                                 attrs.query_tooltip_text.connect(( mark) => {
1117                                         //print("tooltip query? %s\n", mark.name);
1118                                         return mark.name;
1119                                 });
1120
1121                                 this.el.set_mark_attributes ("ERR", attrs, 1);
1122
1123                                  var wattrs = new GtkSource.MarkAttributes();
1124                                 wattrs.set_icon_name ( "process-stop");
1125                                 wattrs.query_tooltip_text.connect(( mark) => {
1126                                         //print("tooltip query? %s\n", mark.name);
1127                                         return mark.name;
1128                                 });
1129
1130                                 this.el.set_mark_attributes ("WARN", wattrs, 1);
1131
1132
1133
1134                                  var dattrs = new GtkSource.MarkAttributes();
1135                                 dattrs.set_icon_name ( "process-stop");
1136                                 dattrs.query_tooltip_text.connect(( mark) => {
1137                                         //print("tooltip query? %s\n", mark.name);
1138                                         return mark.name;
1139                                 });
1140
1141                                 this.el.set_mark_attributes ("DEPR", dattrs, 1);
1142
1143
1144                                 var gattrs = new GtkSource.MarkAttributes();
1145                                 var  grey =   Gdk.RGBA();
1146                                 grey.parse ( "#ccc");
1147                                 gattrs.set_background ( grey);
1148
1149
1150                                 this.el.set_mark_attributes ("grey", gattrs, 1);
1151
1152
1153
1154
1155
1156                                 }
1157
1158                         //listeners
1159                         this.el.query_tooltip.connect( (x, y, keyboard_tooltip, tooltip) => {
1160
1161                                 //GLib.debug("query tooltip");
1162                                 Gtk.TextIter iter;
1163                                 int trailing;
1164
1165                                 var yoff = (int) _this.sourceviewscroll.el.vadjustment.value;
1166
1167                                 this.el.get_iter_at_position (out iter, out trailing,  x,  y + yoff);
1168
1169                                 var l = iter.get_line();
1170                                 //GLib.debug("query tooltip line %d", (int) l);
1171                                 var marks = _this.buffer.el.get_source_marks_at_line(l, null);
1172                                 //GLib.debug("query tooltip line marks %d", (int) marks.length());
1173                                 var str = "";
1174                                 marks.@foreach((m) => {
1175                                         //GLib.debug("got mark %s", m.name);
1176                                         str += (str.length > 0 ? "\n" : "") + m.name;
1177                                 });
1178                                 // true if there is a mark..
1179                                 if (str.length > 0 ) {
1180                                                 tooltip.set_text( str);
1181                                 }
1182                                 return str.length > 0 ? true : false;
1183
1184                         });
1185                 }
1186
1187                 // user defined functions
1188                 public void loadFile ( ) {
1189                     this.loading = true;
1190
1191
1192                     // get the cursor and scroll position....
1193                     var buf = this.el.get_buffer();
1194                         var cpos = buf.cursor_position;
1195
1196                    print("BEFORE LOAD cursor = %d\n", cpos);
1197
1198                     var vadj_pos = this.el.get_vadjustment().get_value();
1199
1200
1201
1202                     buf.set_text("",0);
1203
1204
1205
1206
1207                     if (_this.file == null || _this.file.xtype != "Roo") {
1208                         print("xtype != Roo");
1209                         this.loading = false;
1210                         return;
1211                     }
1212
1213                     // get the string from the rendered tree...
1214
1215                      var str = _this.file.toSource();
1216
1217                 //    print("setting str %d\n", str.length);
1218                     buf.set_text(str, str.length);
1219                     var lm = GtkSource.LanguageManager.get_default();
1220
1221                     //?? is javascript going to work as js?
1222
1223                     ((GtkSource.Buffer)(buf)) .set_language(lm.get_language(_this.file.language));
1224
1225
1226                     _this.main_window.windowstate.updateErrorMarksAll();
1227
1228                     //  restore the cursor position?
1229                     // after reloading the contents.
1230                      GLib.Timeout.add(500, () => {
1231                                 _this.buffer.in_cursor_change = true;
1232                         print("RESORTING cursor to = %d\n", cpos);
1233                                 Gtk.TextIter cpos_iter;
1234                                 buf.get_iter_at_offset(out cpos_iter, cpos);
1235                                 buf.place_cursor(cpos_iter);
1236
1237                                 this.el.get_vadjustment().set_value(vadj_pos);;
1238                                 _this.buffer.in_cursor_change = false;
1239
1240
1241
1242                                 //_this.buffer.checkSyntax();
1243                                 return false;
1244                         });
1245
1246                     this.loading = false;
1247                     _this.buffer.dirty = false;
1248                 }
1249                 public void nodeSelected (JsRender.Node? sel, bool scroll) {
1250
1251
1252                     if (this.loading) {
1253                         return;
1254                         }
1255                     // this is connected in widnowstate
1256                     print("Roo-view - node selected\n");
1257                     var buf = this.el.get_buffer();
1258
1259                     var sbuf = (GtkSource.Buffer) buf;
1260
1261
1262
1263
1264                     // clear all the marks..
1265                      Gtk.TextIter start;
1266                     Gtk.TextIter end;
1267
1268                     sbuf.get_bounds (out start, out end);
1269                     sbuf.remove_source_marks (start, end, "grey");
1270
1271                         this.node_selected = sel;
1272                      if (sel == null) {
1273                         // no highlighting..
1274                         return;
1275                     }
1276                     Gtk.TextIter iter;
1277                     sbuf.get_iter_at_line(out iter,  sel.line_start);
1278
1279
1280                     Gtk.TextIter cur_iter;
1281                     sbuf.get_iter_at_offset(out cur_iter, sbuf.cursor_position);
1282
1283                     //var cur_line = cur_iter.get_line();
1284                     //if (cur_line > sel.line_start && cur_line < sel.line_end) {
1285
1286                     //} else {
1287                     if (! _this.buffer.in_cursor_change) {
1288                         this.el.scroll_to_iter(iter,  0.1f, true, 0.0f, 0.5f);
1289                         }
1290
1291
1292
1293                     for (var i = 0; i < buf.get_line_count();i++) {
1294                         if (i < sel.line_start || i > sel.line_end) {
1295
1296                             sbuf.get_iter_at_line(out iter, i);
1297                             sbuf.create_source_mark(null, "grey", iter);
1298
1299                         }
1300
1301                     }
1302
1303
1304                 }
1305                 public void updateGreySelection (bool scroll) {
1306                         var sel = this.node_selected;
1307                         print("node selected\n");
1308                     var buf = this.el.get_buffer();
1309                     var sbuf = (GtkSource.Buffer) buf;
1310
1311
1312                    this.clearGreySelection();
1313
1314
1315
1316                      if (sel == null) {
1317                              print("no selected node\n");
1318                         // no highlighting..
1319                         return;
1320                     }
1321
1322                     print("highlight region %d to %d\n", sel.line_start,sel.line_end);
1323                     Gtk.TextIter iter;
1324                     sbuf.get_iter_at_line(out iter,  sel.line_start);
1325
1326
1327                     Gtk.TextIter cur_iter;
1328                     sbuf.get_iter_at_offset(out cur_iter, sbuf.cursor_position);
1329
1330                     var cursor_at_line = cur_iter.get_line();
1331
1332
1333                     //var cur_line = cur_iter.get_line();
1334                     //if (cur_line > sel.line_start && cur_line < sel.line_end) {
1335
1336                     //} else {
1337                     if (scroll) {
1338                                 print("scrolling to node -- should occur on node picking.\n");
1339                         this.el.scroll_to_iter(iter,  0.1f, true, 0.0f, 0.5f);
1340                         }
1341
1342                     var start_line = sel.line_start;
1343                     var end_line = sel.line_end;
1344
1345
1346                     this.el.editable = false;
1347
1348                     //var colon_pos = 0;
1349
1350                     this.editable_start_pos = -1;
1351
1352                     // now if we have selected a property...
1353                     if (this.prop_selected.length> 0 ) {
1354
1355                                 int nstart, nend;
1356                                 if (sel.getPropertyRange(this.prop_selected, out nstart, out nend) && nend > nstart) {
1357                                         start_line = nstart;
1358                                         end_line = nend;
1359                                         // this.el.editable = true; << cant do this!!?
1360                                         print("start line = %d, end line = %d\n", start_line, end_line);
1361
1362                                                 // see if we are 'right of ':'
1363                                                 // get an iter for the start of the line.
1364                                         Gtk.TextIter start_first_line_iter,end_first_line_iter;
1365                                         this.el.buffer.get_iter_at_line(out start_first_line_iter, start_line -1);
1366                                         this.el.buffer.get_iter_at_line(out end_first_line_iter, start_line -1);
1367
1368
1369
1370
1371                                         if (end_first_line_iter.forward_to_line_end()) {
1372                                                 var first_line  = this.el.buffer.get_text(start_first_line_iter, end_first_line_iter, false);
1373
1374                                                 print("first line = %s\n", first_line);
1375                                                 if (first_line.contains(":")) {
1376                                                         this.editable_start_pos = start_first_line_iter.get_offset() + first_line.index_of(":") + 1;
1377                                                         print("colon_pos  = %d\n", this.editable_start_pos);
1378                                                 }
1379
1380
1381                                                 //Gtk.TextIter colon_iter;
1382                                                 //sbuf.get_iter_at_offset (out colon_iter, colon_pos);
1383                                                 //sbuf.create_source_mark(null, "active_text", colon_iter);
1384                                         }
1385
1386
1387
1388                                         //print("is cursor at line? %d ?= %d\n", start_line -1 , cursor_at_line);
1389                                         //if (start_line - 1 == cursor_at_line) {
1390                                         // should be ok - current_posssion can not be less than '-1'...
1391                                         if (sbuf.cursor_position < this.editable_start_pos) {
1392
1393                                                 print("cursor is before start pos.. - turn off editable...\n");
1394                                                 //var before_cursor_string = this.el.buffer.get_text(start_line_iter, cur_iter, false);
1395                                                 //print("before cursor string =  %s\n", before_cursor_string);
1396                                                 //if (!before_cursor_string.contains(":")) {
1397                                                         this.el.editable = false;
1398                                                 //}
1399
1400                                         }
1401
1402
1403
1404
1405                                 }
1406                                 print("propSelected = %s range  %d -> %d\n", this.prop_selected, start_line, end_line);
1407
1408
1409                     }
1410
1411                         print("checking selection\n");
1412
1413
1414                     // check selection - if it's out of 'bounds'
1415                     if (this.el.editable && sbuf.get_has_selection()) {
1416                                 Gtk.TextIter sel_start_iter, sel_end_iter;
1417                                 sbuf.get_selection_bounds(out sel_start_iter, out sel_end_iter);
1418
1419                                 if (sel_start_iter.get_line() < start_line || sel_end_iter.get_line() > end_line ||
1420                                         sel_start_iter.get_line() > end_line   || sel_end_iter.get_line() < start_line                  ) {
1421                                         // save?
1422                                         this.el.editable = false;
1423                                 }
1424                                 if (this.editable_start_pos > 0 &&
1425                                         (sel_start_iter.get_offset() < this.editable_start_pos || sel_end_iter.get_offset() < this.editable_start_pos)
1426
1427                                 ) {
1428                                         this.el.editable = false;
1429                                 }
1430
1431
1432
1433                     }
1434
1435
1436
1437
1438                     for (var i = 0; i < buf.get_line_count();i++) {
1439                         if (i < (start_line -1) || i > (end_line -1)) {
1440
1441                             sbuf.get_iter_at_line(out iter, i);
1442                             sbuf.create_source_mark(null, "grey", iter);
1443
1444                         }
1445
1446                     }
1447                     if (scroll && (cursor_at_line > end_line || cursor_at_line < start_line)) {
1448                             Gtk.TextIter cpos_iter;
1449                                 buf.get_iter_at_line(out cpos_iter, start_line);
1450
1451                                 buf.place_cursor(cpos_iter);
1452                         }
1453
1454
1455                 }
1456                 public void clearGreySelection () {
1457                  // clear all the marks..
1458                     var sbuf = (GtkSource.Buffer)this.el.buffer;
1459
1460                     Gtk.TextIter start;
1461                     Gtk.TextIter end;
1462
1463                     sbuf.get_bounds (out start, out end);
1464                     sbuf.remove_source_marks (start, end, "grey");
1465
1466
1467                 }
1468                 public string toString () {
1469                    Gtk.TextIter s;
1470                     Gtk.TextIter e;
1471                     this.el.get_buffer().get_start_iter(out s);
1472                     this.el.get_buffer().get_end_iter(out e);
1473                     var ret = this.el.get_buffer().get_text(s,e,true);
1474                     //print("TO STRING? " + ret);
1475                     return ret;
1476                 }
1477         }
1478         public class Xcls_buffer : Object
1479         {
1480                 public GtkSource.Buffer el;
1481                 private Xcls_WindowRooView  _this;
1482
1483
1484                         // my vars (def)
1485                 public int error_line;
1486                 public bool in_cursor_change;
1487                 public bool dirty;
1488                 public int last_line;
1489
1490                 // ctor
1491                 public Xcls_buffer(Xcls_WindowRooView _owner )
1492                 {
1493                         _this = _owner;
1494                         _this.buffer = this;
1495                         this.el = new GtkSource.Buffer( null );
1496
1497                         // my vars (dec)
1498                         this.error_line = -1;
1499                         this.in_cursor_change = false;
1500                         this.dirty = false;
1501                         this.last_line = -1;
1502
1503                         // set gobject values
1504
1505                         // init method
1506
1507                         {
1508                                 var buf = this.el;
1509                                 buf.create_tag ("bold", "weight", Pango.Weight.BOLD);
1510                                 buf.create_tag ("type", "weight", Pango.Weight.BOLD, "foreground", "#204a87");
1511                                 buf.create_tag ("keyword", "weight", Pango.Weight.BOLD, "foreground", "#a40000");
1512                                 buf.create_tag ("text", "weight", Pango.Weight.NORMAL, "foreground", "#729fcf");
1513                                 buf.create_tag ("number", "weight", Pango.Weight.BOLD, "foreground", "#ad7fa8");
1514                                 buf.create_tag ("method", "weight", Pango.Weight.BOLD, "foreground", "#729fcf");
1515                                 buf.create_tag ("property", "weight", Pango.Weight.BOLD, "foreground", "#BC1F51");
1516                                 buf.create_tag ("variable", "weight", Pango.Weight.BOLD, "foreground", "#A518B5");
1517
1518
1519                                 buf.create_tag ("ERR", "weight", Pango.Weight.BOLD, "background", "pink");
1520                                 buf.create_tag ("WARN", "weight", Pango.Weight.BOLD, "background", "#ABF4EB");
1521                                 buf.create_tag ("DEPR", "weight", Pango.Weight.BOLD, "background", "#EEA9FF");
1522                         }
1523
1524                         //listeners
1525                         this.el.cursor_moved.connect( ( ) => {
1526                         GLib.debug("cursor moved called");
1527
1528
1529                                 if (this.in_cursor_change ) {
1530                                 GLib.debug("cursor changed : %d [ignoring nested call)", this.el.cursor_position);
1531                                 return;
1532                             }
1533
1534                             GLib.debug("cursor changed : %d", this.el.cursor_position);
1535                             Gtk.TextIter cpos;
1536                             this.el.get_iter_at_offset(out cpos, this.el.cursor_position);
1537
1538                             var ln = cpos.get_line();
1539                             if (this.last_line == ln ){
1540                                 return;
1541                                 }
1542                                 this.last_line = ln;
1543                             var node = _this.file.lineToNode(ln);
1544
1545                             if (node == null) {
1546                                 print("can not find node\n");
1547                                 return;
1548                             }
1549                             this.in_cursor_change  = true;
1550                             var ltree = _this.main_window.windowstate.left_tree;
1551                             ltree.model.selectNode(node);
1552                             this.in_cursor_change  = false;
1553                         });
1554                         this.el.changed.connect( () => {
1555
1556                             // check syntax??
1557                             // ??needed..??
1558                            // _this.save_button.el.sensitive = true;
1559                             ///?? has changed occured during loading?
1560
1561                             // only trigger this if
1562
1563
1564
1565
1566                             if (_this.sourceview.loading) {
1567                                         return;
1568                                 }
1569
1570
1571
1572                             print("- PREVIEW EDITOR CHANGED--");
1573
1574                             this.dirty = true;
1575                            // this.checkSyntax(); // this calls backs and highlights errors.. in theory...
1576
1577
1578
1579                                 if (!_this.sourceview.button_is_pressed && !_this.sourceview.key_is_pressed) {
1580                                         print("button or key not pressed to generate change?!\n");
1581                                         return;
1582                                 }
1583
1584
1585                                 // what are we editing??
1586                                 if (null == _this.sourceview.node_selected || _this.sourceview.prop_selected.length  < 1) {
1587                                         return;
1588                                 }
1589
1590                                 // find the colon on the first line...
1591
1592                                 if (_this.sourceview.editable_start_pos > -1) {
1593
1594                                         var buf = (GtkSource.Buffer)_this.sourceview.el.get_buffer();
1595
1596                                 //print("cursor changed : %d\n", buf.cursor_position);
1597                                 Gtk.TextIter spos,epos;
1598                                 buf.get_iter_at_offset(out spos, _this.sourceview.editable_start_pos);
1599                                 buf.get_iter_at_offset(out epos, _this.sourceview.editable_start_pos); // initialize epos..
1600
1601                                 var gotit= false;
1602                                 var line = spos.get_line();
1603                                 var endline = buf.get_line_count();
1604                                 while (line < endline) {
1605                                         line++;
1606                                         buf.get_iter_at_line(out epos, line);
1607                                         if (buf.get_source_marks_at_line(line, "grey").length() > 0) {
1608                                                 buf.get_iter_at_line(out epos, line);
1609                                                 gotit=true;
1610                                                 break;
1611                                         }
1612                                         }
1613
1614                                         if (gotit) {
1615                                                 print("End Offset = %d/%d\n", epos.get_line(), epos.get_offset());
1616                                                 // get the pos...
1617                                                 // in theory the last char will be '}' or '},' .. or ','
1618                                                 // we should chop the ',' of the end...
1619                                                 var str = buf.get_text(spos, epos, false);
1620                                                 print("got string\n%s\n", str);
1621
1622                                         }
1623                                 }
1624                             return ;
1625                         });
1626                 }
1627
1628                 // user defined functions
1629                 public string toString () {
1630
1631                     Gtk.TextIter s;
1632                     Gtk.TextIter e;
1633                     this.el.get_start_iter(out s);
1634                     this.el.get_end_iter(out e);
1635                     var ret = this.el.get_text(s,e,true);
1636                     //print("TO STRING? " + ret);
1637                     return ret;
1638                 }
1639         }
1640
1641         public class Xcls_EventControllerKey16 : Object
1642         {
1643                 public Gtk.EventControllerKey el;
1644                 private Xcls_WindowRooView  _this;
1645
1646
1647                         // my vars (def)
1648
1649                 // ctor
1650                 public Xcls_EventControllerKey16(Xcls_WindowRooView _owner )
1651                 {
1652                         _this = _owner;
1653                         this.el = new Gtk.EventControllerKey();
1654
1655                         // my vars (dec)
1656
1657                         // set gobject values
1658
1659                         //listeners
1660                         this.el.key_pressed.connect( (keyval, keycode, state) => {
1661
1662
1663
1664                                 if (keyval == Gdk.Key.g && (state & Gdk.ModifierType.CONTROL_MASK ) > 0 ) {
1665                                     GLib.debug("SAVE: ctrl-g  pressed");
1666                                         _this.forwardSearch(true);
1667                                     return false;
1668                                 }
1669                                 if (keyval == Gdk.Key.f && (state & Gdk.ModifierType.CONTROL_MASK ) > 0 ) {
1670                                     GLib.debug("SAVE: ctrl-f  pressed");
1671                                         _this.search_entry.el.grab_focus();
1672                                     return false ;
1673                                 }
1674
1675                                 //this.button_is_pressed = true;
1676                                 //return false;
1677                            // print(event.key.keyval)
1678
1679                             return false;
1680
1681
1682                         });
1683                 }
1684
1685                 // user defined functions
1686         }
1687
1688
1689
1690         public class Xcls_Box17 : Object
1691         {
1692                 public Gtk.Box el;
1693                 private Xcls_WindowRooView  _this;
1694
1695
1696                         // my vars (def)
1697
1698                 // ctor
1699                 public Xcls_Box17(Xcls_WindowRooView _owner )
1700                 {
1701                         _this = _owner;
1702                         this.el = new Gtk.Box( Gtk.Orientation.HORIZONTAL, 0 );
1703
1704                         // my vars (dec)
1705
1706                         // set gobject values
1707                         this.el.homogeneous = false;
1708                         this.el.vexpand = false;
1709                         new Xcls_search_entry( _this );
1710                         this.el.append( _this.search_entry.el );
1711                         new Xcls_search_results( _this );
1712                         this.el.append( _this.search_results.el );
1713                         new Xcls_nextBtn( _this );
1714                         this.el.append( _this.nextBtn.el );
1715                         new Xcls_backBtn( _this );
1716                         this.el.append( _this.backBtn.el );
1717                         var child_5 = new Xcls_MenuButton23( _this );
1718                         child_5.ref();
1719                         this.el.append( child_5.el );
1720                 }
1721
1722                 // user defined functions
1723         }
1724         public class Xcls_search_entry : Object
1725         {
1726                 public Gtk.SearchEntry el;
1727                 private Xcls_WindowRooView  _this;
1728
1729
1730                         // my vars (def)
1731
1732                 // ctor
1733                 public Xcls_search_entry(Xcls_WindowRooView _owner )
1734                 {
1735                         _this = _owner;
1736                         _this.search_entry = this;
1737                         this.el = new Gtk.SearchEntry();
1738
1739                         // my vars (dec)
1740
1741                         // set gobject values
1742                         this.el.name = "roo-search-entry";
1743                         this.el.hexpand = true;
1744                         this.el.placeholder_text = "Press enter to search";
1745                         var child_1 = new Xcls_EventControllerKey19( _this );
1746                         child_1.ref();
1747                         this.el.add_controller(  child_1.el );
1748
1749                         //listeners
1750                         this.el.search_changed.connect( ( ) => {
1751
1752                         _this.search(_this.search_entry.el.text);
1753                                  _this.search_results.updateResults();
1754
1755                                 GLib.Timeout.add_seconds(1,() => {
1756                                          _this.search_results.updateResults();
1757                                          return false;
1758                                  });
1759                         });
1760                 }
1761
1762                 // user defined functions
1763                 public void forwardSearch (bool change_focus) {
1764
1765
1766                         _this.forwardSearch(change_focus);
1767
1768                 /*
1769
1770                         switch(_this.windowstate.state) {
1771                                 case WindowState.State.CODEONLY:
1772                                 //case WindowState.State.CODE:
1773                                         // search the code being edited..
1774                                         _this.windowstate.code_editor_tab.forwardSearch(change_focus);
1775
1776                                         break;
1777                                 case WindowState.State.PREVIEW:
1778                                         if (_this.windowstate.file.xtype == "Gtk") {
1779                                                 _this.windowstate.window_gladeview.forwardSearch(change_focus);
1780                                         } else {
1781                                                  _this.windowstate.window_rooview.forwardSearch(change_focus);
1782                                         }
1783
1784                                         break;
1785                         }
1786                         */
1787
1788                 }
1789         }
1790         public class Xcls_EventControllerKey19 : Object
1791         {
1792                 public Gtk.EventControllerKey el;
1793                 private Xcls_WindowRooView  _this;
1794
1795
1796                         // my vars (def)
1797
1798                 // ctor
1799                 public Xcls_EventControllerKey19(Xcls_WindowRooView _owner )
1800                 {
1801                         _this = _owner;
1802                         this.el = new Gtk.EventControllerKey();
1803
1804                         // my vars (dec)
1805
1806                         // set gobject values
1807
1808                         //listeners
1809                         this.el.key_pressed.connect( (keyval, keycode, state) => {
1810
1811                                 if (keyval == Gdk.Key.g && (state & Gdk.ModifierType.CONTROL_MASK ) > 0 ) {
1812                                     GLib.debug("SAVE: ctrl-g  pressed");
1813                                         _this.forwardSearch(true);
1814                                     return true;
1815                                 }
1816
1817
1818                                 if (keyval == Gdk.Key.Return) {
1819                                         _this.forwardSearch(true);
1820
1821
1822                                     return true;
1823
1824                                 }
1825                            // print(event.key.keyval)
1826
1827                             return false;
1828                         });
1829                 }
1830
1831                 // user defined functions
1832         }
1833
1834
1835         public class Xcls_search_results : Object
1836         {
1837                 public Gtk.Label el;
1838                 private Xcls_WindowRooView  _this;
1839
1840
1841                         // my vars (def)
1842
1843                 // ctor
1844                 public Xcls_search_results(Xcls_WindowRooView _owner )
1845                 {
1846                         _this = _owner;
1847                         _this.search_results = this;
1848                         this.el = new Gtk.Label( "No Results" );
1849
1850                         // my vars (dec)
1851
1852                         // set gobject values
1853                         this.el.margin_end = 4;
1854                         this.el.margin_start = 4;
1855                 }
1856
1857                 // user defined functions
1858                 public void updateResults () {
1859                         this.el.visible = true;
1860
1861                         var res = _this.searchcontext.get_occurrences_count();
1862                         if (res < 0) {
1863                                 _this.search_results.el.label = "??? Matches";
1864                                 return;
1865                         }
1866
1867                         _this.nextBtn.el.sensitive = false;
1868                         _this.backBtn.el.sensitive = false;
1869
1870                         if (res > 0) {
1871                                 _this.search_results.el.label = "%d Matches".printf(res);
1872                                 _this.nextBtn.el.sensitive = true;
1873                                 _this.backBtn.el.sensitive = true;
1874                                 return;
1875                         }
1876                         _this.search_results.el.label = "No Matches";
1877
1878                 }
1879         }
1880
1881         public class Xcls_nextBtn : Object
1882         {
1883                 public Gtk.Button el;
1884                 private Xcls_WindowRooView  _this;
1885
1886
1887                         // my vars (def)
1888                 public bool always_show_image;
1889
1890                 // ctor
1891                 public Xcls_nextBtn(Xcls_WindowRooView _owner )
1892                 {
1893                         _this = _owner;
1894                         _this.nextBtn = this;
1895                         this.el = new Gtk.Button();
1896
1897                         // my vars (dec)
1898                         this.always_show_image = true;
1899
1900                         // set gobject values
1901                         this.el.icon_name = "go-down";
1902                         this.el.sensitive = false;
1903
1904                         //listeners
1905                         this.el.clicked.connect( (event) => {
1906
1907                                 _this.forwardSearch(true);
1908
1909                         });
1910                 }
1911
1912                 // user defined functions
1913         }
1914
1915         public class Xcls_backBtn : Object
1916         {
1917                 public Gtk.Button el;
1918                 private Xcls_WindowRooView  _this;
1919
1920
1921                         // my vars (def)
1922                 public bool always_show_image;
1923
1924                 // ctor
1925                 public Xcls_backBtn(Xcls_WindowRooView _owner )
1926                 {
1927                         _this = _owner;
1928                         _this.backBtn = this;
1929                         this.el = new Gtk.Button();
1930
1931                         // my vars (dec)
1932                         this.always_show_image = true;
1933
1934                         // set gobject values
1935                         this.el.icon_name = "go-up";
1936                         this.el.sensitive = false;
1937
1938                         //listeners
1939                         this.el.clicked.connect( (event) => {
1940
1941                                 _this.backSearch(true);
1942
1943
1944                         });
1945                 }
1946
1947                 // user defined functions
1948         }
1949
1950         public class Xcls_MenuButton23 : Object
1951         {
1952                 public Gtk.MenuButton el;
1953                 private Xcls_WindowRooView  _this;
1954
1955
1956                         // my vars (def)
1957                 public bool always_show_image;
1958
1959                 // ctor
1960                 public Xcls_MenuButton23(Xcls_WindowRooView _owner )
1961                 {
1962                         _this = _owner;
1963                         this.el = new Gtk.MenuButton();
1964
1965                         // my vars (dec)
1966                         this.always_show_image = true;
1967
1968                         // set gobject values
1969                         this.el.icon_name = "emblem-system";
1970                         new Xcls_search_settings( _this );
1971                         this.el.popover = _this.search_settings.el;
1972                 }
1973
1974                 // user defined functions
1975         }
1976         public class Xcls_search_settings : Object
1977         {
1978                 public Gtk.Popover el;
1979                 private Xcls_WindowRooView  _this;
1980
1981
1982                         // my vars (def)
1983
1984                 // ctor
1985                 public Xcls_search_settings(Xcls_WindowRooView _owner )
1986                 {
1987                         _this = _owner;
1988                         _this.search_settings = this;
1989                         this.el = new Gtk.Popover();
1990
1991                         // my vars (dec)
1992
1993                         // set gobject values
1994                         var child_1 = new Xcls_Box25( _this );
1995                         this.el.child = child_1.el;
1996                 }
1997
1998                 // user defined functions
1999         }
2000         public class Xcls_Box25 : Object
2001         {
2002                 public Gtk.Box el;
2003                 private Xcls_WindowRooView  _this;
2004
2005
2006                         // my vars (def)
2007
2008                 // ctor
2009                 public Xcls_Box25(Xcls_WindowRooView _owner )
2010                 {
2011                         _this = _owner;
2012                         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
2013
2014                         // my vars (dec)
2015
2016                         // set gobject values
2017                         new Xcls_case_sensitive( _this );
2018                         this.el.append( _this.case_sensitive.el );
2019                         new Xcls_regex( _this );
2020                         this.el.append( _this.regex.el );
2021                         new Xcls_multiline( _this );
2022                         this.el.append( _this.multiline.el );
2023                 }
2024
2025                 // user defined functions
2026         }
2027         public class Xcls_case_sensitive : Object
2028         {
2029                 public Gtk.CheckButton el;
2030                 private Xcls_WindowRooView  _this;
2031
2032
2033                         // my vars (def)
2034
2035                 // ctor
2036                 public Xcls_case_sensitive(Xcls_WindowRooView _owner )
2037                 {
2038                         _this = _owner;
2039                         _this.case_sensitive = this;
2040                         this.el = new Gtk.CheckButton();
2041
2042                         // my vars (dec)
2043
2044                         // set gobject values
2045                         this.el.label = "Case Sensitive";
2046
2047                         // init method
2048
2049                         {
2050                                 this.el.show();
2051                         }
2052                 }
2053
2054                 // user defined functions
2055         }
2056
2057         public class Xcls_regex : Object
2058         {
2059                 public Gtk.CheckButton el;
2060                 private Xcls_WindowRooView  _this;
2061
2062
2063                         // my vars (def)
2064
2065                 // ctor
2066                 public Xcls_regex(Xcls_WindowRooView _owner )
2067                 {
2068                         _this = _owner;
2069                         _this.regex = this;
2070                         this.el = new Gtk.CheckButton();
2071
2072                         // my vars (dec)
2073
2074                         // set gobject values
2075                         this.el.label = "Regex";
2076
2077                         // init method
2078
2079                         {
2080                                 this.el.show();
2081                         }
2082                 }
2083
2084                 // user defined functions
2085         }
2086
2087         public class Xcls_multiline : Object
2088         {
2089                 public Gtk.CheckButton el;
2090                 private Xcls_WindowRooView  _this;
2091
2092
2093                         // my vars (def)
2094
2095                 // ctor
2096                 public Xcls_multiline(Xcls_WindowRooView _owner )
2097                 {
2098                         _this = _owner;
2099                         _this.multiline = this;
2100                         this.el = new Gtk.CheckButton();
2101
2102                         // my vars (dec)
2103
2104                         // set gobject values
2105                         this.el.label = "Multi-line (add \\n)";
2106
2107                         // init method
2108
2109                         {
2110                                 this.el.show();
2111                         }
2112                 }
2113
2114                 // user defined functions
2115         }
2116
2117
2118
2119
2120
2121
2122
2123 }