SCClassLibrary/Common/Quarks/Quarks.sc

   1 /**
   2   *
   3   * Subversion based package repository and package manager
   4   * sk, cx, danstowell, LFSaw
   5   *
   6   *  this is the interface class for
   7   *   accessing the SVN repository, (eg. the sourceforge quarks project)
   8   *   downloading those to the local quarks folder (Platform.userAppSupportDir/quarks)
   9   *   installing individual quarks by symlinking from the local quark folder into the [Platform dependent]/Extensions folder
  10   *
  11   */
  12
  13
  14 Quarks
  15 {
  16         classvar global, <allInstances, <known;
  17         var <repos, <local;
  18
  19         *global { ^(global ?? { global = this.new; }) }
  20
  21         *new { | reposPath, localPath |
  22                 var newQ;
  23                 if((this.known[reposPath].isNil.not) and: (this.known[reposPath] != localPath), {
  24                         ("The repository is in the list of known repositories, but with a different local path. You are recommended to use this local path:"
  25                                          + this.known[reposPath]).warn;
  26                 });
  27                 newQ = super.new.initQuarks(
  28                         reposPath,
  29                         localPath
  30                 );
  31                 allInstances.add(newQ);
  32                 ^newQ;
  33         }
  34         initQuarks{|reposPath, localPath|
  35                 local = LocalQuarks(localPath, this);
  36                 repos = QuarkSVNRepository(reposPath, local);
  37         }
  38
  39         *initClass {
  40                 Class.initClassTree( Platform );
  41                 allInstances = List(1);
  42                 known = Dictionary[
  43                         "https://quarks.svn.sourceforge.net/svnroot/quarks" -> (Platform.userAppSupportDir +/+ "quarks"),
  44                         "https://svn.sonenvir.at/svnroot/SonEnvir/trunk/src/quarks-sonenvir" -> (Platform.userAppSupportDir +/+ "quarks-sonenvir"),
  45                         "https://sc3-plugins.svn.sourceforge.net/svnroot/sc3-plugins/build" -> (Platform.userAppSupportDir +/+ "SC3plugins")
  46                         ];
  47         }
  48         *forUrl { |url|
  49                 var q;
  50                 this.global; // ensure the global one is constructed
  51                 q = allInstances.detect({|q| q.repos.url == url});
  52                 if(q.isNil && this.known[url].isNil.not, {
  53                         q = Quarks.new(url, this.known[url]);
  54                 });
  55                 ^q;
  56         }
  57
  58         update { |name|
  59                 var q;
  60                 if(name.notNil,{
  61                         if((q = local.findQuark(name)).isNil,{
  62                                 Error("Local Quark "+name+" not found, cannot update from repository").throw;
  63                         });
  64                         repos.svn("update", (local.path+/+q.path).escapeChar($ ));
  65                 },{
  66                         //update all
  67                         repos.update(local)
  68                 });
  69         }
  70         /*add { |name|
  71                 // this should create or manage the directory file too if it exists
  72                 var q;
  73                 if((q = local.findQuark(name)).isNil,{
  74                         Error("Local Quark code not found, cannot add to repository").throw;
  75                 });
  76                 repos.svn("add",local.path++"/"++q.path);
  77         }*/
  78         commit { |name,message|
  79                 var q;
  80                 if((q = local.findQuark(name)).isNil,{
  81                         Error("Local Quark code not found, cannot commit to repository").throw;
  82                 });
  83                 if(message.isNil,{
  84                         Error("svn log message required to commit").throw;
  85                 });
  86                 repos.svn("commit","-m",message,"-F",local.path +/+ q.path);
  87         }
  88         // TODO: Deprecate "checkoutDirectory" - "updateDirectory" can be used whether or not there's an existing one
  89         checkoutDirectory {
  90                 "Please wait for directory to be checked out.".postln;
  91                 ^this.updateDirectory
  92         }
  93         updateDirectory {
  94                 repos.updateDirectory
  95         }
  96
  97         listCheckedOut {
  98                 this.checkedOut.do { |q| q.postDesc };
  99         }
 100         listAvailable {
 101                 this.repos.quarks.do { |q| q.postDesc };
 102         }
 103
 104         checkoutAll { repos.checkoutAll(local.path) }
 105         checkout { |name, version, sync=false|
 106                 var q;
 107                 if(local.findQuark(name,version).notNil,{
 108                         inform("Quark "++name++" already checked out");
 109                         ^this
 110                 });
 111
 112                 q = repos.findQuark(name,version);
 113                 if(q.isNil,{
 114                         Error("Quark not found in repository.").throw;
 115                 });
 116                 repos.checkout(q, local.path, sync);
 117         }
 118         // DEPRECATED because it has a different and confusing functionality w.r.t. QuarkSVNRepos.checkDir
 119         checkDir {
 120                 var d;
 121                 "Quarks.checkDir is deprecated".warn;
 122                 d = (Platform.userExtensionDir +/+ local.name).escapeChar($ );
 123                 if(d.pathMatch.isEmpty,{
 124                         ("creating: " + d).inform;
 125                         d.mkdir;
 126                 });
 127         }
 128         checkedOut {
 129                 ^local.quarks
 130         }
 131         status { |name|
 132                 var q;
 133                 if(name.notNil,{
 134                         q = local.findQuark(name);
 135                         repos.svn("status",(local.path +/+ q.path).escapeChar($ ));
 136                 },{
 137                         repos.svn("status",local.path.escapeChar($ ));
 138                 });
 139         }
 140         installed {
 141                 // of quarks in local, select those also present in userExtensionDir
 142                 ^local.quarks.select{|q|
 143                         (Platform.userExtensionDir.escapeChar($ )
 144                                 +/+ local.name
 145                                 +/+ q.path
 146                         ).pathMatch.notEmpty
 147                 }
 148         }
 149         install { | name , includeDependencies=true, checkoutIfNeeded=true |
 150                 var q, deps, installed, dirname, quarksForDep;
 151
 152                 if(this.isInstalled(name),{
 153                         (name + "already installed").inform;
 154                         ^this
 155                 });
 156
 157                 q = local.findQuark(name);
 158                 if(q.isNil,{
 159                         if(checkoutIfNeeded) {
 160                                 (name.asString + " not found in local quarks; checking out from remote ...").postln;
 161                                 this.checkout(name, sync: true);
 162                                 q = local.reread.findQuark(name);
 163                                 if(q.isNil, {
 164                                         Error("Quark" + name + "install: checkout failed.").throw;
 165                                 });
 166                         }
 167                         {
 168                                 Error(name.asString + "not found in local quarks.  Not yet downloaded from the repository ?").throw;
 169                         };
 170                 });
 171
 172                 if(q.isCompatible.not,{
 173                         (q.name + " reports that it is not compatible with your current class library.  See the help file for further information.").inform;
 174                         ^this
 175                 });
 176
 177                 // create /quarks/ directory if needed
 178                 if(this.repos.checkDir.not){this.checkoutDirectory};
 179
 180                 // Now ensure that the dependencies are installed (if available given the current active reposses)
 181                 if(includeDependencies, {
 182                         q.dependencies(true).do({ |dep|
 183                                 quarksForDep = if(dep.repos.isNil, {this}, {Quarks.forUrl(dep.repos)});
 184                                 if(quarksForDep.isNil, {
 185                                         ("Quarks:install - unable to find repository for dependency '" ++ dep.name
 186                                                 ++ "' - you may need to satisfy this dependency manually. No repository detected locally with URL "++dep.repos).warn;
 187                                 }, {
 188                                         if(quarksForDep.isInstalled(dep.name).not, {
 189                                                 try({
 190                                                         quarksForDep.install(dep.name, false, checkoutIfNeeded)
 191                                                 }, {
 192                                                         ("Unable to satisfy dependency of '"++name++"' on '"++dep.name
 193                                                                 ++"' - you may need to install '"++dep.name++"' manually.").warn;
 194                                                 });
 195                                         });
 196                                 });
 197                         });
 198                 });
 199
 200                 // Ensure the correct folder-hierarchy exists first
 201                 dirname = (Platform.userExtensionDir +/+  local.name +/+ q.path).dirname;
 202                 if(File.exists(dirname).not, {
 203                         dirname.mkdir
 204                 });
 205
 206                 // install via symlink to Extensions/<quarks-dir>
 207                 ("ln -s " +  (local.path +/+ q.path).escapeChar($ ) +  (Platform.userExtensionDir +/+ local.name +/+ q.path).escapeChar($ )).systemCmd;
 208                 (q.name + "installed").inform;
 209         }
 210         listInstalled {
 211                 this.installed.do { |q| q.postDesc };
 212         }
 213         isInstalled { arg name;
 214                 ^this.installed.detect{|quark| quark.name == name }.notNil
 215         }
 216         uninstall { | name |
 217                 var q, deps, installed;
 218                 name = name.asString;
 219                 if(this.isInstalled(name).not,{
 220                         ^this
 221                 });
 222
 223                 q = local.findQuark(name);
 224                 if(q.isNil,{
 225                         Error(
 226                                 name +
 227                                 "is not found in Local quarks in order to look up its relative path.  You may remove the symlink manually."
 228                         ).throw;
 229                 });
 230
 231                 // install via symlink to Extensions/Quarks
 232                 ("rm " +  (Platform.userExtensionDir +/+ local.name +/+ q.path).escapeChar($ )).systemCmd;
 233                 (q.name + "uninstalled").inform;
 234         }
 235
 236         help { |name|
 237                 var q;
 238
 239                 q = local.findQuark(name);
 240                 if(q.isNil,{
 241                         Error(
 242                                 name.asString +
 243                                 "not found in local quarks.  Not yet downloaded from the repository ?"
 244                         ).throw;
 245                 });
 246
 247                 q.openHelpFile;
 248         }
 249
 250         name { ^local.name }
 251
 252         ///// convenience methods for Quarks.global
 253
 254         *checkoutAll { this.global.repos.checkoutAll(this.global.local.path) }
 255         *checkout { | name, version, sync | this.global.checkout(name,version, sync); }
 256
 257         /*
 258          return Quark objects for each in App Support/SuperCollider/Quarks
 259          (so actually this would list any Quarks that are in local development
 260          and not yet checked in) */
 261         *checkedOut { ^this.global.checkedOut }
 262         *listCheckedOut {
 263                 this.checkedOut.do { |q| q.postDesc };
 264         }
 265         *listAvailable {
 266                 this.global.listAvailable
 267         }
 268         /*
 269           download/update only the quark specification files from remote repos
 270           and not the quarks themselves */
 271         *updateDirectory {
 272                 ^this.global.repos.updateDirectory
 273         }
 274         *checkoutDirectory {
 275                 ^this.global.checkoutDirectory
 276         }
 277         *update { |quarkName| this.global.update(quarkName) }
 278
 279         /*
 280           this symlinks from {App Support}/SuperCollider/Quarks to
 281           {App Support}/SuperCollider/Extensions
 282           it is then in the SC compile path */
 283         *install { |name, includeDependencies=true, checkoutIfNeeded=true|
 284                 this.global.install(name, includeDependencies, checkoutIfNeeded)
 285         }
 286
 287         /*
 288           return Quark objects for each installed */
 289         *installed { ^this.global.installed }
 290         *listInstalled { ^this.global.listInstalled }
 291         *isInstalled { |name| ^this.global.isInstalled(name) }
 292         /*
 293           removes the symlink */
 294         *uninstall { |name| ^this.global.uninstall(name) }
 295
 296         /*
 297           add code in {App Support}/SuperCollider/Quarks to the remote repos
 298           and also adds the quarks file in DIRECTORY */
 299         //*add { |name| this.global.add(name) }
 300         /*
 301           you may also use standard svn tools within {App Support}/SuperCollider/Quarks */
 302         *commit { |name,message| this.global.commit(name,message) }
 303         // post the SVN status
 304         *status { |name| this.global.status(name) }
 305
 306         *local { ^this.global.local }
 307         *repos { ^this.global.repos }
 308         *help  {|name| ^this.global.help(name) }
 309         *gui { ^this.global.gui }
 310
 311         gui {
 312                 if( GUI.id === \qt ) { ^QuarksViewQt(this) } { ^QuarksView(this) }
 313         }
 314 }
 315
 316 // a gui for Quarks. 2007 by LFSaw.de
 317 QuarksView {
 318         var quarksCtrl, quarks;
 319
 320         var window, caption, explanation, views, resetButton, saveButton, warning,
 321                 scrollview, scrB, flowLayout, /* quarksflow, */ height, maxPerPage, nextButton, prevButton;
 322
 323         *new { |quarksCtrl| ^super.new.init(quarksCtrl) }
 324
 325         init { |q|
 326                 var pageStart = 0, fillPage;
 327
 328                 quarksCtrl = q;
 329
 330                 fillPage = { |start|
 331                         scrollview.visible = false;
 332                         views.notNil.if({
 333                                 views.do({ |view| view.remove });
 334                         });
 335                         scrollview.decorator.reset;
 336                         views = quarks.collect{|quark|
 337                                 var qView = QuarkView.new(scrollview, 500@20, quark,
 338                                         quarksCtrl.installed.detect{|it| it == quark}.notNil);
 339                                 scrollview.decorator.nextLine;
 340                                 qView;
 341                         };
 342                         scrollview.visible = true;
 343                         views
 344                 };
 345
 346                 // note, this doesn't actually contact svn
 347                 // it only reads the DIRECTORY entries you've already checked out
 348                 quarks = quarksCtrl.repos.quarks.copy;
 349
 350                 scrB = GUI.window.screenBounds;
 351                 height = min(quarks.size * 25 + 120, scrB.height - 60);
 352
 353                 window = GUI.window.new(quarksCtrl.name, Rect.aboutPoint( scrB.center, 250, height.div( 2 )));
 354                 flowLayout = FlowLayout( window.view.bounds );
 355                 window.view.decorator = flowLayout;
 356
 357                 caption = GUI.staticText.new(window, Rect(20,15,400,30));
 358                 caption.font_( Font.sansSerif( 24 ));
 359                 caption.string = quarksCtrl.name;
 360                 window.view.decorator.nextLine;
 361
 362                 if ( quarks.size == 0 ){
 363                         GUI.button.new(window, Rect(0, 0, 229, 20))
 364                         .states_([["checkout Quarks DIRECTORY", nil, Color.gray(0.5, 0.8)]])
 365                         .action_({ quarksCtrl.checkoutDirectory; });
 366                 }{
 367                         GUI.button.new(window, Rect(0, 0, 229, 20))
 368                         .states_([["update Quarks DIRECTORY", nil, Color.gray(0.5, 0.8)]])
 369                         .action_({ quarksCtrl.updateDirectory;});
 370                 };
 371
 372                 GUI.button.new(window, Rect(0, 0, 200, 20))
 373                 .states_([["refresh Quarks listing", nil, Color.gray(0.5, 0.8)]])
 374                 .action_({
 375                         window.close;
 376                         quarksCtrl.gui;
 377                 });
 378
 379                 window.view.decorator.nextLine;
 380
 381                 GUI.button.new(window, Rect(0, 0, 150, 20))
 382                         .states_([["browse all help", nil, Color.gray(0.5, 0.8)]])
 383                         .action_({ HelpBrowser.openBrowsePage("Quarks") });
 384
 385                 GUI.button.new(window, Rect(15,15,150,20))
 386                 .states_([["open quark directory", nil, Color.gray(0.5, 0.8)]])
 387                 .action_{ arg butt;
 388                         openOS(quarksCtrl.local.path.escapeChar($ ))
 389                 };
 390
 391                 resetButton = GUI.button.new(window, Rect(15,15,75,20));
 392                 resetButton.states = [
 393                         ["reset", nil, Color.gray(0.5, 0.8)]
 394                 ];
 395                 resetButton.action = { arg butt;
 396                         views.do(_.reset);
 397                 };
 398
 399                 saveButton = GUI.button.new(window, Rect(15,15,75,20));
 400                 saveButton.states = [
 401                         ["save", nil, Color.blue(1, 0.5)]
 402                 ];
 403                 saveButton.action = { arg butt;
 404                         Task{
 405                                 warning.string = "Applying changes, please wait";
 406                                 warning.background_(Color(1.0, 1.0, 0.9));
 407                                 0.1.wait;
 408                                 views.do{|qView|
 409                                         qView.toBeInstalled.if({
 410                                                 quarksCtrl.install(qView.quark.name);
 411                                                 qView.flush
 412                                         });
 413                                         qView.toBeDeinstalled.if({
 414                                                 quarksCtrl.uninstall(qView.quark.name);
 415                                                 qView.flush;
 416                                         })
 417                                 };
 418                                 warning.string = "Done. You should now recompile sclang";
 419                                 warning.background_(Color(0.9, 1.0, 0.9));
 420                         }.play(AppClock);
 421                 };
 422
 423                 window.view.decorator.nextLine;
 424                 explanation = GUI.staticText.new(window, Rect(20,15,500,20));
 425                 explanation.string = "\"+\" -> installed, \"-\" -> not installed, \"*\" -> marked to install, \"x\" -> marked to uninstall";
 426                 window.view.decorator.nextLine;
 427
 428                 warning = GUI.staticText.new(window, Rect(20,15,400,30));
 429                 warning.font_( Font.sansSerif( 18 ));
 430
 431                 window.view.decorator.nextLine;
 432                 GUI.staticText.new( window, 492 @ 1 ).background_( Color.grey );
 433                 window.view.decorator.nextLine;
 434
 435                 flowLayout.margin_( 0 @0 ).gap_( 0@0 );
 436                 scrollview = GUI.scrollView.new(window, 500 @ (height - 165))
 437                         .resize_( 5 )
 438                         .autohidesScrollers_(true);
 439                 scrollview.decorator = FlowLayout( Rect( 0, 0, 500, quarks.size * 25 + 20 ));
 440
 441                 window.front;
 442                 fillPage.(pageStart);
 443                 ^window;
 444         }
 445 }
 446
 447 QuarksViewQt {
 448         var quarksCtrl;
 449
 450         var window, lblCaption,
 451                 btnUpdate, btnHelp, btnUpdateQuarks, btnOpenDir, btnReset, btnApply,
 452                 lblStatus, lblExplanation, quarksView,
 453                 infoView, btnQuarkHelp, btnQuarkOpen, btnQuarkClasses,
 454                 btnQuarkMethods, txtDescription, btnCloseDetails;
 455         var quarks, views, curQuark;
 456         var refresh, msgWorking, msgDone;
 457         var screen, palette, gizmo;
 458
 459         *new { |quarksCtrl| ^super.new.init(quarksCtrl) }
 460
 461         init { |q|
 462                 quarksCtrl = q;
 463
 464                 refresh = {
 465                         quarksView.invokeMethod( \clear );
 466                         quarks = quarksCtrl.repos.quarks.copy;
 467                         quarksView.canSort = false;
 468                         views = quarks.collect{|quark|
 469                                 var qView = QuarkViewQt.new(quarksView, quark,
 470                                         quarksCtrl.installed.detect{|it| it == quark}.notNil);
 471                                 qView;
 472                         };
 473                         quarksView.canSort = true;
 474                         quarksView.sort( 1 );
 475                         quarksView.invokeMethod( \resizeColumnToContents, 0 );
 476                         quarksView.invokeMethod( \resizeColumnToContents, 1 );
 477                         views
 478                 };
 479
 480                 msgWorking = { arg msg;
 481                         lblStatus.background = palette.button.blend(Color.yellow,0.2);
 482                         lblStatus.string = msg;
 483                 };
 484
 485                 msgDone =  { arg msg;
 486                         lblStatus.background = palette.button.blend(Color.green,0.2);
 487                         lblStatus.string = msg;
 488                 };
 489
 490                 palette = GUI.current.palette;
 491                 screen = Window.flipY(Window.availableBounds);
 492                 window = Window( quarksCtrl.name, Rect( 0, 0, 700, screen.height * 0.9 ).center_(screen.center) );
 493
 494                 lblCaption = StaticText().font_( GUI.font.new(size:16,usePointSize:true) ).string_(quarksCtrl.name);
 495
 496                 btnUpdate = Button()
 497                         .states_([["Update Quark Listing"]])
 498                         .toolTip_("Download the latest information and update the Quarks listing")
 499                         .action_({
 500                                 quarksView.enabled = false;
 501                                 msgWorking.value("Downloading the latest information...");
 502                                 AppClock.sched( 0.2, {
 503                                         protect {
 504                                                 quarksCtrl.updateDirectory;
 505                                         } {
 506                                                 refresh.value;
 507                                                 quarksView.enabled = true;
 508                                                 msgDone.value("Quarks listing has been updated with the latest information.")
 509                                         }
 510                                 });
 511                                 nil
 512                         });
 513
 514                 btnUpdateQuarks = Button()
 515                         .states_([["Update Quarks"]])
 516                         .toolTip_("Update installed Quarks")
 517                         .action_({
 518                                 quarksView.enabled = false;
 519                                 msgWorking.value("Updating installed Quarks...");
 520                                 AppClock.sched( 0.2, {
 521                                         protect {
 522                                                 quarksCtrl.update;
 523                                         } {
 524                                                 refresh.value;
 525                                                 quarksView.enabled = true;
 526                                                 msgDone.value("Quarks have been updated." +
 527                                                         " You should recompile the class library for changes to take effect.")
 528                                         }
 529                                 });
 530                                 nil
 531                         });
 532
 533                 btnHelp = Button().states_([["Help"]])
 534                         .toolTip_("Browse help for all the Quarks")
 535                         .action_({ HelpBrowser.openBrowsePage("Quarks") });
 536
 537                 btnOpenDir = Button().states_([["Directory"]])
 538                         .toolTip_("Open the local Quarks directory")
 539                         .action_({ openOS(quarksCtrl.local.path) });
 540
 541                 btnReset = Button()
 542                         .states_([["Reset"]])
 543                         .toolTip_("Clear the marked changes")
 544                         .action_({ arg butt; views.do(_.reset) });
 545
 546                 btnApply = Button().states_([["Apply",nil,Color.blue.blend(palette.button,0.6)]])
 547                         .toolTip_("Apply the marked changes")
 548                         .action_({ arg butt;
 549                                 quarksView.enabled = false;
 550                                 msgWorking.value("Applying changes, please wait...");
 551                                 AppClock.sched( 0.2, {
 552                                         protect {
 553                                                 views.do{|qView|
 554                                                         qView.toBeInstalled.if({
 555                                                                 quarksCtrl.install(qView.quark.name);
 556                                                                 qView.flush
 557                                                         });
 558                                                         qView.toBeDeinstalled.if({
 559                                                                 quarksCtrl.uninstall(qView.quark.name);
 560                                                                 qView.flush;
 561                                                         })
 562                                                 };
 563                                         } {
 564                                                 msgDone.value("Changes applied." +
 565                                                         "You should recompile the class library for changes to take effect."
 566                                                 );
 567                                                 quarksView.enabled = true;
 568                                         }
 569                                 });
 570                         });
 571
 572                 lblExplanation = StaticText().string_(
 573                         "\"+\" installed, \"-\" not installed, \"*\" to install, \"x\" to uninstall"
 574                 );
 575
 576                 lblStatus = StaticText().font_( GUI.font.new( size:12, usePointSize:true ) );
 577
 578                 quarksView = TreeView()
 579                         .setProperty( \rootIsDecorated, false )
 580                         .columns_([nil,"Name","Summary"])
 581                         .itemPressedAction_({ |v|
 582                                 infoView.visible = true;
 583                         })
 584                         .onItemChanged_({ |v|
 585                                 var curItem, curView, inst;
 586                                 curItem = v.currentItem;
 587                                 curQuark = nil;
 588                                 if( curItem.notNil ) {
 589                                         curView = views.detect { |view| view.treeItem == curItem };
 590                                         if( curView.notNil ) {
 591                                                 curQuark = curView.quark;
 592                                                 txtDescription.string = curQuark.longDesc;
 593                                                 btnQuarkOpen.enabled = curQuark.isLocal;
 594                                                 inst = quarksCtrl.installed.detect{|it| it == curQuark}.notNil;
 595                                                 btnQuarkClasses.enabled = inst;
 596                                                 btnQuarkMethods.enabled = inst;
 597                                         }
 598                                 }{
 599                                         infoView.visible = false
 600                                 }
 601                         });
 602
 603                 txtDescription = TextView(bounds:10@10)
 604                         .font_( GUI.font.new( size:10, usePointSize:true ) )
 605                         .tabWidth_(15)
 606                         .autohidesScrollers_( true )
 607                         .hasVerticalScroller_( true )
 608                         .editable_( false )
 609                         //.minSize_(Size(0,0));
 610                         .minHeight_(50);
 611
 612                 btnQuarkHelp = Button()
 613                         .states_([["Help"]])
 614                         .toolTip_("Show help for this Quark")
 615                         .action_({
 616                                 curQuark.openHelpFile
 617                         });
 618
 619                 btnQuarkOpen = Button()
 620                         .states_([["Source"]])
 621                         .toolTip_("Open the source directory of this Quark")
 622                         .action_({
 623                                 openOS( "%/%".format(Quarks.local.path, curQuark.path) );
 624                         });
 625
 626                 btnQuarkClasses = Button()
 627                         .states_([["Classes"]])
 628                         .toolTip_("Show list of classes defined by this Quark")
 629                         .enabled_(false)
 630                         .action_({
 631                                 var cls = curQuark.definesClasses;
 632                                 var tree, item, buts = [
 633                                         Button().states_([["Browse"]]).action_({
 634                                                 cls[item.index].browse;
 635                                         }),
 636                                         Button().states_([["Help"]]).action_({
 637                                                 cls[item.index].openHelpFile;
 638                                         }),
 639                                         Button().states_([["Source"]]).action_({
 640                                                 cls[item.index].openCodeFile;
 641                                         })
 642                                 ];
 643                                 buts.do(_.enabled_(false));
 644                                 Window("% Classes".format(curQuark.name)).layout_(
 645                                         VLayout(
 646                                                 tree = TreeView()
 647                                                         .setProperty( \rootIsDecorated, false )
 648                                                         .columns_(["Classes"])
 649                                                         .onItemChanged_({|v| item = v.currentItem}),
 650                                                 HLayout(*buts)
 651                                         )
 652                                 ).front;
 653                                 if(cls.size>0) {
 654                                         cls.do {|c| tree.addItem([c.name.asString])};
 655                                         tree.itemPressedAction = { buts.do(_.enabled_(true)) }
 656                                 } {
 657                                         tree.addItem(["No classes"]);
 658                                 };
 659                                 tree.invokeMethod( \resizeColumnToContents, 0 );
 660                         });
 661
 662                 btnQuarkMethods = Button()
 663                         .states_([["Ext methods"]])
 664                         .toolTip_("Show list of extension methods added by this Quark")
 665                         .enabled_(false)
 666                         .action_({
 667                                 var mets = curQuark.definesExtensionMethods;
 668                                 var tree, item, buts = [
 669                                         Button().states_([["Browse"]]).action_({
 670                                                 mets[item.index].ownerClass.browse;
 671                                         }),
 672                                         Button().states_([["Help"]]).action_({
 673                                                 mets[item.index].openHelpFile;
 674                                         }),
 675                                         Button().states_([["Source"]]).action_({
 676                                                 mets[item.index].openCodeFile;
 677                                         })
 678                                 ];
 679                                 buts.do(_.enabled_(false));
 680                                 Window("% Extension Methods".format(curQuark.name)).layout_(
 681                                         VLayout(
 682                                                 tree = TreeView()
 683                                                         .setProperty( \rootIsDecorated, false )
 684                                                         .columns_(["Class","Method"])
 685                                                         .onItemChanged_({|v| item = v.currentItem}),
 686                                                 HLayout(*buts)
 687                                         )
 688                                 ).front;
 689                                 if(mets.size>0) {
 690                                         mets.collect{|m|
 691                                                 var x = m.ownerClass.name;
 692                                                 tree.addItem(if(x.isMetaClassName) {[x.asString[5..],"*"++m.name]} {[x.asString,"-"++m.name]});
 693                                         };
 694                                         tree.itemPressedAction = { buts.do(_.enabled_(true)) }
 695                                 } {
 696                                         tree.addItem([nil,"No extension methods"]);
 697                                 };
 698                                 tree.invokeMethod( \resizeColumnToContents, 0 );
 699                                 tree.invokeMethod( \resizeColumnToContents, 1 );
 700                         });
 701
 702                 btnCloseDetails = StaticText()
 703                         .string_("X")
 704                         .align_(\center)
 705                         .toolTip_("Hide Quark information panel")
 706                         .mouseDownAction_({
 707                                 infoView.visible = false;
 708                         });
 709                 gizmo = btnCloseDetails.sizeHint;
 710                 gizmo.width = gizmo.width + 20;
 711                 btnCloseDetails.fixedSize = gizmo;
 712
 713                 infoView = View();
 714                 infoView.layout = VLayout(
 715                         HLayout( btnCloseDetails, btnQuarkHelp, btnQuarkOpen, btnQuarkClasses, btnQuarkMethods, nil ).margins_(0),
 716                         txtDescription
 717                 ).spacing_(0).margins_(0);
 718                 infoView.visible = false;
 719
 720                 window.layout =
 721                         VLayout(
 722                                 lblCaption,
 723                                 HLayout( btnUpdate, btnUpdateQuarks, btnOpenDir, btnHelp, nil ),
 724                                 lblStatus,
 725                                 HLayout( btnReset, btnApply, [lblExplanation, s:1] ).margins_(0),
 726                                 [quarksView, s:5],
 727                                 [infoView, s:2]
 728                         );
 729
 730                 refresh.value;
 731                 window.front;
 732                 ^window;
 733         }
 734 }