3 Pango = imports.gi.Pango;
4 GLib = imports.gi.GLib;
6 GObject = imports.gi.GObject;
7 GtkSource = imports.gi.GtkSource;
8 WebKit = imports.gi.WebKit;
10 GtkClutter = imports.gi.GtkClutter;
11 console = imports.console;
12 XObject = imports.XObject.XObject;
19 XObject.prototype.init.call(this);
24 xtype: GtkClutter.Embed,
27 activate : function(elname)
30 // enter event. - triggers start of possible re-arrange.
32 // leave notify event...- cancel..
33 // --> clear next event
42 /* if (this.lastAct) {
43 if (((new Date()) - this.lastAct) < 1000) {
49 this.lastAct = new Date();
51 // THIS NEEDS TO ACTIVATE CERTIAN LAYOUTS BASED ON WHAT ELEMENT
52 // HAS BEEN ACTIVATED.
53 var Clutter = imports.gi.Clutter;
57 function mv(en, opts) {
59 if (opts.scale && !opts.scale_x) {
60 opts.scale_x = opts.scale;
62 if (opts.scale && !opts.scale_y) {
63 opts.scale_y = opts.scale;
68 var anim = _t.get(en).el.animate( Clutter.AnimationMode.EASE_OUT_ELASTIC, 1000, opts );
70 anim.timeline.start();
72 var left = ['project', 'parts', 'props' ];
73 var right = [ 'filelist', 'editor', 'preview', 'palete' ];
76 left.forEach(function(e) {
77 if (moved.indexOf(e) > -1) { return; } // already moved
78 mv(e, { scale : 0.5, x : 5, y : left.indexOf(e)*60} );
80 right.forEach(function(e) {
81 if (moved.indexOf(e) > -1) { return; } // already moved
82 mv(e, { scale : 0.5, x : 700 , y : right.indexOf(e)*60} );
86 // reserve left < 100 for icons...
87 // elements have a few 'scale' states
88 // a) minimized '50x50' box on left or right....
90 // c) reduced size (visible but not active..)
92 // active element should always end up on left...
98 mv('project', { scale : 2, x : 100 , y : 0}); // full left.
99 mv('filelist', { scale : 2, x : 400 , y : 0}); // right.
103 case 'parts': // tree of parts
105 mv('parts', { scale : 2, x : 60 , y : 0}); // full left.
106 mv('props', { scale : 2, x : 60 , y : 200}); // bottom (full)
107 mv('preview', { scale : 1, x : 260 , y : 0}); // right (half.)
112 // editor = props / tree and editor (main!)
113 mv('editor', { scale : 3, x : 300 , y : 0}); // main?
115 mv('props', { scale : 2, x : 60 , y : 0}); // bottom (full)
116 mv('parts', { scale : 2, x : 60 , y : 200}); // full left.
121 // preview... debugger is probably helpful..?
122 mv('parts', { scale : 1, x : 60 , y : 0}); // full left.
123 mv('props', { scale : 1, x : 60 , y : 200}); // bottom (full)
124 mv('preview', { scale : 3, x : 160 , y : 0}); // right (half.)
129 mv('parts', { scale : 2, x : 60 , y : 0}); // full left.
130 mv('palete', { scale : 2, x : 500 , y : 0}); // bottom (full)
140 mv(this.lastEl, { scale: 0.5 });
143 this.lastEl = elname;
144 mv(elname, { scale: 2});
147 enter : function(n) {
148 print("ENTER : " + n);
151 this.entered = new Date();
152 // set up a timeout..
153 if (this.hasTimeout) {
157 this.hasTimeout = GLib.timeout_add (GLib.PRIORITY_DEFAULT, 100, function() {
159 if (!_t.nextActor) { // no actor..
160 // print("no actor");
164 var lapsed = ((new Date()) - _t.entered);
165 //print ("lapsed: " + lapsed);
166 if (lapsed < 1000) { // not enought time yet..
170 var na = _t.nextActor + '';
171 _t.nextActor = false;
177 this.nextActor = false;
181 xtype: GtkClutter.Actor,
192 enter_notify_event : function (self, event) {
193 this.get('/Canvas').enter('project');
196 leave_notify_event : function (self, event) {
197 print("leave not event?");
198 this.get('/Canvas').leave();
202 height_request : 100,
203 label : "project list",
210 xtype: GtkClutter.Actor,
219 enter_notify_event : function (self, event) {
220 this.get('/Canvas').enter('filelist');
223 leave_notify_event : function (self, event) {
224 this.get('/Canvas').leave();
228 height_request : 100,
236 xtype: GtkClutter.Actor,
243 xtype: Gtk.ScrolledWindow,
245 enter_notify_event : function (self, event) {
246 this.get('/Canvas').enter('parts');
249 leave_notify_event : function (self, event) {
250 this.get('/Canvas').leave();
254 height_request : 400,
258 getActiveElement : function() { // return path to actie node.
260 var path = this.getActivePath();
264 var iter = new Gtk.TreeIter();
265 this.get('model').el.get_iter_from_string(iter, path);
267 var value = new GObject.Value('');
268 this.get('model').el.get_value(iter, 2, value);
270 return JSON.parse(value.value);
272 getActiveFile : function() {
273 return this.get('model').file;
275 getActivePath : function() {
276 var model = this.get('model');
277 var view = this.get('view');
278 if (view.selection.count_selected_rows() < 1) {
281 var iter = new Gtk.TreeIter();
283 view.selection.get_selected(model.el, iter);
284 return model.el.get_path(iter).to_string();
286 getPaleteProvider : function() {
287 var model = this.get('model');
288 var pm = imports.Builder.Provider.ProjectManager.ProjectManager;
289 return pm.getPalete(model.file.getType());
291 getRenderer : function() {
293 switch( this.getActiveFile().getType()) {
295 return this.get('/RightBrowser.view');
297 return this.get('/RightGtkView');
302 XObject.prototype.init.call(this);
303 this.el.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
305 renderView : function() {
306 var render = this.getRenderer();
307 var model = this.get('model');
309 render.renderJS(model.toJS(false,true)[0]);
311 print("NO RENDER JS METHOD?");
314 shadow_type : Gtk.ShadowType.IN,
319 button_press_event : function (self, ev) {
320 // console.log("button press?");
322 if (ev.type != Gdk.EventType.BUTTON_PRESS || ev.button.button != 3) {
323 print("click" + ev.type);
329 this.get('/LeftTree.view').el.get_path_at_pos(ev.button.x,ev.button.y, res);
331 if (!this.get('/LeftTreeMenu').el) this.get('/LeftTreeMenu').init();
333 this.get('/LeftTreeMenu').el.set_screen(Gdk.Screen.get_default());
334 this.get('/LeftTreeMenu').el.show_all();
335 this.get('/LeftTreeMenu').el.popup(null, null, null, null, 3, ev.button.time);
336 print("click:" + res.path.to_string());
339 drag_begin : function (self, drag_context) {
340 print('SOURCE: drag-begin');
341 this.targetData = false;
342 // find what is selected in our tree...
343 var iter = new Gtk.TreeIter();
344 var s = this.selection;
345 s.get_selected(this.get('/LeftTree.model').el, iter);
347 // set some properties of the tree for use by the dropped element.
348 var value = new GObject.Value('');
349 this.get('/LeftTree.model').el.get_value(iter, 2, value);
350 var data = JSON.parse(value.value);
351 var xname = this.get('/LeftTree.model').file.guessName(data);
353 this.el.dragData = xname;
354 this.el.dropList = this.get('/LeftTree').getPaleteProvider().getDropList(xname);
357 // make the drag icon a picture of the node that was selected
358 var path = this.get('/LeftTree.model').el.get_path(iter);
359 this.el.treepath = path.to_string();
361 var pix = this.el.create_row_drag_icon ( path);
363 Gtk.drag_set_icon_pixmap (ctx,
372 drag_end : function (self, drag_context) {
373 Seed.print('LEFT-TREE: drag-end');
374 this.el.dragData = false;
375 this.el.dropList = false;
376 this.targetData = false;
377 this.get('/LeftTree.view').highlight(false);
380 drag_motion : function (self, ctx, x, y, time) {
381 console.log("LEFT-TREE: drag-motion");
382 var src = Gtk.drag_get_source_widget(ctx);
384 // a drag from elsewhere...- prevent drop..
386 print("no drag data!");
387 Gdk.drag_status(ctx, 0, time);
388 this.targetData = false;
391 var action = Gdk.DragAction.COPY;
392 if (src == this.el) {
393 // unless we are copying!!! ctl button..
394 action = ctx.actions & Gdk.DragAction.MOVE ? Gdk.DragAction.MOVE : Gdk.DragAction.COPY ;
398 if (!this.get('/LeftTree.model').el.iter_n_children(null)) {
399 // no children.. -- asume it's ok..
400 this.targetData = [ '' , Gtk.TreeViewDropPosition.INTO_OR_AFTER , ''];
401 Gdk.drag_status(ctx, action ,time);
405 print("GETTING POS");
406 var isOver = this.get('/LeftTree.view').el.get_dest_row_at_pos(x,y, data);
407 print("ISOVER? " + isOver);
409 Gdk.drag_status(ctx, 0 ,time);
410 return false; // not over apoint!?!
412 // drag node is parent of child..
413 console.log("SRC TREEPATH: " + src.treepath);
414 console.log("TARGET TREEPATH: " + data.path.to_string());
416 // nned to check a few here..
417 //Gtk.TreeViewDropPosition.INTO_OR_AFTER
418 //Gtk.TreeViewDropPosition.INTO_OR_BEFORE
419 //Gtk.TreeViewDropPosition.AFTER
420 //Gtk.TreeViewDropPosition.BEFORE
422 if (typeof(src.treepath) != 'undefined' &&
423 src.treepath == data.path.to_string().substring(0,src.treepath.length)) {
424 print("subpath drag");
425 Gdk.drag_status(ctx, 0 ,time);
430 //print("DUMPING DATA");
431 //console.dump(data);
434 print(data.path.to_string() +' => '+ data.pos);
435 var tg = this.get('/LeftTree.model').findDropNodeByPath(
436 data.path.to_string(), src.dropList, data.pos);
438 this.get('/LeftTree.view').highlight(tg);
440 print("Can not find drop node path");
441 this.targetData = false;
442 Gdk.drag_status(ctx, 0, time);
446 this.targetData = tg;
449 Gdk.drag_status(ctx, action ,time);
453 drag_drop : function (w, ctx, x, y, time) {
454 Seed.print("TARGET: drag-drop");
458 w, /* will receive 'drag-data-received' signal */
459 ctx, /* represents the current state of the DnD */
460 this.get('/Window').atoms["STRING"], /* the target type we want */
461 time /* time stamp */
465 /* No target offered by source => error */
470 drag_data_received : function (self, ctx, x, y, sel_data, info, time) {
471 print("Tree: drag-data-received");
473 var delete_selection_data = false;
474 var dnd_success = false;
475 /* Deal with what we are given from source */
476 if( sel_data && sel_data.length ) {
478 if (ctx.action == Gdk.DragAction.ASK) {
479 /* Ask the user to move or copy, then set the ctx action. */
482 if (ctx.action == Gdk.DragAction.MOVE) {
483 //delete_selection_data = true;
486 var source = Gtk.drag_get_source_widget(ctx);
488 if (this.targetData) {
489 if (source != this.el) {
490 this.get('/LeftTree.model').dropNode(this.targetData, source.dragData);
492 // drag around.. - reorder..
493 this.get('/LeftTree.model').moveNode(this.targetData, ctx.action);
497 //Seed.print(this.targetData);
503 // we can send stuff to souce here...
509 if (dnd_success == false)
511 Seed.print ("DnD data transfer failed!\n");
514 Gtk.drag_finish (ctx, dnd_success, delete_selection_data, time);
517 cursor_changed : function (self) {
519 if (this.blockChanges) { // probably not needed..
522 var render = this.get('/LeftTree').getRenderer();
525 if (this.selection.count_selected_rows() < 1) {
526 this.get('/LeftPanel.model').load( false);
527 this.get('/MidPropTree').activeElement = false;
528 this.get('/MidPropTree').hideWin();
530 var pm = this.get('/RightPalete.model');
531 if (!this.get('/LeftTree').getPaleteProvider()) {
532 // it may not be loaded yet..
535 pm.load( this.get('/LeftTree').getPaleteProvider().gatherList(
536 this.get('/LeftTree.model').listAllTypes()));
537 if (render && render.redraw) {
543 //console.log('changed');
544 var s = this.selection;
545 var iter = new Gtk.TreeIter();
546 s.get_selected(this.get('/LeftTree.model').el, iter);
550 var value = new GObject.Value('');
551 this.get('/LeftTree.model').el.get_value(iter, 2, value);
552 this.get('/LeftTree.model').activePath = this.get('/LeftTree.model').el.get_path(iter).to_string();
554 var data = JSON.parse(value.value);
555 this.get('/MidPropTree').activeElement = data;
556 this.get('/MidPropTree').hideWin();
557 this.get('/LeftPanel.model').load( data);
559 console.log(value.value);
560 // _g.button.set_label(''+value.get_string());
562 var pm =this.get('/RightPalete.model');
563 pm.load( this.get('/LeftTree').getPaleteProvider().gatherList(
564 this.get('/LeftTree.model').listAllTypes()));
567 if (render && render.redraw) {
571 //Seed.print( value.get_string());
579 enable_tree_lines : true,
580 headers_visible : false,
581 highlight : function(treepath_ar) {
583 // highlighting for drag/drop
584 if (treepath_ar.length && treepath_ar[0].length ) {
585 this.el.set_drag_dest_row(
586 new Gtk.TreePath.from_string( treepath_ar[0] ), treepath_ar[1]);
588 this.el.set_drag_dest_row(null, Gtk.TreeViewDropPosition.INTO_OR_AFTER);
593 XObject.prototype.init.call(this);
594 var description = new Pango.FontDescription.c_new();
595 description.set_size(8000);
596 this.el.modify_font(description);
598 this.selection = this.el.get_selection();
599 this.selection.set_mode( Gtk.SelectionMode.SINGLE);
602 // is this really needed??
603 this.selection.signal['changed'].connect(function() {
604 _this.get('/LeftTree.view').listeners.cursor_changed.apply(
605 _this.get('/LeftTree.view'), [ _this.get('/LeftTree.view'), '']
609 Gtk.drag_source_set (
610 this.el, /* widget will be drag-able */
611 Gdk.ModifierType.BUTTON1_MASK, /* modifier that will start a drag */
612 null, /* lists of target to support */
613 0, /* size of list */
614 Gdk.DragAction.COPY | Gdk.DragAction.MOVE /* what to do with data after dropped */
617 Gtk.drag_source_set_target_list(this.el, this.get('/Window').targetList);
619 Gtk.drag_source_add_text_targets(this.el);
622 this.el, /* widget that will accept a drop */
623 Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT,
624 null, /* lists of target to support */
625 0, /* size of list */
626 Gdk.DragAction.COPY | Gdk.DragAction.MOVE /* what to do with data after dropped */
629 Gtk.drag_dest_set_target_list(this.el, this.get('/Window').targetList);
630 Gtk.drag_dest_add_text_targets(this.el);
632 selectNode : function(treepath_str) {
633 //this.selection.select_path(new Gtk.TreePath.from_string( treepath_str));
634 var tp = new Gtk.TreePath.from_string(treepath_str);
635 this.el.set_cursor(tp, null, false);
636 this.el.scroll_to_cell(tp, null, false, 0,0);
640 xtype: Gtk.TreeStore,
645 changed : function(n, refresh) {
646 // print("MODEL CHANGED CALLED" + this.activePath);
647 if (this.activePath) {
648 var iter = new Gtk.TreeIter();
649 this.el.get_iter(iter, new Gtk.TreePath.from_string(this.activePath))
650 this.el.set_value(iter, 0, [GObject.TYPE_STRING, this.nodeTitle(n)]);
651 this.el.set_value(iter, 1, [GObject.TYPE_STRING, this.nodeTitle(n)]);
653 this.el.set_value(iter, 2, [GObject.TYPE_STRING, this.nodeToJSON(n)]);
655 //this.currentTree = this.toJS(false, true)[0];
656 this.file.items = this.toJS(false, false);
657 // print("AFTER CHANGED");
658 //console.dump(this.file.items);
660 this.currentTree = this.file.items[0];
661 //console.log(this.file.toSource());
664 print("REDNER BROWSER?!");
665 this.get('/LeftTree').renderView();
667 var pm = this.get('/RightPalete.model');
668 if (!this.get('/RightPalete').provider) {
674 pm.load( this.get('/RightPalete').provider.gatherList(this.listAllTypes()));
675 //imports['Builder/RightBrowser.js'].renderJS(this.toJS());
679 deleteSelected : function() {
680 this.get('/LeftTree.view').blockChanges = true;
681 var old_iter = new Gtk.TreeIter();
682 var s = this.get('/LeftTree.view').selection;
683 s.get_selected(this.el, old_iter);
684 var path = this.el.get_path(old_iter).to_string();
686 this.activePath= false;
689 this.activePath= false;
690 var iter = new Gtk.TreeIter();
691 this.el.get_iter_from_string(iter, path);
692 this.el.remove(iter);
694 // rebuild treemap. -- depreciated.!!
697 //this.toJS(null, true) // does not do anything?
698 this.activePath= false;
699 this.changed(false,true);
700 this.get('/LeftTree.view').blockChanges = false;
702 dropNode : function(target_data, node) {
704 // console.dump(node);
705 // console.dump(target_data);
706 var tp = target_data[0].length ? new Gtk.TreePath.from_string( target_data[0] ) : false;
708 print("add " + tp + "@" + target_data[1] );
711 if (tp && target_data[1] < 2) { // before or after..
712 var ar = target_data[0].split(':');
714 parent = new Gtk.TreePath.from_string( ar.join(':') );
717 var n_iter = new Gtk.TreeIter();
718 var iter_par = new Gtk.TreeIter();
719 var iter_after = after ? new Gtk.TreeIter() : false;
723 if (parent !== false) {
724 this.el.get_iter(iter_par, parent);
731 print(target_data[1] > 0 ? 'insert_after' : 'insert_before');
732 this.el.get_iter(iter_after, after);
733 this.el[ target_data[1] > 0 ? 'insert_after' : 'insert_before'](
734 n_iter, iter_par, iter_after);
737 this.el.append(n_iter, iter_par);
741 if (typeof(node) == 'string') {
742 var ar = node.split('.');
743 var xtype = ar.pop();
746 '|xns' : ar.join('.'),
749 if (target_data.length == 3 && target_data[2].length) {
750 node['*prop'] = target_data[2];
752 node = this.get('/DialogTemplateSelect').show(node);
755 // work out what kind of packing to use..
756 if (typeof(node.pack) == 'undefined' && parent !== false) {
757 var pal = this.get('/LeftTree').getPaleteProvider();
758 if (pal.name == 'Gtk') {
759 var pname = pal.guessName(this.singleNodeToJS(parent.to_string()));
760 var cname = pal.guessName(node);
761 node.pack = pal.getDefaultPack(pname, cname);
772 // load children - if it has any..
775 this.load(xitems, n_iter);
776 this.get('/LeftTree.view').el.expand_row(this.el.get_path(n_iter), true);
778 if (tp && (xitems || after)) {
779 this.get('/LeftTree.view').el.expand_row(this.el.get_path(iter_par), true);
781 // wee need to get the empty proptypes from somewhere..
783 //var olditer = this.activeIter;
784 this.activePath = this.el.get_path(n_iter).to_string();
786 // changed actually set's the node data..
787 this.changed(node, true);
791 this.get('/LeftTree.view').el.set_cursor(this.el.get_path(n_iter), null, false);
793 //Builder.MidPropTree._model.load(node);
794 //Builder.MidPropTree._win.hideWin();
795 //Builder.LeftPanel._model.load( node);
799 findDropNode : function(treepath_str, targets) {
801 // this is used by the dragdrop code in the roo version AFAIR..
803 var path = treepath_str.replace(/^builder-/, '');
804 // treemap is depreciated... - should really check if model has any entries..
806 if (!this.el.iter_n_children(null)) {
808 return [ '', Gtk.TreeViewDropPosition.INTO_OR_AFTER];
810 print("FIND treepath: " + path);
811 //console.dump(this.treemap);
813 if (!treepath_str.match(/^builder-/)) {
814 return []; // nothing!
816 if (targets === true) {
819 return this.findDropNodeByPath(path,targets)
821 findDropNodeByPath : function(treepath_str, targets, pref) {
822 var path = treepath_str + ''; // dupe it..
823 pref = typeof(pref) == 'undefined' ? Gtk.TreeViewDropPosition.INTO_OR_AFTER : pref;
825 //console.dump(this.treemap);
826 while (path.length) {
827 print("LOOKING FOR PATH: " + path);
828 var node_data = this.singleNodeToJS(path);
829 if (node_data === false) {
830 print("node not found");
834 var xname = this.get('/LeftTree.model').file.guessName(node_data);
837 targets.forEach(function(tg) {
841 if ((tg == xname) ) {
844 if (tg.indexOf(xname +':') === 0) {
846 prop = tg.split(':').pop();
851 if (last) { // pref is after/before..
852 // then it's after last
854 return []; // do not allow..
856 return [ last, pref , prop];
859 return [ path , Gtk.TreeViewDropPosition.INTO_OR_AFTER , prop];
861 var par = path.split(':');
864 path = par.join(':');
870 getIterValue : function (iter, col) {
871 var gval = new GObject.Value('');
872 this.el.get_value(iter, col ,gval);
878 XObject.prototype.init.call(this);
879 this.el.set_column_types ( 3, [
880 GObject.TYPE_STRING, // title
881 GObject.TYPE_STRING, // tip
882 GObject.TYPE_STRING // source..
885 listAllTypes : function() {
886 var s = this.get('/LeftTree.view').selection;
887 print ("LIST ALL TYPES: " + s.count_selected_rows() );
889 if (s.count_selected_rows() > 0) {
890 var iter = new Gtk.TreeIter();
891 s.get_selected(this.el, iter);
893 // set some properties of the tree for use by the dropped element.
894 var value = new GObject.Value('');
895 this.el.get_value(iter, 2, value);
896 var data = JSON.parse(value.value);
899 var xname = this.get('/LeftTree.model').file.guessName(data);
900 console.log('selected:' + xname);
904 return []; // could not find it..
912 li.forEach(function(el) {
913 // this is specific to roo!!!?
914 if (!el) { // skip empty?
917 var fullpath = _this.file.guessName(el);
918 if (fullpath.length && ret.indexOf(fullpath) < 0) {
923 if (el.items && el.items.length) {
932 addall([this.currentTree]);
934 // only if we have nothing, should we add '*top'
938 //console.log('all types in tree');
944 load : function(tr,iter)
946 var citer = new Gtk.TreeIter();
947 //this.insert(citer,iter,0);
948 for(var i =0 ; i < tr.length; i++) {
950 this.el.insert(citer,iter,-1);
952 this.el.append(citer);
955 this.el.set_value(citer, 0, [GObject.TYPE_STRING, this.nodeTitle(tr[i]) ]);
956 this.el.set_value(citer, 1, [GObject.TYPE_STRING, this.nodeTip(tr[i]) ]);
957 this.el.set_value(citer, 2, [GObject.TYPE_STRING, this.nodeToJSON(tr[i])]);
958 if (tr[i].items && tr[i].items.length) {
959 this.load(tr[i].items, citer);
963 loadFile : function(f) {
969 console.log('missing file');
973 // load the file if not loaded..
974 if (f.items === false) {
976 f.loadItems(function() {
982 this.get('/Window').setTitle(f.project.getName() + ' - ' + f.name);
984 if (f.items.length && typeof(f.items[0]) == 'string') {
986 this.get('/RightEditor').el.show();
987 this.get('/RightEditor.view').load( f.items[0]);
991 print(JSON.stringify(f.items, null,4));
992 //console.dump(f.items);
994 this.get('/LeftTree.view').el.expand_all();
996 if (!f.items.length) {
999 this.get('/Window.leftvpaned').el.set_position(80);
1001 this.get('/LeftTree.view').el.set_cursor(
1002 new Gtk.TreePath.from_string('0'), null, false);
1006 this.get('/Window.leftvpaned').el.set_position(200);
1010 //print("hide right editior");
1011 this.get('/RightEditor').el.hide();
1012 //print("set current tree");
1013 this.currentTree = this.toJS(false, false)[0];
1014 //console.dump(this.currentTree);
1015 this.currentTree = this.currentTree || { items: [] };
1016 this.get('/LeftTree').renderView();
1017 //console.dump(this.map);
1018 //var RightPalete = imports.Builder.RightPalete.RightPalete;
1019 var pm = this.get('/RightPalete.model');
1020 // set up provider..
1022 this.get('/RightPalete').provider = this.get('/LeftTree').getPaleteProvider();
1024 if (!this.get('/RightPalete').provider) {
1025 print ("********* PALETE PROVIDER MISSING?!!");
1027 this.get('/LeftTree').renderView();
1029 pm.load( this.get('/LeftTree').getPaleteProvider().gatherList(this.listAllTypes()));
1033 this.get('/Window.view-notebook').el.set_current_page(
1034 this.get('/LeftTree.model').file.getType()== 'Roo' ? 0 : -1);
1037 moveNode : function(target_data, action) {
1038 //print("MOVE NODE");
1039 // console.dump(target_data);
1040 var old_iter = new Gtk.TreeIter();
1041 var s = this.get('/LeftTree.view').selection;
1042 s.get_selected(this.el, old_iter);
1043 var node = this.nodeToJS(old_iter,false);
1044 //console.dump(node);
1047 // needs to drop first, otherwise the target_data
1048 // treepath will be invalid.
1050 this.dropNode(target_data, node);
1051 if (action & Gdk.DragAction.MOVE) {
1052 // print("REMOVING OLD NODE");
1053 this.el.remove(old_iter);
1057 this.activePath= false;
1058 this.changed(false,true);
1060 nodeTip : function(c) {
1061 var ret = this.nodeTitle(c,true);
1067 if (!i.length || i[0] != '|') {
1073 if (typeof(c[i]) != 'string') {
1076 //print("prop : " + i + ':' + c[i]);
1077 if (!c[i].match(new RegExp('function'))) {
1080 funcs += "\n<b>" + i.substring(1) + '</b> : ' + c[i].split(/\n/).shift();
1084 ret+="\n\nMethods:" + funcs;
1089 nodeTitle : function(c, renderfull) {
1092 var sr = (typeof(c['+buildershow']) != 'undefined') && !c['+buildershow'] ? true : false;
1093 if (sr) txt.push('<s>');
1094 if (typeof(c['*prop']) != 'undefined') { txt.push(c['*prop']+ ':'); }
1096 if (renderfull && c['|xns']) {
1097 txt.push(c['|xns']);
1100 if (c.xtype) { txt.push(c.xtype); }
1101 if (c.id) { txt.push('<b>[id=' + c.id + ']</b>'); }
1102 if (c.fieldLabel) { txt.push('[' + c.fieldLabel + ']'); }
1103 if (c.boxLabel) { txt.push('[' + c.boxLabel + ']'); }
1106 if (c.layout) { txt.push('<i>' + c.layout + '</i>'); }
1107 if (c.title) { txt.push('<b>' + c.title + '</b>'); }
1108 if (c.label) { txt.push('<b>' + c.label+ '</b>'); }
1109 if (c.header) { txt.push('<b>' + c.header + '</b>'); }
1110 if (c.legend) { txt.push('<b>' + c.legend + '</b>'); }
1111 if (c.text) { txt.push('<b>' + c.text + '</b>'); }
1112 if (c.name) { txt.push('<b>' + c.name+ '</b>'); }
1113 if (c.region) { txt.push('<i>(' + c.region + ')</i>'); }
1114 if (c.dataIndex) { txt.push('[' + c.dataIndex+ ']'); }
1116 // for flat classes...
1117 if (typeof(c['*class']) != 'undefined') { txt.push('<b>' + c['*class']+ '</b>'); }
1118 if (typeof(c['*extends']) != 'undefined') { txt.push(': <i>' + c['*extends']+ '</i>'); }
1121 if (sr) txt.push('</s>');
1122 return (txt.length == 0 ? "Element" : txt.join(" "));
1124 nodeToJS : function (treepath, with_id)
1127 var iter = treepath; // API used to be iter here..
1128 if (typeof(iter) == 'string') {
1129 iter = new Gtk.TreeIter();
1130 if (!this.el.get_iter(iter, new Gtk.TreePath.from_string(treepath))) {
1134 var par = new Gtk.TreeIter();
1135 var iv = this.getIterValue(iter, 2);
1136 // print("IV" + iv);
1137 var k = JSON.parse(iv);
1138 if (k.json && !this.el.iter_parent( par, iter )) {
1143 var treepath_str = this.el.get_path(iter).to_string();
1144 // not sure how we can handle mixed id stuff..
1145 if (typeof(k.id) == 'undefined') {
1146 k.id = 'builder-'+ treepath_str ;
1150 this.treemap[ treepath_str ] = k;
1151 k.xtreepath = treepath_str ;
1154 if (this.el.iter_has_child(iter)) {
1155 citer = new Gtk.TreeIter();
1156 this.el.iter_children(citer, iter);
1157 k.items = this.toJS(citer,with_id);
1161 nodeToJSON : function(c) {
1169 return JSON.stringify(o);
1171 singleNodeToJS : function (treepath)
1173 var iter = new Gtk.TreeIter();
1174 if (!this.el.get_iter(iter, new Gtk.TreePath.from_string(treepath))) {
1178 var iv = this.getIterValue(iter, 2);
1180 return JSON.parse(iv);
1183 toJS : function(treepath, with_id)
1185 //Seed.print("WITHID: "+ with_id);
1186 var iter = treepath; // API used to be iter here..
1187 if (typeof(iter) == 'string') {
1188 iter = new Gtk.TreeIter();
1189 if (!this.el.get_iter(iter, new Gtk.TreePath.from_string(treepath))) {
1198 iter = new Gtk.TreeIter();
1199 if (!this.el.get_iter_first(iter)) {
1209 var k = this.nodeToJS(iter, with_id);
1213 if (!this.el.iter_next(iter)) {
1218 if (treepath === false) {
1220 return JSON.parse(JSON.stringify(ar));
1224 // convert the list into a json string..
1230 xtype: Gtk.TreeViewColumn,
1231 pack : "append_column",
1233 XObject.prototype.init.call(this);
1234 this.el.add_attribute(this.items[0].el , 'markup', 0 );
1238 xtype: Gtk.CellRendererText,
1248 id : "LeftTreeMenu",
1251 xtype: Gtk.MenuItem,
1253 label : "Delete Element",
1255 activate : function (self) {
1257 this.get('/LeftTree.model').deleteSelected();
1262 xtype: Gtk.MenuItem,
1264 activate : function (self) {
1266 var tree = this.get('/LeftTree');
1267 var model = this.get('/LeftTree.model');
1268 var el = tree.getActivePath();
1270 var js = model.toJS(el, false);
1271 // print(JSON.stringify(js[0], null,4));
1272 this.get('/DialogSaveTemplate').show(JSON.stringify(js[0], null,4));
1277 label : "Save as Template",
1287 xtype: GtkClutter.Actor,
1296 enter_notify_event : function (self, event) {
1297 this.get('/Canvas').enter('props');
1300 leave_notify_event : function (self, event) {
1301 this.get('/Canvas').leave();
1305 height_request : 100,
1306 label : "property editor",
1313 xtype: GtkClutter.Actor,
1322 enter_notify_event : function (self, event) {
1323 this.get('/Canvas').enter('editor');
1326 leave_notify_event : function (self, event) {
1327 this.get('/Canvas').leave();
1331 height_request : 100,
1332 label : "text editor",
1339 xtype: GtkClutter.Actor,
1348 enter_notify_event : function (self, event) {
1349 this.get('/Canvas').enter('preview');
1352 leave_notify_event : function (self, event) {
1353 this.get('/Canvas').leave();
1357 height_request : 100,
1358 label : "preview app",
1365 xtype: GtkClutter.Actor,
1374 enter_notify_event : function (self, event) {
1375 this.get('/Canvas').enter('palete');
1378 leave_notify_event : function (self, event) {
1379 this.get('/Canvas').leave();
1383 height_request : 100,
1395 XObject.cache['/Window'] = Window;