What S New in Pulsar Beta 8
Total Page：16
File Type：pdf, Size：1020Kb
What’s New in Pulsar Beta 8
FireMonkey Enum Renaming
Bug Fixes
FireMonkey Enum Renaming FireMonkey Enums were renamed in this beta release. A tool is available for download from the Pulsar beta site that will scan through your project files and try to update them to reflect these changes, RenameFmxEnums.exe. o Put RenameFmxEnums.exe in your project directory and run: RenameFmxEnums –curdir o It will convert the .pas, .fmx, .lfm, and any .style (and .tpl) files that are in that directory. IF YOU HAVE EMBEDDED StyleBooks, you will want to export them using beta 7.5 and save them in your project directory with the extension “.style”. This way, the tool can work on those files as well. The FireMonkey Enums renaming: TImageWrapModeMode -> TImageWrapMode TPathWrapModeMode -> TPathWrapMode
TShape3D3D -> TExtrudedShape3D TExtrudedShapeFace -> TExtrudedShapeSide sfSide -> sfShaft MaterialLeft -> MaterialShaft
TAngleButton -> TArcDial TEditClearBtn -> TClearingEdit
UpdateResource -> UpdateStyleLookup OnUpdateResource -> OnUpdateStyleLookup FNeedResource -> FNeedStyleLookup
// TAlign = (vaNone, vaTop, vaLeft, vaRight, vaBottom, vaMostTop, vaMostBottom, vaMostLeft, vaMostRight, vaClient, // vaContents, vaCenter, vaVertCenter, vaHorzCenter, vaHorizontal, vaVertical, vaScale, vaFit, vaFitLeft, vaFitRight); ReplaceString(t, ' TAlign = (vaNone', ' TAlignLayout = (vaNone'); ReplaceString(t, 'property Align: TAlign ', 'property Align: TAlignLayout '); ReplaceString(t, 'property ItemAlignment: TAlign ', 'property ItemAlignment: TAlignLayout '); ReplaceString(t, ' TAlign;', ' TAlignLayout;'); ReplaceString(t, ' TAlign)', ' TAlignLayout)'); ReplaceString(t, ' TAlign(', ' TAlignLayout(');
ReplaceString(t, 'TAlign.vaNone', 'TAlignLayout.alNone'); ReplaceString(t, 'TAlign.vaTop', 'TAlignLayout.alTop'); ReplaceString(t, 'TAlign.vaLeft', 'TAlignLayout.alLeft'); ReplaceString(t, 'TAlign.vaRight', 'TAlignLayout.alRight'); ReplaceString(t, 'TAlign.vaBottom', 'TAlignLayout.alBottom'); ReplaceString(t, 'TAlign.vaMostTop', 'TAlignLayout.alMostTop'); ReplaceString(t, 'TAlign.vaMostBottom', 'TAlignLayout.alMostBottom'); ReplaceString(t, 'TAlign.vaMostLeft', 'TAlignLayout.alMostLeft'); ReplaceString(t, 'TAlign.vaMostRight', 'TAlignLayout.alMostRight'); ReplaceString(t, 'TAlign.vaClient', 'TAlignLayout.alClient'); ReplaceString(t, 'TAlign.vaContents', 'TAlignLayout.alContents'); ReplaceString(t, 'TAlign.vaCenter', 'TAlignLayout.alCenter'); ReplaceString(t, 'TAlign.vaVertCenter', 'TAlignLayout.alVertCenter'); ReplaceString(t, 'TAlign.vaHorzCenter', 'TAlignLayout.alHorzCenter'); ReplaceString(t, 'TAlign.vaHorizontal', 'TAlignLayout.alHorizontal'); ReplaceString(t, 'TAlign.vaVertical', 'TAlignLayout.alVertical'); ReplaceString(t, 'TAlign.vaScale', 'TAlignLayout.alScale'); ReplaceString(t, 'TAlign.vaFit', 'TAlignLayout.alFit'); ReplaceString(t, 'TAlign.vaFitLeft', 'TAlignLayout.alFitLeft'); ReplaceString(t, 'TAlign.vaFitRight', 'TAlignLayout.alFitRight');
ReplaceString(t, 'vaNone', 'alNone'); ReplaceString(t, 'vaTop', 'alTop'); ReplaceString(t, 'vaLeft', 'alLeft'); ReplaceString(t, 'vaRight', 'alRight'); ReplaceString(t, 'vaBottom', 'alBottom'); ReplaceString(t, 'vaMostTop', 'alMostTop'); ReplaceString(t, 'vaMostBottom', 'alMostBottom'); ReplaceString(t, 'vaMostLeft', 'alMostLeft'); ReplaceString(t, 'vaMostRight', 'alMostRight'); ReplaceString(t, 'vaClient', 'alClient'); ReplaceString(t, 'vaContents', 'alContents'); ReplaceString(t, 'vaCenter', 'alCenter'); ReplaceString(t, 'vaVertCenter', 'alVertCenter'); ReplaceString(t, 'vaHorzCenter', 'alHorzCenter'); ReplaceString(t, 'vaHorizontal', 'alHorizontal'); ReplaceString(t, 'vaVertical', 'alVertical'); ReplaceString(t, 'vaScale', 'alScale'); ReplaceString(t, 'vaFit', 'alFit'); ReplaceString(t, 'vaFitLeft', 'alFitLeft'); ReplaceString(t, 'vaFitRight', 'alFitRight');
// TPlacement = (vgPlacementBottom, vgPlacementTop, vgPlacementLeft, vgPlacementRight, vgPlacementCenter, // vgPlacementBottomCenter, vgPlacementTopCenter, vgPlacementLeftCenter, vgPlacementRightCenter, vgPlacementAbsolute, // vgPlacementMouse, vgPlacementMouseCenter); ReplaceString(t, 'vgPlacementBottom', 'plBottom'); ReplaceString(t, 'vgPlacementTop', 'plTop'); ReplaceString(t, 'vgPlacementLeft', 'plLeft'); ReplaceString(t, 'vgPlacementRight', 'plRight'); ReplaceString(t, 'vgPlacementCenter', 'plCenter'); ReplaceString(t, 'vgPlacementBottomCenter', 'plBottomCenter'); ReplaceString(t, 'vgPlacementTopCenter', 'plTopCenter'); ReplaceString(t, 'vgPlacementLeftCenter', 'plLeftCenter'); ReplaceString(t, 'vgPlacementRightCenter', 'plRightCenter'); ReplaceString(t, 'vgPlacementAbsolute', 'plAbsolute'); ReplaceString(t, 'vgPlacementMouse', 'plMouse'); ReplaceString(t, 'vgPlacementMouseCenter', 'plMouseCenter');
// TCorner = (vgCornerTopLeft, vgCornerTopRight, vgCornerBottomLeft, vgCornerBottomRight); ReplaceString(t, 'vgCornerTopLeft', 'crTopLeft'); ReplaceString(t, 'vgCornerTopRight', 'crTopRight'); ReplaceString(t, 'vgCornerBottomLeft', 'crBottomLeft'); ReplaceString(t, 'vgCornerBottomRight', 'crBottomRight');
// TCornerType = (vgCornerRound, vgCornerBevel, vgCornerInnerRound, vgCornerInnerLine); ReplaceString(t, 'vgCornerRound', 'ctRound'); ReplaceString(t, 'vgCornerBevel', 'ctBevel'); ReplaceString(t, 'vgCornerInnerRound', 'ctInnerRound'); ReplaceString(t, 'vgCornerInnerLine', 'ctInnerLine');
// TSide = (vgSideTop, vgSideLeft, vgSideBottom, vgSideRight); ReplaceString(t, 'vgSideTop', 'sdTop'); ReplaceString(t, 'vgSideLeft', 'sdLeft'); ReplaceString(t, 'vgSideBottom', 'sdBottom'); ReplaceString(t, 'vgSideRight', 'sdRight');
// TBrushStyle = (vgBrushNone, vgBrushSolid, vgBrushGradient, vgBrushBitmap, vgBrushResource, vgBrushVisual); ReplaceString(t, 'TBrushStyle', 'TBrushKind'); ReplaceString(t, 'Style = vgBrushNone', 'Kind = bkNone'); ReplaceString(t, 'Style = vgBrushSolid', 'Kind = bkSolid'); ReplaceString(t, 'Style = vgBrushGradient', 'Kind = bkGradient'); ReplaceString(t, 'Style = vgBrushBitmap', 'Kind = bkBitmap'); ReplaceString(t, 'Style = vgBrushResource', 'Kind = bkResource'); ReplaceString(t, 'Style = vgBrushVisual', 'Kind = bkGrab');
ReplaceString(t, 'Stroke.Style', 'Stroke.Kind'); ReplaceString(t, 'Fill.Style', 'Fill.Kind');
ReplaceString(t, 'vgBrushNone', 'bsNone'); ReplaceString(t, 'vgBrushSolid', 'bsSolid'); ReplaceString(t, 'vgBrushGradient', 'bsGradient'); ReplaceString(t, 'vgBrushBitmap', 'bsBitmap'); ReplaceString(t, 'vgBrushResource', 'bsResource'); ReplaceString(t, 'vgBrushVisual', 'bsGrab');
// TTextAlign = (vgTextAlignCenter, vgTextAlignNear, vgTextAlignFar); ReplaceString(t, 'vgTextAlignCenter', 'taCenter'); ReplaceString(t, 'vgTextAlignNear', 'taLeading'); ReplaceString(t, 'vgTextAlignFar', 'taTrailing');
// TPathPointKind = (vgPathPointMoveTo, vgPathPointLineTo, vgPathPointCurveTo, vgPathPointClose); ReplaceString(t, 'vgPathPointMoveTo', 'ppMoveTo'); ReplaceString(t, 'vgPathPointLineTo', 'ppLineTo'); ReplaceString(t, 'vgPathPointCurveTo', 'ppCurveTo'); ReplaceString(t, 'vgPathPointClose', 'ppClose');
// TStrokeCap = (vgCapFlat, vgCapRound); ReplaceString(t, 'vgCapFlat', 'scFlat'); ReplaceString(t, 'vgCapRound', 'scRound');
// TStrokeJoin = (vgJoinMiter, vgJoinRound, vgJoinBevel); ReplaceString(t, 'vgJoinMiter', 'sjMiter'); ReplaceString(t, 'vgJoinRound', 'sjRound'); ReplaceString(t, 'vgJoinBevel', 'sjBevel');
// TStrokeDash = (vgDashSolid, vgDashDash, vgDashDot, vgDashDashDot, vgDashDashDotDot, vgDashCustom); ReplaceString(t, 'vgDashDashDotDot', 'sdDashDashDotDot'); ReplaceString(t, 'vgDashDashDot', 'sdDashDashDot'); ReplaceString(t, 'vgDashSolid', 'sdSolid'); ReplaceString(t, 'vgDashDash', 'sdDash'); ReplaceString(t, 'vgDashDot', 'sdDashDot'); ReplaceString(t, 'vgDashCustom', 'sdCustom');
// TAnimationType = (vgAnimationIn, vgAnimationOut, vgAnimationInOut); ReplaceString(t, 'vgAnimationInOut', 'atInOut'); ReplaceString(t, 'vgAnimationIn', 'atIn'); ReplaceString(t, 'vgAnimationOut', 'atOut');
// TInterpolationType = (vgInterpolationLinear, vgInterpolationQuadratic, vgInterpolationCubic, vgInterpolationQuartic, // vgInterpolationQuintic, vgInterpolationSinusoidal, vgInterpolationExponential, vgInterpolationCircular, // vgInterpolationElastic, vgInterpolationBack, vgInterpolationBounce); ReplaceString(t, 'vgInterpolationLinear', 'itLinear'); ReplaceString(t, 'vgInterpolationQuadratic', 'itQuadratic'); ReplaceString(t, 'vgInterpolationCubic', 'itCubic'); ReplaceString(t, 'vgInterpolationQuartic', 'itQuartic'); ReplaceString(t, 'vgInterpolationQuintic', 'itQuintic'); ReplaceString(t, 'vgInterpolationSinusoidal', 'itSinusoidal'); ReplaceString(t, 'vgInterpolationExponential', 'itExponential'); ReplaceString(t, 'vgInterpolationCircular', 'itCircular'); ReplaceString(t, 'vgInterpolationElastic', 'itElastic'); ReplaceString(t, 'vgInterpolationBack', 'itBack'); ReplaceString(t, 'vgInterpolationBounce', 'itBounce');
// TGradientStyle = (vgLinearGradient, vgRadialGradient); ReplaceString(t, 'vgLinearGradient', 'gsLinear'); ReplaceString(t, 'vgRadialGradient', 'gsRadial');
// TPathWrap = (vgPathOriginal, vgPathFit, vgPathStretch, vgPathTile); ReplaceString(t, 'TPathWrap', 'TPathWrapMode'); ReplaceString(t, 'vgPathOriginal', 'pwOriginal'); ReplaceString(t, 'vgPathFit', 'pwFit'); ReplaceString(t, 'vgPathStretch', 'pwStretch'); ReplaceString(t, 'vgPathTile', 'pwTile'); // TImageWrap = (vgImageOriginal, vgImageFit, vgImageStretch, vgImageTile); ReplaceString(t, 'TImageWrap', 'TImageWrapMode'); ReplaceString(t, 'vgImageOriginal', 'iwOriginal'); ReplaceString(t, 'vgImageFit', 'iwFit'); ReplaceString(t, 'vgImageStretch', 'iwStretch'); ReplaceString(t, 'vgImageTile', 'iwTile');
// TOrientation = (vgHorizontal, vgVertical); ReplaceString(t, 'vgHorizontal', 'orHorizontal'); ReplaceString(t, 'vgVertical', 'orVertical');
// TListStyle = (vgListVertical, vgListHorizontal); ReplaceString(t, 'vgListVertical', 'lsVertical'); ReplaceString(t, 'vgListHorizontal', 'lsHorizontal');
// TNumValueType = (vgValueInteger, vgValueFloat); ReplaceString(t, 'vgValueInteger', 'vtInteger'); ReplaceString(t, 'vgValueFloat', 'vtFloat');
// TEditCharCase = (vgecNormalCase, vgecUpperCase, vgecLowerCase); ReplaceString(t, 'vgecNormalCase', 'ecNormal'); ReplaceString(t, 'vgecUpperCase', 'ecUpperCase'); ReplaceString(t, 'vgecLowerCase', 'ecLowerCase');
// TLineType = (vgLineNormal, vgLineHorizontal, vgLineVertical); ReplaceString(t, 'vgLineNormal', 'ltDiagonal'); ReplaceString(t, 'vgLineHorizontal', 'ltTop'); ReplaceString(t, 'vgLineVertical', 'ltLeft');
// TAniIndicatorStyle = (vgAniIndicatorLine, vgAniIndicatorCircle); ReplaceString(t, 'vgAniIndicatorLine', 'aiLinear'); ReplaceString(t, 'vgAniIndicatorCircle', 'aiCircular');
// TCalDayOfWeek = (vgMonday, vgTuesday, vgWednesday, vgThursday, vgFriday, // vgSaturday, vgSunday, vgLocaleDefault); ReplaceString(t, 'vgMonday', 'dowMonday'); ReplaceString(t, 'vgTuesday', 'dowTuesday'); ReplaceString(t, 'vgWednesday', 'dowWednesday'); ReplaceString(t, 'vgThursday', 'dowThursday'); ReplaceString(t, 'vgFriday', 'dowFriday'); ReplaceString(t, 'vgSaturday', 'dowSaturday'); ReplaceString(t, 'vgSunday', 'dowSunday'); ReplaceString(t, 'vgLocaleDefault', 'dowLocaleDefault');
// TCalloutPosition = (vgCalloutTop, vgCalloutLeft, vgCalloutBottom, vgCalloutRight); ReplaceString(t, 'vgCalloutTop', 'cpTop'); ReplaceString(t, 'vgCalloutLeft', 'cpLeft'); ReplaceString(t, 'vgCalloutBottom', 'cpBottom'); ReplaceString(t, 'vgCalloutRight', 'cpRight');
// TWrapMode = (vgWrapTile, vgWrapTileOriginal, vgWrapTileStretch); ReplaceString(t, 'vgWrapTile', 'wmTile'); ReplaceString(t, 'vgWrapTileOriginal', 'wmOriginal'); ReplaceString(t, 'vgWrapTileStretch', 'wmStretch');
// TFontStyle = (vgFontBold, vgFontItalic, vgFontUnderline, vgFontStrikeout); ReplaceString(t, 'vgFontBold', 'fsBold'); ReplaceString(t, 'vgFontItalic', 'fsItalic'); ReplaceString(t, 'vgFontUnderline', 'fsUnderline'); ReplaceString(t, 'vgFontStrikeout', 'fsStrikeOut');
// TProjection = (dxProjectionCamera, dxProjectionScreen); ReplaceString(t, 'dxProjectionCamera', 'pjCamera'); ReplaceString(t, 'dxProjectionScreen', 'pjScreen');
// TMultisample = (dxMultisampleNone, dxMultisample2Samples, dxMultisample4Samples); ReplaceString(t, 'dxMultisampleNone', 'msNone'); ReplaceString(t, 'dxMultisample2Samples', 'ms2Samples'); ReplaceString(t, 'dxMultisample4Samples', 'ms4Samples');
// TLightType = (dxLightDirectional, dxLightPoint, dxLightSpot); ReplaceString(t, 'dxLightDirectional', 'ltDirectional'); ReplaceString(t, 'dxLightPoint', 'ltPoint'); ReplaceString(t, 'dxLightSpot', 'ltSpot');
// TTexMode = (dxTexModulate, dxTexReplace); ReplaceString(t, 'dxTexModulate', 'tmModulate'); ReplaceString(t, 'dxTexReplace', 'tmReplace');
// TShadeMode = (dxFlat, dxGouraud); ReplaceString(t, 'dxFlat', 'smFlat'); ReplaceString(t, 'dxGouraud', 'smGouraud');
// TFillMode = (dxSolid, dxWireframe); ReplaceString(t, 'dxSolid', 'fmSolid'); ReplaceString(t, 'dxWireframe', 'fmWireframe'); // ReplaceString(t, ' TAlign;', ' TAlignLayout;'); // ReplaceString(t, ' TAlign)', ' TAlignLayout)'); // ReplaceString(t, ' TAlign(', ' TAlignLayout('); // ReplaceString(t, 'TAlign.vaNone', 'TAlignLayout.alNone'); // ReplaceString(t, 'TAlign.vaTop', 'TAlignLayout.alTop'); // ReplaceString(t, 'TAlign.vaLeft', 'TAlignLayout.alLeft');
// TShape3D3DSide = (dxShape3DFront, dxShape3DBack, dxShape3DLeft); ReplaceString(t, 'TShape3D3DSide', 'TExtrudedShapeFace'); ReplaceString(t, 'dxShape3DFront', 'sfFront'); ReplaceString(t, 'dxShape3DBack', 'sfBack'); ReplaceString(t, 'dxShape3DLeft', 'sfSide');
// TShaderValueType = (feValueFloat, feValuePoint, feValueColor, feValueBitmap); ReplaceString(t, 'feValueFloat', 'vtFloat'); ReplaceString(t, 'feValuePoint', 'vtPoint'); ReplaceString(t, 'feValueColor', 'vtColor'); ReplaceString(t, 'feValueBitmap', 'vtBitmap');
// TInsertOption = (ioSelected, ioMoveCaret, ioCanUndo, ioUnDoPairedWithPriv); ReplaceString(t, 'ioUnDoPairedWithPriv', 'ioUndoPairedWithPrev');
// TCustomFormBorderStyle = (bsNone, bsSingle, bsSizeable, bsToolWindow, bsSizeToolWin); ReplaceString(t, 'TCustomFormBorderStyle', 'TFmxFormBorderStyle');
// TCustomFormState = (fsRecreating, fsModal); ReplaceString(t, 'TCustomFormState', 'TFmxFormState'); Bug Fixes For a list of bugs fixed in Pulsar Beta 7.5, see Pulsar_Beta_8_Bug_Fixes.html on the Pulsar Beta Site.
What’s New in Pulsar Beta 7.5
Deployment Manager
VCL Styles
FireMonkey
Debugger
Bug Fixes
Deployment Manager The Deployment Manager allows you to see the files in your application that are being deployed and to edit the files that are being deployed. The Deployment Manager is not needed for every project that is deployed to a remote system, but it gives you control over your application deployment when you need it.
The Deployment Manager uses seven columns, all of which all are sortable, to display the deployment information. Three of the column fields are editable: Platform, Remote Path, and Remote Name. o Local Path: This is the path of a given file on the local machine. The paths are relative to the project and can contain macros, $(BDS) for example. o Local Name: The name of the local file. o Class: This is the class that the file belongs to. Classes are used to group files with similar deployment rules. Some of these rules might be used to specify that a file is only available for a given platform. o Platforms: Each file will be deployed to a given list of platforms. It is possible for files to be deployed to one platform only. For example, info.plist is only deployed for OSX32, whereas project1.exe may be deployed to Win32/Win64 only. It is also possible for files to be deployed to all or any combination of platforms. You may edit which platform they wish files to be deployed. If you select incorrectly, it could cause your program to not work on a given platform, so some caution must be used. o Remote Path: Remote path is the destination for the file. If the path is not fully qualified, then the path is relative to the scratch directory or to the application bundle for OSX32. The remote path can be edited by the user. If you do not want the path to be relative to the scratch directory or the application bundle, then the path needs to be a fully qualified path. o Remote Status: The Remote Status shows the status between the remote file and the local file. This can only be done if the Connect button on the tool bar is pushed down. The status can be: . Not Connected: The Connect button is not pressed down so no remote data is found. . Unknown: There was an error getting information from the local file. . Newer: The remote file is newer than the local file. . Older: The remote file is older than the local file. . Same: The local and remote file has the same time date stamps. . Not Found: The remote file was not found.
A note on editing: All editing is done in place, so you just need to click on the field you wish to edit and the edit field will appear.
The tool bar has 6 buttons and the configuration select combo box. o Reconcile: Reloads all the information from the project. This is similar to a refresh in other view. o Add Files: Allows you to add files that are not part of the project that you wish to deploy. A common example would be adding data files or configuration files that the program uses. o Delete Files: Allows you to delete files that you added though the add button. You cannot delete files that the IDE adds; the button will be grayed out. o Add Feature Files: Displays a new dialog that has a list of files that you can select to add to your project. This is mainly used for database applications. All of the database drivers are part of this list. You can edit this list by editing the file objrepos\Deploy\featuredfiles.xml. o Deploy: Deploys the files to the remote machine. This uses the currently selected configuration to deploy the files. This is not required to deploy files. Running the project in the IDE will automatically deploy the files as well. o Connect: This is a sticky button. It will remain down while the machines are connected. When the button is pressed, the connection is tested. If the connection is successful, the Remote Status fields are updated. If there is a failure, an error dialog is displayed. This button is disabled when All Configurations is select since you can connect to only one machine at a time. o Configuration Selector: This is the same combo box that is used in the project options dialog. It allows you to select which configuration that you will be looking at. All fields might change if the configurations is changed. VCL Styles This field test includes support for selecting custom themes at design time and a style that is ready for testing. To add a custom style to your project, go to Project | Options and select the Appearance tab under Application.
Known issues: o The use of some components can cause a form to lose its font information and use the system font. o ActionMenu/ActionPopupMenu items are not complete. o DBNavigator/DBGrid glyphs are not complete. FireMonkey The FireMonkey team is making some changes in the naming of classes and components to improve the architecture and use of FireMonkey. You will find, below, a list refactorings for Pulsar Beta 7.5. Thank you for your feedback about the quality and architecture of FireMonkey. Your comments and suggestions are helping make FireMonkey a better Application Platform.
There have been a large set of changes to move from using the term "resource" inside FireMonkey to refer to style elements and switch to "Style". This will avoid any confusion between the current use of the term resource in Windows and other applications. o TResources -> TStyleBook o ResourceName -> StyleName o Resource -> StyleLookup (the style element name for the component to lookup) Fixing Broken Projects: If you have any streamed resources in your ".fmx" file, the best way to handle this is to use a pre- refactoring build. The stream stored in the fmx file is binary, so we need to get it to a text format so we can edit it by hand. Open those resources in the StyleDesigner of the old build. Click "Save..." and store these files on disk with a descriptive name and the extension ".style". Now, you will need to hand edit your project files: ".pas", ".fmx" and any ".style" files (from above step). Search for TResources and replace with TStyleBook In the ".fmx" and ".style" files, search for: o "Style" and replace it with "StyleBook" if this is inside a block for IScene, TForm, TCustomLayer3D, or TPopup, but NOT if it is a TAniIndicator, TGradient, TBrush or TFont. o "ResourceName" and replace with "StyleName" o "Resource" and replace with "StyleLookup". ALMOST everywhere you find Resource, but not when it is bounded by dots (".Resource.") or is part of another type name. It is pretty easy to recognize a reference to a StyleName if you look at the value being set. At this point, you can open the project in Delphi and work through any compile errors. If you had to export your embedded styles, you will need to import them now. Open the StyleDesigner and open the resource. Hit the "Clear All" button then "Load..." your modified style files. FireMonkey Classes renamed: o TBaseObject -> TFmxObject o TControl -> TStyledControl o IVisualObject -> IControl o TVisualObject -> TControl o TVisualObject3D -> TControl3D Debugger Hardware breakpoints for Delphi Win64 applications are now supported. FPU View for Delphi Win64 applications is now supported. Improved fCall x64 stability for cases where Real/Currency/Comp values used as parameters – GP(0) exceptions due to unaligned access to SSE operands fixed. Safecall convention now supported in fCall x64. Exponent loss issue resolved – for cases when Real parameter passed to fCall in form like typical Currency value – i.e. 123.45. Before fix value shown as 1.2345e+06, now 1.2345e+02. Evaluation of virtual methods fixed (AV exception in evaluator). Issue with finding Variant compiler helpers resolved. Known issues: o Merged stack issue, also may be seen in cases when breakpoint set in Windows system DLLs (by address or as result of assert()). o Evaluation of Variant array items Bug Fixes For a list of bugs fixed in Pulsar Beta 7.5, see Pulsar_Beta_75_Bug_Fixes.html on the Pulsar Beta Site.
What’s New in Pulsar Beta 7
FireMonkey for OS X
FireMonkey and VCL refactorings
LiveBindings
Debugger for 64-bit Windows
IDE
RTL
Boost for OS X
Office Automation Components
Bug Fixes
FireMonkey for OS X C++ FireMonkey applications can now be deployed to Mac OS X. o We recommend that you create a new remote profile with this field test release because the default remote profile configuration in previous releases did not include all of the frameworks, libraries and headers that are required by FireMonkey for C++. Note that the new default configuration is compatible with both OS X Snow Leopard (10.6) and OS X Lion (10.7). o For the form background to appear properly at runtime, make sure that you set a brush style in the object inspector. (Fill/Style/choose anything other than vgBrushNone) o C++ access to types and functions in Objective-C frameworks is available via the Delphi RTL. See the notes for Pulsar Beta 5 for information about OS X Objective-C Framework Access. TMainMenu support is available for Mac OS X. Note that the TMainMenu component will not allow you to modify the Application menu (the menu immediately to the right of the Apple menu). The Application menu can be populated by adding code to the main form's OnCreate method. For example:
procedure TForm1.AppPrefsEvent(Sender: TObject); begin // Show preferences dialog end;
procedure TForm1.AppQuitEvent(Sender: TObject); begin Application.Terminate; end;
procedure TForm1.FormCreate(Sender: TObject); var AppQuitItem: TMenuItem; AppPrefsItem: TMenuItem; AppMenuItems: TMenuItem; begin AppQuitItem := TMenuItem.Create(nil); AppQuitItem.Text := 'Quit ' + Application.Name; AppQuitItem.OnClick := AppQuitEvent;
AppPrefsItem := TMenuItem.Create(nil); AppPrefsItem.Text := 'Preferences'; AppPrefsItem.OnClick := AppPrefsEvent;
AppMenuItems := TMenuItem.Create(nil); AppMenuItems.AddObject(AppPrefsItem); AppMenuItems.AddObject(AppQuitItem);
Application.ApplicationMenuItems := AppMenuItems; end;
If no Application menu items are defined in code, then FireMonkey will automatically create a "Quit" menu item for the Application menu.
Clipboard operations are now available for FireMonkey applications on OS X. Drag and drop support has been implemented for FireMonkey applications on OS X. FireMonkey and VCL refactorings FireMonkey and VCL now use the same DataModules. Many commonly named types and constants from their respective locations in VCL and FireMonkey have been moved into a couple of common “System” Units. Many items are moving to System.Types, whereas others are moving to a newly introduced unit, System.UITypes. Many helper functions related to TPointF and TRectF have been moved from FMX.Types over to System.Types. There are a few changes that may require some updates to FMX applications. Several common enumerations moved into System.UITypes and {$SCOPEDENUMS ON} was enabled on them. This means that you must fully qualify references to the enumeration elements using the enumerate type. This is for FMX only. For VCL, type aliases and constants were introduced for backward compatibility. Changes were also made for TColor. VCL’s version of TColor doesn’t carry a notion of an Alpha channel for the purposes of allowing color blends. The high byte of TColor is used to indicate that a particular TColor value is actually a standard Windows system color index value and the real color is obtained via a call to GetSysColor(). TColor in FMX does have the notion of an Alpha channel which occupies this same high byte. This means that the VCL TColor is not interchangeable with FMX’s TColor. In order to eliminate the confusion, FMX TColor has been renamed to TAlphaColor and moved the declaration into System.UITypes. Likewise, TColor remains the same for VCL and was also moved to System.UITypes. FMX has been refactored to use TAlphaColor where appropriate. The Point() and Rect(),functions have been removed from FMX.Types, and we’ve introduced equivalent PointF() and RectF() functions into System.Types. The IntersectRect, UnionRect, PtInRect, etc. functions have been removed from FMX.Types. LiveBindings TCheckBox now supports TBindDBCheckLink, so you can link a boolean database field to a FMX TCheckBox control. The boolean field may be null so there are three states: True, False, Null. A property has been added to TCustomBindingsList (published in TBindingsList) to indicate whether it should have its own manager instance. All managed expressions will be created with this manager instance. Otherwise, the application instance would be used. Debugger for 64-bit Windows Features improved: o Func/procs parameters visible and evaluatable along current proc stoppable line set. Parameter life period depends on how it used inside proc. In case of parameter optimized out in some code range error message appeared in local variable inspector and in Evaluate/Modify window – as designed. o Note about @-operator result evaluation: if result address for given variable is register (GREG or vector XREG) then register name is shown as result. The “typeInfo=edx” problem was fixed, correct Pointer contents shown. o fCall x64 facility partially enabled for static functions/procs and for object methods as well. It is still not stable in terms of result validity, but crashes have been fixed. Aborted fCalls result shown as “Inaccessible Value”. Hidden parameters: Self pointer and Result pointer are handled. Bugs fixed since Beta 6: o Parameters evaluation now available inside procs/funcs. o fCall x64 stack parameters passing fixed. o Self pointer and Result pointer passing fixed. o @-operator evaluation fixed. o Occasional FPU exceptions during local variable inspector parameters parsing fixed. o Currency type evaluation fixed o Variant with assigned Currency value evaluation fixed Known problems: o Merged call stack issue (no full call stack in case of stopping on WinAPI callbacks). o No warranty for fCall result for types used as arguments to evaluated proc: arrays/records/Real/objects. o Wrong exponent scaling for Real/Comp constants. IDE The "Packages" project options page has been broken into two pages - "Packages" will list the installed packages, but the elements associated with runtime packages are on a new page which supports setting values for different platforms and configurations. Win32 packages (the only ones which can be installed, or referred to as runtime dependents of an installed package) are automatically tagged (at build time) with a resource that states which platforms they will support. This implies a contract with the IDE - if a package targets more than the Win32 platform, the IDE will assume the additional platform-specific linkables and runtimes are available. The IDE will use this information to determine for which platforms a runtime package will appear in the runtime package list. For example, if a design-time package requires runtime package(s) that target Win32 and Win64, but not OSX, those runtime packages will be added to the project but only for configurations that are built for Win32 and Win64. RTL There is a new System.Zip: Utility for creating and extracting Zip files. Boost for OS X Boost for OS X is included in this beta release. Office Automation Components Microsoft Office automation components are now included for Office XP, Office 2000 and Office 2010. Bug Fixes For a list of bugs fixed in Pulsar Beta 7, see Pulsar_Beta_7_Bug_Fixes.html on the Pulsar Beta Site. What’s New in Pulsar Beta 6
FireMonkey
DataSnap Mobile Connectors
DataSnap Servers and Clients
Data Binding
Dephi ActiveX for Windows (64-bit)
VCL
Delphi RTL
Debugger
IDE
Bug Fixes
FireMonkey This beta release introduces FireMonkey for iOS (iPhone, iPad, iPod Touch). You can create a FireMonkey application for iOS in Pulsar, export your project to Xcode to build it with FreePascal, and then run it on an emulator or iOS device.
Prerequisites Intel Apple Mac with Snow Leopard iOS SDK requires subscription to Apple Developer Program o 4.2, 4.3 verified working Xcode - download from App Store (or iOS Developer Pages) o 3.2.5, 3.2.6 verified working Installed official FreePascal 2.4.4 binary - http://www.freepascal.org/download.var - Required to build FPC 2.5.1
Preparing Your Mac The installation script will try to pull a known good version of the FPC trunk to "/Developer/fpc" if that directory doesn't exist. If "/Developer/fpc" does exist, the script will build and install with what is already there. If you would like to ensure a clean installation, run the following commands to "clean up" your system:
sudo rm -rf /Developer/fpc sudo rm -rf /usr/local/lib/fpc/2.5.1
Installing FMI Sources on Your Mac Download the latest FMI sources from the Pulsar beta site and save them to your home directory "/Users/
cd ~
unzip FmiForFpc.zip NOTE: While it is possible to install the FMI sources in another location, you will be required to pass this parameter to dpr2xcode if they are not installed in this location.
Build and Installing FPC 2.5.1 for FMI/iOS Development The "FmiForFpc.zip" contains an install script to all the work of building and installing FPC. It will also generate, build, and install the required iOS SDK headers. To run the installation script, open Terminal and issue these commands:
cd ~/fmi
chmod +x InstallFpc.sh
./InstallFpc.sh NOTE: Parts of this script require "sudo" to run. The script will stop and ask for your password if required.
Preparing RAD Studio for iOS Development There are two configuration steps that will make iOS development with RAD Studio easier:
1. FireMonkey iOS projects share project files with XCode through the filesystem. Autosaving can avoid unnecessary round trips. To enable autosaving, go to "Tools | Options..." Then select "Environment Options" and ensure "Editor files" is checked in the "Autosave options".
2. It is necessary to export an XCode project for your RAD Studio iOS project before it can be run on the iOS simulator or device. You generally only need to use this utility to generate the initial XCode project and when additional files are added to the project. To make it easy to run, you can easily add a Tools menu item to run dpr2xcode.exe within RAD Studio. Go to "Tools | Configure Tools..." Then click "Add.." and fill out the dialog as shown below:
Title: Export to Xcode Program: dpr2xcode.exe Parameters: $PROJECT
NOTE: If you didn't put the FMI sources in the expected location "~/fmi", then you will want to enter "-fmi=~/myFmiLocation $PROJECT" into the "Parameters" field.
You can then select "Tools | Export to XCode" to run the utility. Sharing Files Your project files must be shared between RAD Studio and XCode. To facilitate this sharing, you must store your files in a location that is accessible to both programs at the same time. You can do this on a network file server, a local folder shared from one machine to the other, or through the setup of your VM environment.
Typical Project Workflow Start RAD Studio. File | New to go to the Object Gallery and create a "FireMonkey 2D iOS Application" Save project files on a shared directory Work in the form designer and editor to build your app Run and debug it from RAD Studio (running as a Win32 application) Export project to XCode (see above) Switch to Mac, run XCode and open generated project (within the generated "xcode" folder next to your project artifacts) Run and debug your application using XCode on the simulator and device Modify your program in RAD Studio - Save all file Run and debug your application using XCode on the simulator and device Repeat...
Development Notes Ultimately, your project will be compiled using the FPC compiler against the FPC RTL. Some features of the Delphi compiler and RTL are not supported. It is incumbent on the developer to avoid using features and functions that are not supported by FPC. DataSnap Mobile Connectors This beta release introduces the DataSnap Mobile Connectors for iOS, Android, Blackberry and C# Silverlight. DataSnap Mobile Connectors allow you to easily generate proxy source code for all of the supported mobile platforms. You can import the generated proxies into your IDE and use them to develop mobile clients which are DataSnap enabled, easily remotely invoking methods on a DataSnap server from your mobile device.
An overview of the DataSnap Mobile Connectors and more detailed information can be found at: http://docwiki.embarcadero.com/RADStudio/XE2/en/DataSnap_Connectors_for_Mobile_Devices
Wizard Changes The DataSnap Server wizards now have an option for 'Mobile Connectors', which will include the components and static files required for generating and dispatching the mobile proxies. There is a new 'proxy dispatcher' component (either TDSHTTPServiceProxyDispatcher or TDSProxyDispatcher, depending on your server configuration,) which provides a mechanism for generating and downloading the mobile proxy remotely from another machine. Also, there is a 'proxy' directory which is automatically put into your project's directory. This proxy directory contains static files for each of the supported mobile platforms. The generated proxy file will depend on these files. Another thing you will notice with the 'DataSnap Server' and 'DataSnap WebBroker Application' wizards is that if you include Mobile Connectors, there will be an additional wizard page to fill out, which requires you to select the directory you'll be saving the project units to. Also, the project's output location will be changed to ".". Getting the Generated Proxy from the Wizard Once your server is running, anyone can manually request the proxy by opening a browser and going to: "http://host:port/proxy/[DEVICE].zip", where "[DEVICE]" is one of the directory names under the 'proxy' directory (csharp_silverlight, java_android, java_blackberry or objectivec_ios42.) This call will result in a .zip file download, which will contain the proxy source code for the specified mobile device.
Alternatively, you can use the "Win32ProxyDownloader.exe" utility, found in RAD Studio's bin directory. This is a command line program which takes in the server, device and output directory information, and uses it to download and unzip the mobile proxy. An example use-case would be:
C:\Win32ProxyDownloader.exe -language java_android -host 127.0.0.1:8080 -output C:\test
The Proxy Once you have it generated, the proxy itself will be just as easy to use as any of the previously available proxies, and will contain all of your supported server methods, with parameters as you'd expect. For languages not supporting out/var parameters, wrapper objects are used in the method signatures.
Sample Application A DataSnap Mobile Connectors sample application can be found on the Pulsar Beta Site in DSMobileConnector_CompanyTweet.zip. To run the sample, follow these instructions:
SERVER and CONSOLE Import CompanyTweetServer/ctServer.dproj and CompanyTweetDelphiClient/CompanyTweetConsole.dproj into your project group in RAD Studio. If your port 8080 isn't free, change ctServer to use a different HTTP port. (CompanyTweetServerCntainer.pas, on the DSHTTPService1 component, the 'HttpPort' property.) Also, change the port in ClientModuleUnit.pas, in the DSRestConnection1 component, in the console project. Run the server and then the console client. When you know a client is connected, you can refresh the user list to see them. You can also send a message from the server application. Or view sent messages from the console application.
SETUP Obtain your computer’s IP address. (ipconfig from command line, for example.) The clients will need this, along with the server's port. Don't use "localhost" in any of the mobile clients.
ANDROID Set up the development environment: http://developer.android.com/sdk/installing.html. Import the AndroidClients/AndroidDemoClientApp project into your Android eclipse development environment. Right-click the project and choose to run as Android Application. When the emulator starts up, unlock the phone and you'll be in the CompanyTweet app. If not, locate and run the 'AndroidDemoClientapp'. Click the MENU button on the emulated keyboard, and click "Settings" on the menu item that comes up. Change the Host to be your computer's IP address, and port to be the server's HTTP port. Make sure if connecting from outside the network you have the correct outward-facing IP address, and any port-forwarding that may be required. Press the back button located on the emulator keyboard. Type in a name which is more than 3 characters long, and then click the "login" button (make sure the server is running before you do this). This will bring you to a "List of active users" page. If anyone else is logged in, you will see them in this list and be able to select them, to follow their "tweets". When you are done selecting users to "follow", click the double-arrow button at the top. You will now be on the page which allows you to send and view messages. Wait for someone to write a message, or write one in the box at the top and click the "Tweet" button. If more people join the server and you want to follow them, click the MENU button and choose the "Active users" item. Select the users to follow, and click the double-arrow button to go back to the messaging page. When you want to log out, click the MENU button and choose the Logout item.
BLACKBERRY Install the standalone Blackberry-enabled Eclipse ("BlackBerry Java Plug-in for Eclipse v1.3 (full installer)): http://us.blackberry.com/developers/javaappdev/devtools.jsp Import the BlackberryClients\BlackBerryDemoClientApp project into the BlackBerry IDE. Right-Click the project and choose "Run As -> BlackBerry Simulator" find and run the BlackBerryDemoClientapp. Use this app the same way you would use the Android App. Instead of a MENU button, you use the main BlackBerry button (left-click it and choose "Set Server Host").
WINDOWS PHONE 7 Install VisualStudio 2010 Express for Windows Phone: http://www.microsoft.com/express/Phone/ Open WindowsPhone7Clients\CompanyTweetClient\CompanyTweetClient.sln. Right lick on the project and choose "Deploy". Run the "ClientCompanyTweet" app (you may need to swipe to the next page to find it). Click the round settings button at the bottom, and enter the server IP address and port. Enter a name that is longer than 3 characters. Click the arrow at the bottom when done, to log in. Use the app like the Android and Blackberry apps, where the MENU buttons will be along the bottom. iOS Install XCode on a MAC and open iOSClients\client_company_tweet\client_company_tweet.xcodeproj. Choose to use the latest SDK and a 4.2 iPhone emulator (don't choose to run on device). Run the application from Xcode. In the iPhone emulator you can use the settings button at the top to set host and port. Use the App like any of the other mobile apps. DataSnap Servers and Clients Due to changes in the way DataSnap uses Indy, DataSnap client or server applications will need to have a new unit, IndyPeerImpl, added to the uses clause. For new DataSnap applications, or if you modify your existing DataSnap application in Pulsar, this unit will automatically be added to the uses clause. If you haven’t modified your existing DataSnap application, you will need to add the unit to your uses clause manually. Data Binding New DataSnap modules are supported for FireMonkey applications. TBindDBLink has been added to improve Data Binding usability. The Object inspector has a "DataBindings?" property for all TComponents. This property provides commands in a drop down. o New Bindings... is used to create a Binding component and associate with the selected TComponent o Link to DB Field... is used to create a Bind DB Link component and associate with the selected TComponent (usually a TControl) and a TField. Data Binding samples can be found in FireMonkeySamples.zip on the Pulsar Beta Site. Dephi ActiveX for Windows (64-bit)
ActiveX Controls The typelibrary and ActiveX Control importer (TLIBIMP and IDE) should now generate 64-bit friendly code. Note that to install a 64-bit ActiveX Control on the Palette and use it at design-time, you must also have a 32-bit version of the control. The latter is what the IDE will use at design-time. At runtime, a 64-bit application will use the 64-bit version of the Control. The TWebBrowser component (which has been re-imported) illustrates this. If you have a 64-bit ActiveX Control but not the 32-bit version, you won't be able to use the control at design-time. But you may create the control programmatically at runtime.
Linking & Embedding The TOleContainer component can now be used in 64-bit applications to embed or link to OLE Servers.
Automation Shortint and Word are now considered Automation-compatible (e.g. can be used in dispinterfaces). And variables of these types, as well as those of 'String' type will be passed by ref in Variant-based automation.
Office Wrappers The Office2K wrappers have been replaced by Office2010 wrappers. Both 64-bit and 32-bit version of the Office2010 packages are available. In order to provide a consistent set of Office component wrappers across all Office packages (Delphi, C++, 32-bit, 64-bit) and to workaround a current compiler limitation in 64-bit, the set of wrapper components has been trimmed to the basic top level classes. All interfaces exposed by the typelibraries, however, are still exposed in the generated bindings. VCL Custom themes have been renamed to custom styles. With this beta release, custom styles are testable although official default styles are still in development. "Place holder" styles are available (see the binary group in the forums). Bug reports are welcome for functional issues not related to the place holder styles. To use a custom style in a project, add Vcl.Styles to the uses lists and call TStyleManager.SetStyle(TStyleManager.LoadFromFile(
What’s New in Pulsar Beta 5
Delphi Debugger for Windows (64-bit)
FireMonkey
IDE
Database
ActiveX for Windows (64-bit)
Delphi Debugger for Windows (64-bit) The Delphi Debugger for Windows (64-bit) is available in this beta release. Known issues with the Delphi Debugger for Windows (64-bit) in this beta release: Function call evaluation is disabled. You will just receive “Inaccessible value” if you attempt to evaluate. Exceptions are being ignored by the debugger. Stack Frame in CPU View is showing data as 32 bit value. Thread Naming not working. Call stack doesn’t display line numbers or file names. Evaluation of Real (or any float types) variables is not working yet. Evaluation of Self hidden parameter in object methods. Application returns: E2171 Variable 'Self' inaccessible here due to optimization. FireMonkey Delphi FireMonkey apps can now be run on Windows (64-bit). C++ FireMonkey apps can now be developed and run on Windows (32-bit). This field test release includes the ability to deploy a Delphi FireMonkey application to Mac OS X. FireMonkey C++ support for Mac OS X is not yet ready for testing.
To enable FireMonkey for Mac OS X, do the following:
1. Create or open a Delphi FireMonkey 2D or 3D Application. 2. Right-click on the "Target Platforms" node of the Project Manager and choose "Add Platform" 3. Select "OS X" from the popup dialog. 4. Make OS X the active platform. 5. Create a Remote Profile for connecting to your Mac OS X machine by right-clicking on the OS X target platform in the Project Manager and selecting “Assign Remote Profile…”. 6. Start RASAM on the Mac and use the IDE's remote profile dialog to test the connection. 7. Once the connection is successful, the application can be run with or without debugging.
The application will be built, and the RASAM will deploy and execute the application on the Mac.
This release is a very early look at FireMonkey's Mac support. There are several issues that we are aware of and are actively working on:
Button captions: For button captions to appear at runtime, you must enable the "WordWrap" property of the button. Other text issues: Text rendering does not respect alignment or font settings and it sometimes is drawn backwards or upside down. These issues should be reported on a component-by-component basis. Edit controls: The TEdit control does not work. Main menu: The main menu does not work yet. Choosing "Quit" from the application menu also does not work. The application can be closed by clicking on the Close button of the window title bar, or by adding your own close button on your application's main form.
Even though this is an early version of FireMonkey's Mac support, we do want to start receiving bug reports about it. Before entering a bug report in QC, please check to see if the issue has already been reported, and please raise the issue in the FireMonkey field test forum. OS X Objective-C Framework Access One of the technologies underpinning FireMonkey for Mac OS X is a mechanism that allows Delphi to communicate with Apple's Objective-C frameworks. This is implemented in several new Delphi RTL units. The core engine of this mechanism is in Macapi.ObjectiveC.pas.
By making use of Delphi interfaces and enhanced RTTI, it is possible to instantiate Objective-C objects, call methods on those objects, create a Delphi-implemented subclass of an Objective-C type and implement Objective-C protocols with a Delphi class.
This mechanism requires that the Objective-C framework API be translated as Delphi interfaces. We have provided partial translations of the Cocoa frameworks required by FireMonkey. Except for the portions of the frameworks that are actively used by FireMonkey, these translations are untested.
Application developers should generally not access the Objective-C frameworks directly. FireMonkey methods should be used wherever possible to maintain cross-platform capability. IDE The Deployment Manager now supports deployment of the following application types: Win64 deployment for SOAP & web service applications (Delphi) OSX32 deployment for SOAP & web service applications (Delphi & C++) Win64 deployment for ActiveX projects (Delphi) Win64 deployment for Database and DataSnap applications (Delphi) OSX32 deployment for Database and DataSnap applications (Delphi & C++) Win64 deployment for Packages (Delphi) OSX32 deployment for Packages (Delphi & C++) Win64 deployment for Dynamic link libraries (Delphi) OSX32 deployment for Dynamic link libraries (Delphi & C++) Win64 deployment for FireMonkey applications (Delphi & C++) OSX32 deployment for FireMonkey applications (Delphi & C++) Win64 deployment for Console applications (Delphi) OSX32 deployment for Console applications (Delphi & C++)
Known IDE issue in this beta release: When building a Delphi application with runtime packages, you will need to edit the runtime package list and remove the ones which are not available for Win64. Database The ODBC driver now supports transactions. The ODBC driver now works from with the Data Explorer. ActiveX for Windows (64-bit) A 64-bit TRegSvr command line utility for type library registration is included in this beta release. Use bin64\TRegSvr.exe to register 64-bit Servers and bin\TRegSvr.exe for 32-bit servers. TWebBrowser is ready for 64-bit usage. The unit generated by TLIBIMP (SHDocVw.pas) was manually modified to be 64-bit ready. Generic importing of 64-bit ActiveX Controls (via TLIBIMP or the IDE) is not ready yet. What’s New in Pulsar Beta 4
UnitScope Names
IDE
FireMonkey
Data Binding
Delphi Compiler
Delphi RTL
DataSnap
C++ Audits/Metrics
C++ RTTI
UnitScope Names This beta release introduces UnitScope names to RAD Studio. With support for multiple platforms (Win32, Win64, OS X) in Pulsar, UnitScope names provide organizational and usability benefits for using the libraries and frameworks in RAD Studio. UnitScope names disallow ambiguity, and they provide a context for the RAD Studio units, helping to categorize, articulate and better delineate the boundaries between what units go with what part of the overall frameworks, or are specific to a platform. UnitScope names consist generally of words separated by a period ('.'). For example: System.Win.Registry.pas and Vcl.Forms.pas.
All cross-platform units such as Classes, SysUtils, Contnrs, RTTI, etc., in the base RTL package are now prefixed with “System”. OS/Platform specific units have a prefix indicating the platform (Winapi.Windows, Macapi.CoreFoundation, Posix.Base, etc.). Traditional Visual VCL units are prefixed with “Vcl” (Vcl.Menus, Vcl.Graphics, Vcl.Forms, Vcl.Controls, etc.). Core Database units are prefixed with “Data” (Data.DB, Data.DBCommon, etc.). DataSnap units are prefixed with “DataSnap” (DataSnap.DBClient, DataSnap.Win.TConnect, etc.). XML units are prefixed with “Xml” (Xml.xmldom, Xml.Win.msxmldom, etc.). Internet units are prefixed with “Web” (Web.WebBroker, Web.Win.ISAPIApp, etc.). Soap units are prefixed with “Soap” (Soap.SOAPHTTPClient, Soap.Win.CertHelper, etc.). BDE units are prefixed with “Bde”. You will not need to make any changes to your existing projects when you work with them in Pulsar. When you open an existing Delphi project in Pulsar, the project will automatically be upgraded to use the appropriate UnitScope names.
When a new project is created, Pulsar will automatically ensure that the search path includes the appropriate UnitScope prefixes, based on what framework it will be using coupled with what platform it is targeting.
For example, a new FireMonkey application will contain System, RTL, FMX, and Data as the platform agnostic UnitScope prefixes. When you are targeting Windows, it will add Winapi, and for OS X it will add Macapi. When you add a unit to the uses list that is actually specific to an operating system, such as Macapi, it will fail to compile for Windows since there will be no Winapi.CoreFoundation.
The following top-level UnitScope names are globally reserved and should not be used by third-parties or users, and they should not appear anywhere in a UnitScope hierarchy. o System o Xml o Vcl o Fmx o Data o Datasnap o Bde o Web o Soap These following UnitScope names can be used, but should only appear at the top level: o Winapi o Macapi o Posix IDE The Object Gallery is filtered properly to enforce what files/modules can be added to a project. For example, you should not be able to add a FireMonkey form to a VCL application , and you should not be able to add a VCL form to a FireMonkey application. To support application development for multiple platforms, the main project icon, version information and manifest information are now stored in the project file, and the information can be different for each build configuration and platform. Previously this information was stored in the project.res file. Pulsar will automatically upgrade existing projects and add the needed information to the project file. If you have other information stored in the .res file, Pulsar will separate the known resources from the unknown resources. The unknown resources are added to a project.otares file which is added to the project. o When build your project, if you receive this error: [BRCC32 Error] Project1.vrc(58): resource file Project1_Icon.ico is not in 3.00 format then your icon resource has been imported incorrectly. We are aware of this problem, and we are working on a fix. In the mean time you can correct the problem by going to Project Options > Application > Appearance and select Load Icon. Enter "%BDS%\bin" and select the CBuilder or Delphi icon. In the following dialog, select "Leave icon in the current directory". This will allow your project to build. FireMonkey Several FireMonkey identifier names have been updated to be more precise and consistent: Identifier New Name
CanFocused CanFocus OnCanFocused OnCanFocus EnterFocus Enter KillFocus Exit OnEnterFocus OnEnter OnKillFocus OnExit RotateAngle RotationAngle RotateCenter RotationCenter CanClipped CanClip OnBeforePaint OnPainting DragDisableHighlight EnableDragHighlight DesignHide DesignVisible ObjectByPoint ObjectAtPoint SetxRadius SetXRadius SetyRadius SetYRadius xRadius XRadius yRadius YRadius is* Is* *Vertexs *Vertices *Indexs *Indices Dotimer DoTimer
We’ve added some support for FireMonkey animations within the property inspector. Properties that can be animated are indicated with a greyed out “film strip” icon. For properties that are animated, this icon is bold. Expanding a property with animations will list the animations associated with that property. Appropriate animations can be created using a dropdown menu directly on those properties that can be animated. We’d appreciate your feedback on this approach. FireMonkey Print, Page Setup and Save File dialogs have been added. Data Binding This Pulsar beta release introduces new Data Binding components for FireMonkey: o TBindList fills a TListBox or TListView using expressions. o TBindNavigator FMX navigator for a bind scope component such as TBindScopeDB. o TBindLink supports data editing using expressions. For example, a TEdit may be used to edit a TField (TBindScopeDB is also required). TBindScopeDB now supports editing and navigation. A new component editor is provided for bind components TBindList, TBindExpression and TBindLink. Use this editor to enter and test expressions. Double click on TBindCompList, and then double click on a binding component. The Data Binding examples have been updated. Download FireMonkeySamples.zip from the Pulsar beta site for the latest FireMonkey and Data Binding examples. Delphi Compiler A new compiler hint has been added , "H1066 Lost Extended floating point precision. Reduced to Double". Overload resolution has been updated to favor Extended for (untyped) intermediates. This resolves ambiguous overload errors when calling a function with both a Double and Extended overload with an expression. Delphi RTL Added CoreFoundation utilities unit (System.Mac.CFUtils). TSize, TSizeF and TSmallPoint now include utility methods. Introduced 10-byte compatibility type for streaming Extended on Win64. Further improvements to our Windows SDK header translations. There is a new TPropertyList to read/write .plist files. DataSnap Added support in TSQLConnection and TDSRESTConnection for proxy info (host, port, user, password) for DataSnap HTTP connections. C++ Audits/Metrics This beta includes a first look at C++ Audits support. To try it out open your C++ project, select the "View|C++ Audits" menu item and click the 'Run' toolbar button of the 'C++ Checks' tab. Results of the run will show up in the tab including a description, the file, line and column. Please note the following limitations of this release: The Audit tool does not have access to the IDE's Virtual File System; hence, you must save your Editor changes before running the Audit tool. The Audit tool does not yet support the STL library (under $(BDS)\include\dinkumware). If your application uses any STL facility (containers or algorithms) you will not see any Audits (or incorrect ones) The IDE does not yet report errors encountered by the Audit tool. There's no a command line/console version of Audit tool yet. We will provide one in future betas. There's no UI yet to configure or enable/disable Audits. C++ RTTI The C++ compiler now emits more detailed RTTI information for Delphi classes to bring it further into compatibility with that produced by the Delphi compiler. In addition, there is now a #pragma option that provides greater control over which classes members are exposed in the RTTI. Here’s an example: #pragma explicit_rtti methods(public) fields(__published,public) properties(__published,public,protected,private) This pragma applies to each subsequently encountered class member declaration for the remainder of the file, or until another pragma changes the settings. The member kinds controlled by the pragma (methods, fields and properties) can be in any order. The argument for each member kind specification is a comma separated list of any combination of: __published public protected private If the list is empty, as in: #pragma explicit_rtti methods() then none of the members of that kind will be exposed. When a member kind is not specified (as properties and fields are not in the example above), then the current setting is preserved. The default setting is: #pragma explicit_rtti methods (__published,public) properties (__published,public) fields(__published,public,protected,private) This setting won’t be in effect unless the command line option --xrtti is specified. Note that if the --xrtti option is not specified, no new extended rtti is emitted for any classes encountered until the first use of the explicit_rtti pragma. The extended RTTI still only applies to Delphi classes with RTTI enabled (classes descending from TObject and declared with __declspec(delphirtti) ). Note that the #pragma option is scanned by the macro preprocessor, so it’s also possible to use defines: #define VIS_ALL __published,public,protected,private #define VIS_NONE #pragma explicit_rtti methods(VIS_ALL) properties(VIS_NONE) Class unitnames now include the full namespace. Class properties are listed in the RTTI. Methods and Fields for non-Delphi classes are included (but only if referenced from a Delphi classes). Closures include the full type information for the parameters. All of the RTTI information described above is accessible via the RTTI unit (System.RTTI).
What’s New in Pulsar Beta 3
FireMonkey
Data Binding
IDE Enhancements
Debugger
VCL Enhancements
SOAP for OS X
Docwiki
Known Problems
FireMonkey This Pulsar beta release introduces FireMonkey menus. The FireMonkey designer has many new Property Editors, including TColorProperty Many bugs have been fixed in the FireMonkey designer for this beta build.
Data Binding This Pulsar beta release introduces Data Binding for FireMonkey components. This Pulsar beta release also includes the new Expression Engine. Four data binding components have been introduced: TBindExpression, TBindCompList, TBindComponentScope, and TBindScopeDB. You can download FireMonkeySamples.zip from the Pulsar beta site for examples of how you can use expressions and the new data binding components to bind data to your FireMonkey components. IDE Enhancements The Project Options Build Events page is now platform and configuration aware. C++ static package builds are now supported. Debugger C++ debugging for OS X is now supported. See http://docwiki.embarcadero.com/RADStudio/XE2/en/Debugging_Cross- Platform_Applications for more information. Debugger project options now support multiple platforms. VCL Enhancements This Pulsar beta release includes a preview of the new Extended Customizable Theme Support. A demo and some themes will be posted to the Pulsar beta newsgroups for you to use. SOAP for OS X Delphi SOAP for OS X is now supported. Docwiki The Pulsar Beta Docwiki is open to all Beta testers. The Pulsar Docwiki is located here: o http://docwiki.embarcadero.com/RADStudio/XE2/en/Main_Page Everyone on the Pulsar Beta test has been given access to the Dowiki, and you should be able to write on content and Discussion pages. We invite you to participate and contribute information, ideas, or questions. If you have a problem of any sort, send email to [email protected] for assistance. For information on cross-platform development: o http://docwiki.embarcadero.com/RADStudio/XE2/en/Cross- Platform_Applications_Index o http://docwiki.embarcadero.com/RADStudio/XE2/en/Developing_Cross- Platform_Applications Known Problems Attempting to debug the same OSX project twice (without shutting down the IDE) will cause the IDE to hang during the second attempt to run with debugging. To workaround this problem, after you are done with a debug session, close the dbkosx_16_0 window on Mac machine before you launch another debug session. Sometimes, when you start a debug session, the IDE will prompts you with an “Unable to connect to remote host” dialog. When this happens, close this dialog, and restart the debug session again. We are working on a fix for this problem, and we will post the fix on the Pulsar newsgroups. What’s New in Pulsar Beta 2
FireMonkey
C++ Linker for OS X
Delphi RTL Enhancements
IDE Enhancements
DataSnap Enhancements
Modeling Enhancements
More Information
FireMonkey This Pulsar beta release introduces the FireMonkey application platform: Cross-platform Modern themed/skinned UIs Real-time image and animation effects Direct2D, D3D and OpenGL Native Delphi and C++ 100% Object Pascal Framework
This beta release of FireMonkey supports Delphi/Win32 only. Please focus your efforts in this domain.
This is an early drop of FireMonkey. Please keep that in mind as you explore. The component model is fairly stable, but the IDE/Designer support is very much in its infancy. It may not be possible to reconstruct the FireMonkey sample programs due to limitations in the designer. We are including these samples to demonstrate FireMonkey features that may go beyond the current constraints of the designer. We will be making significant improvements to the designer and IDE support in future field tests.
FireMonkey Sample applications • Download FireMonkeySamples.zip from the Pulsar beta site for sample applications that demonstrate FireMonkey capabilities. • FireMonkey Sample Program Descriptions • anidemo: 2D animation demo • anidemo3D: 3D animation demo • ctrlsdemo: Demonstrates a wide range of FireMonkey controls • form2dsample: Demonstrates working with 2D and 3D components inside a 2D form • form3dsample: Demonstrates working with 2D and 3D components inside a 3D form • fxshow: Demonstrates the power of FireMonkey's Effects and Filters • helloworld3d: FireMonkey low-level 3D sample • WindowsPrintingSample: Demonstrates printing support using a FireMonkey canvas.
FireMonkey Architecture • FireMonkey visual components descend from either TVisualObject or TVisualObject3D. To be displayed, a TVisualObject descendent needs to be hosted inside a container that implements IScene (TForm, TLayer3D). TVisualObject3D descendents need to be hosted in a container that implements IViewport3D (TForm3D, TViewport3D). As such, while you can drop a TSphere on a TForm, it will not be rendered because TForm does not implement IViewport3D. The same is true for a TButton dropped on a TForm3D. To host 3D objects in a TForm, make sure they are contained in a TViewport3D. To host 2D objects in a TForm3D, make sure they are contained in a TLayer3D. (See "form2dsample" and "form3dsample" from FireMonkeySamples.zip) • TPlatform • Abstraction layer to OS features like Windows, Menus, OS Menus, Timer, Common Dialogs, Printers and more. • TCanvas • Abstraction layer to 2D graphics frameworks like GDI+, Direct2D, Quartz, Cairo, etc. • TContext3D • Abstraction layer to 3D frameworks like Direct3D, OpenGL or OpenGL ES. • TBaseObject = class(TComponent) • Create, destroy and release object • Cloning, storing and loading object from a stream • Child object manipulations (add, remove, search) • Free notifications • Abstraction layer for tab order • Support for FireMonkey resources • Support for FireMonkey animations • IVisualObject • Handles Focus, Mouse and Keyboard events • Implemented by TVisualObject and TVisualObject3D • IRoot • Interface for top-level containers • Handles Focused, Captured, Active controls • Implemented by TCustomForm • IScene • Container interface for 2D objects • Implemented by TForm, TCustomLayer3D • IViewport3D • Container interface for 3D objects • Implemented by TForm3D, TViewport3D • FireMonkey Resources • Any object inherited from TBaseObject • Set ResourceName to identify • Found using FindResource method from parented object • Stored In / Loaded From a stream file • FireMonkey Styles • A collection of FireMonkey resources • WPF type of implementation • Styles can be inherited, saved, loaded • Look and Feel style files for Win7, MacOS, and custom themes FireMonkey: 2D, 3D, and GPU • FireMonkey takes advantage of GPU whenever possible • 2D Form can be rendered on a computer without a GPU with a few restrictions: • No TViewport3D, No Shader based Filters • A 3D Form requires a GPU - performs sophisticated transitions and manipulations of the user interface… … in other words, a 3D form may be the best choice for building a sophisticated 2D user interface
FireMonkey: Animation • Used to modify property values over time • Machine speed independent • Can be looped and / or reversed • Can follow a variety of time / value curves • Can be triggered by MouseOver, Focus, Visibility, etc.
FireMonkey: Effects / Filters • Can be applied to bitmaps • Can be applied to controls • Can be triggered by MouseOver, Focus, Visibility, etc.
FireMonkey works with Non-Visual Components • dbExpress • Data Modules • DataSnap • Actions • GestureManager • Basically the same • Different implementations on different platforms
FireMonkey is Cross-Platform • RTL • GUI • Database • Operating System • Compile on Windows 32 and Run on all platforms supported by RAD Studio
Additional information on how to get started with FireMonkey application development can be found in the Pulsar Help System: • See ms-help://embarcadero.rs_xe2/rad/Developing_Cross-Platform_Applications.html
Known issues • The form in the designer must be selected before the palette will update. • There are some rendering issues of 3D components on Windows XP. • FireMonkey applications running on Windows XP hosted in VirtualBox are not stable. This is NOT a recommended configuration for this release. • Please select a "Default Printer" before running the FireMonkey printing sample. • AssignPrn is not working yet. C++ Linker for OS X • The C++ linker now supports linking to Mac Frameworks. Delphi RTL Enhancements • TVirtualInterface has been added to the RTTI unit. • RegEx and Zlib are now available for Delphi 64-bit development. • Exception support for OS X is now available. • You can now build, run and deploy RTL packages for OS X. IDE Enhancements Project Options now support multiple platforms. In the Project > Options dialog, select the Target dropdown to set the options for a platform. View > Configuration Manager now supports saving more options in option sets, such as lib prefix, lib suffix, version, etc. DataSnap Enhancements Stand-alone DataSnap servers now support HTTPS. The DataSnap wizards now prompt for HTTPS in addition to HTTP and TCP/IP. Stand-alone WebBroker servers now support HTTPS. The WebBroker wizards now prompt for HTTPS in addition to HTTP. The ability to specify a KeepAlive value for DataSnap TCP connections has been added. • Three published properties have been added to the TDSTCPServerTransport component: • KeepAliveEnablement - (Set: Default, Enabled, Disabled) • KeepAliveTime - Integer Milliseconds value • KeepAliveInterval - Integer Milliseconds value • The time and interval properties map to the input parameters of the "TDSTCPChannel.EnableKeepAlive" procedure. The KeepAliveEnablement property sets if KeepAlive should be enabled, disabled or left however the OS has it set up. • Note that the Time and Interval properties will only be used if KeepAliveEnablement is set to 'kaEnabled', and that regardless of what this is set to, it can be overridden by implementing the OnConnect property of TDSTCPServerTransport, and in that event get the Channel from the TDSTCPConnectEventObject instance and call "EnableKeepAlive" or "DisableKeepAlive". You can change the JSON result format in REST calls An event has been added to the TDSHTTPWebDispatcher and TDSHTTPService components. This event is called "OnResult" and is a procedure with the following signature:
(Sender: TObject; var ResultVal: TJSONValue; const Command: TDBXCommand; var Handled: Boolean)
Handled is set to true by default from the code calling the event. If this event wishes to not modify the result, it can set Handled to false. Also, if it DOES modify the result, but wants the new result to be wrapped in a {"result":X} JSON Object, then Handled can be set to false, even though changes were made.
The value passed into the event in ResultVal is, in every currently foreseeable case, going to be a TJSONArray, containing zero or more elements. The result of a function call will be the last element of the JSON Array. All other elements before it will be the final value of "VAR" or "OUT" (or DBX Writer) variables, in the order they appear in the method's signature.
An implementation could look like this:
procedure TServerContainer4.DSHTTPServiceTest1Result(Sender: TObject; var ResultVal: TJSONValue; const Command: TDBXCommand; var Handled: Boolean); var Aux: TJSONValue; begin if Command.Text = 'TServerMethods1.EchoString' then begin Aux := ResultVal; ResultVal := TJSONArray(Aux).Get(0); TJSONArray(Aux).Remove(0); //remove the item so it isn't disposed when array is freed Aux.Free; end; end; DataSnap servers now allow any query parameters in DataSnap REST calls, and the DataSnap server stores them. In a server method being called by an HTTP request, you have access to the parameters by calling:
GetInvocationMetadata().QueryParams
Note that you need to add the DBXPlatform unit to your uses clause to have access to the invocation metadata.
The QueryParams property is a TStrings instance which holds key value pairs for all of the query parameters passed in through the URL of the REST call. Callback channel client side events. o Delphi DBX Client Events
With a DBX client, using a TDSClientCallbackChannelManager component, you can add an event to the OnChannelStateChange property which will be notified whenever the manager’s tunnel is opened or closed, or when callbacks are added to it or removed from it. An implementation of this event will have the following signature:
procedure ChannelMan1ChannelStateChange(Sender: TObject; const EventItem: TDSClientChannelEventItem);
The EventItem passed in to the event contains information similar to the server event. However, instead of specifying the callback’s ChannelName list, it provides a TDSCallbackItem which wraps the callback. This item can be used to get the callback’s unique Id and the list of server channel names the callback is listening on.
There is an additional supported event type for this client: TunnelClosedByServer. This event occurs whenever the client’s tunnel has been closed by the server, either intentionally or by a lost connection between the client and server.
o Delphi REST Client Events
For a REST Client written in Delphi, the ‘tunnel’ in most cases is referred to as the Channel or ClientChannel. When using the TDSRestClientChannel class to implement channels on the client, you can set a value for its OnChannelStateChange property, specifying the event procedure you’ve implemented. The signature of the event is as follows:
procedure ChannelStateChange(const EventItem: TDSRESTChannelEventItem);
The EventItem passed into the event contains very similar properties as the previously mentioned EventItems did, but with some differences. The EventType property returns a TDSRESTChannelEventType, which can be one of; rChannelCreate, rChannelClose, rChannelClosedByServer, rCallbackAdded, rCallbackRemoved.
The rChannelCreate and rChannelClose take the place of the TunnelCreate and TunnelClose event on the server and DBX client. Also, the rChannelClosedByServer event is similar to the DBX Client’s TunnelClosedByServer event, but is only used in the event there is an abrupt connection loss with the server. If the server intentionally disconnects the client’s channel, then the rChannelClose event type will be provided.
o JavaScript REST Client Events
REST clients written in JavaScript can also set an event function to be invoked when changes happen to the channel or one of its callbacks. An example of using this feature looks like this:
var channel = new ClientChannel (clientID, channelName); channel.onChannelStateChange = HandleChannelEvent;
//EventItem is an instance of ClientChannelEventItem, which has as its properties: //eventType, channel (ClientChannel) and callback (ClientCallback) function HandleChannelEvent(EventItem) { switch(EventItem.eventType) { case EventItem.channel.EVENT_CHANNEL_START: alert("Channel Started: " + EventItem.channel.channelId); break; case EventItem.channel.EVENT_CHANNEL_STOP: alert("Channel Stopped: " + EventItem.channel.channelId); break; case EventItem.channel.EVENT_CALLBACK_ADDED: alert("Callback Added: " + EventItem.callback.callbackId); break; case EventItem.channel.EVENT_CALLBACK_REMOVED: alert("Callback Removed: " + EventItem.callback.callbackId); break; case EventItem.channel.EVENT_SERVER_DISCONNECT: alert("Channel disconnected by server: " + EventItem.channel.channelId); break; } }
With JavaScript REST clients, you have the same feedback as with the Delphi REST clients: If the server gracefully closes the channel, then the client gets an event type of “ClientChannel .EVENT_CHANNEL_STOP”, but if the connection is abruptly lost, the client will get an event type of “ClientChannel. EVENT_SERVER_DISCONNECT”.
Modeling Enhancements • The UML Editor now supports comments in the implementation section. • Metrics/Kivat graph has improved interaction and reporting. When a Kiviat graph is generated, metrics that are in violation will be highlighted. When those metrics are double- clicked, the corresponding lines in results table will be selected. More Information • More information on What’s New in Pulsar can be found in the Pulsar Help System at ms- help://embarcadero.rs_xe2/rad/What's_New_in_Delphi_and_C++Builder_XE2.html What’s New in Pulsar Beta 1
Delphi Windows 64-bit support
64-bit requirements and migration
64-bit Inline Assembler
64-bit Known Issues
32-bit Mac OSX – Delphi / C++
Building a Cross-Platform OS X "Hello World" Console Application
Deployment Manager
ODBC Driver
RTTI for indexed properties and RTL support for method pointers
DataSnap Enhancements
Database Enhancements
IDE Enhancements
Delphi RTL Enhancements
Delphi Windows 64-bit support 64-bit support is very preliminary. Simple console applications are working but beyond that most functionality has had little or no testing. 64-bit command line compiler is “dcc64.exe”, compiled runtime unit are in lib\win64\release (or debug). To target a new or existing project for 64-bit, right click on the “Target Platform” node in the project manager, select “Add platform…” and choose 64-bit. There is currently no IDE support for debugging. However, “Run without debugging” can be used from the IDE to launch 64-bit exes. Some of the core RTL routines have not been ported and will generate “not implemented” errors. In terms of feedback, we are most interested in small test cases with valid code which either fail to compile or execute incorrectly. Please report any code that causes an internal compiler error or fails at runtime due to code generation issues. 64-bit requirements and migration 32 and 64-bit code cannot be used together in the same process Separate 32-bit / 64-bit DLLs/components/libraries will be required Calls to Windows API have to be 64-bit versions Most migration issues involve changing code which assumes SizeOf(Pointer)=SizeOf(Integer) SSE/SSE2 instructions and register set are used for floating point numbers, instead of FPU/x87 instructions and registers. Extended type is a 64bit floating point number on x64 instead of an 80bit floating point number on x86. In this beta release, all trigonometric and transcendent functions are implemented, however some functions have low precision and will be enhanced in a future beta release. 64-bit Inline Assembler Inline assembler for 64-bit code is supported with some limitations. No mixing of assembler and Pascal code. Routines must be all assembler or all Pascal. Direct Stack pointer (RSP & RBP) should be avoided. New pseudo ops have been provided to help manage stack use, .PARAMS, .PUSHNV, .SAVENV and .NOFRAME. o .PARAMS # – Used when calling external functions to setup the register parameter backing store as per the x64 calling convention. When used, a pseudo-variable, @params, is available for passing stack params to called functions. Use @params as a byte array where the first stack parameter will be @params[32], locations 0-31 represent the 4 register parameters. o .PUSHNV REG – Generates code to save and restore the non-volatile general purpose register in the prologue and epilogue. o .SAVENV XMM# – Same functionality as .PUSHNV for non-volatile XMM registers. o .NOFRAME – Forcibly disables the generation of a stack frame as long as there are no local variables declared and the parameter count <= 4. Use *only* for leaf functions. 64-bit Known Issues TReader.Read returns unexpected values in Pulsar as compared to Delphi XE [281545] For DateTime values < -693593, DateTimeToTimeStamp function creates invalid timestamps [281569] Variant array functions such as VarArrayCreate and VarArrayRedim cause unexpected exception errors at runtime [281639] Delete function deletes entire string (ShortString) and not only a section of characters [281884] Issues with VarUtils.SafeArrayCreate() [281954] EOutOfMemory exception is raised when you use TRttiRecordType.GetFields method [281955] IOUtils.TDirectory.GetDirectories function raise an AV [281968] DirectoryExists returns TRUE for non-existing paths [281994] AV involving TRttiProperty.GetProperty() involving Real [281996] The "delayed" directive is non-operational pending support in the RTL. 32-bit Mac OSX – Delphi / C++ This beta release includes the functionality to develop, deploy and debug Delphi and C++ applications for OS X: Delphi compiler, RTL, debugger, dbExpress C++ compiler, RTL, debugger, dbExpress Support for GUI applications is not included yet in this beta release Instructions for Building a Cross-Platform OS X "Hello World" Console Application This "Hello World" procedure demonstrates the essential steps for creating a cross-platform application in RAD Studio using either Delphi or C++. This cross-platform application uses the OS X platform (the Mac), a console window, an event, and displays a dialog in response to a user action.
Summary: How to create a cross-platform OS X "Hello World" console application
1. Connect your PC to a Mac. 2. Install and run the RASAM server on the Mac. 3. Create a remote profile on the development PC to describe the target machine, the Mac. 4. Create a cross-platform console application in the IDE. 5. Write the code (associate code with the console window). 6. Run the cross-platform console application in the IDE. 7. Debug the cross-platform application in the IDE.
(1) Connect your PC to a Mac
1. Connect the target Mac system to a LAN to which the development PC is also attached. 2. Use free software such as RealVNC, TightVNC, or Putty to establish a connection between the Mac and the PC.
(2) Run the RASAM server on the Mac
1. If the RASAM server is already installed on the Mac, go to the next step. If RASAM is not yet installed on the Mac, run the InstallAnywhere installer to install RASAM. The installer is available to run from either the target Mac or the development PC. 2. Open a Terminal window on the Mac. 3. Change the directory (cd) to the directory that contains the RASAM server. 4. Run the RASAM server by entering: ./rasam 5. When you are prompted for a password, enter an optional password string, which is subsequently used for connecting to the RASAM server. To set no password, press Enter. 6. The RASAM server displays a sign-on message and its command prompt (>).
(3) Create a remote profile for the Mac
1. Choose Tools > Options > Remote Profiles. 2. Click Add. The Create a Remote Profile wizard opens. 3. On the first page of the wizard (Profile information): o In Profile name, enter a name for the remote profile. o In Platform, select the target platform, in this case OS X. o Click Next. 4. On the second page of the wizard (Host machine information): o In Host name, enter the name or the IP address of the target machine. o Leave Port number as the default, 64211. o In the Password field, enter the optional password string that was set for the RASAM server. Click the ellipsis (...) to search for a password file (*.passfile), which encrypts the password for sharing. If no password is specified, leave this field blank. o Click Test Connection. . If the connection fails, verify the target machine name or IP address (try pinging them on the cmd window), and then ensure that the RASAM server is running on the target machine. . If the connection succeeds (or fails), click Next. Note: You can create a remote profile even if the connection to the target has not yet succeeded. However, a valid remote profile is necessary at several times during cross-platform application development.
5. On the third page of the wizard (C++ directory information), do either of the following:
o For Delphi applications, ignore this page and click Finish unless you want the application to use C++.
o For C++ applications, check the checkbox Use this profile with C++ projects and then click Finish.
6. For C++ applications, return to the Remote Profiles page and click Update Local File Cache. This pulls all of the specified files from the Mac.
(4) Create a cross-platform console application
1. Choose File > New > Other. The New Items dialog box appears. 2. Select either Delphi Projects or C++Builder Projects and then double-click Console Application. 3. For C++ only, in the New Console Application dialog box, make sure that Console application is checked and that Use VCL, Use UCL and Multi-threaded are all unchecked. Then click OK. 4. In the Project Manager, right-click the Target Platforms node, click Add Platform, select OS X on the Select Platform dialog box, and click OK. 5. Right-click the OS X platform in the Project Manager and select Assign Remote Profile from the context menu. 6. In the Select Remote Profile for 'OS X' Platform dialog box, select the remote profile that you want to use with this Hello World application, and click OK. The profile name is now displayed next to the OS X platform in the Project Manager. To create a remote profile, click either Add or Import.
(5) Write the code
1. In the code template that is displayed in the Code Editor: o For Delphi, enter the following statements after the try keyword and before the except keyword: Writeln('Hello, World!'); Readln; o For C++, enter the following line after #pragma hdrstop: #include
(6) Run the cross-platform console application
1. Choose Run > Run Without Debugging. 2. Go to the target machine and press the ENTER key. The RASAM server redisplays its command prompt (>) after your cross-platform console application terminates.
(7) Debug the cross-platform application To debug your cross-platform application in the IDE, use any of the following Run commands: o Run > Run (F9) o Run > Step Over (F8) o Run > Trace Into (F7) These Run commands: Transfer the required files to the target machine, based on the current selected profile. Run the application in debug mode.
Using the embedded debugger to debug an OS X cross-platform application is very similar to using the embedded debugger for Win32 applications.
See "Overview of Debugging" in the online help for high-level information about debugging. Deployment Manager Use the Deployment Manager to manage deployments to remote machines, and to deploy to Microsoft Azure and Amazon EC2 Clouds. Deployment Manager: Select Project > Deployment to use the Deployment Manager to specify details of the project you will deploy. You can view both the local files that are configured for deployment and the files on the remote system, and the differences. You can change the deployment configuration and delete remote files. Use the "File Items" view to view and edit all of the files configured for deployment, including items that are not part of the current platform. The bottom of the deployment manager has tabs. Choose the first tab to see this view. This view will show information related to the active platform and active configuration. Use the project manager to change the active platform and configuration. The object inspector is used to edit the configuration of a local item. For example, the object inspector can be used to change the "RemoteDir" property for a file. This is the relative path where a local file will be deployed to the remote computer. The remote files are shown when the connected box is checked (this check box will be enabled when there is no profile for the active platform). Check the "Show External Files" check box to see all of the files on the remote computer (within the remote project root directory). Otherwise, only the files that relate to the local items are displayed. Right click for additional commands. If no files are shown, choose the "Reconcile" command. Use the "Add..." command to add a file to the deployment configuration. This command is available by right clicking on the deployment manager. Multiple selection is supported. The selected files will be configured to deploy to all platforms. Any added files should appear in the deployment manager views. Use the "Add from project..." command to add a project file, or a file in the project directory, to the deployment. Only files that are not already part of the deployment are shown. Check the "Show files in project directory" check box to show more files. Any checked files will be added to the deployment and should appear in the deployment manager views. All selected files will be deployed to all platforms. Use the “Remote Files” view to view the files on the remote system. From this view, you can delete remote files. The "connected" check box must be checked before this view shows files. A profile must be associated with the active platform. Choose the third tab on the bottom of the Deployment Manager to see the “Remote Files” view. Check the "Show External Files" to show all remote files in the remote project root directory, otherwise only the remote files that match the local configuration are shown. Right click for additional commands. Use the “Add feature files...” to add well-known files that can't be determined automatically by the Deployment Manager, such as DBExpress drivers, DBExpress .ini files and Midas.dll. ODBC Driver Pulsar includes a dbExpress ODBC Driver that provides access to all ODBC-compliant database systems. This driver is in progress, and in this beta parameterized queries are working and data can be retrieved. o Stored procedures should work. o Metadata support is not in yet (ensure that GetMetadata and ParamCheck are set to false). o Data Explorer support is not in yet. RTTI for indexed properties and RTL support for method pointers Get and set most indexed properties (ones using []) on Delphi classes via RTTI. Invoke a method pointer / event in a general way via RTTI. DataSnap Enhancements GetAllChannelNames method has been added to TDSServer to get the names of all callback channels. Sub-properties with IP address, protocol, and application name have been added to DSConnectEventObject.ChannelInfo. There is a new record type called 'TDBXClientInfo' which you can get from the 'TDBXChannelInfo' stored in the 'TDSConnectEventObject' of the OnConnect event. This record contains the IP Address, Protocol and (if possible) application name. Application name is only populated with http protocol. You will need to use the IP to find the client machine name doing a lookup on your network, as this isn't provided with the requests. JavaScript session support: initSessionData function (in serverFunctionExecutor.js) now optionally takes a second parameter. This parameter is a string, and will be prefixed to the general cookie ID (dssessionid). This means if you call initSessionData(true, "chat_"), then cookies are enabled, and the cookie used will have key named "chat_dssessionid". This allows you to have complete control over which application uses which session ID/cookie. You could also have multiple instances of the same client storing their own unique session ID, provided you persist the prefix somehow between page refresh/reloads. Heavyweight callbacks now support broadcasting to specific callbacks. DataSnap REST Server code now supports multiple Callback Tunnels. This support includes a public API to TDSSession which allows for the storing and retrieving of TObject instances within the Session. TDSSessionManager.Instance.AddSessionEvent and TDSSessionManager.Instance.RemoveSessionEvent are now notified for sessions created and destroyed with the TCP/IP protocol. There is a new TDSCallbackTunnelManager class in the DSServer unit. You can use it like this:
TDSCallbackTunnelManager.Instance.AddTunnelEvent(Event: TDSCallbackTunnelEvent) TDSCallbackTunnelManager.Instance.RemoveTunnelEvent(Event: TDSCallbackTunnelEvent)
The tunnel event type is defined as follows:
TDSCallbackTunnelEvent = reference to procedure(Sender: TObject; const EventItem: TDSCallbackTunnelEventItem);
The TDSCallbackTunnelEventItem type is a record which holds several bits of information, such as the event type (TDSCallbackTunnelEventType) which is from the set:
TDSCallbackTunnelEventType = (TunnelCreate, TunnelClose, CallbackAdded, CallbackRemoved);
The event type also holds the tunnel instance, it's ID and server channel name (for convenience, or if the tunnel instance itself is unavailable,) and optionally the callback ID and callback's channel names.
The RoleItem objects in the 'Roles' collection on the Authentication Manager component now has an 'Exclude' list that negates any possible matches made by the 'ApplyTo' list. This, for example, is useful in the case where you want the role item to apply to all methods of a class, except for a single method. Or, for all methods of all classes (Blank ApplyTo) except for one or a few. Pulsar includes minified versions of the core JS framework files (base64, json2, callbackframework, serverfunctionexecutor). Json2.js has replaced json-min.js. With Pulsar, DataSnap servers with TDSTCPServerTransport components are able to monitor connections, and close any TCP connection they wish. The connections are linked with a Session Id, which can be used in a server method or authentication manager to get the TCP connection for the current session. This allows both server methods and authentication managers to terminate a connection for any reason. o Listening for Connections: On the TDSTCPServerTransport component there are two new events which can be assigned; OnConnect and OnDisconnect. An implementation of the OnConnect event may look like this: procedure TForm1. ServerTransportConnectEvent(Event: TDSTCPConnectEventObject); begin //Add both the connection and Channel (TDSTCPChannel) to a dictionary for later use FConnections.Add(TIdTCPConnection(Event.Connection), Event.Channel); end; o The above code captures and stores the Channel, which is an instance of TDSTCPChannel, as well as the connection for later use. The connection will be provided without a channel in the disconnect event, so in a way it can be used to uniquely identify a channel. The channel has a GetConnection function which will return its connection if needed. o Listening for Disconnects: An implementation of the OnDisconnect event may look like this: procedure TForm1. Server TransportDisconnectEvent(Event: TDSTCPDisconnectEventObject); begin //Remove the connection and its associated channel from the dictionary FConnections.Remove(TIdTCPConnection(Event.Connection)); end; o The above code is called whenever the TDSTCPServerTransport component is still active and a TCP connection has been closed. If the transport is being disposed, then this event will not be notified. Note that the event provides only the connection, but this connection could be used to look up a channel you've obtained with the OnConnect event. o Detecting Graceless Disconnects: By default, the OnDisconnect event will not be notified if the client abruptly loses his internet connection. This is because the socket remains open until an IO operation is attempted and fails. If your OS is configured to use keep-alive packets for all TCP/IP connections then based on its configuration, you will eventually see the disconnect event being notified. If you'd like to control this behavior on a per-connection basis, then you can use the EnableKeepAlive and DisableKeepAlive methods on the TDSTCPChannel: //If the connection is idle for 10 seconds, then send a keep-alive packet to check if the client is //still there. Event.Channel.EnableKeepAlive(10000); o The above code will enable keep-alive for the specific channel/connection. This will send a keep-alive packet to the client whenever it has been idle for more than the specified time (10 seconds.) If the client does not respond then the packet will be resent a number of times, as defined by the Operating System. (For example, in Windows 7, it will retry 10 times.) o There is an optional second parameter to the EnableKeepAlive procedure, which is an integer representing the number of milliseconds to wait between retries if a client doesn't respond to a packet. If undefined, it defaults to a value of 100 milliseconds. o If you wish to disable keep-alive for a specific connection, then get the Channel instance and call DisableKeepAlive. o Closing a Connection: You can close a connection at any time by getting the connection's channel, and calling its Close procedure. An example could look like this: //Get the associated Channel for the given connection, and if successful close it if FConnections.TryGetValue(Connection, Channel) then Channel.Close;
Database Enhancements The InterBase dbExpress driver now supports InterBase XE. The Firebird dbExpress driver now supports Firebird 2.5. The SQL Anywhere dbExpress driver now supports SQL Anywhere 12. The TDBNavigator control now has “Apply Updates” and “Cancel Updates” buttons. MetaData support has been added to the TAzureQueueManagement component. Now on each Queue node in the Queue Management component there is a context menu item called "Queue Metadata". This allows you to view the queue's metadata, as well as add and remove items from it, and update existing items. An API has been added for the Amazon Simple Queue Service, similar to the API for the Azure Queue Service. An API has been added for the Amazon SimpleDB, similar to the API for the Azure Table Service. An API has been added for the Amazon Simple Storage Service. Continuation Token support has been added for the Azure Table visual component. The API for the Azure Queue and Table services has been improved. The previous Azure API is deprecated. IDE Enhancements The Project Manager can target multiple compilation platforms: o Select one or more target platforms for a given project o Set options for specific targets and build configurations o Build each target individually o Use the Options dialog to set options for the selected target and build configuration The Project Manager has a new node called "Target Platforms" which allows you to add and remove platforms that your application will target. Choices are restricted based on the platforms a particular application/framework can support. Application creators must now specify what platforms they support. Imported projects will enable a target for Win32 only, but will support Win64. OS X is not a supported platform for imported projects. The Configuration Manager supports multiple platforms. It allows the creation of a "Build Group" which is stored in the project group file (.groupproj). It contains information on which projects in the group will have a particular target run on them (e.g., clean, make, build), and which configurations and platforms will participate. The Configuration Manager presents a list of all projects in the project group. For each project, you will be able to select which configurations and platforms in each project are used, and be given the option of including or excluding the project as a whole. User will be able to save and load any build group in the project group. Selected projects in a Build Group will honor project dependencies, but will have to enforce available configurations and platforms in the dependent project. "CompileAll", "BuildAll" and "Clean All" local menu items for the project group have pull-right submenus to easily select which Build Group to use. Deployment to multiple platforms: 1. Define a profile by right-clicking on the platform in the Project Manager and selecting Assign Remote Profile. This profile is used by the IDE to connect to the remote machine. 2. Select which target platform to use. 3. Compile and link the application. 4. Install and run RASAM.exe on the remote machine. RASAM.exe will be used to acquire the files your project needs to run on the remote machine. 5. In the IDE, press F9 to run the application in run or debug mode. Based on the current selected profile, the application and all the files it needs will be transferred to the remote machine, and the application will run in debug or run mode. Code folding for XML Doc has been added to the Code Editor. Find in Files now displays a hit count for each file in the Message View along with the search results. Template libraries: This feature allows RAD Studio to create new projects from an XML template file. The template file includes information about the project, such as the name of the project file, gallery icon, description and personality (such as Delphi or CBuilder). When a template file is installed, an icon will appear in the File/New/Other... gallery dialog box. When the icon is selected, the user will be prompted for a directory and a new project will be created in that directory. An XML template file must be created by hand and must reference an existing project file. The template file is installed using the Tools/Template Libraries.../Add... button. If this command is not available, then the projpageide160.bpl IDE package is not installed. The projpageide160.bpl package installs another feature related to template libraries, called the project page. The project page is an html file that is associated with a project (and may be part of the project or not). When a project is opened the project page is automatically shown in the RAD studio HTML browser. In order to get a project page to show when a project is created from a template library, the project referenced by the template library must have a project page. A project page is defined using the Project/Project page... command. If this command is not available, then the projpageide160.bpl IDE package is not installed. The project page may have a resources folder. This is where to put image files that are reference by the project page html. Delphi RTL Enhancements A cross-platform class to retrieve OS version information has been added to the Delphi RTL. o Interface: type TOSVersion = record public type TArchitecture = (arIntelX86, arIntelX64); TPlatform = (pfWindows, pfMacOS); private class var FArchitecture: TArchitecture; class var FBuild: Integer; class var FMajor: Integer; class var FMinor: Integer; class var FName: string; class var FPlatform: TPlatform; class var FServicePackMajor: Integer; class var FServicePackMinor: Integer; class constructor Create; public class function Check(Major: Integer): Boolean; overload; static; class function Check(Major, Minor: Integer): Boolean; overload; static; class function Check(Major, Minor, ServicePackMajor: Integer): Boolean; overload; static; class function ToString: string; static; class property Architecture: TArchitecture read FArchitecture; class property Build: Integer read FBuild; class property Major: Integer read FMajor; class property Minor: Integer read FMinor; class property Name: string read FName; class property Platform: TPlatform read FPlatform; class property ServicePackMajor: Integer read FServicePackMajor; class property ServicePackMinor: Integer read FServicePackMinor; end; o Implementation notes: . class function Check(Major): Returns True if the major/minor/service pack major OS version number is greater than or equal to Major/Minor/ServicePackMajor. . class function ToString: Returns a string representing the full OS version information. . class property Architecture: Returns the processor architecture of the OS. [1] [2] . class property Build: Returns the internal build number for Windows, or 0 for Mac OS X. . class property Major: Returns the major version number of the OS. . class property Minor: Returns the minor version number of the OS. . class property Name: Returns the name of the OS. . class property Platform: Returns the current platform (pfWindows or pfMacOS) . class property ServicePackMajor: Returns the major service pack version number for Windows, or the bug fix version number for Mac OS X. . class property ServicePackMinor: Returns the minor service pack version number for Windows, or 0 for Mac OS X.