LogoLogo
WinForms to WebPowerBuilder to .NETPowerBuilder to Java
  • WebMAP Documentation | Mobilize.Net
  • WinForms
    • Introduction
    • Getting Started
    • Conversion Process
    • Post-Conversion
    • Extend or Modify the Converted Application
      • NoWebMap Forms Winforms
        • How to add a new Form
        • Adding the created form to the migrated App
        • Interacting with the application data
        • Call the custom API
        • Interaction between the no webmap added Form and the WebMap components
      • Adding a component
      • Adding a component dynamically
      • Add a new control model
      • Switching CSS theme
      • Adding new window
      • Conversion Configuration
        • WebMAP configuration file
        • Stub Filter
      • Adding Non-WebMap Angular Forms
      • Adding FrontEnd Handler to a ToolStripMenuItem
      • Changing ToolStripButton icons
      • Adding new items to existing toolbar
      • Adding FrontEnd element properties and JS listeners
      • Adding FrontEnd output handlers
      • Access FrontEnd components
      • Create custom components based on existing WebMap Component
      • Override FrontEnd methods
    • Assessment Mode
    • Errors and Troubleshooting
      • How to resolve broken reference problems with VBUC
    • Portability
    • Glossary
    • Release Notes
    • Internal Demos
    • Known Issues
    • WinForms DCP
  • WebForms
    • Introduction
    • Overview
    • Desktop Compatibility Platform (DCP)
      • Pages and Master Pages
      • GridView and DataList data synchronization
      • HTTP objects
    • Post-Conversion
    • Extend or Modify the Converted Application
      • Adding FrontEnd validator
      • Adding Page
      • Adding MasterPage
    • Designer classes on WebForms Conversion Tool
    • Errors and Troubleshooting
      • How fix Solution when have been added website from filesystem without project file
    • Release Notes
  • PowerBuilder to .Net
    • Introduction
    • Getting Started
      • Conversion Tool
    • Desktop Compatibility Platform (DCP)
      • Data Manager
    • Reports
      • Report Rendering in Modernized Code
      • ReportWatcher Service Configuration
      • Data Manager to RDL Conversion
      • Reporting Service Internals
      • Troubleshooting
  • PowerBuilder to Java
    • Introduction
    • Getting started
    • Post-Conversion
      • Setup PBJava Environment
      • Architecture
      • App Start
    • Glossary
    • Errors
    • Glossary
    • FAQ
      • How to create a new Control
      • How to create a new Screen
      • What is the Mobilize.WebMAP.CoreServices.All?
      • What is the DesignerAttribute?
      • What is the InterceptedAttribute?
      • What is the InterceptedAttribute?
      • What is the ObservableAttribute?
      • What is the Mobilize.Weaving.WebMAPExtensions.All?
  • General
    • FrontEnd
      • Documentation
        • Webforms Angular Components
          • Web Components
            • Base Components
              • BaseValidator Component
            • KendoUI Components
              • CompareValidator
              • CustomValidator
              • RegularExpressionValidator
              • RequiredFieldValidator
              • ValidationSummary
          • Directives
          • AJAX Web Components
            • AjaxCalendar
            • AjaxModalPopupExtender
          • Ajax Interaction Services
        • Client Core
          • WebMap's Client Core
        • Angular Client
          • Introduction
          • WebMap Service
          • WebMap Interceptor Service
        • Base Components
          • Introduction
          • Components
            • Container
            • Control
            • ControlContainer
            • FormsContainer
            • Loading
            • Stub
        • Winforms Angular Components
          • Web Components
            • Base Components
              • Control Component
              • Form Container
              • Grid Component
              • Style
            • KendoUI Components
              • AdoDataControl
              • Button
              • C1TrueDBGrid
              • CheckBox
              • CheckedListBox
              • ComboBox
              • ContextMenuStrip
              • DataGridView
              • DataGridViewFlex
              • DateTimePicker
              • FileDialog
              • GroupBox
              • Label
              • ListBox
              • ListView
              • MaskedTextBox
              • MessageBox
              • NumericUpDown
              • Panel
              • PictureBox
              • PrintDialog
              • ProgressBar
              • RadioButton
              • RichTextBox
              • StatusStrip
              • Stup
              • TabControl
              • TabPage
              • TextBox
              • Timer
              • ToolStrip
              • TreeView
              • WebBrowser
              • Window
            • JQuery Web Components
          • WebMap FrontEnd Architecture
          • Migrated Structure
          • Setup
            • Front-End setup and compilation
            • Components Manual
            • Browser Support
            • Unit Test Manual
            • Development Process
            • Setup AOT/JIT Compilation
          • Decorators
            • Server Event
          • Conventions
            • Application Structure and NgModules
            • Coding
            • Components
            • Data Service
            • Directives
            • Lifecycle hooks
            • Names
            • Services
        • PowerBuilder Kendo Components
          • Base Components
            • base-component
            • column-control
            • controlcontainer
          • Data Manager Componets
            • base-data-manager
            • data-manager-control
            • data-manager-control-base
            • dw-checkbox
            • dw-column
            • dw-complexNumericMaskComponent
            • dw-compute
            • dw-date-time-edit-mask
            • dw-dropdowndatawindow
            • dw-edit
            • dw-edit-mask
            • dw-radio-button
            • dw-simple-numeric-edit-mask
            • dw-string-edit-mask
            • dw-time-edit-mask
          • Window Components
            • basemask
            • graphics
            • w-checkbox
            • w-command-button
            • w-complex-numeric-mask
            • w-date-time-edit-mask
            • w-dropdownlistbox
            • w-group-box
            • w-line
            • w-listbox
            • w-maskedtextbox
            • w-mdiclient
            • w-menu
            • w-multiline
            • w-picture
            • w-picture
            • w-radiobutton
            • w-rectangle
            • w-simple-numeric-edit-mask
            • w-single-line-edit
            • w-statictext
            • w-string-edit-mask
            • w-time-edit-mask
            • w-toolbar
            • w-toolbaritem
            • w-user-object
            • w-window
          • Services
            • DmInteractionService
          • DataManagerEvents
          • FocusManager guide
      • Api Documentation
        • WebMap Silverlight
        • WfNetC1Components
        • WebFormsComponents
      • Guides
        • Setup NPM package registry in the workspace
        • How to Setup WebMap Applications To Run Over SubDomains or WebApplications In IIS
        • Deploy several WebMap Apps in the same Server
        • Update to Angular 16
        • Appearance
          • How to change the CSS
          • How to override the style for a component
        • Component maintenance
          • How link WebMap package to the migrated Application
          • How to resolve broken reference problems with VBUC
          • How to test a local WebMap Components package
          • How to add a new component in a migrated application
          • How to update a component
          • Dynamic Control Support
          • How to add new set of component with a different provider
          • How to test your component in the playground
          • Tools
        • WMLogger
          • How to use the WMLogger's instance
          • How to change log's level
          • How to add log tags
        • Integration test
        • Setup WebMap Applications to Run Front-End And Back-End In Separates Sites
          • Setup WebMap Applications To Run Front-End And Back-End In Separates Sites in Production (IIS)
        • Setup Migrated WebMap Applications To Run Front-end & Back-end In Separates Sites (Only development)
        • Initial Set Up
          • Software to Install
          • Necessary Repositories
      • Errors
      • Version Notes
        • Client Core
        • Angular Client
        • Web Base Components
        • Winforms Angular Components
        • PowerBuilder Kendo Components
      • Licenses
        • Client Core
        • Angular Client
        • Base Components
        • PB Kendo Components
        • WFNet Kendo Components
        • WebForms Components
        • WFNet Access Components
        • WFNet Janus Components
        • WFNet C1 Components
        • Silverlight wms-framework
        • Silverlight i-components
    • BackEnd
      • WebMAP From Scratch
      • Setup
      • DCP: Desktop Compatibly Platform
        • Overview
        • Library Bundles
          • Bundle Library
            • Create an Observable Object
          • Bundle DTO
            • DTO: Data Transfer Objects
              • Creating a DTO
            • Mappers
              • Create Mappers
            • Observable Wrappers
              • Create an Observable Wrapper
            • API/Controllers
      • Architecture
      • Weaving on WebMAP
      • Glossary
      • FAQ
        • How to create a new Control
        • How to create a new Screen
        • What is the Mobilize.WebMAP.CoreServices.All?
        • What is the DesignerAttribute?
        • What is the InterceptedAttribute?
        • What is the Mobilize.Extensions.Logging.RollingFile?
        • What is the ObservableAttribute?
        • What is the Mobilize.Weaving.WebMAPExtensions.All?
      • Licenses
        • PBNet DCP
        • WebFormsDCP
        • WFNet DCP
        • CoreServices
        • CoreServicesCommon
    • Request and Response
  • SCALABILITY
    • Introduction
    • Microservices
    • Containerizing a WebMap .Net Application with Docker
    • Vertical scalability
Powered by GitBook
On this page
  • Overview
  • DataManager layout vs RDL File organization
  • Page configuration section:
  • Data configuration section
  • Header and footer configuration
  • Controls and report content
  • Dealing with embedded reports
  • Label reports
  • Crosstab reports
  • Limitations
  • Position of elements could not be changed at render time
  • Evaluation of code inside report expressions
  • Evaluation of code and render time properties

Was this helpful?

  1. PowerBuilder to .Net
  2. Reports

Data Manager to RDL Conversion

PreviousReportWatcher Service ConfigurationNextReporting Service Internals

Was this helpful?

This section explains some details on how reports defined in DataManager classes are converted to the Report Definition Language (RDL).

Notice that this mapping is done automatically at runtime . This document gives and overview on how the internal process of converting DataManagers to RDL work.

Overview

As described in the section when a report is requested to the modernized application the ReportWatcher service is invoked when all the elements required for creating the report. These elements are (mainly):

  1. Report definitions in the RDL format

  2. Report data using XML and System.Data.DataSet format

The generation of the RDL format is performed at runtime from the definition of a DataManager. This conversion is performed based on the object model of a DataManager. The runtime system takes the definition and converts all of the parts of a DataManager to the RDL format. For example for a DataManager with a label control like this:

    this.name_t = new Mobilize.Web.DmText();
    this.name_t.Band = Mobilize.Web.CaseExtensions.String("detail");
    this.name_t.Alignment = 1;
    this.name_t.Text = "Name:";
    this.name_t.Border = 0;
    this.name_t.Color = "33554432";
    this.name_t.X = 37;
    this.name_t.Y = 4;
    this.name_t.Height = 64;
    this.name_t.Width = 174;
    this.name_t.Name = Mobilize.Web.CaseExtensions.String("name_t");
    this.name_t.Visible = true;
    this.name_t.Font.FontFace = "Tahoma";
    this.name_t.Font.Height = -10;

The conversion generates the following RDL Fragment for DataManager instances created with the previous snippet:


    0.01042in
    0.08333in
    0.39583in
    0.16667in
    true
    
    
        
        
            Name:
            
        
        
        
    
    

Notice that this conversion is performed at runtime. This is done this way to support dynamic operations performed on the DataManager at runtime .

DataManager layout vs RDL File organization

The following diagrams show how different top-level sections of a DataManager are converted to RDL.

Page configuration section:

This section contains properties for page width, height, margins, etc. (left: lines 14-18 in the left source file). These properties are converted to XML elements in RDL in lines 24-29.

Data configuration section

This section contains configuration for report data columns (left: lines 27-30). Theses columns are converted to RDL report Fields in the DataSet section (right: lines 8-12).

Header and footer configuration

This section contains configuration for report header and footers (left: lines 27-30). Theses columns are converted to RDL report Fields in the DataSet section (right: lines 30-31).

Controls and report content

This section contains most of the elements of the report. Controls used inside the report are defined as class properties (left: lines 5-9) and also inside the DataManager constructor as a sequence of control property initialization (left: lines 32-40). These elements are converted to RDL elements inside the report body (right: line 18) .

Dealing with embedded reports

The following code snippet shows an embedded report inside a DataManager:

this.rpt_1 = new DmReport();
this.rpt_1.Band = "detail";
this.rpt_1.Name = "rpt_1";
this.rpt_1.DataObject = "my_subrepo";
this.rpt_1.Nest_Arguments = new string[] { "col1", "col1 + 1" };
this.rpt_1.X = 37;
this.rpt_1.Y = 4;
this.rpt_1.Width = 174;
this.rpt_1.Height = 64;

The DataObject property says which DataManager will be used to render the embedded report. This control is converted to RDL as follows:


  0.39583in
  0.16667in
  rpt_1
    
        
        = Fields!col1.Value 
        
        
        =Code.SumValues( Fields!col1.Value , 1)
        
    

Label reports

The original platform allowed the creation of a special DataWindow used to print labels. This concept is converted to a DataManager which is converted to a RDL report that tries to emulate the behavior of the original report.

Crosstab reports

Limitations

There are some limitations to the DataManager to RDL conversion strategy. There are some techniques that were valid on the original platform but that could not be emulated in the target platform.

Here is a list of some of this issues

Position of elements could not be changed at render time

In the original platform the position, height or width of an element could be changed at runtime by evaluating a custom expresion. For example:

this.myLabel.X = "10\t opt_1 + 10"

In this cases the X property of the myLabel control is determined at runtime depending on the evaluation of the opt_1 + 10 expression. This in turn is evaluated for each row. In SSRS and RDL it's not possible to associate an expression to the position, with or height of an element or band.

To support this same behavior it is recommended to examine the original intension of the developer. As an example, the following snippet specify that the height of a label will be zero if the opt_1 = 100 condition is satisfied:

this.myLabel.Height = "10\t IF(opt_1 = 100,0, 10)"

In this case it's better to use the Visible property . This property supports expressions in SSRS.

Evaluation of code inside report expressions

The original platform supports calling global functions inside report expressions. This is not supported in the SSRS/RDL version since the report is being rendered outside of the application process.

In this case the DataManager to RDL conversion generates evaluation of report expressions that required access to original code as part of the data of the report. This allows the evaluation of the original expressions.

For example if a property is assigned as:

this.name_t.Text = "a\tmyglobalfunc(10)";

The generated report definition is going to have an additional field to stored the evaluation of this property:


    name_t__TEXT

The process that generates the data dump for the report data evaluates these expressions for each row of the DataManager. This data dump is passed to the ReportWatcher service to render the report.

Evaluation of code and render time properties

The original platform allowed the evaluation of functions which value could only be determined at render time. For example the Page() function which returns the current page of the report. Uses of this function are converted to the RDL equivalent Globals!PageNumber . However the evaluation of this property could not be combined with expressions evaluated on the server side .For example:

this.name_t.Text = "a\tmyglobalfunc(Page())";

This expression could not be converted to RDL since it requires both evaluating user code and evaluating a render time property.

The DataManager to RDL conversion support embedded reports using the RDL .

The binding to the new report is performed by the ReportWatcher service. This service uses the to provide the definition of the embedded report .

The is used to emulate the layout of a label DataWindow . The general strategy to create a Tablix having row groups for blocks of labels, a column group is created to show several labels in the same row, with a dummy column at the end for spacing.

The CrossTab DataWindow, which presents data in a spreadsheet-like grid. A CrossTab lets users view summary data instead of a long series of rows and columns. The strategy was to use the to create a report using multiple Tablix elements to generate the matrix-like structure that emulates the same structure as the original DataWindow.

Reports in code
Subreport element
ReportViewer.LoadSubReportDefinition
Tablix SSRS concept
Tablix SSRS concept