What's new/improved in Diamondback
IDE
Multiple personality IDE
The IDE now allows you to create projects and manage for multiple languages and platforms.
C#
Full support for developing C# applications is included in the IDE
Delphi/Win32
Full support for developing Delphi for Win32 applications is included in the IDE
Delphi.NET
Full support for developing Delphi for .NET applications is included in the IDE
Current personality indicator
An icon appears to the right of the menu, indicating which personality is currently active for that project.
General IDE changes
Object Inspector
New look and feel
Better context management
Tool Palette
New look and feel
Better context management
Incremental search improved
Optionally display gallery/repository items in Tool Palette when no project is active
Project manager
Project manager now displays folder structure of project items
Delphi/Win32, Delphi/.NET and C#Builder projects in the same project group.
Alphabetical sorting option
Additional context menu items
Welcome page enhancements
Integrated News feed
Better looking
Debugging
Win32 & .NET debuggers working simultaneously.
Debugging .NET code hosted in a Win32 process.
AppDomain support in the Module view for managed apps (App Domains show up in the module panes and in the scope browser pane)
Sorting in the modules view
Better stack traces in Win32 apps (for frames that don't have debug info)
Locals view allows for changing frames in Win32
Exception notification dialog enhancements
Break/continue buttons
Ignore exception type checkbox
.NET exceptions now show the exception message on dialog
Breakpoint view
Supports in-place editing
Check box to quickly enable/disable breakpoint
Toolbar
"Log call stack" breakpoint action
CPU view showing IL disassembly for .managed processes
Full SSE support including disassembly and SSE register view
Unicode enabling views that show program data (watch, locals, inspector, stack, etc.)
Refactoring
Rename
Extract method
Extract Resource string.
Sync Edit
Find unit/namespace
Declare field
Declare variable
Undo
Currently, Undo uses a local stripe. Changes since the file has been refactored are not monitored. So, before the Undo is applied, a warning comes up asking if you want to perform the Undo. Applying the Undo, your source file will revert changes back to before the refactoring was applied in all files that were modified. This means you will oose any changes that happened in those files since before the refactoring was done.
Note: Undo only does stripes for “Rename” since that is the only refactoring that affects multiple files. The “Extract Method” refactoring is undone in the IDE via Ctrl-Z (regular Undo). Same with declare field and declare variable.
C# & Delphi (Win32 & .NET)
VCL designer (.NET & Win32)
Embedded/non embedded
Left/Top properties can be independently set and persisted with embedded
Can now drag-n-drop from palette
Demand loading of Win32 design-time packages
Persistent bookmarks
Versioning
Multi-level backups with History view
StarTeam integration
Main menu item
StarTeam Project management
Create
Check in/out
create directories
Embedded client
External client launching
Project Manager
Project groups
Manage associations for project groups
Structure pane
Items pane files open in IDE
History view StarTeam aware
locking/unlocking/merging
Change requests
File renames are tracked
SCC API improvements?
Error insight
Expanded real-time error information for source
Integration into the structure view.
Help insight
Tooltip from XML doc information
Updated/consolidated new component wizard
Combines all functions of New VCL component/import AX Type library/control
Open API
New Open Tools API services
Structure View API (native and managed)
History View API (native and managed)
Property Inspector API (native and managed)
Tool Palette API (native)
Better main Toolbar/menu services
Splash Screen and About Box services (native and managed)
Syntax highlighting services (adding new syntax highlighting styles)
Code-insight services (for adding new code-insight handlers)
Compiler
XML doc option for compiler in IDE
This compiler option will generate an XML file with the same "first name" as the original source file, in the same directory as the source file. All comments beginning with /// will be extracted into the XML file.
For example, if your source file is named "myfile.pas" the output file will be named "myfile.xml".
New for Win32 and .NET
for..in..do enumeration syntax
This enumeration syntax is commonly referred to as "foreach" syntax.
Function inlining
Diamondback has an INLINE compiler directive and compiler option {$INLINE AUTO|ON|OFF}. The INLINE directive can be specified at end of function declaration. and longname option {$INLINE ON/AUTO/OFF} can be specified before compiling function body (not for per statements).
{$INLINE ON} is the default. Inline function declared with INLINE directive will be expanded at the call site.
{$INLINE AUTO} is ike {$INLINE ON}, except the compiler tries to make an inline function even if the INLINE directive is not specified, if the function code size is less than or equal to 32 bytes. With {$INLINE OFF}, the inline directive is ignored for function declarations and inline functions are not expanded at the call site.
Here is a simple example.
{$APPTYPE CONSOLE}
procedure Sum(N :Integer): Integer; inline;
var
I: Integer;
begin
Result := 0;
for I := 1 to N do
Inc(Result, I);
end;
procedure Test;
begin
WriteLn(Sum(10));
end;
begin
Test;
end.
// procedure Test is equivalent to:
procedure Test;
var
t1, t2, t3, t4: Integer;
begin
t1 := 10;
t2 := 0;
for t3 := 1 to t1 do
Inc(t2, t3);
t4 := t2;
WriteLn(t4);
end.
Inlining rules
Don't rely on $INLINE AUTO when you're trying to measure the performance or code differences of inlining. $INLINE AUTO is more restrictive / less likely to select your routines for inlining than when you declare the function with the inline directive.
Look out for cross-unit effects. Inlining a routine at a call site within its own unit is a very different situation than inlining a routine imported from another unit. Also, compiling the other unit at the same time as compiling the call site (build all) is a different situation than inlining a function that was loaded from a precompiled.dcu.
$INLINE AUTO is considerably more experimental than declared inlines. Our primary objective with $INLINE AUTO right now is to verify that your programs continue to work as they do without inlining, and maybe some functions get inlined here and there as well. $INLINE AUTO will not be the default setting, will probably never be the default setting, and will not be recommended for general coding scenarios. $INLINE ON is the default and recommended path. $INLINE AUTO is the corner case.
It's acceptable for this release for the compiler to refuse to inline a routine in seemingly trivial situations. We can sort out the corner cases on a time permitting basis as long as inlining works in specific useful cases.
When diagnosing a case that does not inline, carefully whittle down the contributing factors until the test case does inline: parameters and local variables of the inlined function, parameters and local variables at the call site, same unit or cross-unit, build all or load from dcu, compiler options such as range checking or overflow checking, and so forth.
Functions are not inlined across package boundaries. Functions can be inlined between units within a package, though.
Virtual methods are not inlined. This includes methods declared virtual, dynamic, or message, and all methods of interfaces and dispinterfaces.
Functions are not inlined between circularly dependent units. The interface and implementation sections of unit A must be fully compiled before unit B calls to functions in unit A may be inlined.
The RTL and VCL will receive light inlining (by explicit declaration) where the benefits are the greatest. The "macro" functions in Windows.pas, for example, will be marked for inlining. VCL in general, though, will not be marked for extensive inlining, partly for schedule reasons and partly because the VCL core units are heavily circular.
Functions implemented using asm blocks are not inlinable.
Functions with open array parameters are not inlinable. (dynamic arrays and static arrays are ok)
Functions that refer to private or protected members of a class are not inlinable except within methods of that class itself (or possibly descendents, in the case of protected)
Functions that refer to symbols declared in the implementation section of a unit are not inlinable. Such types are not addressable outside of their unit of definition.
This list is not complete and may contain errors or omissions.
support for compiling Unicode and UTF8 source files
Multi-unit namespaces
Unicode identifiers
The Delphi compiler now supports Unicode characters in source code identifiers, and in symbols imported from assembly metadata.
Unicode characters are accepted in identifiers only when the source file encoding is UTF8 or UCS2. High-ascii chars in an identifier in locale-based source will produce an “invalid character” error message just as it did before. Note that source code given to the compiler by the IDE is always encoded in UTF-8. You’ll see differences with the command line compiler since it has to read the files directly.
The compiler is oblivious to the actual content of the Unicode chars. It sees them only as an opaque UTF8 payload. There is no analysis to see if a Unicode char is a special whitespace or punctuation char that probably shouldn’t be allowed in a program identifier. Validation of the unicode chars may be added in the future.
Unicode identifiers are handled as case-insensitive strings, just as with traditional Pascal identifiers
This should have no effect on existing source code. There will probably be glitches in the food chain downstream of the compiler (code insight, error insight) but those can only be reached by using source code that was previously invalid.
Unicode characters are not allowed in published property, field, or method names. This is to prevent “funny chars” from showing up in the RTTI and upsetting third party VCL code that uses RTTI.
Applies to Delphi for .NET and Delphi for Win32
New wild-card "uses" syntax (a.b.*)
Win32 only
Unit initialization consolidation optimization?
.NET only
CF support
DCCIL codegen targeting the .NET Compact Framework should work in Diamondback.
Delphi relies on a .NET function “RunClassConstructor” to touch the unit type and induce initialization if it has not already been done. This function is not implemented in .NET CF.
If the compiler can’t locate the RunClassConstructor function, it will emit a warning and skip the unit-touching codegen step. This means on CF the order in which your units are initialized is determined solely by when your code touches symbols in those units. The order is not determined by the order of the units in the uses clause.
For the desktop .NET platform, unit initialization sequencing is the same as before.
Forward declared record types
Runtime
COM/Interop
Wizards
COM+ Object
COM+ Event Object
COM+ Subscription Object
Remote Data Module
Type library
ActiveX library
Virtual Library Interfaces
Import .NET control for Win32
Register/Unregister ActiveX server
VCL
New components (TButtonGroup and TCategoryButtons; used as basis for new palette).
Better encapsulation of IE WebBrowser component
New TCaptionedDockTree (Dock tree used in IDE).
Various Windows "macro" functions now inlined.
New design time support for Help text in OI
New design time support for hot-link pane in OI
Support for enumerator syntax
VCL.NET
Now supports Weak Packaged units
Security audits done to allow GUI VCL applications to run in < full trust environments for 20% faster performance
Various Windows "macro" functions now inlined.
Support for enumerator syntax
Internet/ASP.NET
ASP.NET/ECO
Project manager improvements
Directory management
Show all files
Context-sensitive new files
web config
page
ASP.NET/HTML Error Insight
Deployment manager wizard
ASP.NET
IntraWeb
Designers
Rubber band (mouse drag) control selection in the designer
Improved Tag Editor support (editing of outer html for most tags)
Edit | Select All Controls
Improved pasting
Template Editor
Run as Server control
Editors
CSS syntax highlighting
CSS code completion
HTML Structure pane
HTML Tidy has been updated to the latest version
Lots of bug fixes
Web Control wizard improved
Improved TWebBrowser
Better code reformatting
If your page has an <HTML> and <BODY> tag and you use the designer and modify the page when you click back to the code editor we will reformat the entire contents of the file excluding any <@ xxx ...> directives.
If you have a BODY tag and are missing the <HTML> tag and you modify the page from the designer you will get back a page that includes both an HTML and BODY tag. Additionally, the entire contents of the file will be formatted (including the <HTML> tags and any tags between HTML and BODY which is different from D8).
If you don't have either an <HTML> or a <BODY> tag and you use the designer and modify the page you will get back only your markup without <HTML> or <BODY> tags. Again, this formatting excludes the <@ xxx> directives they will remain at the top of the file. This makes it possible to work with XML files (like RSS feeds) in the designer and it will not add additional <HTML> or <BODY> tags around your markup however it will format your markup.
Previously, we were attempting to format the smallest amount of text possible and trying to find/replace the body tags but with the nature of HTML (that being inherently broken <g>) it caused various problems and resulted in jumbled .aspx files. The new mechanism will be reformatting the entire contents of the file and therefore we won't be doing any tag replacement thus avoiding the previous problems.
FYI, these changes will show up in a post Borcon build.
DBWeb controls
ECO support
DBWeb control wizard
DBWebDataSource improvements
OnAutoApplyRequest
CascadingDeletes
CascadingUpdates
XML file support
XMLFile
XMLSchemaFile
AutoUpdateCache
UseUniqueFileName
Navigation API
RegisterNextControl
RegisterPreviousControl
RegisterFirstControl
RegisterLastControl
RegisterInsertControl
RegisterDeleteControl
RegisterUpdateControl
RegisterCancelControl
RegisterUndoControl
RegisterUndoAllControl
RegisterApplyControl
RegisterRefreshControl
RegisterGoToControl
New & Improved Controls
EcoDataSource
dbWebNavigationExtender
DBWebAggregateControl
dbWebSound
dbWebVideo
DBWebImage enhancement for external links
Locate Support
Lookup Support
Database
BDP
Metadata services
Schema creation
Create table, view, index
Alter table
Drop table, view, index
Data migration
bdpCopyTable component
Stored procedure dialog
AutoUpdate
multi-table resolving
error handling
Provider improvements
InterBase Boolean
Oracle packages
localized table name support
Schema Name list retrieval
Sybase 12.5 support
Data remoting
DataHub
DataSync
RemoteConnection
RemoteServer
Data Explorer
Data migration
Drag and drop stored procedures, and automatic parameter population
Metadata services
Create table
Alter table
Designers & Wizards
Stored procedure dialog
Table mapping dialog
Stored procedure drop down list
SchemaName drop down list
Typed datasets (.NET)
Compile to standalone assembly
Support datasets from Web Services
Relations and table editors
Properties dialog
SQLConnection string editor
dbExpress
Metadata improvements
TSimpleDataSet for .NET
CommandText editor
SchemaName discovery
TSQLStoredProc performance improvements
TDataSet consumes IListSource
Driver enhancements
MySQL
DB2
Oracle numeric parameter binding
BDE for .NET
Dynamic loading of DLLs w/o path
Blob performance improvements
TUpdateSQL
TNestedTable
TStoredProc
dbGo for .NET
DataSnap for .NET
Remoting
DCOM
Socket
TLocalConnection
TConnectionBroker
TSharedConnection
Unit Testing
NUnit (.NET) support
DUnit (Delphi/Win32) support
New test case (Delphi & C#)
New test project (Delphi & C#)
Deployment services
XCopy deployment
FTP deployment
Pluggable architecture
Comparison engine
Modeling/UML
ECO
Now supports ASP.NET projects
Pluggable ECO tools in EcoDesigners
Component editors
handles now filter out circular references
Tools
Build an XML mapping file based on default mapping of current model
Generate code and XML mapping from existing DB schema
General options
Auto compile
Activity help: on EcoDesigners, ECO components have flyover hints explaining what can be done and what has been done
Hook up EcoSpace components automatically
Package selector
flyover hint for packages now displays all classes in that package
Packages in references DLLs now appear as selectable
New templates
New ECO ASP.NET application
PersistenceMapperProvider for PersistenceMapper pooling
ECO.WebServices
ECO run-time enhancements
Thread safe persistence mapper
Persistence mapper pooling (local and remote)
ObjectSpace pooling in ASP.NET apps
Improved autoforms
Full support for arbitrary OR mapping to existing schemas
Handles revised for speed
Synchronization of object spaces
Programmatic access to conflict resolution
Highly improved access to change framework behavior
Together modeling
General source code diagramming
Class model view
ECO integration
Translation manager
QualityCentral
Tools menu client
IDE incident reporting
J2EE/EJB interop with Janeva
Delphi and C# support
C# wizard
Select individual or all EJBs from a J2EE archive (EAR or JAR) to generate the client for
Automatically parses vendor-specific (BES, Weblogic and Websphere) Deployment Descriptors for the correct JNDI name to bind to
Generates a ServiceLocator for easy, one step, EJB binding and home interface access
Generates assemblies (instead of .cs) for .NET language transparency
Automatically creates an app.config file with the required Janeva parameters
It has cool About box and Splash screen icons :)
XMLDoc tool (unsupported)
