installer/ui/Installer.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.Installer;
  20
  21 private import ui.Main;
  22 private import ui.Exec;
  23 private import gtk.Duit;
  24 private import gtk.MainWindow;
  25 private import gtk.Widget;
  26 private import gtk.ProgressBar;
  27 private import gtk.Label;
  28 private import gtk.VBox;
  29
  30 private import gdk.Gdk;
  31 private import gdk.Event;
  32
  33 private import compd.Compiler;
  34
  35 private import std.stdio;
  36
  37 private import std.path;
  38 private import std.file;
  39 private import std.process;
  40
  41 private import std.thread;
  42 private import std.c.time;
  43
  44
  45 /**
  46  * From the informatino collected from the UI this will install Duit, Duitgl and or leds
  47  */
  48 class Installer : MainWindow
  49 {
  50         InstallerUI installerUI;
  51         Label label;
  52         ProgressBar progressBar;
  53
  54         bool cancel = false;
  55
  56         this(InstallerUI installerUI)
  57         {
  58                 super("Installing Duit components");
  59                 this.installerUI = installerUI;
  60                 setDefaultSize(400,300);
  61                 setup();
  62                 showAll();
  63                 install();
  64                 progressBar.setFraction(1.0);
  65                 progressBar.setText("");
  66         }
  67
  68         private void setup()
  69         {
  70                 VBox vbox = new VBox(false, 7);
  71                 vbox.setBorderWidth(11);
  72                 label = new Label("");
  73                 vbox.packStart(new Label("Installing"), false, false, 14);
  74                 vbox.packStart(label, false, false, 14);
  75                 progressBar = new ProgressBar();
  76                 progressBar.setPulseStep(0.01);
  77                 vbox.packStart(progressBar, false, false, 14);
  78                 add(vbox);
  79         }
  80
  81         protected int windowDelete(Event event, Widget widget)
  82         {
  83                 cancel = true;
  84                 mainInstaller.show();
  85                 return super.windowDelete(event, widget);
  86         }
  87
  88         char[] dmdHome;
  89         char[] duitDevHome;
  90         char[] phobos;
  91         char[] compilerExec;
  92
  93         int ccount;
  94
  95
  96         private void install()
  97         {
  98                 bool ok = true;
  99                 duitDevHome = installerUI.getDirectory("duitDevHome");
 100                 dmdHome = installerUI.getDirectory("dmdHome");
 101                 phobos = std.path.join(std.path.join(dmdHome,"src"),"phobos");
 102                 compilerExec = std.path.join(installerUI.getDirectory("dmdHome"),"bin");
 103                 version(Win32)
 104                 {
 105                         compilerExec = std.path.join(compilerExec,"dmd.exe");
 106                 }
 107                 else
 108                 {
 109                         compilerExec = std.path.join(compilerExec,"dmd");
 110                 }
 111
 112 //              if ( ok && installerUI.getSelection("duit") )
 113 //              {
 114 //                      label.setText("");
 115 //                      Gdk.flush();
 116 //                      ok = installDuit();
 117 //              }
 118
 119
 120
 121                 class CompileThread : Thread
 122                 {
 123                         bool delegate() compile;
 124                         bool ok;
 125
 126                         this(char[] stepLabel, bool delegate() compile)
 127                         {
 128                                 super(&run);
 129                                 this.compile = compile;
 130                                 label.setText(stepLabel);
 131                                 progressBar.setText(stepLabel);
 132                                 go();
 133                                 //ok = compile();
 134                         }
 135
 136                         private void go()
 137                         {
 138                         std.gc.fullCollect();
 139                                 start();
 140                                 while ( !cancel && getState() != Thread.TS.TERMINATED )
 141                                 {
 142                                         progressBar.pulse();
 143                                         while ( Duit.eventsPending() )
 144                                         {
 145                                                 Duit.mainIterationDo(false);
 146                                         }
 147                                         std.c.time.usleep(30000);
 148                                 }
 149                         }
 150
 151                         int run()
 152                         {
 153                                 ok = compile();
 154                                 return ok;
 155                         }
 156
 157                 }
 158
 159                 if ( !cancel && ok && installerUI.getSelection("duitDev") )
 160                 {
 161                         ok = (new CompileThread("Duit Development", &installDuitDev)).ok;
 162                 }
 163
 164 //              if ( ok && installerUI.getSelection("duitgl") )
 165 //              {
 166 //                      label.setText("Duitgl - openGL bindings");
 167 //                      Gdk.flush();
 168 //                      ok = installDuitgl();
 169 //              }
 170
 171                 if ( !cancel && ok && installerUI.getSelection("duiglDev") )
 172                 {
 173                         ok = (new CompileThread("Duitgl Development", &installDuitglDev)).ok;
 174                 }
 175
 176 //              if ( !cancel && ok && installerUI.getSelection("leds") )
 177 //              {
 178 //                      label.setText("leds");
 179 //                      Gdk.flush();
 180 //                      ok = installLeds();
 181 //              }
 182 //
 183 //              if ( !cancel && ok && installerUI.getSelection("duitdi") )
 184 //              {
 185 //                      label.setText("Duit .di files");
 186 //                      Gdk.flush();
 187 //                      ok = installDuitdi();
 188 //              }
 189 //
 190 //              if ( !cancel && ok && installerUI.getSelection("duitSource") )
 191 //              {
 192 //                      label.setText("Duit source files");
 193 //                      Gdk.flush();
 194 //                      ok = installDuitSource();
 195 //              }
 196 //
 197                 if ( !cancel && ok && installerUI.getSelection("duitTests") )
 198                 {
 199                         ok = (new CompileThread("Duit Test and demos programs", &installDuitTests)).ok;
 200                 }
 201
 202                 if ( !cancel && ok && installerUI.getSelection("duitglSimple") )
 203                 {
 204                         ok = (new CompileThread("Duitgl SimpleGL demo program", &installDuitglSimpleGL)).ok;
 205                 }
 206
 207                 if ( !cancel && ok && installerUI.getSelection("duitglShapes") )
 208                 {
 209                         ok = (new CompileThread("Duitgl ShapeGL and demo program", &installDuitglShapesGL)).ok;
 210                 }
 211
 212 //              if ( !cancel && ok && installerUI.getSelection("ledsDuit") )
 213 //              {
 214 //                      label.setText("Leds project for Duit");
 215 //                      Gdk.flush();
 216 //                      ok = installLedsDuit();
 217 //              }
 218 //
 219 //              if ( !cancel && ok && installerUI.getSelection("ledsLeds") )
 220 //              {
 221 //                      label.setText("Leds project for leds");
 222 //                      Gdk.flush();
 223 //                      ok = installLedsLeds();
 224 //              }
 225 //
 226 //              if ( !cancel && ok && installerUI.getSelection("ledsDool") )
 227 //              {
 228 //                      label.setText("Leds project for Dool");
 229 //                      Gdk.flush();
 230 //                      ok = installLedsDool();
 231 //              }
 232 //
 233 //              if ( !cancel && ok && installerUI.getSelection("ledsDante") )
 234 //              {
 235 //                      label.setText("Leds project for Dante");
 236 //                      Gdk.flush();
 237 //                      ok = installLedsDante();
 238 //              }
 239 //
 240 //              if ( !cancel && ok && installerUI.getSelection("ledsPhobos") )
 241 //              {
 242 //                      label.setText("Leds project for phobos");
 243 //                      Gdk.flush();
 244 //                      ok = installLedsPhobos();
 245 //              }
 246
 247         }
 248
 249
 250         private bool makeDirs(char[] dir)
 251         {
 252                 bool ok = false;
 253                 version(Win32)
 254                 {
 255                         system("md "~dir);
 256                 }
 257                 else
 258                 {
 259                         system("mkdir -p "~dir);
 260                 }
 261                 try
 262                 {
 263                         std.file.isdir(dir);
 264                         ok = true;
 265                 }
 266                 catch ( FileException fe )
 267                 {
 268
 269                 }
 270                 return ok;
 271         }
 272
 273         private bool installDuitglSimpleGL()
 274         {
 275                 bool ok = moveDuitDev();
 276                 if ( ok )
 277                 {
 278                         char[] cwd = std.file.getcwd();
 279                         Compiler compiler;
 280                         std.file.chdir(duitDevHome);
 281
 282                         compiler = new Compiler();
 283                         compiler.setExecutor(new Exec());
 284                         compiler.setCompilerExec(compilerExec);
 285
 286                         compiler.addArg("-Isrc");
 287                         compiler.addArg("-Isrcgl");
 288                         compiler.addArg("-Idemos");
 289                         compiler.addArg("demos/gl/SimpleGL.d");
 290                         compiler.addArg("-I"~phobos);
 291                         compiler.addArg("-L"~std.path.join(dmdHome,"lib"));
 292                         compiler.addArg("-o SimpleGL");
 293                         compiler.addArg("-L .");
 294                         compiler.addArg("-lduit");
 295                         compiler.addArg("-lduitgl");
 296                         compiler.addArg("-lGL");
 297                         compiler.addArg("-lGLU");
 298                         version(linux)compiler.addArg("-ldl");
 299
 300                         compiler.addArg("-c");
 301                         compiler.addArg("-op");
 302
 303                         version(Win32)
 304                         {
 305                                 compiler.addArg("-lkernel32");
 306                                 compiler.addArg("-luser32");
 307                         }
 308                         else
 309                         {
 310                                 compiler.addArg("-lpthread");
 311                                 compiler.addArg("-lm");
 312                         }
 313                         compiler.compile();
 314                         if ( compiler.compileStatus == 0
 315                                 && compiler.linkStatus == 0
 316                                 )
 317                         {
 318                                 ok = true;
 319                         }
 320                         else
 321                         {
 322                                 ok = false;
 323                         }
 324
 325                         std.file.chdir(cwd);
 326                 }
 327                 return ok;
 328         }
 329
 330         private bool installDuitglShapesGL()
 331         {
 332                 bool ok = moveDuitDev();
 333                 if ( ok )
 334                 {
 335                         char[] cwd = std.file.getcwd();
 336                         Compiler compiler;
 337                         std.file.chdir(duitDevHome);
 338
 339                         compiler = new Compiler();
 340                         compiler.setExecutor(new Exec());
 341                         compiler.setCompilerExec(compilerExec);
 342
 343                         compiler.addArg("-Isrc");
 344                         compiler.addArg("-Isrcgl");
 345                         compiler.addArg("demos/gl/TrackBall.d");
 346                         compiler.addArg("demos/gl/ShapesGL.d");
 347                         compiler.addArg("-I"~phobos);
 348                         compiler.addArg("-L"~std.path.join(dmdHome,"lib"));
 349                         compiler.addArg("-o ShapesGL");
 350                         compiler.addArg("-L .");
 351                         compiler.addArg("-lduit");
 352                         compiler.addArg("-lduitgl");
 353                         compiler.addArg("-lGL");
 354                         compiler.addArg("-lGLU");
 355                         version(linux)compiler.addArg("-ldl");
 356
 357                         compiler.addArg("-c");
 358                         compiler.addArg("-op");
 359
 360                         version(Win32)
 361                         {
 362                                 compiler.addArg("-lkernel32");
 363                                 compiler.addArg("-luser32");
 364                         }
 365                         else
 366                         {
 367                                 compiler.addArg("-lpthread");
 368                                 compiler.addArg("-lm");
 369                         }
 370                         compiler.compile();
 371                         if ( compiler.compileStatus == 0
 372                                 && compiler.linkStatus == 0
 373                                 )
 374                         {
 375                                 ok = true;
 376                         }
 377                         else
 378                         {
 379                                 ok = false;
 380                         }
 381
 382                         std.file.chdir(cwd);
 383                 }
 384                 return ok;
 385         }
 386
 387         private bool installDuitglDev()
 388         {
 389                 bool ok = true;
 390
 391                 Compiler compiler;
 392
 393                 char[] cwd = std.file.getcwd();
 394
 395
 396
 397                 version(Win32)
 398                 {
 399                         char[] libDuitgl = "duitgl";
 400                 }
 401                 else
 402                 {
 403                         char[] libDuitgl = "libduitgl";
 404                 }
 405
 406
 407
 408                 ok = moveDuitDev();
 409                 if ( ok )
 410                 {
 411                         std.file.chdir(duitDevHome);
 412                         compiler = new Compiler();
 413                         compiler.setExecutor(new Exec());
 414                         compiler.setCompilerExec(compilerExec);
 415
 416                         compiler.addArg("-Isrc");
 417                         compiler.addArg("-Isrcgl");
 418                         compiler.addArg("srcgl/glgdk");
 419                         compiler.addArg("srcgl/glgtk");
 420                         compiler.addArg("srcgl/lib");
 421                         compiler.addArg("-I"~phobos);
 422                         compiler.addArg("-L"~std.path.join(dmdHome,"lib"));
 423                         compiler.addArg("-olib "~libDuitgl);
 424                         compiler.addArg("-L. ");
 425                         compiler.addArg("-lduit ");
 426                         compiler.addArg("-c");
 427                         compiler.addArg("-op");
 428
 429                         version(Win32)
 430                         {
 431                                 compiler.addArg("-lkernel32");
 432                                 compiler.addArg("-luser32");
 433                         }
 434                         else
 435                         {
 436                                 compiler.addArg("-lpthread");
 437                                 compiler.addArg("-lm");
 438                         }
 439                         compiler.compile();
 440                         if ( compiler.compileStatus == 0
 441                                 && compiler.linkStatus == 0
 442                                 )
 443                         {
 444                                 ok = true;
 445                         }
 446                         else
 447                         {
 448                                 ok = false;
 449                         }
 450
 451                         std.file.chdir(cwd);
 452                 }
 453                 return ok;
 454         }
 455
 456
 457         private bool installDuitTests()
 458         {
 459                 bool ok = moveDuitDev();
 460                 if ( ok )
 461                 {
 462                         char[] cwd = std.file.getcwd();
 463                         Compiler compiler;
 464                         std.file.chdir(duitDevHome);
 465
 466                         compiler = new Compiler();
 467                         compiler.setExecutor(new Exec());
 468                         compiler.setCompilerExec(compilerExec);
 469
 470                         compiler.addArg("-Isrc");
 471                         compiler.addArg("-Idemos");
 472                         compiler.addArg("demos/duit");
 473                         compiler.addArg("-I"~phobos);
 474                         compiler.addArg("-L"~std.path.join(dmdHome,"lib"));
 475                         compiler.addArg("-o DuitTests");
 476                         compiler.addArg("-L .");
 477                         compiler.addArg("-lduit");
 478                         version(linux)compiler.addArg("-ldl");
 479
 480                         compiler.addArg("-c");
 481                         compiler.addArg("-op");
 482
 483                         version(Win32)
 484                         {
 485                                 compiler.addArg("-lkernel32");
 486                                 compiler.addArg("-luser32");
 487                         }
 488                         else
 489                         {
 490                                 compiler.addArg("-lpthread");
 491                                 compiler.addArg("-lm");
 492                         }
 493                         compiler.compile();
 494                         if ( compiler.compileStatus == 0
 495                                 && compiler.linkStatus == 0
 496                                 )
 497                         {
 498                                 ok = true;
 499                         }
 500                         else
 501                         {
 502                                 ok = false;
 503                         }
 504
 505                         std.file.chdir(cwd);
 506                 }
 507                 return ok;
 508         }
 509
 510         private bool movePackToDestiny(char[] from, char[] to)
 511         {
 512                 int ok;
 513                 version(Win32)
 514                 {
 515                          ok = system("xcopy /s /Y /E /Q "~from~" "~to);
 516                 }
 517                 else
 518                 {
 519                         ok = system("cp -R "~from~" "~to);
 520                 }
 521                 return ok == 0;
 522         }
 523
 524         bool duitDevMoved;
 525
 526         private bool moveDuitDev()
 527         {
 528                 if ( !duitDevMoved )
 529                 {
 530                         if ( makeDirs(duitDevHome) )
 531                         {
 532                                 duitDevMoved = movePackToDestiny("*", duitDevHome);
 533                         }
 534                 }
 535                 return duitDevMoved;
 536         }
 537
 538 //      private bool installDuit()
 539 //      {
 540 //              // nothing
 541 //              return true;
 542 //      }
 543
 544         private bool installDuitDev()
 545         {
 546                 bool ok = true;
 547
 548                 Compiler compiler;
 549
 550                 char[] cwd = std.file.getcwd();
 551
 552
 553
 554                 version(Win32)
 555                 {
 556                         char[] libDuit = "duit";
 557                 }
 558                 else
 559                 {
 560                         char[] libDuit = "libduit";
 561                 }
 562
 563
 564                 ok = moveDuitDev();
 565                 if ( ok )
 566                 {
 567                         std.file.chdir(duitDevHome);
 568                         compiler = new Compiler();
 569                         compiler.setExecutor(new Exec());
 570
 571                         compiler.setCompilerExec(compilerExec);
 572
 573                         compiler.addArg("-Isrc");
 574                         compiler.addArg("src/atk");
 575                         compiler.addArg("src/cairoLib");
 576                         compiler.addArg("src/gdk");
 577                         compiler.addArg("src/glib");
 578                         compiler.addArg("src/gobject");
 579                         compiler.addArg("src/gthread");
 580                         compiler.addArg("src/gtk");
 581                         compiler.addArg("src/lib");
 582                         compiler.addArg("src/pango");
 583                         compiler.addArg("-I"~phobos);
 584                         compiler.addArg("-L"~std.path.join(dmdHome,"lib"));
 585                         compiler.addArg("-olib "~libDuit);
 586                         compiler.addArg("-c");
 587                         compiler.addArg("-op");
 588
 589                         version(Win32)
 590                         {
 591                                 compiler.addArg("-lkernel32");
 592                                 compiler.addArg("-luser32");
 593                         }
 594                         else
 595                         {
 596                                 compiler.addArg("-lpthread");
 597                                 compiler.addArg("-lm");
 598                         }
 599                         compiler.compile();
 600                         if ( compiler.compileStatus == 0
 601                                 && compiler.linkStatus == 0
 602                                 )
 603                         {
 604                                 ok = true;
 605                         }
 606                         else
 607                         {
 608                                 ok = false;
 609                         }
 610
 611                         std.file.chdir(cwd);
 612                 }
 613                 return ok;
 614         }
 615
 616 }