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                                 if (this.el == null) {
 702                                         return true;
 703                                 }
 704
 705                                 var msg = dialog.get_message();
 706                                 if (msg.length < 4) {
 707                                         return false;
 708                                 }
 709
 710                                  //GLib.debug("script dialog got %s", msg);
 711
 712                                 if (msg.substring(0,4) != "IPC:") {
 713                                         return false;
 714                                 }
 715                                 var ar = msg.split(":", 3);
 716                                 if (ar.length < 3) {
 717                                         return false;
 718                                 }
 719
 720                                 switch(ar[1]) {
 721
 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
 728                                         default:
 729                                             return false;
 730                                 }
 731
 732                         });
 733                         this.el.ready_to_show.connect( ( ) => {
 734                           this.initInspector();
 735
 736                         });
 737                         this.el.load_changed.connect( (le) => {
 738                             if (le != WebKit.LoadEvent.FINISHED) {
 739                                 return;
 740                             }
 741                             if (this.runjs.length < 1) {
 742                                 return;
 743                             }
 744                           //  this.el.run_javascript(this.runjs, null);
 745                              FakeServerCache.remove(    this.runjs);
 746                             this.runjs = "";
 747                         });
 748                 }
 749
 750                 // user defined functions
 751                 public void initInspector () {
 752
 753
 754
 755                    // this.inspector.open_window.connect(() => {
 756                          this.inspector = this.el.get_inspector();
 757
 758                          this.inspector.open_window.connect(() => {
 759                         print("inspector attach\n");
 760                         var wv = this.inspector.get_web_view();
 761                         if (wv != null) {
 762                             print("got inspector web view\n");
 763
 764                             var cn = _this.inspectorcontainer.el.get_first_child();
 765                             if (cn != null) {
 766                                  _this.inspectorcontainer.el.remove(cn);
 767                              }
 768
 769                             _this.inspectorcontainer.el.append(wv);
 770                             wv.show();
 771                         } else {
 772                                  print("got inspector web view FAILED\n");
 773                             //this.inspector.close();
 774
 775                             //this.inspector = null;
 776
 777
 778                         }
 779                       return true;
 780
 781                    });
 782                      this.inspector.show();
 783
 784
 785
 786                 }
 787                 public void renderJS (bool force) {
 788
 789                     // this is the public redraw call..
 790                     // we refresh in a loop privately..
 791                     var autodraw = _this.AutoRedraw.el.active;
 792                     if (!autodraw && !force) {
 793                         print("Skipping redraw - no force, and autodraw off");
 794                         return;
 795                     }
 796
 797                     this.refreshRequired  = true;
 798
 799                 }
 800                 public void reInit () {
 801                    print("reInit?");
 802                          // if this happens destroy the webkit..
 803                          // recreate it..
 804                      this.el.stop_loading();
 805
 806                      if (_this.viewbox.el.get_parent() == null) {
 807                         return;
 808                      }
 809
 810                          /*
 811                     _this.viewbox.el.remove(_this.viewcontainer.el);
 812                     //_this.paned.el.remove(_this.inspectorcontainer.el);
 813
 814                          // destory seems to cause problems.
 815                          //this.el.destroy();
 816                         //_this.viewcontainer.el.destroy();
 817                          //_this.inspectorcontainer.el.destroy();
 818                      var  inv =new Xcls_inspectorcontainer(_this);
 819
 820                       _this.paned.el.set_end_child(inv.el);
 821                       _this.inspectorcontainer = inv;
 822
 823                      this.el = null;
 824                      var nv =new Xcls_viewcontainer(_this);
 825                     // nv.ref();
 826                      _this.viewbox.el.append(nv.el);
 827
 828                          _this.viewcontainer = nv;
 829                      inv.el.show();
 830                      nv.el.show();
 831                          //while(Gtk.events_pending ()) Gtk.main_iteration ();
 832                          //_this.view.renderJS(true);
 833                      _this.view.refreshRequired  = true;
 834
 835                      */
 836                 }
 837                 public void runRefresh ()
 838                 {
 839                     // this is run every 2 seconds from the init..
 840
 841
 842                     if (!this.refreshRequired) {
 843                        // print("no refresh required");
 844                         return;
 845                     }
 846
 847                     if (this.lastRedraw != null) {
 848                        // do not redraw if last redraw was less that 5 seconds ago.
 849                        if ((int64)(new DateTime.now_local()).difference(this.lastRedraw) < 5000 ) {
 850                             return;
 851                         }
 852                     }
 853
 854                     if (_this.file == null) {
 855                         return;
 856                     }
 857
 858
 859                      this.refreshRequired = false;
 860                    //  print("HTML RENDERING");
 861
 862
 863                      //this.get('/BottomPane').el.show();
 864                      //this.get('/BottomPane').el.set_current_page(2);// webkit inspector
 865                     _this.file.webkit_page_id  = this.el.get_page_id();
 866
 867                     var js = _this.file.toSourcePreview();
 868
 869                     if (js.length < 1) {
 870                         print("no data");
 871                         return;
 872                     }
 873                 //    var  data = js[0];
 874                     this.redraws++;
 875
 876                     var project = (Project.Roo) _this.file.project;
 877
 878                      //print (project.fn);
 879                      // set it to non-empty.
 880
 881                 //     runhtml = runhtml.length ?  runhtml : '<script type="text/javascript"></script>';
 882
 883
 884                 //   this.runhtml  = this.runhtml || '';
 885
 886
 887                     // then we need to reload the browser using
 888                     // load_html_string..
 889
 890                     // then trigger a redraw once it's loaded..
 891                     this.pendingRedraw = true;
 892
 893                     var runhtml = "<script type=\"text/javascript\">\n" ;
 894                     uint8[] builderhtml;
 895
 896                     try {
 897                         GLib. File.new_for_uri("resource:///html/roo.builder.js").load_contents(null,  out   builderhtml, null);
 898                     } catch (Error e) {
 899                         builderhtml = {};
 900                     }
 901
 902                     runhtml += (string) builderhtml + "\n";
 903                     runhtml += "</script>\n" ;
 904
 905                     // fix to make sure they are the same..
 906                     this.runhtml = project.runhtml;
 907                     // need to modify paths
 908
 909                     uint8[] inhtml;
 910                     var base_template = project.base_template;
 911                     var f = GLib. File.new_for_uri("resource:///html/" + base_template);
 912
 913                     if (base_template.length > 0 && !f.query_exists(null)) {
 914
 915                            GLib.debug("invalid base_template name - using default:  %s", base_template);
 916                            f = GLib. File.new_for_uri("resource:///html/roo.builder.html");
 917
 918                     }
 919                     try {
 920                             f.load_contents(null,  out inhtml, null);
 921
 922
 923                     } catch (Error e) {
 924                         inhtml = {};
 925                     }
 926                     this.renderedData = js;
 927
 928
 929                     string js_src = js + "
 930                 Roo.onReady(function() {
 931                 if (" + _this.file.name +".show) {
 932                                 " + _this.file.name +".show({});
 933                                 (function() {
 934                                         Builder.saveHTML.defer(100, Builder);
 935                                 }).defer(100);
 936                 }
 937                 Roo.XComponent.build();
 938                 });\n";
 939
 940                    // print("render js: " + js);
 941                     //if (!this.ready) {
 942                   //      console.log('not loaded yet');
 943                     //}
 944                     this.lastRedraw = new DateTime.now_local();
 945
 946
 947                     //this.runjs = js_src;
 948                     var fc =    FakeServerCache.factory_with_data(js_src);
 949                     this.runjs = fc.fname;
 950                     var html  = (string) inhtml;
 951                         html = html.replace("</head>", runhtml + this.runhtml +
 952                         "<script type=\"text/javascript\" src=\"xhttp://localhost" + fc.fname + "\"></script>" +
 953                           //  "<script type=\"text/javascript\">\n" +
 954                           //  js_src + "\n" +
 955                           //  "</script>" +
 956
 957                     "</head>");
 958                     //print("LOAD HTML " + html);
 959
 960                      var rootURL = project.rootURL;
 961
 962
 963
 964                     this.el.load_html( html ,
 965                         //fixme - should be a config option!
 966                         (rootURL.length > 0 ? rootURL : "xhttp://localhost/roobuilder/")
 967                     );
 968                       this.initInspector();
 969                     // force the inspector...
 970                        //   this.initInspector();
 971
 972                         // - no need for this, the builder javascript will call it when build is complete
 973                         //GLib.Timeout.add_seconds(1, () => {
 974                         //    this.el.run_javascript("Builder.saveHTML()",null);
 975                         //    return false;
 976                         //});
 977                 //     print( "before render" +    this.lastRedraw);
 978                 //    print( "after render" +    (new Date()));
 979
 980                 }
 981         }
 982
 983
 984         public class Xcls_inspectorcontainer : Object
 985         {
 986                 public Gtk.Box el;
 987                 private Xcls_WindowRooView  _this;
 988
 989
 990                         // my vars (def)
 991
 992                 // ctor
 993                 public Xcls_inspectorcontainer(Xcls_WindowRooView _owner )
 994                 {
 995                         _this = _owner;
 996                         _this.inspectorcontainer = this;
 997                         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
 998
 999                         // my vars (dec)
1000
1001                         // set gobject values
1002                         this.el.vexpand = true;
1003                 }
1004
1005                 // user defined functions
1006         }
1007
1008
1009         public class Xcls_Box12 : Object
1010         {
1011                 public Gtk.Box el;
1012                 private Xcls_WindowRooView  _this;
1013
1014
1015                         // my vars (def)
1016
1017                 // ctor
1018                 public Xcls_Box12(Xcls_WindowRooView _owner )
1019                 {
1020                         _this = _owner;
1021                         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
1022
1023                         // my vars (dec)
1024
1025                         // set gobject values
1026                         this.el.vexpand = true;
1027                         new Xcls_sourceviewscroll( _this );
1028                         this.el.append( _this.sourceviewscroll.el );
1029                         var child_2 = new Xcls_Box17( _this );
1030                         child_2.ref();
1031                         this.el.append( child_2.el );
1032                 }
1033
1034                 // user defined functions
1035         }
1036         public class Xcls_sourceviewscroll : Object
1037         {
1038                 public Gtk.ScrolledWindow el;
1039                 private Xcls_WindowRooView  _this;
1040
1041
1042                         // my vars (def)
1043
1044                 // ctor
1045                 public Xcls_sourceviewscroll(Xcls_WindowRooView _owner )
1046                 {
1047                         _this = _owner;
1048                         _this.sourceviewscroll = this;
1049                         this.el = new Gtk.ScrolledWindow();
1050
1051                         // my vars (dec)
1052
1053                         // set gobject values
1054                         this.el.vexpand = true;
1055                         new Xcls_sourceview( _this );
1056                         this.el.set_child ( _this.sourceview.el  );
1057                 }
1058
1059                 // user defined functions
1060         }
1061         public class Xcls_sourceview : Object
1062         {
1063                 public GtkSource.View el;
1064                 private Xcls_WindowRooView  _this;
1065
1066
1067                         // my vars (def)
1068                 public int editable_start_pos;
1069                 public bool loading;
1070                 public bool button_is_pressed;
1071                 public string prop_selected;
1072                 public Gtk.CssProvider? css;
1073                 public bool key_is_pressed;
1074                 public JsRender.Node? node_selected;
1075
1076                 // ctor
1077                 public Xcls_sourceview(Xcls_WindowRooView _owner )
1078                 {
1079                         _this = _owner;
1080                         _this.sourceview = this;
1081                         this.el = new GtkSource.View();
1082
1083                         // my vars (dec)
1084                         this.editable_start_pos = -1;
1085                         this.loading = true;
1086                         this.button_is_pressed = false;
1087                         this.prop_selected = "";
1088                         this.css = null;
1089                         this.key_is_pressed = false;
1090                         this.node_selected = null;
1091
1092                         // set gobject values
1093                         this.el.name = "roo-view";
1094                         this.el.editable = false;
1095                         this.el.show_line_marks = true;
1096                         this.el.show_line_numbers = true;
1097                         this.el.css_classes = { "code-editor" };
1098                         new Xcls_buffer( _this );
1099                         this.el.set_buffer ( _this.buffer.el  );
1100                         var child_2 = new Xcls_EventControllerKey16( _this );
1101                         child_2.ref();
1102                         this.el.add_controller ( child_2.el  );
1103
1104                         // init method
1105
1106                         {
1107
1108
1109
1110                                 this.loading = true;
1111                                 //var buf = this.el.get_buffer();
1112                                 //buf.notify.connect(this.onCursorChanged);
1113
1114
1115                                 var attrs = new GtkSource.MarkAttributes();
1116                                 attrs.set_icon_name ( "process-stop");
1117                                 attrs.query_tooltip_text.connect(( mark) => {
1118                                         //print("tooltip query? %s\n", mark.name);
1119                                         return mark.name;
1120                                 });
1121
1122                                 this.el.set_mark_attributes ("ERR", attrs, 1);
1123
1124                                  var wattrs = new GtkSource.MarkAttributes();
1125                                 wattrs.set_icon_name ( "process-stop");
1126                                 wattrs.query_tooltip_text.connect(( mark) => {
1127                                         //print("tooltip query? %s\n", mark.name);
1128                                         return mark.name;
1129                                 });
1130
1131                                 this.el.set_mark_attributes ("WARN", wattrs, 1);
1132
1133
1134
1135                                  var dattrs = new GtkSource.MarkAttributes();
1136                                 dattrs.set_icon_name ( "process-stop");
1137                                 dattrs.query_tooltip_text.connect(( mark) => {
1138                                         //print("tooltip query? %s\n", mark.name);
1139                                         return mark.name;
1140                                 });
1141
1142                                 this.el.set_mark_attributes ("DEPR", dattrs, 1);
1143
1144
1145                                 var gattrs = new GtkSource.MarkAttributes();
1146                                 var  grey =   Gdk.RGBA();
1147                                 grey.parse ( "#ccc");
1148                                 gattrs.set_background ( grey);
1149
1150
1151                                 this.el.set_mark_attributes ("grey", gattrs, 1);
1152
1153
1154
1155
1156
1157                                 }
1158
1159                         //listeners
1160                         this.el.query_tooltip.connect( (x, y, keyboard_tooltip, tooltip) => {
1161
1162                                 //GLib.debug("query tooltip");
1163                                 Gtk.TextIter iter;
1164                                 int trailing;
1165
1166                                 var yoff = (int) _this.sourceviewscroll.el.vadjustment.value;
1167
1168                                 this.el.get_iter_at_position (out iter, out trailing,  x,  y + yoff);
1169
1170                                 var l = iter.get_line();
1171                                 //GLib.debug("query tooltip line %d", (int) l);
1172                                 var marks = _this.buffer.el.get_source_marks_at_line(l, null);
1173                                 //GLib.debug("query tooltip line marks %d", (int) marks.length());
1174                                 var str = "";
1175                                 marks.@foreach((m) => {
1176                                         //GLib.debug("got mark %s", m.name);
1177                                         str += (str.length > 0 ? "\n" : "") + m.name;
1178                                 });
1179                                 // true if there is a mark..
1180                                 if (str.length > 0 ) {
1181                                                 tooltip.set_text( str);
1182                                 }
1183                                 return str.length > 0 ? true : false;
1184
1185                         });
1186                 }
1187
1188                 // user defined functions
1189                 public void loadFile ( ) {
1190                     this.loading = true;
1191
1192
1193                     // get the cursor and scroll position....
1194                     var buf = this.el.get_buffer();
1195                         var cpos = buf.cursor_position;
1196
1197                    print("BEFORE LOAD cursor = %d\n", cpos);
1198
1199                     var vadj_pos = this.el.get_vadjustment().get_value();
1200
1201
1202
1203                     buf.set_text("",0);
1204
1205
1206
1207
1208                     if (_this.file == null || _this.file.xtype != "Roo") {
1209                         print("xtype != Roo");
1210                         this.loading = false;
1211                         return;
1212                     }
1213
1214                     // get the string from the rendered tree...
1215
1216                      var str = _this.file.toSource();
1217
1218                 //    print("setting str %d\n", str.length);
1219                     buf.set_text(str, str.length);
1220                     var lm = GtkSource.LanguageManager.get_default();
1221
1222                     //?? is javascript going to work as js?
1223
1224                     ((GtkSource.Buffer)(buf)) .set_language(lm.get_language(_this.file.language));
1225
1226
1227                     _this.main_window.windowstate.updateErrorMarksAll();
1228
1229                     //  restore the cursor position?
1230                     // after reloading the contents.
1231                      GLib.Timeout.add(500, () => {
1232                                 _this.buffer.in_cursor_change = true;
1233                         print("RESORTING cursor to = %d\n", cpos);
1234                                 Gtk.TextIter cpos_iter;
1235                                 buf.get_iter_at_offset(out cpos_iter, cpos);
1236                                 buf.place_cursor(cpos_iter);
1237
1238                                 this.el.get_vadjustment().set_value(vadj_pos);;
1239                                 _this.buffer.in_cursor_change = false;
1240
1241
1242
1243                                 //_this.buffer.checkSyntax();
1244                                 return false;
1245                         });
1246
1247                     this.loading = false;
1248                     _this.buffer.dirty = false;
1249                 }
1250                 public void nodeSelected (JsRender.Node? sel, bool scroll) {
1251
1252
1253                     if (this.loading) {
1254                         return;
1255                         }
1256                     // this is connected in widnowstate
1257                     print("Roo-view - node selected\n");
1258                     var buf = this.el.get_buffer();
1259
1260                     var sbuf = (GtkSource.Buffer) buf;
1261
1262
1263
1264
1265                     // clear all the marks..
1266                      Gtk.TextIter start;
1267                     Gtk.TextIter end;
1268
1269                     sbuf.get_bounds (out start, out end);
1270                     sbuf.remove_source_marks (start, end, "grey");
1271
1272                         this.node_selected = sel;
1273                      if (sel == null) {
1274                         // no highlighting..
1275                         return;
1276                     }
1277                     Gtk.TextIter iter;
1278                     sbuf.get_iter_at_line(out iter,  sel.line_start);
1279
1280
1281                     Gtk.TextIter cur_iter;
1282                     sbuf.get_iter_at_offset(out cur_iter, sbuf.cursor_position);
1283
1284                     //var cur_line = cur_iter.get_line();
1285                     //if (cur_line > sel.line_start && cur_line < sel.line_end) {
1286
1287                     //} else {
1288                     if (! _this.buffer.in_cursor_change) {
1289                         this.el.scroll_to_iter(iter,  0.1f, true, 0.0f, 0.5f);
1290                         }
1291
1292
1293
1294                     for (var i = 0; i < buf.get_line_count();i++) {
1295                         if (i < sel.line_start || i > sel.line_end) {
1296
1297                             sbuf.get_iter_at_line(out iter, i);
1298                             sbuf.create_source_mark(null, "grey", iter);
1299
1300                         }
1301
1302                     }
1303
1304
1305                 }
1306                 public void updateGreySelection (bool scroll) {
1307                         var sel = this.node_selected;
1308                         print("node selected\n");
1309                     var buf = this.el.get_buffer();
1310                     var sbuf = (GtkSource.Buffer) buf;
1311
1312
1313                    this.clearGreySelection();
1314
1315
1316
1317                      if (sel == null) {
1318                              print("no selected node\n");
1319                         // no highlighting..
1320                         return;
1321                     }
1322
1323                     print("highlight region %d to %d\n", sel.line_start,sel.line_end);
1324                     Gtk.TextIter iter;
1325                     sbuf.get_iter_at_line(out iter,  sel.line_start);
1326
1327
1328                     Gtk.TextIter cur_iter;
1329                     sbuf.get_iter_at_offset(out cur_iter, sbuf.cursor_position);
1330
1331                     var cursor_at_line = cur_iter.get_line();
1332
1333
1334                     //var cur_line = cur_iter.get_line();
1335                     //if (cur_line > sel.line_start && cur_line < sel.line_end) {
1336
1337                     //} else {
1338                     if (scroll) {
1339                                 print("scrolling to node -- should occur on node picking.\n");
1340                         this.el.scroll_to_iter(iter,  0.1f, true, 0.0f, 0.5f);
1341                         }
1342
1343                     var start_line = sel.line_start;
1344                     var end_line = sel.line_end;
1345
1346
1347                     this.el.editable = false;
1348
1349                     //var colon_pos = 0;
1350
1351                     this.editable_start_pos = -1;
1352
1353                     // now if we have selected a property...
1354                     if (this.prop_selected.length> 0 ) {
1355
1356                                 int nstart, nend;
1357                                 if (sel.getPropertyRange(this.prop_selected, out nstart, out nend) && nend > nstart) {
1358                                         start_line = nstart;
1359                                         end_line = nend;
1360                                         // this.el.editable = true; << cant do this!!?
1361                                         print("start line = %d, end line = %d\n", start_line, end_line);
1362
1363                                                 // see if we are 'right of ':'
1364                                                 // get an iter for the start of the line.
1365                                         Gtk.TextIter start_first_line_iter,end_first_line_iter;
1366                                         this.el.buffer.get_iter_at_line(out start_first_line_iter, start_line -1);
1367                                         this.el.buffer.get_iter_at_line(out end_first_line_iter, start_line -1);
1368
1369
1370
1371
1372                                         if (end_first_line_iter.forward_to_line_end()) {
1373                                                 var first_line  = this.el.buffer.get_text(start_first_line_iter, end_first_line_iter, false);
1374
1375                                                 print("first line = %s\n", first_line);
1376                                                 if (first_line.contains(":")) {
1377                                                         this.editable_start_pos = start_first_line_iter.get_offset() + first_line.index_of(":") + 1;
1378                                                         print("colon_pos  = %d\n", this.editable_start_pos);
1379                                                 }
1380
1381
1382                                                 //Gtk.TextIter colon_iter;
1383                                                 //sbuf.get_iter_at_offset (out colon_iter, colon_pos);
1384                                                 //sbuf.create_source_mark(null, "active_text", colon_iter);
1385                                         }
1386
1387
1388
1389                                         //print("is cursor at line? %d ?= %d\n", start_line -1 , cursor_at_line);
1390                                         //if (start_line - 1 == cursor_at_line) {
1391                                         // should be ok - current_posssion can not be less than '-1'...
1392                                         if (sbuf.cursor_position < this.editable_start_pos) {
1393
1394                                                 print("cursor is before start pos.. - turn off editable...\n");
1395                                                 //var before_cursor_string = this.el.buffer.get_text(start_line_iter, cur_iter, false);
1396                                                 //print("before cursor string =  %s\n", before_cursor_string);
1397                                                 //if (!before_cursor_string.contains(":")) {
1398                                                         this.el.editable = false;
1399                                                 //}
1400
1401                                         }
1402
1403
1404
1405
1406                                 }
1407                                 print("propSelected = %s range  %d -> %d\n", this.prop_selected, start_line, end_line);
1408
1409
1410                     }
1411
1412                         print("checking selection\n");
1413
1414
1415                     // check selection - if it's out of 'bounds'
1416                     if (this.el.editable && sbuf.get_has_selection()) {
1417                                 Gtk.TextIter sel_start_iter, sel_end_iter;
1418                                 sbuf.get_selection_bounds(out sel_start_iter, out sel_end_iter);
1419
1420                                 if (sel_start_iter.get_line() < start_line || sel_end_iter.get_line() > end_line ||
1421                                         sel_start_iter.get_line() > end_line   || sel_end_iter.get_line() < start_line                  ) {
1422                                         // save?
1423                                         this.el.editable = false;
1424                                 }
1425                                 if (this.editable_start_pos > 0 &&
1426                                         (sel_start_iter.get_offset() < this.editable_start_pos || sel_end_iter.get_offset() < this.editable_start_pos)
1427
1428                                 ) {
1429                                         this.el.editable = false;
1430                                 }
1431
1432
1433
1434                     }
1435
1436
1437
1438
1439                     for (var i = 0; i < buf.get_line_count();i++) {
1440                         if (i < (start_line -1) || i > (end_line -1)) {
1441
1442                             sbuf.get_iter_at_line(out iter, i);
1443                             sbuf.create_source_mark(null, "grey", iter);
1444
1445                         }
1446
1447                     }
1448                     if (scroll && (cursor_at_line > end_line || cursor_at_line < start_line)) {
1449                             Gtk.TextIter cpos_iter;
1450                                 buf.get_iter_at_line(out cpos_iter, start_line);
1451
1452                                 buf.place_cursor(cpos_iter);
1453                         }
1454
1455
1456                 }
1457                 public void clearGreySelection () {
1458                  // clear all the marks..
1459                     var sbuf = (GtkSource.Buffer)this.el.buffer;
1460
1461                     Gtk.TextIter start;
1462                     Gtk.TextIter end;
1463
1464                     sbuf.get_bounds (out start, out end);
1465                     sbuf.remove_source_marks (start, end, "grey");
1466
1467
1468                 }
1469                 public string toString () {
1470                    Gtk.TextIter s;
1471                     Gtk.TextIter e;
1472                     this.el.get_buffer().get_start_iter(out s);
1473                     this.el.get_buffer().get_end_iter(out e);
1474                     var ret = this.el.get_buffer().get_text(s,e,true);
1475                     //print("TO STRING? " + ret);
1476                     return ret;
1477                 }
1478         }
1479         public class Xcls_buffer : Object
1480         {
1481                 public GtkSource.Buffer el;
1482                 private Xcls_WindowRooView  _this;
1483
1484
1485                         // my vars (def)
1486                 public int error_line;
1487                 public bool in_cursor_change;
1488                 public bool dirty;
1489                 public int last_line;
1490
1491                 // ctor
1492                 public Xcls_buffer(Xcls_WindowRooView _owner )
1493                 {
1494                         _this = _owner;
1495                         _this.buffer = this;
1496                         this.el = new GtkSource.Buffer( null );
1497
1498                         // my vars (dec)
1499                         this.error_line = -1;
1500                         this.in_cursor_change = false;
1501                         this.dirty = false;
1502                         this.last_line = -1;
1503
1504                         // set gobject values
1505
1506                         // init method
1507
1508                         {
1509                                 var buf = this.el;
1510                                 buf.create_tag ("bold", "weight", Pango.Weight.BOLD);
1511                                 buf.create_tag ("type", "weight", Pango.Weight.BOLD, "foreground", "#204a87");
1512                                 buf.create_tag ("keyword", "weight", Pango.Weight.BOLD, "foreground", "#a40000");
1513                                 buf.create_tag ("text", "weight", Pango.Weight.NORMAL, "foreground", "#729fcf");
1514                                 buf.create_tag ("number", "weight", Pango.Weight.BOLD, "foreground", "#ad7fa8");
1515                                 buf.create_tag ("method", "weight", Pango.Weight.BOLD, "foreground", "#729fcf");
1516                                 buf.create_tag ("property", "weight", Pango.Weight.BOLD, "foreground", "#BC1F51");
1517                                 buf.create_tag ("variable", "weight", Pango.Weight.BOLD, "foreground", "#A518B5");
1518
1519
1520                                 buf.create_tag ("ERR", "weight", Pango.Weight.BOLD, "background", "pink");
1521                                 buf.create_tag ("WARN", "weight", Pango.Weight.BOLD, "background", "#ABF4EB");
1522                                 buf.create_tag ("DEPR", "weight", Pango.Weight.BOLD, "background", "#EEA9FF");
1523                         }
1524
1525                         //listeners
1526                         this.el.cursor_moved.connect( ( ) => {
1527                         GLib.debug("cursor moved called");
1528
1529
1530                                 if (this.in_cursor_change ) {
1531                                 GLib.debug("cursor changed : %d [ignoring nested call)", this.el.cursor_position);
1532                                 return;
1533                             }
1534
1535                             GLib.debug("cursor changed : %d", this.el.cursor_position);
1536                             Gtk.TextIter cpos;
1537                             this.el.get_iter_at_offset(out cpos, this.el.cursor_position);
1538
1539                             var ln = cpos.get_line();
1540                             if (this.last_line == ln ){
1541                                 return;
1542                                 }
1543                                 this.last_line = ln;
1544                             var node = _this.file.lineToNode(ln);
1545
1546                             if (node == null) {
1547                                 print("can not find node\n");
1548                                 return;
1549                             }
1550                             this.in_cursor_change  = true;
1551                             var ltree = _this.main_window.windowstate.left_tree;
1552                             ltree.model.selectNode(node);
1553                             this.in_cursor_change  = false;
1554                         });
1555                         this.el.changed.connect( () => {
1556
1557                             // check syntax??
1558                             // ??needed..??
1559                            // _this.save_button.el.sensitive = true;
1560                             ///?? has changed occured during loading?
1561
1562                             // only trigger this if
1563
1564
1565
1566
1567                             if (_this.sourceview.loading) {
1568                                         return;
1569                                 }
1570
1571
1572
1573                             print("- PREVIEW EDITOR CHANGED--");
1574
1575                             this.dirty = true;
1576                            // this.checkSyntax(); // this calls backs and highlights errors.. in theory...
1577
1578
1579
1580                                 if (!_this.sourceview.button_is_pressed && !_this.sourceview.key_is_pressed) {
1581                                         print("button or key not pressed to generate change?!\n");
1582                                         return;
1583                                 }
1584
1585
1586                                 // what are we editing??
1587                                 if (null == _this.sourceview.node_selected || _this.sourceview.prop_selected.length  < 1) {
1588                                         return;
1589                                 }
1590
1591                                 // find the colon on the first line...
1592
1593                                 if (_this.sourceview.editable_start_pos > -1) {
1594
1595                                         var buf = (GtkSource.Buffer)_this.sourceview.el.get_buffer();
1596
1597                                 //print("cursor changed : %d\n", buf.cursor_position);
1598                                 Gtk.TextIter spos,epos;
1599                                 buf.get_iter_at_offset(out spos, _this.sourceview.editable_start_pos);
1600                                 buf.get_iter_at_offset(out epos, _this.sourceview.editable_start_pos); // initialize epos..
1601
1602                                 var gotit= false;
1603                                 var line = spos.get_line();
1604                                 var endline = buf.get_line_count();
1605                                 while (line < endline) {
1606                                         line++;
1607                                         buf.get_iter_at_line(out epos, line);
1608                                         if (buf.get_source_marks_at_line(line, "grey").length() > 0) {
1609                                                 buf.get_iter_at_line(out epos, line);
1610                                                 gotit=true;
1611                                                 break;
1612                                         }
1613                                         }
1614
1615                                         if (gotit) {
1616                                                 print("End Offset = %d/%d\n", epos.get_line(), epos.get_offset());
1617                                                 // get the pos...
1618                                                 // in theory the last char will be '}' or '},' .. or ','
1619                                                 // we should chop the ',' of the end...
1620                                                 var str = buf.get_text(spos, epos, false);
1621                                                 print("got string\n%s\n", str);
1622
1623                                         }
1624                                 }
1625                             return ;
1626                         });
1627                 }
1628
1629                 // user defined functions
1630                 public string toString () {
1631
1632                     Gtk.TextIter s;
1633                     Gtk.TextIter e;
1634                     this.el.get_start_iter(out s);
1635                     this.el.get_end_iter(out e);
1636                     var ret = this.el.get_text(s,e,true);
1637                     //print("TO STRING? " + ret);
1638                     return ret;
1639                 }
1640         }
1641
1642         public class Xcls_EventControllerKey16 : Object
1643         {
1644                 public Gtk.EventControllerKey el;
1645                 private Xcls_WindowRooView  _this;
1646
1647
1648                         // my vars (def)
1649
1650                 // ctor
1651                 public Xcls_EventControllerKey16(Xcls_WindowRooView _owner )
1652                 {
1653                         _this = _owner;
1654                         this.el = new Gtk.EventControllerKey();
1655
1656                         // my vars (dec)
1657
1658                         // set gobject values
1659
1660                         //listeners
1661                         this.el.key_pressed.connect( (keyval, keycode, state) => {
1662
1663
1664
1665                                 if (keyval == Gdk.Key.g && (state & Gdk.ModifierType.CONTROL_MASK ) > 0 ) {
1666                                     GLib.debug("SAVE: ctrl-g  pressed");
1667                                         _this.forwardSearch(true);
1668                                     return false;
1669                                 }
1670                                 if (keyval == Gdk.Key.f && (state & Gdk.ModifierType.CONTROL_MASK ) > 0 ) {
1671                                     GLib.debug("SAVE: ctrl-f  pressed");
1672                                         _this.search_entry.el.grab_focus();
1673                                     return false ;
1674                                 }
1675
1676                                 //this.button_is_pressed = true;
1677                                 //return false;
1678                            // print(event.key.keyval)
1679
1680                             return false;
1681
1682
1683                         });
1684                 }
1685
1686                 // user defined functions
1687         }
1688
1689
1690
1691         public class Xcls_Box17 : Object
1692         {
1693                 public Gtk.Box el;
1694                 private Xcls_WindowRooView  _this;
1695
1696
1697                         // my vars (def)
1698
1699                 // ctor
1700                 public Xcls_Box17(Xcls_WindowRooView _owner )
1701                 {
1702                         _this = _owner;
1703                         this.el = new Gtk.Box( Gtk.Orientation.HORIZONTAL, 0 );
1704
1705                         // my vars (dec)
1706
1707                         // set gobject values
1708                         this.el.homogeneous = false;
1709                         this.el.vexpand = false;
1710                         new Xcls_search_entry( _this );
1711                         this.el.append( _this.search_entry.el );
1712                         new Xcls_search_results( _this );
1713                         this.el.append( _this.search_results.el );
1714                         new Xcls_nextBtn( _this );
1715                         this.el.append( _this.nextBtn.el );
1716                         new Xcls_backBtn( _this );
1717                         this.el.append( _this.backBtn.el );
1718                         var child_5 = new Xcls_MenuButton23( _this );
1719                         child_5.ref();
1720                         this.el.append( child_5.el );
1721                 }
1722
1723                 // user defined functions
1724         }
1725         public class Xcls_search_entry : Object
1726         {
1727                 public Gtk.SearchEntry el;
1728                 private Xcls_WindowRooView  _this;
1729
1730
1731                         // my vars (def)
1732
1733                 // ctor
1734                 public Xcls_search_entry(Xcls_WindowRooView _owner )
1735                 {
1736                         _this = _owner;
1737                         _this.search_entry = this;
1738                         this.el = new Gtk.SearchEntry();
1739
1740                         // my vars (dec)
1741
1742                         // set gobject values
1743                         this.el.name = "roo-search-entry";
1744                         this.el.hexpand = true;
1745                         this.el.placeholder_text = "Press enter to search";
1746                         var child_1 = new Xcls_EventControllerKey19( _this );
1747                         child_1.ref();
1748                         this.el.add_controller(  child_1.el );
1749
1750                         //listeners
1751                         this.el.search_changed.connect( ( ) => {
1752
1753                         _this.search(_this.search_entry.el.text);
1754                                  _this.search_results.updateResults();
1755
1756                                 GLib.Timeout.add_seconds(1,() => {
1757                                          _this.search_results.updateResults();
1758                                          return false;
1759                                  });
1760                         });
1761                 }
1762
1763                 // user defined functions
1764                 public void forwardSearch (bool change_focus) {
1765
1766
1767                         _this.forwardSearch(change_focus);
1768
1769                 /*
1770
1771                         switch(_this.windowstate.state) {
1772                                 case WindowState.State.CODEONLY:
1773                                 //case WindowState.State.CODE:
1774                                         // search the code being edited..
1775                                         _this.windowstate.code_editor_tab.forwardSearch(change_focus);
1776
1777                                         break;
1778                                 case WindowState.State.PREVIEW:
1779                                         if (_this.windowstate.file.xtype == "Gtk") {
1780                                                 _this.windowstate.window_gladeview.forwardSearch(change_focus);
1781                                         } else {
1782                                                  _this.windowstate.window_rooview.forwardSearch(change_focus);
1783                                         }
1784
1785                                         break;
1786                         }
1787                         */
1788
1789                 }
1790         }
1791         public class Xcls_EventControllerKey19 : Object
1792         {
1793                 public Gtk.EventControllerKey el;
1794                 private Xcls_WindowRooView  _this;
1795
1796
1797                         // my vars (def)
1798
1799                 // ctor
1800                 public Xcls_EventControllerKey19(Xcls_WindowRooView _owner )
1801                 {
1802                         _this = _owner;
1803                         this.el = new Gtk.EventControllerKey();
1804
1805                         // my vars (dec)
1806
1807                         // set gobject values
1808
1809                         //listeners
1810                         this.el.key_pressed.connect( (keyval, keycode, state) => {
1811
1812                                 if (keyval == Gdk.Key.g && (state & Gdk.ModifierType.CONTROL_MASK ) > 0 ) {
1813                                     GLib.debug("SAVE: ctrl-g  pressed");
1814                                         _this.forwardSearch(true);
1815                                     return true;
1816                                 }
1817
1818
1819                                 if (keyval == Gdk.Key.Return) {
1820                                         _this.forwardSearch(true);
1821
1822
1823                                     return true;
1824
1825                                 }
1826                            // print(event.key.keyval)
1827
1828                             return false;
1829                         });
1830                 }
1831
1832                 // user defined functions
1833         }
1834
1835
1836         public class Xcls_search_results : Object
1837         {
1838                 public Gtk.Label el;
1839                 private Xcls_WindowRooView  _this;
1840
1841
1842                         // my vars (def)
1843
1844                 // ctor
1845                 public Xcls_search_results(Xcls_WindowRooView _owner )
1846                 {
1847                         _this = _owner;
1848                         _this.search_results = this;
1849                         this.el = new Gtk.Label( "No Results" );
1850
1851                         // my vars (dec)
1852
1853                         // set gobject values
1854                         this.el.margin_end = 4;
1855                         this.el.margin_start = 4;
1856                 }
1857
1858                 // user defined functions
1859                 public void updateResults () {
1860                         this.el.visible = true;
1861
1862                         var res = _this.searchcontext.get_occurrences_count();
1863                         if (res < 0) {
1864                                 _this.search_results.el.label = "??? Matches";
1865                                 return;
1866                         }
1867
1868                         _this.nextBtn.el.sensitive = false;
1869                         _this.backBtn.el.sensitive = false;
1870
1871                         if (res > 0) {
1872                                 _this.search_results.el.label = "%d Matches".printf(res);
1873                                 _this.nextBtn.el.sensitive = true;
1874                                 _this.backBtn.el.sensitive = true;
1875                                 return;
1876                         }
1877                         _this.search_results.el.label = "No Matches";
1878
1879                 }
1880         }
1881
1882         public class Xcls_nextBtn : Object
1883         {
1884                 public Gtk.Button el;
1885                 private Xcls_WindowRooView  _this;
1886
1887
1888                         // my vars (def)
1889                 public bool always_show_image;
1890
1891                 // ctor
1892                 public Xcls_nextBtn(Xcls_WindowRooView _owner )
1893                 {
1894                         _this = _owner;
1895                         _this.nextBtn = this;
1896                         this.el = new Gtk.Button();
1897
1898                         // my vars (dec)
1899                         this.always_show_image = true;
1900
1901                         // set gobject values
1902                         this.el.icon_name = "go-down";
1903                         this.el.sensitive = false;
1904
1905                         //listeners
1906                         this.el.clicked.connect( (event) => {
1907
1908                                 _this.forwardSearch(true);
1909
1910                         });
1911                 }
1912
1913                 // user defined functions
1914         }
1915
1916         public class Xcls_backBtn : Object
1917         {
1918                 public Gtk.Button el;
1919                 private Xcls_WindowRooView  _this;
1920
1921
1922                         // my vars (def)
1923                 public bool always_show_image;
1924
1925                 // ctor
1926                 public Xcls_backBtn(Xcls_WindowRooView _owner )
1927                 {
1928                         _this = _owner;
1929                         _this.backBtn = this;
1930                         this.el = new Gtk.Button();
1931
1932                         // my vars (dec)
1933                         this.always_show_image = true;
1934
1935                         // set gobject values
1936                         this.el.icon_name = "go-up";
1937                         this.el.sensitive = false;
1938
1939                         //listeners
1940                         this.el.clicked.connect( (event) => {
1941
1942                                 _this.backSearch(true);
1943
1944
1945                         });
1946                 }
1947
1948                 // user defined functions
1949         }
1950
1951         public class Xcls_MenuButton23 : Object
1952         {
1953                 public Gtk.MenuButton el;
1954                 private Xcls_WindowRooView  _this;
1955
1956
1957                         // my vars (def)
1958                 public bool always_show_image;
1959
1960                 // ctor
1961                 public Xcls_MenuButton23(Xcls_WindowRooView _owner )
1962                 {
1963                         _this = _owner;
1964                         this.el = new Gtk.MenuButton();
1965
1966                         // my vars (dec)
1967                         this.always_show_image = true;
1968
1969                         // set gobject values
1970                         this.el.icon_name = "emblem-system";
1971                         new Xcls_search_settings( _this );
1972                         this.el.popover = _this.search_settings.el;
1973                 }
1974
1975                 // user defined functions
1976         }
1977         public class Xcls_search_settings : Object
1978         {
1979                 public Gtk.Popover el;
1980                 private Xcls_WindowRooView  _this;
1981
1982
1983                         // my vars (def)
1984
1985                 // ctor
1986                 public Xcls_search_settings(Xcls_WindowRooView _owner )
1987                 {
1988                         _this = _owner;
1989                         _this.search_settings = this;
1990                         this.el = new Gtk.Popover();
1991
1992                         // my vars (dec)
1993
1994                         // set gobject values
1995                         var child_1 = new Xcls_Box25( _this );
1996                         child_1.ref();
1997                         this.el.child = child_1.el;
1998                 }
1999
2000                 // user defined functions
2001         }
2002         public class Xcls_Box25 : Object
2003         {
2004                 public Gtk.Box el;
2005                 private Xcls_WindowRooView  _this;
2006
2007
2008                         // my vars (def)
2009
2010                 // ctor
2011                 public Xcls_Box25(Xcls_WindowRooView _owner )
2012                 {
2013                         _this = _owner;
2014                         this.el = new Gtk.Box( Gtk.Orientation.VERTICAL, 0 );
2015
2016                         // my vars (dec)
2017
2018                         // set gobject values
2019                         new Xcls_case_sensitive( _this );
2020                         this.el.append( _this.case_sensitive.el );
2021                         new Xcls_regex( _this );
2022                         this.el.append( _this.regex.el );
2023                         new Xcls_multiline( _this );
2024                         this.el.append( _this.multiline.el );
2025                 }
2026
2027                 // user defined functions
2028         }
2029         public class Xcls_case_sensitive : Object
2030         {
2031                 public Gtk.CheckButton el;
2032                 private Xcls_WindowRooView  _this;
2033
2034
2035                         // my vars (def)
2036
2037                 // ctor
2038                 public Xcls_case_sensitive(Xcls_WindowRooView _owner )
2039                 {
2040                         _this = _owner;
2041                         _this.case_sensitive = this;
2042                         this.el = new Gtk.CheckButton();
2043
2044                         // my vars (dec)
2045
2046                         // set gobject values
2047                         this.el.label = "Case Sensitive";
2048
2049                         // init method
2050
2051                         {
2052                                 this.el.show();
2053                         }
2054                 }
2055
2056                 // user defined functions
2057         }
2058
2059         public class Xcls_regex : Object
2060         {
2061                 public Gtk.CheckButton el;
2062                 private Xcls_WindowRooView  _this;
2063
2064
2065                         // my vars (def)
2066
2067                 // ctor
2068                 public Xcls_regex(Xcls_WindowRooView _owner )
2069                 {
2070                         _this = _owner;
2071                         _this.regex = this;
2072                         this.el = new Gtk.CheckButton();
2073
2074                         // my vars (dec)
2075
2076                         // set gobject values
2077                         this.el.label = "Regex";
2078
2079                         // init method
2080
2081                         {
2082                                 this.el.show();
2083                         }
2084                 }
2085
2086                 // user defined functions
2087         }
2088
2089         public class Xcls_multiline : Object
2090         {
2091                 public Gtk.CheckButton el;
2092                 private Xcls_WindowRooView  _this;
2093
2094
2095                         // my vars (def)
2096
2097                 // ctor
2098                 public Xcls_multiline(Xcls_WindowRooView _owner )
2099                 {
2100                         _this = _owner;
2101                         _this.multiline = this;
2102                         this.el = new Gtk.CheckButton();
2103
2104                         // my vars (dec)
2105
2106                         // set gobject values
2107                         this.el.label = "Multi-line (add \\n)";
2108
2109                         // init method
2110
2111                         {
2112                                 this.el.show();
2113                         }
2114                 }
2115
2116                 // user defined functions
2117         }
2118
2119
2120
2121
2122
2123
2124
2125 }