The Ecere SDK - sdk/blob - ide/src/ProjectSettings.ec

   1 import "ide"
   2 import "WorkspaceSettings"
   3 import "ProjectTabSettings"
   4 import "StringsBox"
   5 // import "SelectorBar"
   6
   7 static ProjectConfig config;
   8 static Platform platform;
   9 static ProjectNode currentNode;
  10 static Project project;
  11
  12 static String MakeString(char * s, int len)
  13 {
  14    String string = new char[len+1];
  15    memcpy(string, s, len);
  16    string[len] = 0;
  17    return string;
  18 }
  19
  20 class StringListBox : EditBox
  21 {
  22    textHorzScroll = true;
  23
  24    property Array<String> strings
  25    {
  26       set
  27       {
  28          contents = "";
  29          if(value)
  30          {
  31             bool first = true;
  32             for(item : value)
  33             {
  34                bool quoted = strchr(item, ' ') != null;
  35                if(!first)
  36                   AddS(" ");
  37                if(quoted)
  38                   AddS("\"");
  39                AddS(item);
  40                if(quoted)
  41                   AddS("\"");
  42                first = false;
  43             }
  44          }
  45       }
  46       get
  47       {
  48          Array<String> array { };
  49          int c, start = 0;
  50          char * contents = property::contents;
  51          char ch;
  52          bool quoted = false;
  53
  54          for(c = 0; (ch = contents[c]); c++)
  55          {
  56             if(ch == ' ' && !quoted)
  57             {
  58                if(c - start)
  59                   array.Add(MakeString(contents + start, c - start));
  60                start = c + 1;
  61             }
  62             else if(ch == '\"')
  63             {
  64                if(quoted)
  65                {
  66                   if(c - start)
  67                      array.Add(MakeString(contents + start, c - start));
  68                   quoted = false;
  69                   start = c + 1;
  70                }
  71                else
  72                {
  73                   quoted = true;
  74                   start = c + 1;
  75                }
  76             }
  77          }
  78          if(c - start)
  79             array.Add(MakeString(contents + start, c - start));
  80          return array;
  81       }
  82    }
  83 }
  84
  85 define dialogTitle = $"Project Settings";
  86 static Color unfocusedSelectorColor { 70, 96, 166 };
  87 class ProjectSettings : Window
  88 {
  89    text = dialogTitle;
  90    background = formColor;
  91    borderStyle = sizable;
  92    minClientSize = { 650, 490 };
  93    hasClose = true;
  94    tabCycle = true;
  95    size = { 650, 490 };
  96
  97    property Project project
  98    {
  99       set
 100       {
 101          ::project = value;
 102          projectTab.project = value;
 103          buildTab.Init();
 104
 105          buildTab.SelectNode(project.topNode, false);
 106
 107          if(project && project.topNode && project.topNode.name && project.topNode.name[0])
 108             UpdateDialogTitle();
 109       }
 110       get { return ::project; }
 111    };
 112
 113    property ProjectNode projectNode
 114    {
 115       set { buildTab.SelectNode(value, false); }
 116       get { return currentNode; }
 117    }
 118
 119    void UpdateDialogTitle()
 120    {
 121       //char * s = PrintString("Project Settings - ", project.topNode.fileName);
 122       //text = s;
 123       char * projectName = new char[strlen(project.topNode.name) + 1];
 124       char * nodeName = currentNode && currentNode != project.topNode ? currentNode.name : "";
 125       char * config = buildTab.selectedConfigName;
 126       char * platform = buildTab.selectedPlatformName;
 127       char * label = new char[strlen(dialogTitle) + 3 + strlen(project.topNode.name) + 3 +
 128                               strlen(nodeName) + 2 + strlen(config) + 1 + strlen(platform) + 1 + 1];
 129       strcpy(label, dialogTitle);
 130       strcat(label, " - ");
 131       strcpy(projectName, project.topNode.name);
 132       StripExtension(projectName);
 133       strcat(label, projectName);
 134       if(currentNode && currentNode.type != project)
 135       {
 136          strcat(label, " - ");
 137          strcat(label, nodeName);
 138       }
 139       if(strlen(config) || strlen(platform))
 140       {
 141          strcat(label, " (");
 142          if(strlen(config))
 143             strcat(label, config);
 144          if(strlen(config) && strlen(platform))
 145             strcat(label, "/");
 146          if(strlen(platform))
 147             strcat(label, platform);
 148          strcat(label, ")");
 149       }
 150       text = label;
 151       delete projectName;
 152       delete label;
 153    }
 154
 155    ~ProjectSettings()
 156    {
 157       currentNode = null;
 158    }
 159
 160    TabControl prjTabControl
 161    {
 162       this, background = formColor, anchor = { left = 8, top = 4, right = 8, bottom = 38 };
 163    };
 164    ProjectTab projectTab { this, tabControl = prjTabControl };
 165    BuildTab buildTab { this, tabControl = prjTabControl };
 166    WorkspaceTab workspaceTab { this, tabControl = prjTabControl };
 167
 168    Button cancel
 169    {
 170       this, size = { 80, 22 };
 171       anchor = { right = 8, bottom = 8 };
 172       text = $"Cancel", hotKey = escape, id = DialogResult::cancel;
 173
 174       bool NotifyClicked(Button button, int x, int y, Modifiers mods)
 175       {
 176          if(prjTabControl.curTab.modifiedDocument)
 177          {
 178             DialogResult diagRes = MessageBox
 179             {
 180                type = okCancel, master = ide,
 181                text = $"Lose Changes?",
 182                contents = $"Are you sure you wish to discard changes made to the build options?"
 183             }.Modal();
 184             if(diagRes == ok)
 185             {
 186                if(prjTabControl.curTab == buildTab)
 187                {
 188                   buildTab.RevertChanges();
 189                   buildTab.modifiedDocument = false;
 190                }
 191                if(prjTabControl.curTab == workspaceTab)
 192                {
 193                   workspaceTab.modifiedDocument = false;
 194                }
 195                if(prjTabControl.curTab == projectTab)
 196                {
 197                   projectTab.modifiedDocument = false;
 198                }
 199                Destroy(DialogResult::cancel);
 200             }
 201          }
 202          else
 203             Destroy(DialogResult::cancel);
 204          return true;
 205       }
 206    };
 207    Button ok
 208    {
 209       this, size = { 80, 22 };
 210       anchor = { right = 96, bottom = 8 };
 211       text = $"OK", isDefault = true;
 212
 213       bool NotifyClicked(Button button, int x, int y, Modifiers mods)
 214       {
 215          if(prjTabControl.curTab == buildTab && buildTab.modifiedDocument)
 216          {
 217             buildTab.modifiedDocument = false;
 218
 219             project.topNode.modified = true;
 220             project.MarkChanges(buildTab.backupNode);
 221             ide.projectView.modifiedDocument = true;
 222             ide.projectView.Update(null);
 223          }
 224          if(prjTabControl.curTab == workspaceTab && workspaceTab.modifiedDocument)
 225          {
 226             workspaceTab.SaveChanges();
 227             workspaceTab.modifiedDocument = false;
 228          }
 229          if(prjTabControl.curTab == projectTab && projectTab.modifiedDocument)
 230          {
 231             projectTab.SaveChanges();
 232             projectTab.modifiedDocument = false;
 233          }
 234          Destroy(DialogResult::ok);
 235          return true;
 236       }
 237    };
 238
 239    bool OnPostCreate()
 240    {
 241       UpdateDialogTitle();
 242       prjTabControl.curTab = buildTab;
 243       return true;
 244    }
 245 }
 246
 247 #define OPTION(x) ((uint)(&((ProjectOptions)0).x))
 248
 249 // TOFIX: USING T INSTEAD OF Z HERE CAUSED US SOME CONFLICTS WITH T IN Array TEMPLATES
 250
 251 class OptionBox<class Z> : CommonControl
 252 {
 253    bool mergeValues, configReplaces;
 254    void * chainKeyDown;
 255
 256    autoCreate = false;
 257
 258    ~OptionBox()
 259    {
 260       delete editor;
 261    }
 262    property Window editor
 263    {
 264       set
 265       {
 266          editor = value;
 267          incref editor;
 268          editor.OnRightButtonDown = OptionBox_OnRightButtonDown;
 269          chainKeyDown = (void *)editor.OnKeyDown;
 270          editor.OnKeyDown = OptionBox_OnKeyDown;
 271       }
 272    }
 273
 274    property bool visible { set { editor.visible = value; } get { return editor.visible; } }
 275    property Window parent { set { editor.parent = value; Window::parent = value; master = value; editor.id = (int)this; } }
 276    property Point position { set { editor.position = value; } }
 277    property Size size { set { editor.size = value; } }
 278    property Anchor anchor { set { editor.anchor = value; } }
 279    property Key hotKey { set { editor.hotKey = value; } }
 280    property char * text { set { editor.text = value; Window::text = value; } }
 281
 282    uint option;
 283
 284    Window editor;
 285    Menu clearMenu { };
 286    MenuItem clearItem
 287    {
 288       clearMenu, $"Clear";
 289
 290       bool NotifySelect(MenuItem selection, Modifiers mods)
 291       {
 292          OptionBox ob = (OptionBox)id;
 293          ob.Unset();
 294          return true;
 295       }
 296    };
 297
 298    bool Window::OptionBox_OnRightButtonDown(int x, int y, Modifiers mods)
 299    {
 300       OptionBox ob = (OptionBox)id;
 301       GuiApplication app = ((GuiApplication)__thisModule.application);
 302       Activate();
 303       PopupMenu { null, this, menu = ob.clearMenu,
 304          position = { absPosition.x + clientStart.x + x - app.desktop.position.x, absPosition.y + clientStart.y + y - app.desktop.position.y } }.Create();
 305       return true;
 306    }
 307
 308    bool Window::OptionBox_OnKeyDown(Key key, unichar ch)
 309    {
 310       OptionBox ob = (OptionBox)id;
 311       if(key == Key { del, ctrl = true } || key == Key { keyPadDelete, ctrl = true })
 312       {
 313          ob.Unset();
 314          return false;
 315       }
 316       return (((bool(*)(Window, Key, unichar)) ob.chainKeyDown)(this, key, ch);
 317    }
 318
 319    // code: 0 = not set anywhere, 1 = overridden here, 2 = inherited
 320    void SetAttribs(int code)
 321    {
 322       Window c;
 323       Label label = null;
 324
 325       for(c = Window::parent.firstChild; c; c = c.next)
 326       {
 327          if(eClass_IsDerived(c._class, class(Label)))
 328          {
 329             label = (Label)c;
 330             if(label.labeledWindow == this)
 331                break;
 332          }
 333       }
 334
 335       if(!c)
 336       {
 337          label = null;
 338          for(c = editor.firstChild; c; c = c.next)
 339          {
 340             if(eClass_IsDerived(c._class, class(Label)))
 341             {
 342                label = (Label)c;
 343                break;
 344             }
 345          }
 346       }
 347       // control.foreground = foreground;
 348
 349       if(code == 0 || code == 1)
 350       {
 351          editor.font = { editor.font.faceName, editor.font.size, bold = (code == 1) };
 352          editor.background = white;
 353       }
 354       else if(code == 2)
 355       {
 356          Color foreground = 0x0F3F66;
 357          int r = foreground.r, g = foreground.g, b = foreground.b;
 358          Color src = white;
 359          double alpha = 0.1;
 360
 361          editor.font = { editor.font.faceName, editor.font.size };
 362
 363          r = (int)(alpha * r + src.r * (1 - alpha));
 364          g = (int)(alpha * g + src.g * (1 - alpha));
 365          b = (int)(alpha * b + src.b * (1 - alpha));
 366
 367          r = Max(0,Min(255,r));
 368          g = Max(0,Min(255,g));
 369          b = Max(0,Min(255,b));
 370
 371          editor.background = Color { (byte) r, (byte) g, (byte) b };
 372
 373       }
 374       if(label)
 375       {
 376          label.font = { editor.font.faceName, editor.font.size, bold = (code == 1) };
 377          //label.foreground = foreground;
 378       }
 379    }
 380
 381    virtual void FinalizeLoading();
 382
 383    virtual void LoadOption(ProjectOptions options);
 384    virtual void RetrieveOption(ProjectOptions options, bool isCfgOrPlt);
 385    virtual void UnsetOption(ProjectOptions options)
 386    {
 387       Z value = (Z)0;
 388       *(Z*)((byte *)options + option) = value;
 389    }
 390
 391    virtual bool OptionSet(ProjectOptions options)
 392    {
 393       // TOFIX: If you get a crash here, it might be because JSON.ec must be after ProjectConfig.ec in the project files
 394       //        JSON.ec must also be before ProjectSettings.ec in the project files
 395       if(*(Z*)((byte *)options + option))
 396          return true;
 397       return false;
 398    }
 399    // BUG: OptionCheck = OptionSet; // Overrides derived classes OptionCheck ?
 400
 401    virtual bool OptionCheck(ProjectOptions options)
 402    {
 403       return OptionSet(options);
 404    }
 405
 406    void MarkBuildTabModified()
 407    {
 408       BuildTab buildTab = (BuildTab)master;
 409       while(buildTab && buildTab._class != class(BuildTab))
 410          buildTab = (BuildTab)buildTab.master;
 411       if(buildTab) buildTab.modifiedDocument = true;
 412    }
 413
 414    void Unset()
 415    {
 416       char * platformName = platform ? platform.OnGetString(0,0,0) : null;
 417       MarkBuildTabModified();
 418
 419       if(config)
 420       {
 421          ProjectConfig c = null;
 422          if(currentNode.configurations)
 423          {
 424             for(i : currentNode.configurations; !strcmpi(i.name, config.name)) { c = i; break; }
 425             if(c)
 426             {
 427                if(platform)
 428                {
 429                   PlatformOptions p = null;
 430                   if(c.platforms)
 431                   {
 432                      for(i : c.platforms; !strcmpi(i.name, platformName)) { p = i; break; }
 433                      if(p)
 434                      {
 435                         if(p.options && OptionSet(p.options))
 436                            UnsetOption(p.options);
 437                         if(p.options && p.options.isEmpty)
 438                            delete p.options;
 439                         if(!p.options)
 440                         {
 441                            Iterator<PlatformOptions> it { c.platforms };
 442                            if(it.Find(p))
 443                            {
 444                               it.Remove();
 445                               delete p;
 446                            }
 447                         }
 448                      }
 449                      if(!c.platforms.count)
 450                         c.platforms = null;
 451                   }
 452                   Load();
 453                   return;
 454                }
 455                if(c.options && OptionSet(c.options))
 456                   UnsetOption(c.options);
 457                if(c.options && c.options.isEmpty)
 458                   delete c.options;
 459
 460                // DON'T DELETE PROJECT CONFIGS HERE!
 461                if(!c.options && currentNode != project.topNode)
 462                {
 463                   Iterator<ProjectConfig> it { currentNode.configurations };
 464                   if(it.Find(c))
 465                   {
 466                      it.Remove();
 467                      delete c;
 468                   }
 469                }
 470             }
 471             if(!currentNode.configurations.count)
 472                currentNode.configurations = null;
 473          }
 474          Load();
 475          return;
 476       }
 477       if(platform)
 478       {
 479          PlatformOptions p = null;
 480          if(currentNode.platforms)
 481          {
 482             for(i : currentNode.platforms; !strcmpi(i.name, platformName)) { p = i; break; }
 483             if(p)
 484             {
 485                if(p.options && OptionSet(p.options))
 486                   UnsetOption(p.options);
 487                if(p.options && p.options.isEmpty)
 488                   delete p.options;
 489                if(!p.options)
 490                {
 491                   Iterator<PlatformOptions> it { currentNode.platforms };
 492                   if(it.Find(p))
 493                   {
 494                      it.Remove(p);
 495                      delete p;
 496                   }
 497                }
 498             }
 499             if(!currentNode.platforms.count)
 500                currentNode.platforms = null;
 501          }
 502          Load();
 503          return;
 504       }
 505
 506       if(currentNode.options && OptionSet(currentNode.options))
 507          UnsetOption(currentNode.options);
 508       if(currentNode.options && currentNode.options.isEmpty)
 509       {
 510          // delete currentNode.options;
 511          // Property will free:
 512          currentNode.options = null;
 513       }
 514
 515       Load();
 516    }
 517
 518    void FigureOutInherited()
 519    {
 520       ProjectNode node;
 521       char * platformName = platform ? platform.OnGetString(0,0,0) : null;
 522       bool skipped = false;
 523       for(node = currentNode; node; node = node.parent)
 524       {
 525          bool configXplatformSet = false;
 526          if(config && node.configurations)
 527          {
 528             for(c : node.configurations; !strcmpi(c.name, config.name))
 529             {
 530                if(platform && c.platforms)
 531                {
 532                   for(p : c.platforms; !strcmpi(p.name, platformName))
 533                   {
 534                      if(p.options && OptionSet(p.options))
 535                      {
 536                         if(skipped)
 537                            LoadOption(p.options);
 538                      }
 539                      configXplatformSet = true;
 540                      skipped = true;
 541                      break;
 542                   }
 543                }
 544
 545                if(skipped && c.options && OptionSet(c.options))
 546                {
 547                   LoadOption(c.options);
 548                   if(configReplaces) return;
 549                }
 550                skipped = true;
 551                break;
 552             }
 553          }
 554          if((!configXplatformSet || !configReplaces) && platform && node.platforms)
 555          {
 556             for(p : node.platforms; !strcmpi(p.name, platformName))
 557             {
 558                if(skipped && p.options && OptionSet(p.options))
 559                   LoadOption(p.options);
 560                skipped = true;
 561                break;
 562             }
 563          }
 564          if(skipped && node.options && OptionSet(node.options))
 565             LoadOption(node.options);
 566          else if(skipped && !node.parent)
 567             LoadOption(null);
 568          skipped = true;
 569       }
 570    }
 571
 572    void Retrieve()
 573    {
 574       char * platformName = platform ? platform.OnGetString(0,0,0) : null;
 575       MarkBuildTabModified();
 576       if(config)
 577       {
 578          ProjectConfig c = null;
 579          if(!currentNode.configurations) currentNode.configurations = { };
 580          for(i : currentNode.configurations; !strcmpi(i.name, config.name)) { c = i; break; }
 581          if(!c)
 582             currentNode.configurations.Add(c = ProjectConfig { name = CopyString(config.name) });
 583          if(platform)
 584          {
 585             PlatformOptions p = null;
 586             if(!c.platforms) c.platforms = { };
 587
 588             for(i : c.platforms; !strcmpi(i.name, platformName)) { p = i; break; }
 589             if(!p)
 590                c.platforms.Add(p = PlatformOptions { CopyString(platformName) });
 591
 592             if(!p.options) p.options = { };
 593             RetrieveOption(p.options, true);
 594             if(!mergeValues) SetAttribs(1);
 595             return;
 596          }
 597          if(!c.options) c.options = { };
 598          RetrieveOption(c.options, true);
 599          if(!mergeValues) SetAttribs(1);
 600          return;
 601       }
 602       if(platform)
 603       {
 604          PlatformOptions p = null;
 605          if(!currentNode.platforms) currentNode.platforms = { };
 606          for(i : currentNode.platforms; !strcmpi(i.name, platformName)) { p = i; break; }
 607          if(!p)
 608             currentNode.platforms.Add(p = PlatformOptions { CopyString(platformName) });
 609
 610          if(!p.options) p.options = { };
 611          RetrieveOption(p.options, true);
 612          if(!mergeValues) SetAttribs(1);
 613          return;
 614       }
 615
 616       if(!currentNode.options) currentNode.options = { };
 617       RetrieveOption(currentNode.options, false);
 618       if(!mergeValues) SetAttribs((currentNode.parent || OptionCheck(currentNode.options)) ? 1 : 0);
 619    }
 620
 621    void Load()
 622    {
 623       ProjectNode node;
 624       char * platformName = platform ? platform.OnGetString(0,0,0) : null;
 625       bool setAttribs = false;
 626       for(node = currentNode; node; node = node.parent)
 627       {
 628          bool configXplatformSet = false;
 629          ProjectConfig nodeConfig = null;
 630          if(config && node.configurations)
 631          {
 632             for(c : node.configurations; !strcmpi(c.name, config.name))
 633             {
 634                if(platform && c.platforms)
 635                {
 636                   for(p : c.platforms; !strcmpi(p.name, platformName))
 637                   {
 638                      if(p.options && (mergeValues ? OptionCheck(p.options) : OptionSet(p.options)))
 639                      {
 640                         LoadOption(p.options);
 641                         if(!setAttribs) { setAttribs = true; SetAttribs((node == currentNode) ? 1 : 2); }
 642                         if(!mergeValues) { FinalizeLoading(); return; }
 643                         configXplatformSet = true;
 644                      }
 645                      break;
 646                   }
 647                }
 648
 649                nodeConfig = c;
 650                break;
 651             }
 652          }
 653          if(platform && node.platforms && (!configXplatformSet || !configReplaces))
 654          {
 655             for(p : node.platforms; !strcmpi(p.name, platformName))
 656             {
 657                if(p.options && (mergeValues ? OptionCheck(p.options) : OptionSet(p.options)))
 658                {
 659                   LoadOption(p.options);
 660                   if(!setAttribs) { setAttribs = true; SetAttribs((node == currentNode && !config) ? 1 : 2); }
 661                   if(!mergeValues) { FinalizeLoading(); return; }
 662                }
 663                break;
 664             }
 665          }
 666
 667          if(nodeConfig && nodeConfig.options && ((mergeValues && !configReplaces) ? OptionCheck(nodeConfig.options) : OptionSet(nodeConfig.options)))
 668          {
 669             LoadOption(nodeConfig.options);
 670             if(!setAttribs) { setAttribs = true; SetAttribs((node == currentNode && !platform) ? 1 : 2); }
 671             if(!mergeValues || configReplaces) { FinalizeLoading(); return; }
 672          }
 673
 674          if(node.options && (mergeValues ? OptionCheck(node.options) : OptionSet(node.options)))
 675          {
 676             LoadOption(node.options);
 677             if(!node.parent && !OptionCheck(node.options))
 678             {
 679                if(!setAttribs) { setAttribs = true; SetAttribs(0); }
 680             }
 681             else
 682             {
 683                if(!setAttribs) { setAttribs = true; SetAttribs((node == currentNode && !config && !platform) ? 1 : 2); }
 684             }
 685             if(!mergeValues) { FinalizeLoading(); return; }
 686          }
 687          else if(!node.parent)
 688          {
 689             LoadOption(null);
 690             if(!setAttribs) { setAttribs = true; SetAttribs(0); }
 691             if(!mergeValues) { FinalizeLoading(); return; }
 692          }
 693       }
 694       FinalizeLoading();
 695    }
 696 }
 697
 698 class StringOptionBox : OptionBox<String>
 699 {
 700    editor = EditBox
 701    {
 702       bool NotifyModified(EditBox editBox)
 703       {
 704          ((OptionBox)editBox.id).Retrieve();
 705          return true;
 706       }
 707
 708       textHorzScroll = true;
 709    };
 710
 711    void RetrieveOption(ProjectOptions options, bool isCfgOrPlt)
 712    {
 713       String * string = (String*)((byte *)options + option);
 714       if(*string) delete *string;
 715       *string = CopyString(((EditBox)editor).contents);
 716    }
 717
 718    void LoadOption(ProjectOptions options)
 719    {
 720       ((EditBox)editor).contents = options ? *(String*)((byte *)options + option) : "";
 721       ((EditBox)editor).Deselect();
 722    }
 723
 724    bool OptionCheck(ProjectOptions options)
 725    {
 726       String string = *(String*)((byte *)options + option);
 727       return string && string[0];
 728    }
 729
 730    void UnsetOption(ProjectOptions options)
 731    {
 732       delete *(String*)((byte *)options + option);
 733    }
 734 }
 735
 736 class PathOptionBox : OptionBox<String>
 737 {
 738    bool Window::EditBoxORB(int x, int y, Modifiers mods)
 739    {
 740       Window parent = this.parent;
 741       x += clientStart.x + position.x;
 742       y += clientStart.y + position.y;
 743       return ((OptionBox)this).OptionBox_OnRightButtonDown(parent, x, y, mods);
 744    }
 745
 746    editor = PathBox
 747    {
 748       typeExpected = directory, browseDialog = { };
 749       editBox.OnRightButtonDown = (void *)EditBoxORB;
 750
 751       bool NotifyModified(PathBox pathBox)
 752       {
 753          ((OptionBox)pathBox.id).Retrieve();
 754          return true;
 755       }
 756    };
 757
 758    void RetrieveOption(ProjectOptions options, bool isCfgOrPlt)
 759    {
 760       String * string = (String*)((byte *)options + option);
 761       String slashPath = ((PathBox)editor).slashPath;
 762       if(*string) delete *string;
 763       *string = CopyString(slashPath);//(slashPath && slashPath[0]) ? CopyString(slashPath) : null;
 764    }
 765
 766    void LoadOption(ProjectOptions options)
 767    {
 768       ((PathBox)editor).path = options ? *(String*)((byte *)options + option) : "";
 769       ((PathBox)editor).Deselect();
 770    }
 771
 772    bool OptionCheck(ProjectOptions options)
 773    {
 774       String string = *(String*)((byte *)options + option);
 775       return string && string[0];
 776    }
 777
 778    void UnsetOption(ProjectOptions options)
 779    {
 780       delete *(String*)((byte *)options + option);
 781    }
 782 }
 783
 784 class MultiStringOptionBox : OptionBox<Array<String>>
 785 {
 786    bool caseSensitive;
 787
 788    mergeValues = true;
 789    caseSensitive = true;
 790
 791    virtual Array<String> GetStrings();
 792    virtual void SetStrings(Array<String> value);
 793
 794    Array<String> tempStrings;
 795
 796    void RetrieveOption(ProjectOptions options, bool isCfgOrPlt)
 797    {
 798       Array<String> newStrings = GetStrings();
 799       Array<String> * strings = (Array<String>*)((byte *)options + option);
 800       if(*strings) { strings->Free(); delete *strings; }
 801
 802       if(mergeValues)
 803       {
 804          Iterator<String> it { newStrings };
 805
 806          FigureOutInherited();
 807
 808          if(tempStrings)
 809          {
 810             Array<String> ts = tempStrings;
 811             while(it.Next())
 812             {
 813                String s = it.data;
 814                bool found = false;
 815                for(i : tempStrings; !(caseSensitive ? strcmp : strcmpi)(i, s)) { found = true; break; }
 816                if(found && (!configReplaces || platform))   // ADDED || platform here...
 817                {
 818                   delete s;
 819                   it.Remove();
 820                }
 821             }
 822          }
 823          delete tempStrings;
 824       }
 825
 826       *strings = newStrings;
 827
 828       Load();
 829    }
 830
 831    void LoadOption(ProjectOptions options)
 832    {
 833       if(mergeValues)
 834       {
 835          Array<String> strings = options ? *((Array<String>*)((byte *)options + option) : null;
 836          if(strings)
 837          {
 838             if(!tempStrings)
 839                tempStrings = { };
 840             for(s : strings)
 841             {
 842                bool found = false;
 843                for(i : tempStrings; !(caseSensitive ? strcmp : strcmpi)(i, s)) { found = true; break; }
 844                if(!found) tempStrings.Add(s);
 845             }
 846          }
 847       }
 848       else
 849       {
 850          SetStrings(options ? *(Array<String>*)((byte *)options + option) : null);
 851       }
 852    }
 853
 854    void FinalizeLoading()
 855    {
 856       if(mergeValues)
 857       {
 858          SetStrings(tempStrings);
 859          delete tempStrings;
 860       }
 861    }
 862
 863    bool OptionSet(ProjectOptions options)
 864    {
 865       Array<String> strings = *(Array<String>*)((byte *)options + option);
 866       if(mergeValues && !configReplaces)
 867       {
 868          return strings && strings.count;
 869       }
 870       else
 871          return strings != null;
 872    }
 873
 874    bool OptionCheck(ProjectOptions options)
 875    {
 876       Array<String> strings = *(Array<String>*)((byte *)options + option);
 877       return strings && strings.count;
 878    }
 879
 880    void UnsetOption(ProjectOptions options)
 881    {
 882       Array<String> * strings = (Array<String>*)((byte *)options + option);
 883       if(*strings) { strings->Free(); delete *strings; }
 884    }
 885 }
 886
 887 class StringArrayOptionBox : MultiStringOptionBox
 888 {
 889    editor = StringListBox
 890    {
 891       bool NotifyModified(EditBox editBox)
 892       {
 893          ((OptionBox)editBox.id).Retrieve();
 894          return true;
 895       }
 896    };
 897
 898    // NO VIRTUAL PROPERTIES YET...
 899    Array<String> GetStrings() { return ((StringListBox)editor).strings; }
 900    void SetStrings(Array<String> value) { ((StringListBox)editor).strings = value; }
 901 }
 902
 903 class StringsArrayOptionBox : MultiStringOptionBox
 904 {
 905    editor = StringsBox
 906    {
 907       bool OnCreate()
 908       {
 909          project = ::project;
 910          return true;
 911       }
 912
 913       bool NotifyModified(StringsBox stringsBox)
 914       {
 915          ((OptionBox)stringsBox.id).Retrieve();
 916          return true;
 917       }
 918    };
 919
 920    Array<String> GetStrings() { return ((StringsBox)editor).strings; }
 921    void SetStrings(Array<String> value) { ((StringsBox)editor).strings = value; }
 922 }
 923
 924 class DirsArrayOptionBox : MultiStringOptionBox
 925 {
 926    editor = DirectoriesBox
 927    {
 928       bool NotifyModified(DirectoriesBox dirsBox)
 929       {
 930          ((OptionBox)dirsBox.id).Retrieve();
 931          return true;
 932       }
 933
 934       bool OnChangedDir(char * * directory)
 935       {
 936          char fixedDirectory[MAX_LOCATION] = "";
 937          if(PathCat(fixedDirectory, *directory))
 938          {
 939             char cwdBackup[MAX_LOCATION];
 940             if(project)
 941             {
 942                GetWorkingDir(cwdBackup, sizeof(cwdBackup));
 943                ChangeWorkingDir(project.topNode.path);
 944             }
 945             FileFixCase(fixedDirectory);
 946             if(project)
 947                ChangeWorkingDir(cwdBackup);
 948             delete *directory;
 949             *directory = CopyString(fixedDirectory);
 950             return true;
 951          }
 952          return false;
 953       }
 954
 955       bool OnPrepareBrowseDir(char * * directory)
 956       {
 957          char dir[MAX_LOCATION];
 958          if(project)
 959          {
 960             GetSystemPathBuffer(dir, project.topNode.path);
 961             if(*directory)
 962                PathCat(dir, *directory);
 963          }
 964          else if(*directory)
 965             strcpy(dir, *directory);
 966          else
 967             dir[0] = '\0';
 968
 969          delete *directory;
 970          *directory = CopyString(dir);
 971
 972             // GCC 4.4 bug:  -----  path becomes *directory
 973             //strcpy(dir, path ? path : "");
 974          return true;
 975       }
 976
 977       bool OnBrowsedDir(char * * directory)
 978       {
 979          if(project)
 980          {
 981             char path[MAX_LOCATION];
 982             MakePathRelative(*directory, project.topNode.path, path);
 983             delete *directory;
 984             *directory = CopyString(path);
 985          }
 986          return true;
 987       }
 988    };
 989
 990    Array<String> GetStrings() { return ((DirectoriesBox)editor).strings; }
 991    void SetStrings(Array<String> value) { ((DirectoriesBox)editor).strings = value; }
 992 }
 993
 994 class BoolOptionBox : OptionBox<SetBool>
 995 {
 996    editor = Button
 997    {
 998       isCheckbox = true;
 999
1000       bool NotifyClicked(Button button, int x, int y, Modifiers mods)
1001       {
1002          ((OptionBox)button.id).Retrieve();
1003          return true;
1004       }
1005    };
1006
1007    bool OptionCheck(ProjectOptions options)
1008    {
1009       return *(SetBool*)((byte *)options + option) == true;
1010    }
1011
1012    void RetrieveOption(ProjectOptions options, bool isCfgOrPlt)
1013    {
1014       bool checked = ((Button)editor).checked;
1015       *(SetBool*)((byte *)options + option) = checked ? true :
1016          ((currentNode.parent || isCfgOrPlt) ? false : unset);
1017    }
1018
1019    void LoadOption(ProjectOptions options)
1020    {
1021       ((Button)editor).checked = options && (*(SetBool*)((byte *)options + option) == true);
1022    }
1023 }
1024
1025 class DropOptionBox : OptionBox
1026 {
1027    editor = DropBox
1028    {
1029       bool NotifySelect(DropBox dropBox, DataRow row, Modifiers mods)
1030       {
1031          ((OptionBox)dropBox.id).Retrieve();
1032          return true;
1033       }
1034    };
1035
1036    void LoadOption(ProjectOptions options)
1037    {
1038       DropBox dropBox = (DropBox)editor;
1039       Z value = options ? *(Z*)((byte *)options + option) : (Z)0;
1040       dropBox.currentRow = value ? dropBox.FindRow((int)value) : dropBox.firstRow;
1041    }
1042
1043    void RetrieveOption(ProjectOptions options, bool isCfgOrPlt)
1044    {
1045       DropBox dropBox = (DropBox)editor;
1046       DataRow row = dropBox.currentRow;
1047       Z value = (Z)(row ? row.tag : 0);
1048       *(Z*)((byte *)options + option) = value;
1049    }
1050 }
1051
1052 class TargetTypeDB : DropOptionBox<TargetTypes>
1053 {
1054    TargetTypeDB()
1055    {
1056       DataRow row;
1057
1058       row = ((DropBox)editor).AddRow();
1059       row.tag = TargetTypes::executable;
1060       row.SetData(null, $"Executable");
1061
1062       row = ((DropBox)editor).AddRow();
1063       row.tag = TargetTypes::sharedLibrary;
1064       row.SetData(null, $"Shared Library");
1065
1066       row = ((DropBox)editor).AddRow();
1067       row.tag = TargetTypes::staticLibrary;
1068       row.SetData(null, $"Static Library");
1069    }
1070
1071    bool OptionCheck(ProjectOptions options)
1072    {
1073       TargetTypes value = *(TargetTypes*)((byte *)options + option);
1074       return value && value != executable;
1075    }
1076 }
1077
1078 class OptimizationDB : DropOptionBox<OptimizationStrategy>
1079 {
1080    OptimizationDB()
1081    {
1082       DataRow row;
1083       row = ((DropBox)editor).AddRow();
1084       row.tag = OptimizationStrategy::none;
1085       row.SetData(null, $"None");
1086
1087       row = ((DropBox)editor).AddRow();
1088       row.tag = OptimizationStrategy::speed;
1089       row.SetData(null, $"For Speed (-O2)");
1090
1091       row = ((DropBox)editor).AddRow();
1092       row.tag = OptimizationStrategy::size;
1093       row.SetData(null, $"For Size (-Os)");
1094    }
1095
1096    bool OptionCheck(ProjectOptions options)
1097    {
1098       OptimizationStrategy value = *(OptimizationStrategy*)((byte *)options + option);
1099       return value && value != none;
1100    }
1101 }
1102
1103 class WarningsDB : DropOptionBox<WarningsOption>
1104 {
1105    WarningsDB()
1106    {
1107       DataRow row;
1108       row = ((DropBox)editor).AddRow();
1109       row.tag = WarningsOption::normal;
1110       row.SetData(null, $"Normal");
1111
1112       row = ((DropBox)editor).AddRow();
1113       row.tag = WarningsOption::none;
1114       row.SetData(null, $"None");
1115
1116       row = ((DropBox)editor).AddRow();
1117       row.tag = WarningsOption::all;
1118       row.SetData(null, $"All");
1119    }
1120
1121    bool OptionCheck(ProjectOptions options)
1122    {
1123       WarningsOption value = *(WarningsOption*)((byte *)options + option);
1124       return value && value != none;
1125    }
1126 }
1127
1128 void DrawStipple(Surface surface, Size clientSize)
1129 {
1130    int x1 = 0;
1131    int y1 = 0;
1132    int x2 = clientSize.w - 1;
1133    int y2 = clientSize.h - 1;
1134    if((x2 - x1) & 1) x2--;
1135    if((y2 - y1) & 1) y2--;
1136
1137    surface.LineStipple(0x5555);
1138    surface.Rectangle(x1, y1, x2, y2);
1139    surface.LineStipple(0);
1140 }
1141
1142 class BuildTab : Tab
1143 {
1144    text = $"Build";
1145    background = formColor;
1146    tabCycle = true;
1147
1148    ProjectNode backupNode;
1149    String activeConfigName;
1150
1151    ProjectNode lastSelectedNode;
1152
1153    property char * selectedConfigName
1154    {
1155       get
1156       {
1157          if(created)
1158          {
1159             SelectorButton button = (SelectorButton)configSelector.selectedButton;
1160             if(button && button.id)
1161             {
1162                ProjectConfig config = (ProjectConfig)button.id;
1163                return config.name;
1164             }
1165          }
1166          return "";
1167       }
1168    }
1169
1170    property char * selectedPlatformName
1171    {
1172       get
1173       {
1174          if(created)
1175          {
1176             SelectorButton button = (SelectorButton)platformSelector.selectedButton;
1177             if(button && button.id)
1178             {
1179                Platform platform = (Platform)button.id;
1180                char * platformName = platform ? platform.OnGetString(0,0,0) : null; // all these platformName are leaking, no?
1181                return platformName;
1182             }
1183          }
1184          return "";
1185       }
1186    }
1187
1188    Label labelConfigurations
1189    {
1190       this, anchor = { left = 8, top = 14 }, labeledWindow = configSelector;
1191
1192       void OnRedraw(Surface surface)
1193       {
1194          Label::OnRedraw(surface);
1195          if(labeledWindow.active) DrawStipple(surface, clientSize);
1196       }
1197    };
1198    SelectorBar configSelector
1199    {
1200       this, text = $"Configurations: ", anchor = { left = 98, top = 8, right = 54 }; size = { 0, 26 };
1201       opacity = 0;
1202       direction = horizontal, scrollable = true;
1203
1204       bool OnKeyDown(Key key, unichar ch)
1205       {
1206          if(key == insert)
1207          {
1208             ((BuildTab)parent).createConfig.NotifyClicked(parent, ((BuildTab)parent).createConfig, 0, 0, 0);
1209             return false;
1210          }
1211          else if(key == del)
1212          {
1213             ((BuildTab)parent).deleteConfig.NotifyClicked(parent, ((BuildTab)parent).deleteConfig, 0, 0, 0);
1214             return false;
1215          }
1216          return SelectorBar::OnKeyDown(key, ch);
1217       }
1218
1219       bool OnActivate(bool active, Window previous, bool * goOnWithActivation, bool direct)
1220       {
1221          ((BuildTab)master).labelConfigurations.Update(null);
1222          return true;
1223       }
1224    };
1225
1226    Button createConfig
1227    {
1228       parent = this, bevelOver = true, inactive = true;
1229       size = { 22, 22 };
1230       anchor = { top = 10, right = 31 };
1231       hotKey = altC, bitmap = BitmapResource { fileName = ":actions/docNew.png", alphaBlend = true };
1232
1233       bool NotifyClicked(Button b, int x, int y, Modifiers mods)
1234       {
1235          char tmp[MAX_F_STRING];
1236          ProjectConfig config;
1237          EditableSelectorButton button;
1238
1239          FindUniqueConfigName("NewConfig", false, tmp);
1240
1241          config =
1242          {
1243             makingModified = true;
1244             compilingModified = true;
1245             linkingModified = true;
1246             name = CopyString(tmp);
1247             options =
1248             {
1249                // objectsDirectory = /*CopyString(*/defaultObjDirExpression/*)*/;
1250             };
1251          };
1252          if(!project.topNode.configurations) project.topNode.configurations = { };
1253          project.topNode.configurations.Add(config);
1254          /*
1255          targetType = project.config.options.targetType;
1256          config.options.
1257          config.options.targetFileName = project.moduleName;
1258          config.options.targetDir.dir = "";
1259          config.options.objectsDirectory = defaultObjDirExpression);
1260          config.options.debug = true;
1261          config.options.optimization = none;
1262          config.options.warnings = all;
1263          */
1264
1265          button =
1266          {
1267             configSelector, renameable = true, master = this, text = config.name, id = (int)config;
1268             NotifyClicked = ConfigClicked, OnRename = ConfigOnRename;
1269          };
1270
1271          configSelector.Select(button);
1272          modifiedDocument = true;
1273          return true;
1274       }
1275    };
1276    /*Button duplicateConfig
1277    {
1278       parent = this, bevelOver = true, inactive = true;
1279       size = { 22, 22 };
1280       anchor = { top = 10, right = 31 };
1281       hotKey = altU, bitmap = BitmapResource { fileName = ":actions/editCopy.png", alphaBlend = true };
1282    };*/
1283    Button deleteConfig
1284    {
1285       parent = this, bevelOver = true, inactive = true;
1286       size = { 22, 22 };
1287       anchor = { top = 10, right = 8 };
1288       hotKey = altD, bitmap = BitmapResource { fileName = ":actions/delete2.png", alphaBlend = true };
1289
1290       bool NotifyClicked(Button button, int x, int y, Modifiers mods)
1291       {
1292          if(config)
1293          {
1294             String title = PrintString($"Delete ", config.name, $" Configuration");
1295             String msg = PrintString($"Are you sure you wish to delete the ", config.name, $" configuration?");
1296             if(MessageBox { type = okCancel, text = title, contents = msg }.Modal() == ok)
1297             {
1298                Iterator<Window> it { configSelector.controls };
1299                ProjectConfig configToDelete = config;
1300                /*
1301                while(it.Next())
1302                {
1303                   SelectorButton button = (SelectorButton)it.data;
1304                   if((ProjectConfig)button.id == config)
1305                   {
1306                      button.visible = false;
1307                      button.Destroy(0);
1308
1309                      if(it.Prev())
1310                      {
1311                         button = (SelectorButton)it.data;
1312                         config = (ProjectConfig)button.id;
1313                         configSelector.Select(button);
1314                      }
1315                      break;
1316                   }
1317                }
1318                */
1319                SelectorButton button = configSelector.FindButtonByID((int)configToDelete);
1320                if(button)
1321                   configSelector.RemoveButton(button);
1322
1323                project.topNode.DeleteConfig(configToDelete);
1324
1325                modifiedDocument = true;
1326             }
1327             delete title;
1328             delete msg;
1329          }
1330          return true;
1331       }
1332    };
1333
1334    Label labelPlatforms
1335    {
1336       this, anchor = { left = 8, top = 44 }, labeledWindow = platformSelector;
1337
1338       void OnRedraw(Surface surface)
1339       {
1340          Label::OnRedraw(surface);
1341          if(labeledWindow.active) DrawStipple(surface, clientSize);
1342       }
1343    };
1344    SelectorBar platformSelector
1345    {
1346       this, text = $"Platforms: ", anchor = { left = 64, top = 38, right = 54 }; size = { 0, 26 };
1347       opacity = 0;
1348       direction = horizontal, scrollable = true;
1349
1350       bool OnActivate(bool active, Window previous, bool * goOnWithActivation, bool direct)
1351       {
1352          ((BuildTab)master).labelPlatforms.Update(null);
1353          return true;
1354       }
1355    };
1356
1357    TabControl buildTabControl
1358    {
1359       this, background = formColor, anchor = { left = 8, top = 64, right = 8, bottom = 8 };
1360       curTab = compilerTab;
1361    };
1362    CompilerTab compilerTab { this, tabControl = buildTabControl };
1363    LinkerTab linkerTab { this, tabControl = buildTabControl };
1364    BuilderTab builderTab { this, tabControl = buildTabControl };
1365    Label rightClick
1366    {
1367       this, font = { font.faceName, font.size, italic = true }, stayOnTop = true,
1368       text = $"(Right click or press Ctrl-Del to revert an option to inherited value)", anchor = { top = 72, right = 16 }
1369    };
1370
1371    void FindUniqueConfigName(char * baseName, bool startWithNumber, char * output)
1372    {
1373       int num = 0;
1374       char tmp[MAX_F_STRING];
1375       if(startWithNumber)
1376          sprintf(tmp, "%s%d", baseName, num);
1377       else
1378          strcpy(tmp, baseName);
1379       while(true)
1380       {
1381          ProjectConfig config = null;
1382          for(c : project.topNode.configurations)
1383          {     // TOFIX: Error when omitting these brackets, c not found
1384             if(c.name && !strcmp(c.name, tmp))
1385             {
1386                config = c;
1387                break;
1388             }
1389          }
1390          if(config)
1391          {
1392             num++;
1393             sprintf(tmp, "%s%d", baseName, num);
1394          }
1395          else
1396             break;
1397       }
1398       strcpy(output, tmp);
1399    }
1400
1401    bool PlatformClicked(Button clickedButton, int x, int y, Modifiers mods)
1402    {
1403       if(!eClass_IsDerived(clickedButton._class, class(EditableSelectorButton)) || !((EditableSelectorButton)clickedButton).editBox)
1404       {
1405          platform = (Platform)clickedButton.id;
1406
1407          // Load Settings Into Dialog
1408          compilerTab.LoadSettings();
1409          linkerTab.LoadSettings();
1410          builderTab.LoadSettings();
1411
1412          if(!mods)
1413             buildTabControl.Activate();
1414
1415          if(compilerTab.rightPaneHeader.visible)
1416             compilerTab.rightPaneHeader.Update(null);
1417          ((ProjectSettings)master).UpdateDialogTitle();
1418       }
1419       return true;
1420    }
1421
1422    ~BuildTab()
1423    {
1424       platformSelector.DestroyChildren();
1425       configSelector.DestroyChildren();
1426
1427       delete activeConfigName;
1428    }
1429
1430    bool ConfigOnRename(EditableSelectorButton button, char * * oldName, char * * newName)
1431    {
1432       int c, d = 0;
1433       char ch;
1434
1435       for(c = 0; (ch = (*newName)[c]); c++)
1436       {
1437          if(ch == '_' || isalpha(ch) || (isdigit(ch) && d))
1438             (*newName)[d++] = ch;
1439       }
1440       (*newName)[d] = 0;
1441
1442       {
1443          bool found = false;
1444          for(c : project.topNode.configurations; c != config)
1445          {
1446             if(!strcmpi(c.name, *newName))
1447             {
1448                found = true;
1449                break;
1450             }
1451          }
1452          if(found || !(*newName)[0])
1453          {
1454             char tmp[MAX_F_STRING];
1455             char * tmpName = config.name;
1456             config.name = null;
1457             FindUniqueConfigName("NewConfig", false, tmp);
1458             config.name = tmpName;
1459             delete *newName;
1460             *newName = CopyString(tmp);
1461          }
1462       }
1463
1464       if(activeConfigName && !strcmp(activeConfigName, *oldName))
1465       {
1466          delete activeConfigName;
1467          activeConfigName = CopyString(*newName);
1468       }
1469
1470       project.topNode.RenameConfig(config.name, *newName);
1471
1472       modifiedDocument = true;
1473       return true;
1474    }
1475
1476    bool ConfigClicked(Button clickedButton, int x, int y, Modifiers mods)
1477    {
1478       if(!eClass_IsDerived(clickedButton._class, class(EditableSelectorButton)) || !((EditableSelectorButton)clickedButton).editBox)
1479       {
1480          config = (ProjectConfig)clickedButton.id;
1481
1482          // Load Settings Into Dialog
1483          compilerTab.LoadSettings();
1484          linkerTab.LoadSettings();
1485          builderTab.LoadSettings();
1486
1487          deleteConfig.disabled = (clickedButton._class == class(SelectorButton));
1488
1489          if(!mods)
1490             buildTabControl.Activate();
1491
1492          if(compilerTab.rightPaneHeader.visible)
1493             compilerTab.rightPaneHeader.Update(null);
1494          ((ProjectSettings)master).UpdateDialogTitle();
1495       }
1496       return true;
1497    }
1498
1499    void SelectNode(ProjectNode node, bool ignoreAsLastSelection)
1500    {
1501       if(node != currentNode)
1502       {
1503          Window ac = compilerTab.rightPane.activeChild;
1504          bool prevNodeRes = currentNode ? currentNode.isInResources : false;
1505          bool newNodeRes;
1506
1507          if(!node) node = project.topNode;
1508
1509          newNodeRes = node.isInResources;
1510
1511          currentNode = node;
1512          if(!ignoreAsLastSelection)
1513             lastSelectedNode = node;
1514
1515          ((ProjectSettings)master).UpdateDialogTitle();
1516          if(node.type == project)
1517          {
1518             compilerTab.rightPaneHeader.visible = false;
1519          }
1520          else
1521          {
1522             compilerTab.rightPaneHeader.id = (int)node;
1523             compilerTab.rightPaneHeader.Update(null);
1524             compilerTab.rightPaneHeader.visible = true;
1525          }
1526
1527          {
1528             DataRow row = compilerTab.fileList.FindSubRow((int)currentNode);
1529             if(row)
1530             {
1531                compilerTab.fileList.currentRow = row;
1532                while((row = row.parent))
1533                   row.collapsed = false;
1534             }
1535          }
1536
1537          if(prevNodeRes != newNodeRes)
1538          {
1539             compilerTab.labelObjDir.visible = !newNodeRes;
1540             compilerTab.objDir.visible = !newNodeRes;
1541             compilerTab.excludeFromBuild.visible = !newNodeRes;
1542             compilerTab.labelPreprocessorDefs.visible = !newNodeRes;
1543             compilerTab.preprocessorDefs.visible = !newNodeRes;
1544             compilerTab.labelDefaultNameSpace.visible = !newNodeRes;
1545             compilerTab.defaultNameSpace.visible = !newNodeRes;
1546             compilerTab.strictNameSpaces.visible = !newNodeRes;
1547             compilerTab.memoryGuard.visible = !newNodeRes;
1548             compilerTab.noLineNumbers.visible = !newNodeRes;
1549             compilerTab.debug.visible = !newNodeRes;
1550             compilerTab.labelWarnings.visible = !newNodeRes;
1551             compilerTab.warnings.visible = !newNodeRes;
1552             compilerTab.profiling.visible = !newNodeRes;
1553             compilerTab.labelOptimization.visible = !newNodeRes;
1554             compilerTab.optimization.visible = !newNodeRes;
1555             compilerTab.labelIncludeDirs.visible = !newNodeRes;
1556             compilerTab.includeDirs.visible = !newNodeRes;
1557          }
1558
1559          if(node == project.topNode)
1560          {
1561             compilerTab.objDir.visible = true;
1562             compilerTab.labelObjDir.visible = true;
1563
1564             compilerTab.excludeFromBuild.visible = false;
1565          }
1566          else
1567          {
1568             compilerTab.objDir.visible = false;
1569             compilerTab.labelObjDir.visible = false;
1570
1571             compilerTab.excludeFromBuild.visible = (node != project.resNode);
1572          }
1573
1574          // Load Settings Into Dialog
1575          compilerTab.LoadSettings();
1576          linkerTab.LoadSettings();
1577          builderTab.LoadSettings();
1578
1579          if(ac)
1580          {
1581             if(!ac.visible)
1582             {
1583                if(ac == compilerTab.excludeFromBuild.editor)
1584                   ac = compilerTab.objDir.editor;
1585                else if(compilerTab.excludeFromBuild.editor.visible)
1586                   ac = compilerTab.excludeFromBuild.editor;
1587             }
1588             ac.MakeActive();
1589          }
1590       }
1591    }
1592
1593    void CreateConfigButtons()
1594    {
1595       SelectorButton commonButton;
1596
1597       // Create Config Buttons
1598       commonButton = SelectorButton
1599       {
1600          configSelector, master = this, text = $"Common", id = (int)null; font = { font.faceName, font.size, true };
1601          checked = true;
1602          NotifyClicked = ConfigClicked;
1603       };
1604
1605       config = null;
1606
1607       if(project.topNode.configurations)
1608       {
1609          for(c : project.topNode.configurations)
1610          {
1611             EditableSelectorButton button
1612             {
1613                configSelector, master = this, renameable = true, text = c.name, id = (int)c;
1614                NotifyClicked = ConfigClicked, OnRename = ConfigOnRename;
1615             };
1616          }
1617       }
1618    }
1619
1620    void Init()
1621    {
1622       Platform p;
1623       SelectorButton button;
1624
1625       activeConfigName = project.config ? CopyString(project.config.name) : null;
1626
1627       compilerTab.AddNode(project.topNode, null);
1628
1629       CreateConfigButtons();
1630
1631       platformButton = button =
1632       {
1633          platformSelector, master = this, text = $"Common", id = 0;  font = { font.faceName, font.size, true };
1634          NotifyClicked = PlatformClicked; checked = true;
1635       };
1636
1637       platform = 0;
1638
1639       for(p = (Platform)1; p < Platform::enumSize; p++)
1640       {
1641          SelectorButton button
1642          {
1643             platformSelector, master = this, text = p.OnGetString(0,0,0), id = (int)p;
1644             NotifyClicked = PlatformClicked;
1645          };
1646       }
1647    }
1648    SelectorButton platformButton;
1649
1650    bool OnPostCreate()
1651    {
1652       // Backup Current Settings
1653       backupNode = project.topNode.Backup();
1654
1655       buildTabControl.Activate();
1656
1657       {
1658          Iterator<Window> it { configSelector.controls };
1659          while(it.Next())
1660          {
1661             SelectorButton configButton = (SelectorButton)it.data;
1662             ProjectConfig buttonConfig = (ProjectConfig)configButton.id;
1663             if(buttonConfig == project.config)
1664             {
1665                configButton.Activate();
1666                configButton.checked = true;
1667                ConfigClicked(configButton, 0, 0, (Modifiers)null);
1668                break;
1669             }
1670          }
1671       }
1672       if(platformButton)
1673       {
1674          platformButton.MakeActive();
1675          platformButton = null;
1676       }
1677       return true;
1678    }
1679
1680    void OnDestroy()
1681    {
1682       delete backupNode;
1683
1684       lastSelectedNode = null;
1685
1686       project.config = null;
1687
1688       /* // THIS IS NOW AUTOMATED WITH A project CHECK IN ProjectNode
1689       project.configurations = project.topNode.configurations;
1690       project.platforms = project.topNode.platforms;
1691       project.options = project.topNode.options;
1692       */
1693
1694       if(project.topNode.configurations)
1695       {
1696          for(c : project.topNode.configurations)
1697          {
1698             if(!strcmpi(c.name, activeConfigName))
1699             {
1700                project.config = c;
1701                break;
1702             }
1703          }
1704       }
1705    }
1706
1707    void RevertChanges()
1708    {
1709       String configName = config ? CopyString(config.name) : null;
1710
1711       // Revert to saved project options
1712       project.topNode.Revert(backupNode);
1713
1714       configSelector.DestroyChildren();
1715       CreateConfigButtons();
1716
1717       // Reselect Configuration
1718       if(configName)
1719       {
1720          Iterator<Window> it { configSelector.controls };
1721          while(it.Next())
1722          {
1723             Button button = (Button)it.data;
1724             ProjectConfig c = (ProjectConfig)button.id;
1725             if(c && !strcmp(c.name, configName))
1726             {
1727                config = c;
1728                button.Activate();
1729                button.checked = true;
1730                ConfigClicked(button, 0,0, 0);
1731                break;
1732             }
1733          }
1734       }
1735
1736       SelectNode(project.topNode, false);
1737
1738       delete configName;
1739    }
1740
1741    bool OnClose(bool parentClosing)
1742    {
1743       if(modifiedDocument)
1744       {
1745          DialogResult diagRes = MessageBox
1746          {
1747             type = yesNoCancel, master = ide,
1748             text = $"Save changes to project settings?",
1749             contents = $"Would you like to save changes made to the build options?"
1750          }.Modal();
1751          if(diagRes == no)
1752             RevertChanges();
1753          if(diagRes == cancel)
1754             return false;
1755          if(diagRes == yes)
1756          {
1757             project.MarkChanges(backupNode);
1758             project.topNode.modified = true;
1759             ide.projectView.modifiedDocument = true;
1760             ide.projectView.Update(null);
1761          }
1762          modifiedDocument = false;
1763       }
1764       return true;
1765    }
1766 }
1767
1768 class CompilerTab : Tab
1769 {
1770    background = formColor;
1771    text = $"Compiler";
1772
1773    Window leftPane { this, size = { 180 }, anchor = { left = 0, top = 0, bottom = 0 }, background = formColor };
1774
1775    Label labelFileList { leftPane, this, position = { 8, 8 }, labeledWindow = fileList };
1776    ListBox fileList
1777    {
1778       leftPane, this, borderStyle = deep, hasVertScroll = true, hasHorzScroll = true;
1779       // THIS WOULD BE EVEN MORE FUN: multiSelect = true,
1780       fullRowSelect = false, collapseControl = true, treeBranches = true;
1781       alwaysHighLight = true;
1782       selectionColor = unfocusedSelectorColor;
1783       size = { 180 };
1784       anchor = Anchor { left = 8, top = 24, right = 4, bottom = 8 };
1785       text = $"Files";
1786
1787       bool NotifySelect(ListBox listBox, DataRow row, Modifiers mods)
1788       {
1789          BuildTab buildTab = (BuildTab)master;
1790          ProjectNode node = (ProjectNode)row.tag;
1791          buildTab.SelectNode(node, false);
1792          return true;
1793       }
1794
1795       void OnRedraw(Surface surface)
1796       {
1797          ide.projectView.drawingInProjectSettingsDialog = true;
1798          ListBox::OnRedraw(surface);
1799          ide.projectView.drawingInProjectSettingsDialog = false;
1800       }
1801
1802       bool NotifyActivate(Window window, bool active, Window previous)
1803       {
1804          if(active)
1805          {
1806             //subclass(Skin) skinClass = (subclass(Skin))eSystem_FindClass(app, app.skin);
1807             fileList.selectionColor = Color { 10, 36, 106 }; //skinClass.selectionColor; // darkBlue;
1808          }
1809          else if(fileList.currentRow)
1810          {
1811             DataRow currentRow = fileList.currentRow;
1812             //int headerSize = ((fileList.style.header) ? fileList.rowHeight : 0);
1813             int height = fileList.clientSize.h + 1;// - fileList.headerSize;
1814             fileList.selectionColor = unfocusedSelectorColor;
1815             if(currentRow && currentRow.index * fileList.rowHeight > fileList.scroll.y + height - fileList.rowHeight)
1816                fileList.SetScrollPosition(fileList.scroll.x, currentRow.index * fileList.rowHeight - height + fileList.rowHeight);
1817             else if(!currentRow || currentRow.index * fileList.rowHeight < fileList.scroll.y)
1818                fileList.SetScrollPosition(fileList.scroll.x, currentRow ? currentRow.index * fileList.rowHeight : 0);
1819
1820          }
1821
1822          return true;
1823       }
1824    };
1825
1826    Window rightPane
1827    {
1828       this, anchor = { left = 196, top = 0, right = 0, bottom = 0 }, background = formColor, tabCycle = true;
1829    };
1830
1831    Window rightPaneHeader
1832    {
1833       rightPane, this, size = { h = 21 }, anchor = { left = 0, top = 0, right = 0 }, background = Color { 70, 96, 166 };//0x0F3F66;
1834       foreground = white; visible = false;
1835
1836       void OnRedraw(Surface surface)
1837       {
1838          if(id)
1839          {
1840             ide.projectView.drawingInProjectSettingsDialogHeader = true;
1841             class(ProjectNode)._vTbl[__ecereVMethodID_class_OnDisplay](class(ProjectNode),
1842                id, surface, 8, 2, clientSize.w, ide.projectView, Alignment::left, DataDisplayFlags { selected = true });
1843             ide.projectView.drawingInProjectSettingsDialogHeader = false;
1844          }
1845       }
1846    };
1847
1848    PaneSplitter splitter
1849    {
1850       this, leftPane = leftPane, rightPane = rightPane, split = 188
1851    };
1852
1853    Label labelObjDir { rightPane, this, position = { 8, 8 }, labeledWindow = objDir };
1854    PathOptionBox objDir
1855    {
1856       rightPane, this, size = { 250, 22 }, anchor = { left = 8, top = 24, right = 8 };
1857       text = $"Intermediate Objects Directory", hotKey = altJ, option = OPTION(objectsDirectory);
1858    };
1859
1860    BoolOptionBox excludeFromBuild
1861    {
1862       rightPane, this, position = { 8, 28 },
1863       text = $"Exclude from Build", visible = false, option = OPTION(excludeFromBuild);
1864    };
1865
1866    Label labelPreprocessorDefs { rightPane, this, position = { 8, 50 }, labeledWindow = preprocessorDefs };
1867    StringArrayOptionBox preprocessorDefs
1868    {
1869       rightPane, this, size = { 290, 22 }, anchor = { left = 8, top = 66, right = 8 };
1870       text = $"Preprocessor Definitions", hotKey = altD, option = OPTION(preprocessorDefinitions);
1871    };
1872
1873    Label labelDefaultNameSpace { rightPane, this, position = { 8, 92 }, labeledWindow = defaultNameSpace };
1874    StringOptionBox defaultNameSpace
1875    {
1876       rightPane, this, size = { 160, 22 }, position = { 8, 108 };
1877       text = $"Default Name Space", option = OPTION(defaultNameSpace);
1878    };
1879    BoolOptionBox strictNameSpaces
1880    {
1881       rightPane, this, position = { 172, 112 },
1882       text = $"Strict Name Spaces", option = OPTION(strictNameSpaces);
1883    };
1884
1885    BoolOptionBox memoryGuard
1886    {
1887       rightPane, this, position = { 8, 154 };
1888       text = $"MemoryGuard", hotKey = altM, option = OPTION(memoryGuard);
1889    };
1890
1891    Label labelWarnings { rightPane, position = { 116, 138 }, labeledWindow = warnings };
1892    WarningsDB warnings
1893    {
1894       rightPane, this, position = { 116, 154 };
1895       text = $"Warnings", hotKey = altW, option = OPTION(warnings);
1896    };
1897
1898    Label labelOptimization { rightPane, position = { 244, 138 }, labeledWindow = optimization };
1899    OptimizationDB optimization
1900    {
1901       rightPane, this, position = { 244, 154 }, size = { 120, 22 };
1902       text = $"Optimization", hotKey = altO, option = OPTION(optimization);
1903    };
1904
1905    BoolOptionBox debug
1906    {
1907       rightPane, this, position = { 8, 188 };
1908       text = $"Debuggable", hotKey = altG, option = OPTION(debug);
1909    };
1910
1911    BoolOptionBox profiling
1912    {
1913       rightPane, this, position = { 116, 188 };
1914       text = $"Profiling Data", hotKey = altP, option = OPTION(profile);
1915    };
1916
1917    BoolOptionBox noLineNumbers
1918    {
1919       rightPane, this, position = { 244, 188 };
1920       text = $"No Line Numbers", hotKey = altN, option = OPTION(noLineNumbers);
1921    };
1922
1923    Label labelIncludeDirs { includeDirs.editor, labeledWindow = includeDirs, position = { 0, 6 }; };
1924    DirsArrayOptionBox includeDirs
1925    {
1926       rightPane, this, size = { 290, 22 }, anchor = { left = 8, top = 208, right = 8, bottom = 8 };
1927       text = $"Additional Include Directories", hotKey = altI, option = OPTION(includeDirs);
1928    };
1929
1930    CompilerTab()
1931    {
1932       fileList.AddField(DataField { dataType = class(ProjectNode), freeData = false,
1933          userData = null /* Now set in the ProjectNode directly to know we're in ProjectSettings Dialog -- ide.projectView*/ });
1934    }
1935
1936    bool OnCreate()
1937    {
1938       BuildTab buildTab = (BuildTab)master;
1939       buildTab.SelectNode(buildTab.lastSelectedNode, true);
1940       return true;
1941    }
1942
1943    void AddNode(ProjectNode node, DataRow addTo)
1944    {
1945       DataRow row = addTo ? addTo.AddRow() : fileList.AddRow();
1946
1947       row.tag = (int)node;
1948
1949       row.SetData(null, node);
1950
1951       if(node.files && node.files.first && node.parent &&
1952             !(!node.parent.parent &&
1953                (!strcmpi(node.name, "notes") || !strcmpi(node.name, "sources") ||
1954                   !strcmpi(node.name, "src") || !strcmpi(node.name, "tools"))))
1955          row.collapsed = true;
1956       else if(node.type == folder)
1957          node.icon = openFolder;
1958
1959       if(node.files)
1960       {
1961          for(child : node.files)
1962             AddNode(child, row);
1963       }
1964    }
1965
1966    void LoadSettings()
1967    {
1968       OptionBox ob;
1969       for(ob = (OptionBox)firstSlave; ob; ob = (OptionBox)ob.nextSlave)
1970          if(eClass_IsDerived(ob._class, class(OptionBox)))
1971             ob.Load();
1972
1973       if(activeChild && activeChild.active)
1974       {
1975          Window control = activeChild;
1976          control.Deactivate();
1977          control.Activate();
1978       }
1979    }
1980
1981    bool OnPostCreate()
1982    {
1983       objDir.editor.Activate();
1984       return true;
1985    }
1986 }
1987
1988 class LinkerTab : Tab
1989 {
1990    background = formColor;
1991    text = $"Linker";
1992
1993    Label labelTargetName { this, position = { 8, 8 }, labeledWindow = targetName };
1994    StringOptionBox targetName
1995    {
1996       this, position = { 8, 24 }, size = { 200, 22 };
1997       text = $"Target Name", hotKey = altN, option = OPTION(targetFileName);
1998    };
1999
2000    Label labelTargetType { this, position = { 216, 8 }, labeledWindow = targetType };
2001    TargetTypeDB targetType
2002    {
2003       this, position = { 216, 24 }, size = { 120, 22 };
2004       text = $"Target Type", hotKey = altT, option = OPTION(targetType);
2005    };
2006
2007    Label labelTargetDirectory { this, position = { 344, 8 }, labeledWindow = targetDirectory };
2008    PathOptionBox targetDirectory
2009    {
2010       this, size = { 270, 22 }, anchor = { left = 344, top = 24, right = 8 };
2011       hotKey = altR, text = $"Target Directory", option = OPTION(targetDirectory);
2012    };
2013
2014    Label labelLibraries { this, position = { 8, 50 }, labeledWindow = libraries };
2015    StringArrayOptionBox libraries
2016    {
2017       this, size = { 290, 22 }, anchor = { left = 8, top = 66, right = 8 };
2018       text = $"Additional Libraries", hotKey = altL, option = OPTION(libraries);
2019       configReplaces = true;
2020    };
2021
2022    Label labelLinkerOptions { this, position = { 8, 92 }, labeledWindow = linkerOptions };
2023    StringArrayOptionBox linkerOptions
2024    {
2025       this, size = { 290, 22 }, anchor = { left = 8, top = 108, right = 8 };
2026       text = $"Linker Options", hotKey = altO, option = OPTION(linkerOptions);
2027       configReplaces = true;
2028    };
2029
2030    BoolOptionBox console
2031    {
2032       this, position = { 8, 138 };
2033       text = $"Console Application", hotKey = altC, option = OPTION(console);
2034    };
2035
2036    BoolOptionBox compress
2037    {
2038       this, position = { 8, 162 };
2039       text = $"Compress", hotKey = altW, option = OPTION(compress);
2040    };
2041
2042    Label labelLibraryDirs { libraryDirs.editor, labeledWindow = libraryDirs, position = { 0, 6 }; };
2043    DirsArrayOptionBox libraryDirs
2044    {
2045       this, size = { 290, 22 }, anchor = { left = 8, top = 182, right = 8, bottom = 8 };
2046       text = $"Additional Library Directories", hotKey = altY, option = OPTION(libraryDirs);
2047    };
2048
2049    bool OnCreate()
2050    {
2051       ((BuildTab)master).SelectNode(project.topNode, true);
2052       return true;
2053    }
2054
2055    void LoadSettings()
2056    {
2057       OptionBox ob;
2058       for(ob = (OptionBox)firstSlave; ob; ob = (OptionBox)ob.nextSlave)
2059          if(eClass_IsDerived(ob._class, class(OptionBox)))
2060             ob.Load();
2061       compress.disabled = (config && config.options && config.options.debug == true) || project.topNode.options.debug == true;
2062
2063       if(activeChild && activeChild.active)
2064       {
2065          Window control = activeChild;
2066          control.Deactivate();
2067          control.Activate();
2068       }
2069    }
2070 }
2071
2072 class BuilderTab : Tab
2073 {
2074    background = formColor;
2075    text = $"Builder";
2076
2077    Label labelPrebuildCommands { prebuildCommands.editor, labeledWindow = prebuildCommands, position = { 0, 6 }; };
2078    StringsArrayOptionBox prebuildCommands
2079    {
2080       this, size = { 290, 100 }, anchor = { left = 8, top = 52, right = 8 };
2081       text = $"Pre-build Commands", hotKey = altE, option = OPTION(prebuildCommands);
2082    };
2083
2084    Label labelPostbuildCommands { postbuildCommands.editor, labeledWindow = postbuildCommands, position = { 0, 6 }; };
2085    StringsArrayOptionBox postbuildCommands
2086    {
2087       this, size = { 290, 100 }, anchor = { left = 8, top = 160, right = 8 };
2088       text = $"Post-build Commands", hotKey = altT, option = OPTION(postbuildCommands);
2089    };
2090
2091    void LoadSettings()
2092    {
2093       bool disabled = strlen(((BuildTab)master).selectedPlatformName) > 0;
2094       OptionBox ob;
2095       for(ob = (OptionBox)firstSlave; ob; ob = (OptionBox)ob.nextSlave)
2096          if(eClass_IsDerived(ob._class, class(OptionBox)))
2097             ob.Load();
2098
2099       if(activeChild && activeChild.active)
2100       {
2101          Window control = activeChild;
2102          control.Deactivate();
2103          control.Activate();
2104       }
2105    }
2106 }