Visual Basic em Português

Introdução

Para começar, foi criada uma tabela em SQL com alguma informação para este exemplo. É uma lista de equipamento electrónico como PDA, computadores, etc. Da tabela criada é necessário criar um DataSet, com duas DataTables. Chamar a este DataSet “dsReport.xsd”.

A primeira DataTable, “products”, contém a lista de todos os produtos na tabela SQL. A segunda DataTable, “groupTotal”, é uma vista agrupada (Group By) com os grupos e os somatórios das quantidades. que serão usados para o SubReport e para o gráfico.

Depois disto é necessário adicionar o relatório à aplicação. Seleccionar o relatório e indicar um nome apropriado. Para o exemplo podem utilizar “rptProducts”.

Com o novo relatório criado e aberto, existe uma nova opção na barra de ferramentas Report. Seleccionar o “Page Header” e “Page footer” para mostrar estas duas secções no relatório. Depois disto vamos arrastar da Toolbox para a secção “Body” (corpo) do relatório.

DataSource

Agora é altura para definir a Data Source. No menu Report, seleccionar Data Source. Irá aparecer uma nova janela onde se pode escolher as Data Sources (DataSets) disponíveis na nossa aplicação. Seleccionar a DataSet criada.

NOTA: O nome do “Report Data Sources” pode ser renomeado, e será usado no código mais tarde.

Depois de definir a Data Source para o relatório, as DataTables estarão disponíveis no Data Source Explorer (normalmente disponível na janela da Soluction Explorer). Da tabela Produtos arrastar as colunas para o objecto Table que foi inserido na secção “Body”


O objecto Table funciona como uma folha de Excel. Pode-se unir células, alterar a cor de fundo, fontes, etc. Este exemplo utiliza um campo do tipo Moeda. Para mostrar como é simples formatar as células, clicar com o botão direito do rato sobre o campo e seleccionar Propriedades. Na janela das propriedade ir à Tab Format e definir a célula com o formato Currency.

 

Alterar o formato dos restantes campos, como negrito, títulos, etc., para obter um aspecto profissional.

Imagens

Para incluir imagens na nossa aplicação, pode-se embeber e depois usar como um logótipo (por exemplo). Pode-se também ir buscar directamente as imagens à base de dados, se estiverem armazenados como binário (Binary).

Para embeber as imagens no relatório é apenas necessário ir ao menu Report e seleccionar Embedded Images. Na nova janela seleccionar o botão New Image e escolher a imagem pretendida.

Fechar a janela e depois, na Toolbox, adicionar um controlo Image ao relatório. Nas propriedades do controlo, seleccionar a imagem adicionada da Combobox disponível na propriedade Value.

Expression Editor

Uma das novidades do Visual Studio 2008 para o Microsoft Reporting Services Expression Editor é o intellissense disponível quando se precisa de criar alguma fórmula ou expressão.

Na secção Footer, pode-se adicionar duas TextBoxes. Numa delas, iremos colocar o número da pagina e o total de páginas. Para isso, já existem fórmulas criadas na categoria Global.


Como se pode ver na imagem seguinte, pode-se usar fórmulas de VB (a maioria delas) no Expression Editor. O intellissence ajuda bastante para prevenir erros e para lembrar o sintaxe das fórmulas . Na segunda Textbox vamos colocar simplesmente a data de impressão.

 

Parâmetros (Parameters)

Pode-se utilizar Parameters para diversas coisas. Neste exemplo será apenas usado para passar informação da aplicação para o relatório.

No menu Report, seleccionar Report Parameters. Definir dois parâmetros: “ApplicationUser” e “ApplicationLevel” do tipo String.

Depois, no relatório, pode-se usar o Expression Editor para definir os parâmetros (eles serão definidos no código) para as TextBoxes. Eles estarão disponíveis na categoria Parameters.

Gráficos (Chart)

Pode-se usar vários gráficos no relatório e eles são muito fáceis de usar e alimentar com informação.

Adicionar um controlo Chart da Toolbox para a secção Body do relatório. Efectuar um duplo-clique no gráfico e irá mostrar as áreas “Data Field” e “Category Field”.

Arrastar os campos “Group” e Totals” da janela DataSource Explorer.

Pode-se também fazer isto nas propriedades do gráfico. Nesta janela pode-se também personalizar as cores das séries, legendas, efeitos 3D, filtros, eixos, etc.

Usando o código

Nos passos anteriores, foram usadas diversas Data Sources no relatório. Agora, iram ser adicionadas novas Data Sources, filtradas ou não, e essa será a informação que será visível no relatório.

Imports System.Data.SqlClient
Imports Microsoft.Reporting.WinForms

Public Class Form1

    ' Connection string
   Private connString As String = _ 
"DataSource=.\SQLEXPRESS;AttachDbFilename='|DataDirectory|\myDatabase.mdf'”_
";Integrated Security=True;User Instance=True"

   ''' <summary>
   ''' Evento Form load
    ''' </summary>
   Private Sub Form1_Load(ByVal sender As Object, _
                                   ByVal e As System.EventArgs) Handles Me.Load

        Try

           ' Chama a personalização
           Call customizeReportViewer(Me.ReportViewer1)

            ' Adiciona um novo botão
           Call AddReportViewerButton()

            With Me.ReportViewer1.LocalReport

                ' Caminho para o relatório
               .ReportPath = Application.StartupPath & "\..\..\rptProducts.rdlc"
               .DataSources.Clear()

                ' Define os parameters
               Dim parameters(1) AsReportParameter
                parameters(0) = _
                         New ReportParameter("ApplicationUser", "jpaulino")
                parameters(1) = _
                         New ReportParameter("ApplicationLevel", "Administrator")

                .SetParameters(parameters) 
            End With

           ' ----------------------------------------------------
            ' Datasource para o relatório principal (where price > 200)
            ' ----------------------------------------------------
           Dim SQL As String = "SELECT * FROM products WHERE price > @price"
           Using da As New SqlDataAdapter(SQL, connString)
                da.SelectCommand.Parameters.Add("@price", SqlDbType.Int).Value = 200

                Using ds As New DataSet
                    da.Fill(ds, "products")

                    ' É preciso usar o mesmo nome como foi de definido 
                    ' no Data Source Definition
                   Dim rptDataSource As New ReportDataSource _
                                          ("dsReport_products", ds.Tables("products"))
                    Me.ReportViewer1.LocalReport.DataSources.Add(rptDataSource)

                End Using

            End Using

           ' ----------------------------------------------------
            ' Datasource para o gráfico
            ' ----------------------------------------------------
           Dim SQL_Chart As String = "SELECT [group], SUM(quantity) AS " _ 
                   “Total FROM products GROUP BY [group]"
           Using da As New SqlDataAdapter(SQL_Chart, connString)
                Using ds As New DataSet
                    da.Fill(ds, "groupTotal")

                    Dim rptDataSource As New ReportDataSource("dsReport_groupTotal", _
    ds.Tables("groupTotal"))
                    Me.ReportViewer1.LocalReport.DataSources.Add(rptDataSource)

                End Using
            End Using


           ' Refresh do relatório
           ReportViewer1.RefreshReport()


        Catch ex As Exception
            MessageBox.Show(ex.Message, My.Application.Info.Title, _
                                              MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try

    End Sub

End Class

SubReports

Pode-se usar um ou vários subreports no relatório. Para fazer isso, é necessário preencher a Data Source para cada um deles. Uma vez que não se pode aceder directamente à Data Source do relatório, é preciso definir um evento (handler) ao SubreportProcessing, e depois quando o relatório está a ser carregado, recolhe-se a informação da base de dados e preenche-se a Data Source.

Pode parecer difícil de fazer, mas na verdade é bastante simples!

Definir a Data Source para o subreport e usar um objecto Table, como no relatório principal. Adicionar os campos ao objecto Table. No relatório principal, adicionar um objecto SubReport da Toolbox e escolher o subreport criado.

Depois, no evento Form Load onde está o relatório principal, adicionar o evento para o SubreportProcessing.

AddHandler ReportViewer1.LocalReport.SubreportProcessing, _
                  AddressOf SubreportProcessingEvent

Finalmente, no evento SubreportProcessing, define-se a nova Data Source, da mesma maneira dos anteriores.

 ''' <summary>
''' Quando o subreport está a ser carregado/processado, preenche a DataSource
'''  </summary>
Sub SubreportProcessingEvent(ByVal sender As Object, _
                                         ByVal e As SubreportProcessingEventArgs)

     Try

         Dim SQL As String = "SELECT [group], SUM(quantity) AS " _
             “Total FROM products GROUP BY [group]"
         Using da As New SqlDataAdapter(SQL, connString)
             Using ds As New DataSet
                 da.Fill(ds, "groupTotal")
                 Dim rptDataSource As New ReportDataSource _
                                           ("dsReport_groupTotal", ds.Tables("groupTotal"))
                 e.DataSources.Add(rptDataSource)
             End Using
         End Using

     Catch ex As Exception
         MessageBox.Show(ex.Message, My.Application.Info.Title, _ 
                                      MessageBoxButtons.OK, MessageBoxIcon.Error)
     End Try

End Sub

Personalização do ReportViewer

O ReportViewer é o controlo que mostra os Microsoft Reports num Form ou numa Webpage. Pode-se personalizar a maioria dos controlos deste, para melhorar ou personalizar como pretendido.

Neste artigo, será mostrado duas personalizações simples.

Primeiro, pode-se alterar os títulos dos controlos. Pode-se também fazer outras coisas, como desabilitar itens, renomear tooltips, etc. Isto é especialmente interessante para alterar a linguagem do controlo, uma vez que está disponível apenas em Inglês.

Para isto, será criado um método recursivo que irá fazer um ciclo em todos os controlo do ReportViewer e fazer algumas alterações.

'''  <summary>
''' Ciclo em todos os controlos do ReportViewer
''' </summary>
''' <remarks></remarks>
Sub customizeReportViewer(ByVal ctrl AsControl)

    For Each c As Control In ctrl.Controls

        ' ----------------------------------------------------
        ' Verifica o texto das labels disponíveis 
        ' ----------------------------------------------------
       If TypeOf c Is Label Then
            Dim lbl As Label = DirectCast(c, Label)
            Select Case lbl.Name
                Case "LblGeneratingReport"
                   lbl.Text = "My report is loading now ... "
               Case Else
                   ' Podem ser adicionadas mais personalizações
           End Select
        End If

       ' ----------------------------------------------------
        ' Altera os textos da ToolStrip para Português
        ' ----------------------------------------------------
       If TypeOf c Is ToolStrip Then
            Dim ts AsToolStrip = DirectCast(c, ToolStrip)
            For Each item AsToolStripItem In ts.Items

                Select Case item.Text
                    Case "Find"
                       item.Text = "Pesquisar"
                   Case "Next"
                       item.Text = "Próximo"
                   Case "of"
                        item.Text = "de"
                     Case Else
                        ' Podem ser adicionadas mais personalizações
               End Select
            Next
        End If

       ' Se o controlo tiver child controls
        If c.HasChildren Then
           customizeReportViewer(c)
        End If

    Next

End Sub

Finalmente é apenas necessário chamar o método criado no evento Form Load, onde se encontra o ReportViewer.

   ' Chama o método criado
Call customizeReportViewer(Me.ReportViewer1)

A segunda personalização mostra como incluir um novo botão na Toolstrip. Irá encontrar a ToolStrip principal do relatório e adicionar um botão alinhado à direita.

'''  <summary>
'''  Encontra a ToolStrip principal e adiciona um novo botão alinhado à direita
''' </summary>
Sub AddReportViewerButton()

    Dim ts() As Control = Me.ReportViewer1.Controls.Find("toolStrip1", True)
    If ts IsNot Nothing Then
        Dim tsItem As ToolStrip = DirectCast(ts(0), ToolStrip)
        Dim item As New ToolStripButton
        item.Name = "newButton"
        item.Text = "New Button"
        item.BackColor = Color.Green
        item.ForeColor = Color.White
        item.Alignment = ToolStripItemAlignment.Right

        tsItem.Items.Add(item)

        AddHandler item.Click, AddressOf newButtonClick
   End If

End Sub

Quando o botão for pressionado:

'''  <summary>
''' Mostra uma mensagem quando o botão no ReportViewer for pressionado
'''  </summary>
Sub newButtonClick()
    MessageBox.Show("This is my new button!")
End Sub

Este artigo mostra os primeiros passo, e os mais importantes, para usar os Microsoft Reports, e como utilizar o código. Espero que isto ajude a utiliza-los e mostrar como é simples trabalhar com eles.

Para se conseguir isto é apenas necessário criar um novo projecto, ir às propriedades do projecto (My Properties ou menu Project – «Nome da Aplicação» Properties) e no separador Resources adicionar o executável pretendido.

Depois, no Solution Explorer, selecciona-se o executável e na janela de propriedades (Properties Window) definir na Build Action como Embedded Resource.

Depois, no código, pode-se usar uma função semelhante a esta, que irá ler o executável dos resources usando Reflection para uma Stream, e que irá depois gravar para o disco usando um FileStream.

''' <summary>
''' Extrai um ficheiro executável dos resources da aplicação
'''</summary>
'''<param name="fileName">Nome completo do ficheiro a extrair</param>
'''<returns>Localização do ficheiro extraido</returns>
'''<remarks></remarks>
Private Function GetResourceFile(ByVal fileName As String) As String

    Try

       ' Cria um nome/localização temporária para o ficheiro. Por defeito é criado um
        ' ficheiro com o a extensão *.tmp e por isso é necessário alterar o para *.exe
       Dim tempPath As String = IO.Path.ChangeExtension(IO.Path.GetTempFileName(), ".exe")

        ' Verifica o nome da aplicação (Assembly)
       Dim currentAssembly As Reflection.Assembly = Reflection.Assembly.GetExecutingAssembly()

        ' Verifica todos os objectos disponíveis nos resources
       Dim arrResources As String() = currentAssembly.GetManifestResourceNames()
        For Each resource As String In arrResources

            ' Verifica se o resource tem o nome do ficheiro a extrair
           If resource.Contains(fileName) Then

               ' Lê o executável dos resources para uma Stream
               Using resourceStream As IO.Stream = currentAssembly.GetManifestResourceStream(resource)

                    ' Cria um novo FileStream que irá escrever o ficheiro final
                   Using writer As New IO.FileStream(tempPath, IO.FileMode.Create, IO.FileAccess.Write)

                        Const size As Int16 = 4096
                        Dim bytes(size) As Byte
                        Dim numBytes As Int32 = 0

                        ' Escreve todos os bytes da Stream criada, usando
                        ' o FileStream e o método Write() num ciclo Do
                       Do
                           numBytes = resourceStream.Read(bytes, 0, size)
                            writer.Write(bytes, 0, numBytes)

                        Loop While (numBytes > 0)

                    End Using ' writer

               End Using ' resourceStream

                ' Retorna a localização do ficheiro
               Return tempPath

            End If
        Next

       ' Caso não tenha encontrado o ficheiro pretendido
       Return String.Empty

    Catch ex As Exception
        Return String.Empty
    End Try

End Function

Finalmente, é apenas necessário chamar a função indicando o nome do executável e, neste caso, executá-lo.

If file <> String.Empty Then 

      ' Inicia a aplicação da localização temporária. Se fosse necessário 
      ' podia-se copiar o ficheiro final para outra localização qualquer
       Process.Start(file)
Else

   MessageBox.Show("Não foi possível extrair o executável")

End If

Este exemplo, bastante simples, utiliza apenas um pequeno ficheiro, mas permite ver o funcionamento geral deste processo. Foi escolhido um executável para o exemplo mas pode ser utilizado outro tipo de ficheiros.

Exemplo do artigo: DOWNLOAD

PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!

É bastante simples utilizar WPF em Windows Forms e com isso usar todas as suas potencialidades. Muitos utilizadores queixam-se dos controlos disponíveis no Visual Studio e esta é uma oportunidade de criar os seus próprios controlos quase sem limites. Estes dois exemplos iram mostrar como incorporar um controlo WPF em Windows Forms e como fazer algumas alterações com o objectivo de melhorar visualmente os mesmos.

Para criar um controlo WPF é apenas necessário adicionar um novo item ao projecto (desde que esteja seleccionado a plataforma . NET Framework 3.0 ou superior) e seleccionar User Control (WPF)

Depois, para cada controlo, indicar o nome pretendido de acordo com os exemplos.

wpfPictureBox

Este controlo tem algumas personalizações com é o caso de:

• Sombra na PictureBox
• Possibilidade de alterar a opacidade da imagem

No editor de XAML utilizar o seguinte código:

<UserControl x:Class="wpfPictureBox"
    xmlns=http://schemas.microsoft.com/winfx/2006/xaml/presentation
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="300" Height="300">

    <!-- Definição da imagem e da sombra –>
    <Image Margin="10" x:Name="Image" Stretch="Uniform" Opacity="1">
      <Image.BitmapEffect>
            <DropShadowBitmapEffect Opacity="1" />
        </Image.BitmapEffect>
     </Image>

</UserControl>

Após compilar a aplicação ficará disponível na Toolbox o controlo wpfPictureBox. Arrastar para o Form, adicionar também uma TrackBar e utilizar o seguinte código para definir a imagem e alterar a opacidade da imagem:

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

        ' Definições da TrackBar
        Me.TrackBar1.Maximum = 100
        Me.TrackBar1.Minimum = 0
        Me.TrackBar1.Value = 100 

        ' Carrega uma imagem no nosso controlo
        WpfPictureBox1.Image.Source = New Windows.Media.Imaging.BitmapImage(New Uri("c:\imagem.jpg"))

    End Sub

    ' Quando se mexe na TrackBar diminui/aumenta a opacidade da imagem
    Private Sub TrackBar1_Scroll(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles TrackBar1.Scroll

        WpfPictureBox1.Image.Opacity = Me.TrackBar1.Value / 100

    End Sub

wpfComboBox

Este controlo tem algumas personalizações (algumas apenas para ilustração das potencialidades do WPF) com é o caso de:

• Sombra na ComboBox
• Botão dentro da lista para adicionar novos itens
• Efeito de fundo na caixa e lista

No editor de XAML utilizar o seguinte código: 

<UserControl  x:Class="wpfComboBox" 
    xmlns=http://schemas.microsoft.com/winfx/2006/xaml/presentation
    xmlns:x=http://schemas.microsoft.com/winfx/2006/xaml 
    Width="200" Height="30">

    <ComboBox x:Name="wpfCombo" Margin="5" Foreground="White" BorderBrush="White" MaxDropDownHeight="150">

        <!-- Define o efeito da sombra –>
        <ComboBox.BitmapEffect>
            <DropShadowBitmapEffect ShadowDepth="1" Opacity="1" Color="DarkSeaGreen" />
        </ComboBox.BitmapEffect>

        <!-- Define o efeito do fundo –>
        <ComboBox.Background>
            <LinearGradientBrush>

                <LinearGradientBrush.GradientStops>
                    <GradientStopCollection>
                        <GradientStop Color="DarkSeaGreen" Offset="0" />
                        <GradientStop Color="White" Offset="1" />
                    </GradientStopCollection>
                </LinearGradientBrush.GradientStops>

           </LinearGradientBrush>
        </ComboBox.Background>

        <ComboBox.Resources>
            <Style TargetType="{x:Type ComboBoxItem}">               

                <!-- Define o efeito do fundo para os itens –>
                <Setter Property="Background">
                    <Setter.Value>
                        <LinearGradientBrush>
                            <GradientStop Color="DarkSeaGreen" Offset="0"/>
                            <GradientStop Color="White" Offset="1"/>
                        </LinearGradientBrush>
                    </Setter.Value>
                </Setter>

                <!-- Define a cor do texto dos items –>
                <Setter Property="Foreground" Value="White" />

            </Style>
        </ComboBox.Resources>

         <!-- Insere um botão para criar um novo item –>
        <Button x:Name="btnCombo" Width="150" Background="White" Height="22" Foreground="DarkSeaGreen">
            <TextBlock>Inserir novo item ... </TextBlock>
        </Button>

    </ComboBox>

</UserControl>

Após compilar a aplicação ficará disponível na Toolbox o controlo wpfComboBox. Arrastar para o Form e utilizar o seguinte código para o preencher e detectar que o botão foi pressionado:

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

        ' Insere alguns itens na wpfCombobox
        For x As Byte = 0 To 20
            WpfComboBox1.wpfCombo.Items.Add("Combobox Item " & x.ToString.PadLeft(2, "0"c))
        Next

        ' Define uma acção para quando for pressionado o botão da wpfComboBox
        AddHandler WpfComboBox1.btnCombo.Click, AddressOf btnComboBoxClick 

    End Sub

    Sub btnComboBoxClick()
        MessageBox.Show("Adicionar um novo item à wpfComboBox")
    End Sub

São pequenos exemplos que mostram como utilizar controlos WPF numa aplicação WinForms. Com estes controlos consegue-se personalizar bastante a aplicação e melhorar o aspecto visual.

PS: Como sempre, qualquer dúvida, comentário ou correcção ao artigo é sempre bem vinda!