installer/ui/Main.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * duit is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with duit; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 module ui.Main;
  20
  21 //version = leds;
  22 version = duitdev;
  23 version = duittest;
  24 //version = difiles
  25 //version = compiler;
  26 version(linux)
  27 {
  28         version = duitgl;
  29         version = duitgltest;
  30 }
  31 version = dmd;
  32 //version = gdc;
  33
  34 private import ui.Installer;
  35
  36 private import ui.duitLogo;
  37
  38 private import gtk.Duit;
  39 private import gtk.Alignment;
  40 private import gtk.MainWindow;
  41 private import gtk.VBox;
  42 private import gtk.HBox;
  43 private import gtk.Button;
  44 private import gtk.Label;
  45 private import gtk.Frame;
  46 private import gtk.ButtonBox;
  47 private import gtk.HButtonBox;
  48 private import gtk.Entry;
  49 private import gtk.CheckButton;
  50 private import gtk.Notebook;
  51 private import gtk.Widget;
  52 private import gtk.Image;
  53 private import gtk.gtktypes;
  54 private import gtk.SizeGroup;
  55
  56 private import gdk.Event;
  57 private import std.stdio;
  58
  59 private import std.c.stdlib;
  60 private import std.string;
  61
  62 interface InstallerUI
  63 {
  64         void setUserPanel(UserPanel panel);
  65         void addSelection(char[] id, CheckButton check);
  66         CheckButton getSelectionButton(char[] id);
  67         bool getSelection(char[] id);
  68         void setSelection(char[] id, bool state);
  69         void setSensitive(char[] id, bool state);
  70
  71         void addDirectory(char[] id, Entry entry);
  72         char[] getDirectory(char[] id);
  73         void setDirectory(char[] id, char[] value);
  74
  75         //void nextPanel();
  76         //void prevPanel();
  77 }
  78
  79 public class MainInstaller : MainWindow , InstallerUI
  80 {
  81
  82         HBox topBox;
  83         VBox leftBox;
  84         VBox tasksBox;
  85         VBox mainBox;
  86         Notebook notebook;
  87         ButtonBox buttonBox;
  88
  89         Button backButton;
  90         Button nextButton;
  91         Button exitButton;
  92         Button installButton;
  93
  94         UserPanel[] userPanels;
  95         UserPanel currentUserPanel;
  96         CheckButton[char[]] selections;
  97         Entry[char[]] directories;
  98
  99         int movingDirection;    // going back or next, 0=don't know
 100
 101         this()
 102         {
 103                 super("Duit and Leds installer");
 104                 setup();
 105                 addPanels();
 106                 setUserPanel(0);
 107                 showAll();
 108         }
 109
 110         public void addSelection(char[] id, CheckButton check)
 111         {
 112                 selections[id] = check;
 113         }
 114
 115         public CheckButton getSelectionButton(char[] id)
 116         {
 117                 CheckButton check;
 118                 if ( id in selections )
 119                 {
 120                         check = selections[id];
 121                 }
 122                 return check;
 123         }
 124
 125         public bool getSelection(char[] id)
 126         {
 127                 if ( id in selections )
 128                 {
 129                         return cast(bool)selections[id].getActive();
 130                 }
 131                 return false;
 132         }
 133         public void setSelection(char[] id, bool active)
 134         {
 135                 if ( id in selections )
 136                 {
 137                         selections[id].setActive(active);
 138                 }
 139         }
 140         public void setSensitive(char[] id, bool active)
 141         {
 142                 if ( id in selections )
 143                 {
 144                         selections[id].setSensitive(active);
 145                 }
 146         }
 147
 148         public void addDirectory(char[] id, Entry entry)
 149         {
 150                 directories[id] = entry;
 151         }
 152         public char[] getDirectory(char[] id)
 153         {
 154                 if ( id in directories )
 155                 {
 156                         return directories[id].getText();
 157                 }
 158                 return null;
 159         }
 160         public void setDirectory(char[] id, char[] value)
 161         {
 162                 if ( id in directories )
 163                 {
 164                         return directories[id].setText(value);
 165                 }
 166         }
 167
 168         public void nextPanel()
 169         {
 170                 movingDirection = 1;
 171                 notebook.nextPage();
 172                 setUserPanel(notebook.getCurrentPage());
 173         }
 174
 175         public void prevPanel()
 176         {
 177                 movingDirection = -1;
 178                 notebook.prevPage();
 179                 setUserPanel(notebook.getCurrentPage());
 180         }
 181
 182 private import gtk.HSeparator;
 183         private void setup()
 184         {
 185                 topBox = new HBox(false, 2);
 186                 leftBox = new VBox(false, 7);
 187                 tasksBox = new VBox(false, 7);
 188                 mainBox = new VBox(false, 2);
 189                 notebook = new Notebook;
 190                 notebook.setShowTabs(false);
 191                 notebook.setSizeRequest(400,300);
 192                 buttonBox = HButtonBox.createActionBox();
 193
 194                 exitButton = makeButton(null, StockID.QUIT, "Exit", "exit");
 195                 buttonBox.packStart(Alignment.west(exitButton), true, true, 7);
 196
 197                 backButton = makeButton(buttonBox, StockID.GO_BACK, "Back", "back");
 198                 nextButton = makeButton(buttonBox, StockID.GO_FORWARD, "Next", "next");
 199                 installButton = makeButton(buttonBox, StockID.OK, "Install", "install");
 200
 201 //              Button logo = new Button();
 202 //              logo.setImage(getDuitLogo());
 203 //              logo.addOnButtonPress(&logoClicked);
 204 //              logo.setRelief(ReliefStyle.NONE);
 205 //              logo.setFocusOnClick(false);
 206
 207                 mainBox.packStart(Alignment.west(getDuitLogo()), false, false, 2);
 208                 mainBox.packStart(notebook, true, true, 2);
 209                 mainBox.packStart(buttonBox, false, false, 2);
 210
 211                 topBox.packStart(new Frame(tasksBox,""), false, false, 2);
 212                 topBox.packStart(mainBox, true, true, 2);
 213
 214                 add(topBox);
 215         }
 216
 217 private import gtk.PopupBox;
 218
 219         private int logoClicked(GdkEventButton* event, Widget widget)
 220         {
 221
 222                 PopupBox.information(this, "Help with the graphics design is apreciated", "DuitLogo");
 223                 return false;
 224         }
 225
 226         private Button makeButton(ButtonBox box,StockID id, char[] label, char[] action)
 227         {
 228                 Button button = new Button();
 229                 button.setActionName(action);
 230                 button.removeAll();
 231                 button.setImage(new Image(id, IconSize.BUTTON));
 232                 button.setLabel(label);
 233                 if ( box !is null )
 234                 {
 235                         box.packStart(button, false, false, 7);
 236                 }
 237                 button.addOnClicked(&userActions);
 238                 return button;
 239         }
 240
 241         private void addPanels()
 242         {
 243                 addPanel(new SelectionsPanel(this));
 244                 version(duitdev)addPanel(new DevPanel(this));
 245                 version(leds)   addPanel(new LedsPanel(this));
 246                 version(compiler)       addPanel(new MainCompilerPanel(this));
 247                 addPanel(new LocalPanel(this));
 248                 addPanel(new InstallPanel(this));
 249         }
 250
 251         CheckButton[char[]] tasksList;
 252
 253         private void addPanel(UserPanel userPanel)
 254         {
 255                 notebook.appendPage(userPanel.getWidget(), userPanel.getName());
 256
 257                 HBox hbox = new HBox(false, 1);
 258                 CheckButton check = new CheckButton();
 259                 hbox.packStart(check, false, false, 4);
 260
 261                 hbox.packStart(Alignment.west(new Label(userPanel.getName())), false, false, 4);
 262                 tasksBox.packStart(hbox, false, false, 4);
 263                 tasksList[userPanel.getName()] = check;
 264                 check.setSensitive(false);
 265                 userPanels ~= userPanel;
 266         }
 267
 268         private void userActions(Button button)
 269         {
 270                 char[] action = button.getActionName();
 271                 switch ( action )
 272                 {
 273                         case "exit":
 274                                 Duit.exit(0);
 275                                 break;
 276
 277                         case "back":
 278                                 prevPanel();
 279                                 break;
 280
 281                         case "next":
 282                                 nextPanel();
 283                                 break;
 284
 285                         case "install":
 286                                 hide();
 287                                 new Installer(this);
 288                                 break;
 289
 290                         default:
 291                                 writefln("userAction = %s", action);
 292                                 break;
 293
 294                 }
 295         }
 296
 297         private void setUserPanel(uint number)
 298         {
 299                 if ( number < userPanels.length )
 300                 {
 301                         UserPanel panel = userPanels[number];
 302                         setUserPanel(panel);
 303                 }
 304         }
 305
 306         public void setUserPanel(UserPanel panel)
 307         {
 308                 if ( currentUserPanel !is null )
 309                 {
 310                         currentUserPanel.exited();
 311                 }
 312                 while ( !panel.selected()
 313                                 && movingDirection != 0
 314                                 )
 315                 {
 316                         if ( movingDirection > 0 )
 317                         {
 318                                 nextPanel();
 319                         }
 320                         else
 321                         {
 322                                 prevPanel();
 323                         }
 324                         return;
 325                 }
 326                 backButton.setSensitive(panel.allowBack());
 327                 nextButton.setSensitive(panel.allowNext());
 328                 bool allowInstall = true;
 329                 foreach ( UserPanel userPanel ; userPanels )
 330                 {
 331                         if ( !userPanel.complete() )
 332                         {
 333                                 allowInstall = false;
 334                         }
 335                         if ( userPanel.getName in tasksList )
 336                         {
 337                                 tasksList[userPanel.getName()].setActive(userPanel.complete());
 338                         }
 339                 }
 340                 installButton.setSensitive(allowInstall);
 341                 currentUserPanel = panel;
 342         }
 343 }
 344
 345 class UserPanel
 346 {
 347         InstallerUI installerUI;
 348
 349         bool completed = false;
 350
 351
 352
 353         abstract Widget getWidget();
 354         abstract char[] getName();
 355         public this(InstallerUI installerUI)
 356         {
 357                 this.installerUI = installerUI;
 358
 359         }
 360         public bool allowNext()
 361         {
 362                 return true;
 363         }
 364         public bool allowBack()
 365         {
 366                 return true;
 367         }
 368         public bool selected()
 369         {
 370                 return true;
 371         }
 372         public bool exited()
 373         {
 374                 return selected();
 375         }
 376         public bool complete()
 377         {
 378                 return completed;
 379         }
 380
 381         protected HBox newSelection(char[] selection, char[] id)
 382         {
 383                 HBox box = new HBox(false, 2);
 384
 385                 Button button = new Button(StockID.HELP, &userHelp, true);
 386                 button.setActionName(id);
 387                 button.setImage(new Image(StockID.HELP, IconSize.MENU));
 388                 CheckButton check = new CheckButton(selection, &userSelection);
 389                 check.setActionName(id);
 390
 391                 box.packStart(button, false, false, 2);
 392                 box.packStart(check, false, false, 2);
 393                 installerUI.addSelection(id, check);
 394                 return box;
 395         }
 396
 397         protected HBox newDirectory(char[] label, char[] id, SizeGroup sizeGroup)
 398         {
 399                 HBox box = new HBox(false, 2);
 400                 Button button = new Button(StockID.HELP, &userHelp, true);
 401                 button.setActionName(id);
 402                 button.setImage(new Image(StockID.HELP, IconSize.MENU));
 403                 Entry entry = new Entry();
 404
 405                 box.packStart(button, false, false, 2);
 406                 Label l = new Label(label);
 407                 Alignment alig = Alignment.west(l);
 408                 sizeGroup.addWidget(alig);
 409                 box.packStart(alig, false, false, 2);
 410                 box.packStart(entry, true, true, 2);
 411                 button = new Button(StockID.INDEX, &userDirectory);
 412                 button.setActionName(id);
 413                 button.setLabel("Browse");
 414                 button.setImage(new Image(StockID.INDEX, IconSize.MENU));
 415                 box.packStart(button, false, false, 2);
 416                 installerUI.addDirectory(id, entry);
 417                 return box;
 418         }
 419
 420         void userSelection(CheckButton check)
 421         {
 422                 switch ( check.getActionName() )
 423                 {
 424
 425                         case "leds":
 426                                 bool active = cast(bool)check.getActive();
 427                                 installerUI.setSensitive("ledsDuit", active);
 428                                 installerUI.setSensitive("ledsLeds", active);
 429                                 installerUI.setSensitive("ledsDool", active);
 430                                 installerUI.setSensitive("ledsDante", active);
 431                                 installerUI.setSensitive("ledsPhobos", active);
 432                                 break;
 433
 434                         default:
 435                                 // nothing
 436                                 break;
 437                 }
 438         }
 439
 440         void userHelp(Button button)
 441         {
 442
 443         }
 444 private import gtk.FileChooserDialog;
 445 private import gtk.FileChooser;
 446         void userDirectory(Button button)
 447         {
 448                 char[] id = button.getActionName();
 449                 char[] dir = installerUI.getDirectory(id);
 450                 if ( dir != null )
 451                 {
 452                         FileChooserDialog chooserDialog = new FileChooserDialog(
 453                                                 "Select directory",
 454                                                 mainInstaller,
 455                                                 FileChooserAction.SELECT_FOLDER
 456                                                 );
 457                         FileChooser chooser = chooserDialog.getFileChooser();
 458                         chooser.setCurrentFolder(dir);
 459                         ResponseType response = cast(ResponseType)chooserDialog.run();
 460                         if ( response == ResponseType.GTK_RESPONSE_OK )
 461                         {
 462                                 installerUI.setDirectory(id, chooser.getCurrentFolder());
 463                         }
 464                         chooserDialog.hide(); // is it released ?
 465                 }
 466         }
 467 }
 468
 469 class SelectionsPanel : UserPanel
 470 {
 471         VBox vbox;
 472
 473         public this(InstallerUI installerUI)
 474         {
 475                 super(installerUI);
 476         }
 477         public char[] getName()
 478         {
 479                 return "Selections";
 480         }
 481         public Widget getWidget()
 482         {
 483                 if ( vbox is null )
 484                 {
 485                         vbox = new VBox(false, 2);
 486                         setup();
 487                 }
 488                 return vbox;
 489         }
 490
 491         public bool allowBack()
 492         {
 493                 return false;
 494         }
 495
 496         public bool selected()
 497         {
 498                 completed = true;
 499                 return true;
 500         }
 501
 502         private void setup()
 503         {
 504                 vbox.packStart(new Label("Select the components to install"), false, false, 14);
 505                 vbox.packStart(newSelection("Install Duit", "duit"), false, false, 2);
 506                 version(duitdev) vbox.packStart(newSelection("Install Duit for development", "duitDev"), false, false, 2);
 507                 version(duitgl) vbox.packStart(newSelection("Install Duitgl", "duitgl"), false, false, 2);
 508                 version(duitdev) version(duitgl) vbox.packStart(newSelection("Install Duitgl for development", "duiglDev"), false, false, 2);
 509                 version(leds) vbox.packStart(newSelection("Install Leds", "leds"), false, false, 2);
 510
 511                 installerUI.setSelection("duit", true);
 512                 version(duitdev) installerUI.setSelection("duitDev", true);
 513                 version(duitgl) installerUI.setSelection("duitgl", true);
 514                 version(duitdev) version(duitgl) installerUI.setSelection("duiglDev", true);
 515                 version(leds) installerUI.setSelection("leds", true);
 516
 517         }
 518
 519 }
 520
 521 class DevPanel : UserPanel
 522 {
 523         VBox vbox;
 524
 525         public this(InstallerUI installerUI)
 526         {
 527                 super(installerUI);
 528         }
 529         public char[] getName()
 530         {
 531                 return "Development for Duit";
 532         }
 533         public Widget getWidget()
 534         {
 535                 if ( vbox is null )
 536                 {
 537                         vbox = new VBox(false, 2);
 538                         setup();
 539                 }
 540                 return vbox;
 541         }
 542
 543         public bool selected()
 544         {
 545                 completed = true;
 546                 return installerUI.getSelection("duitDev")
 547                                 || installerUI.getSelection("duitglDev");
 548         }
 549
 550         private void setup()
 551         {
 552                 vbox.packStart(new Label("Select Duit modules"), false, false, 14);
 553                 version(difiles) vbox.packStart(newSelection("Duit .di files", "duitdi"), false, false, 2);
 554                 vbox.packStart(newSelection("Duit source files", "duitSource"), false, false, 2);
 555                 vbox.packStart(newSelection("DuitTests - general UI tests", "duitTests"), false, false, 2);
 556                 version(duitgl) vbox.packStart(newSelection("SimpleGL - simplest GL test", "duitglSimple"), false, false, 2);
 557                 version(duitgl) vbox.packStart(newSelection("ShapesGL - showing more of openGL integration", "duitglShapes"), false, false, 2);
 558
 559                 version(difiles) installerUI.setSelection("duitdi", true);
 560                 installerUI.setSelection("duitSource", true);
 561                 installerUI.setSelection("duitTests", true);
 562                 version(duitgl) installerUI.setSelection("duitglSimple", true);
 563                 version(duitgl) installerUI.setSelection("duitglShapes", true);
 564
 565         }
 566
 567 }
 568
 569
 570 class LedsPanel : UserPanel
 571 {
 572         VBox vbox;
 573
 574         public this(InstallerUI installerUI)
 575         {
 576                 super(installerUI);
 577         }
 578         public char[] getName()
 579         {
 580                 return "Leds projects";
 581         }
 582         public Widget getWidget()
 583         {
 584                 if ( vbox is null )
 585                 {
 586                         vbox = new VBox(false, 2);
 587                         setup();
 588                 }
 589                 return vbox;
 590         }
 591
 592         public bool selected()
 593         {
 594                 completed = true;
 595                 return installerUI.getSelection("leds");
 596         }
 597
 598         private void setup()
 599         {
 600                 vbox.packStart(new Label("Select the leds projects to create"), false, false, 14);
 601                 vbox.packStart(newSelection("Create a leds project for Duit", "ledsDuit"), false, false, 2);
 602                 vbox.packStart(newSelection("Create a leds project for Leds", "ledsLeds"), false, false, 2);
 603                 vbox.packStart(newSelection("Create a leds project for Dool", "ledsDool"), false, false, 2);
 604                 vbox.packStart(newSelection("Create a leds project for Dante", "ledsDante"), false, false, 2);
 605                 vbox.packStart(newSelection("Create a leds project for phobos", "ledsPhobos"), false, false, 2);
 606
 607                 installerUI.setSelection("ledsDuit", true);
 608                 installerUI.setSelection("ledsLeds", true);
 609                 installerUI.setSelection("ledsDool", true);
 610                 installerUI.setSelection("ledsDante", true);
 611                 installerUI.setSelection("ledsPhobos", true);
 612
 613         }
 614
 615 }
 616
 617
 618 class MainCompilerPanel : UserPanel
 619 {
 620         VBox vbox;
 621
 622         public this(InstallerUI installerUI)
 623         {
 624                 super(installerUI);
 625         }
 626         public char[] getName()
 627         {
 628                 return "D Compiler";
 629         }
 630         public Widget getWidget()
 631         {
 632                 if ( vbox is null )
 633                 {
 634                         vbox = new VBox(false, 2);
 635                         setup();
 636                 }
 637                 return vbox;
 638         }
 639
 640         public bool selected()
 641         {
 642                 completed = true;
 643                 return true;
 644         }
 645
 646         private void setup()
 647         {
 648                 vbox.packStart(new Label("Select your D compiler"), false, false, 14);
 649
 650                 vbox.packStart(new Label("For the installation"), false, false, 7);
 651                 vbox.packStart(newSelection("Digital Mars DMD", "instalCompilerDMD"), false, false, 2);
 652                 vbox.packStart(newSelection("gnu D GDC", "installCompilerGDC"), false, false, 2);
 653
 654                 vbox.packStart(new Label("For your leds projects"), false, false, 7);
 655                 vbox.packStart(newSelection("Digital Mars DMD", "ledsCompilerDMD"), false, false, 2);
 656                 vbox.packStart(newSelection("gnu D GDC", "ledsCompilerGDC"), false, false, 2);
 657
 658                 installerUI.setSelection("instalCompilerDMD", true);
 659                 installerUI.setSelection("installCompilerGDC", false);
 660                 version(leds) installerUI.setSelection("ledsCompilerDMD", true);
 661                 version(leds) installerUI.setSelection("ledsCompilerGDC", false);
 662
 663                 installerUI.setSensitive("instalCompilerDMD", false);
 664                 installerUI.setSensitive("installCompilerGDC", false);
 665                 version(leds) installerUI.setSensitive("ledsCompilerDMD", false);
 666                 version(leds) installerUI.setSensitive("ledsCompilerGDC", false);
 667         }
 668
 669 }
 670
 671
 672
 673 class LocalPanel : UserPanel
 674 {
 675         VBox vbox;
 676         SizeGroup sizeGroup;
 677
 678         char[] home;
 679
 680         public this(InstallerUI installerUI)
 681         {
 682                 super(installerUI);
 683                 sizeGroup = new SizeGroup(SizeGroupMode.HORIZONTAL);
 684                 version(Win32)
 685                 {
 686                         home = std.string.toString(getenv("HOMEPATH"));
 687                 }
 688                 else
 689                 {
 690                         home = std.string.toString(getenv("HOME"));
 691                 }
 692
 693         }
 694         public char[] getName()
 695         {
 696                 return "Local";
 697         }
 698
 699         private import std.path;
 700         private import std.file;
 701
 702         private bool validDir(char[] dir)
 703         {
 704                 bool valid = dir.length > 0;
 705                 return valid;
 706         }
 707
 708         public bool validDMDHome()
 709         {
 710                 bool valid = false;
 711                 char[] dir = installerUI.getDirectory("dmdHome");
 712                 valid = validDir(dir);
 713                 if ( valid )
 714                 {
 715                         try
 716                         {
 717                                 version(Win32) char[] dmd = std.path.join(std.path.join(dir ,"bin"), "dmd.exe");
 718                                 else  char[] dmd = std.path.join(std.path.join(dir ,"bin"), "dmd");
 719                                 std.file.isfile(dmd);
 720                                 version(Win32)
 721                                 {
 722                                         char[] dm = std.path.join(std.path.join(dir,"..\\dm"),"bin");
 723                                         char[] link = std.path.join(dm, "link.exe");
 724                                         std.file.isfile(link);
 725                                         char[] lib = std.path.join(dm, "lib.exe");
 726                                         std.file.isfile(lib);
 727                                 }
 728                                 else  char[] link = std.path.join(std.path.join(dir ,"bin"), "dmd");
 729                                 valid = true;
 730                         }
 731                         catch ( FileException pe )
 732                         {
 733                                 valid = false;
 734                         }
 735                 }
 736
 737                 return valid;
 738         }
 739
 740 //      class GuessFile
 741 //      {
 742 //              char[] guess;
 743 //              char[] fetch;
 744 //              char[] userChoice;
 745 //              bool create;
 746 //              bool confirmed;
 747 //
 748 //              bool isDir(char[] dir)
 749 //              {
 750 //                      bool ok = false;
 751 //                      try
 752 //                      {
 753 //                              ok = cast(bool)std.file.isfile(dir);
 754 //                      }
 755 //                      catch ( FileException fe )
 756 //                      {
 757 //                              ok = false;
 758 //                      }
 759 //                      return ok;
 760 //              }
 761 //
 762 //              bool exists(char[] fileName)
 763 //              {
 764 //                      bool ok = false;
 765 //                      try
 766 //                      {
 767 //                              ok = cast(bool)std.file.exists(fileName);
 768 //                      }
 769 //                      catch ( FileException fe )
 770 //                      {
 771 //                              ok = false;
 772 //                      }
 773 //                      return ok;
 774 //              }
 775 //      }
 776
 777         public char[] guessDMDHome()
 778         {
 779                 char[] guess;
 780                 version(Win32)
 781                 {
 782                         guess = "\\dmd";
 783                 }
 784                 else
 785                 {
 786                         guess = std.path.join(home, "dmd");
 787                 }
 788                 return guess;
 789         }
 790
 791         public char[] guessGtkHome()
 792         {
 793                 char[] guess;
 794                 version(Win32)
 795                 {
 796                         guess = "\\Program Files\\Common Files\\GTK\\2.0\\bin";
 797                 }
 798                 else
 799                 {
 800                         guess = "/usr/lib";
 801                 }
 802                 return guess;
 803         }
 804
 805         public char[] guessDuitLibHome()
 806         {
 807                 char[] guess;
 808                 version(Win32)
 809                 {
 810                         guess = "\\Program Files\\Common Files\\GTK\\2.0\\bin";
 811                 }
 812                 else
 813                 {
 814                         guess = "/home/ruimt/usr/lib";
 815                 }
 816                 return guess;
 817         }
 818
 819         public char[] guessDuitDevHome()
 820         {
 821                 char[] guess;
 822                 version(Win32)
 823                 {
 824                         guess = "\\testRelease";
 825                 }
 826                 else
 827                 {
 828                         guess = std.path.join(home, "devel/D/testInstall/Duit1");
 829                 }
 830                 return guess;
 831         }
 832
 833         public char[] guessLedsHome()
 834         {
 835                 char[] guess;
 836                 version(Win32)
 837                 {
 838                         guess = "\\Program Files\\Common Files\\org\\dsource\\leds";
 839                 }
 840                 else
 841                 {
 842                         guess = std.path.join(home, "devel/D/Leds1");
 843                 }
 844                 return guess;
 845         }
 846
 847
 848         public bool selected()
 849         {
 850                 completed = true;
 851                 version(dmd)
 852                 {
 853                         if ( completed )
 854                         {
 855                                 completed = validDMDHome();
 856                         }
 857                 }
 858                 version(duitdev)
 859                 {
 860                         if ( completed )
 861                         {
 862                                 completed = installerUI.getDirectory("duitDevHome").length > 0;
 863                         }
 864                 }
 865                 version(leds)
 866                 {
 867                         if ( completed )
 868                         {
 869                                 completed = installerUI.getDirectory("ledsHome").length > 0;
 870                         }
 871                 }
 872
 873                 if ( completed )
 874                 {
 875                         completed = installerUI.getDirectory("gtkHome").length > 0;
 876                 }
 877                 if ( completed )
 878                 {
 879                         completed = installerUI.getDirectory("duitLibHome").length > 0;
 880                 }
 881
 882                 return true;
 883         }
 884         public Widget getWidget()
 885         {
 886                 if ( vbox is null )
 887                 {
 888                         vbox = new VBox(false, 2);
 889                         setup();
 890                 }
 891                 return vbox;
 892         }
 893         private void setup()
 894         {
 895                 vbox.packStart(new Label("Select the paths for installation"), false, false, 14);
 896                 vbox.packStart(newDirectory("DMD home", "dmdHome", sizeGroup), false, false, 2);
 897                 vbox.packStart(newDirectory("Gtk lib home", "gtkHome", sizeGroup), false, false, 2);
 898                 vbox.packStart(newDirectory("Duit lib home", "duitLibHome", sizeGroup), false, false, 2);
 899                 version(duitdev) vbox.packStart(newDirectory("Duit dev home", "duitDevHome", sizeGroup), false, false, 2);
 900                 version(leds) vbox.packStart(newDirectory("leds home", "ledsHome", sizeGroup), false, false, 2);
 901
 902                 installerUI.setDirectory("dmdHome", guessDMDHome());
 903                 installerUI.setDirectory("gtkHome", guessGtkHome());
 904                 installerUI.setDirectory("duitLibHome", guessDuitLibHome());
 905                 version(duitdev) installerUI.setDirectory("duitDevHome", guessDuitDevHome());
 906                 version(leds) installerUI.setDirectory("ledsHome", guessLedsHome());
 907         }
 908 }
 909
 910 class InstallPanel : UserPanel
 911 {
 912         VBox vbox;
 913         //bool installed = false;
 914         public this(InstallerUI installerUI)
 915         {
 916                 super(installerUI);
 917         }
 918         public bool selected()
 919         {
 920                 completed = true;
 921                 return true;
 922         }
 923         public char[] getName()
 924         {
 925                 return "Install";
 926         }
 927         public Widget getWidget()
 928         {
 929                 if ( vbox is null )
 930                 {
 931                         vbox = new VBox(false, 2);
 932                         setup();
 933                 }
 934                 return vbox;
 935         }
 936
 937         bool allowNext()
 938         {
 939                 return false;
 940         }
 941
 942         private void setup()
 943         {
 944                 Label label = new Label(
 945                         "Thank you for installing Duit\n"
 946                         ~"press Install to continue"
 947                 );
 948                 vbox.packStart(label, true, true, 2);
 949
 950                 version(duittest) vbox.packStart(newSelection("Create desktop icon for duit tests", "duitTestsIcon"), false, false, 2);
 951                 version(leds) vbox.packStart(newSelection("Create desktop icon for leds", "ledsIcon"), false, false, 2);
 952                 version(leds) vbox.packStart(newSelection("set leds as your D editor", "ledsDEditor"), false, false, 2);
 953
 954                 version(duittest) installerUI.setSelection("duitTestsIcon", false);
 955                 version(leds) installerUI.setSelection("ledsIcon", false);
 956                 version(leds) installerUI.setSelection("ledsDEditor", false);
 957
 958                 version(duittest) installerUI.setSensitive("duitTestsIcon", false);
 959                 version(leds) installerUI.setSensitive("ledsIcon", false);
 960                 version(leds) installerUI.setSensitive("ledsDEditor", false);
 961         }
 962 }
 963
 964 MainInstaller mainInstaller;
 965
 966 int main(char[][] args)
 967 {
 968         version(Win32)
 969         {
 970                 Duit.init(args);
 971         }
 972         else
 973         {
 974                 Duit.initMultiThread(args);
 975         }
 976         mainInstaller = new MainInstaller();
 977         Duit.main();
 978         return 0;
 979 }