Estado da Arte Projeto Global
Biblioteca Virtual
Aluno: Célio Faustino Nº: 1887
Coordenador: Prof. Dr. Pedro Brandão
Lisboa 2015/2016
I
Índice
Resumo .......................................................................................................................................... 1
Abtract ........................................................................................................................................... 2
Introdução ..................................................................................................................................... 3
ESTADO DA ARTE ................................................................................................................... 4
Cloud Computing ......................................................................................................................... 4
1. Referencial teórico ............................................................................................................ 4
2. Conceito de Cloud ............................................................................................................. 4
3. Vantagens da utilização do Cloud Computing .................................................................. 5
4. Desvantagens da utilização do Cloud Computing ............................................................. 6
Virtualização ................................................................................................................................. 7
1. Referencial teórico ............................................................................................................ 7
2. Vantagens da Virtualização ............................................................................................... 8
3. Desvantagens da Virtualização ......................................................................................... 8
ADO.NET ................................................................................................................................... 10
1. Referencial teórico .......................................................................................................... 10
2. Características ................................................................................................................. 10
3. Vantagens do ADO.NET ................................................................................................. 13
4. Desvantagens do ADO.NET ........................................................................................... 13
SQL ............................................................................................................................................. 14
1. Referencial teórico .......................................................................................................... 14
2. Vantagens do SQL .......................................................................................................... 14
3. Desvantagens do SQL ..................................................................................................... 15
Digital Library ........................................................................................................................... 16
Criação das Máquinas Virtuais ................................................................................................. 17
1. Arranque por Disco Virtual VHD ................................................................................... 17
1. Configuração das Redes .................................................................................................. 18
2. Criação das máquinas virtuais ......................................................................................... 19
a) DC1 - Controlador de Domínio ................................................................................... 19
b) Instalação do servidor de DHCP ................................................................................. 31
c) Criação das unidades organizacionais ......................................................................... 34
d) SQL – Servidor de base de dados ................................................................................ 36
e) VMM – Servidor de virtualização ............................................................................... 43
f) Criação da máquina cliente ......................................................................................... 50
3. Aplicação Digital Library 1.0 .......................................................................................... 56
II
Conclusão ................................................................................................................................... 77
Bibliografia ................................................................................................................................ 78
Anexos ........................................................................................................................................ 80
a) SQL Server – Diagrama da base de dados .................................................................. 80
b) SQL Server – Tabelas ................................................................................................. 81
Tabela de Livros .............................................................................................................. 81
Tabela de Utilizadores ..................................................................................................... 82
Tabela de Tipos de Utilizadores ...................................................................................... 83
Tabela de Editoras ........................................................................................................... 83
Tabela de Categorias ....................................................................................................... 84
c) Visual Studio Community 2015 - Código fonte da aplicação em C# .NET ................ 84
Classe - category_info.cs ................................................................................................. 84
Classe - ComboBoxItem.cs ............................................................................................. 85
Classe - SelectedEventArgs.cs ........................................................................................ 86
Formulário - frmMain.cs ................................................................................................. 87
Formulário - frmManBooks.cs ...................................................................................... 135
Formulário - frmManCategories.cs ............................................................................... 140
Formulário - frmManEditors.cs ..................................................................................... 141
Formulário - frmManUsers.cs ....................................................................................... 142
Formulário - frmSelectCategory.cs ............................................................................... 143
Formulário - frmSplash.cs ............................................................................................. 148
Classe - RibbonContextMenuStrip.cs ........................................................................... 149
Controlo - ucBooks.cs ................................................................................................... 150
Controlo - ucEditors.cs .................................................................................................. 158
Controlo - ucUsers.cs .................................................................................................... 161
Classe - Utils.cs ............................................................................................................. 165
Configuração da Ribbon - RibbonMarkup.xml ............................................................. 175
d) Visual Studio Community 2015 - Acesso ao SQL Server ........................................ 189
DS_SQLAccess.xsd ...................................................................................................... 189
III
Índice de Imagens
Figura 1 - Disco VHD com Windows Server 2012 R2 exposto como disco Z ........................... 17
Figura 2 - Comando de boot ........................................................................................................ 17
Figura 3 - Configuração de arranque de ambos os Sistemas Operativos .................................... 18
Figura 4 - Configuração das Redes ............................................................................................. 18
Figura 5 - Utilizadores................................................................................................................. 18
Figura 6 - Consola VMware Workstation 12 .............................................................................. 19
Figura 7 - Criação em modo avançado para permitir configurar a máquina virtual ................... 19
Figura 8 - Compatibilidade para o VMware WS 12 ................................................................... 20
Figura 9 - Instalação através de uma imagem de disco do tipo ISO ........................................... 20
Figura 10 - Inserção da chave do produto, a versão e as credenciais .......................................... 21
Figura 11 - Atribuição do nome e da localização do controlador de domínio ............................ 21
Figura 12 - Tipo de Firmware ..................................................................................................... 22
Figura 13 - Quantidade de processadores e quantos cores por cada ........................................... 22
Figura 14 - Atribuição de memória ............................................................................................. 23
Figura 15 - Placa de rede em modo NAT para permitir acesso à rede externa ........................... 23
Figura 16 - Controlador SCSI ..................................................................................................... 24
Figura 17 - Definir o tipo de disco .............................................................................................. 24
Figura 18 - Criar a máquina virtual a partir de um novo disco ................................................... 25
Figura 19 - Tamanho do disco guardado como um único ficheiro.............................................. 25
Figura 20 - Localização do disco virtual ..................................................................................... 26
Figura 21 - Resumo das configurações da máquina DC1 ........................................................... 26
Figura 22 - Consola para a gestão do servidor DC1 .................................................................... 27
Figura 23 - Instalação da role Active Directory Domain Services .............................................. 28
Figura 24 - Finalização da instalação da role .............................................................................. 28
Figura 25 - Janela de alerta para promoção do servidor .............................................................. 29
Figura 26 - Adicionar uma nova floresta .................................................................................... 29
Figura 27 - Nível funcional da floresta e do domínio principal .................................................. 30
Figura 28 - Verificação do nome do domínio NetBIOS ............................................................. 30
Figura 29 - Verificação dos requisitos para a promoção a controlador de domínio .................... 31
Figura 30 - Instalação da role "DHCP Server" e as ferramentas administrativas ....................... 31
Figura 31 - Instalação com sucesso ............................................................................................. 32
Figura 32 - Alerta para terminar a configuração do servidor DHCP .......................................... 32
Figura 33 - Assistente de criação de range de IP's ...................................................................... 32
Figura 34 - Configuração dos IP's ............................................................................................... 33
Figura 35 - Intervalo de IP’s para distribuição ............................................................................ 33
Figura 36 - Credenciais para o servidor DHCP usar na Active Directory .................................. 34
Figura 37 - Utilizador de serviço para o SQL Server .................................................................. 34
Figura 38 - Utilizadores de serviço para o System Center Virtual Machine Manager ................ 35
Figura 39 - Grupo de administração dos utilizadores de serviço ................................................ 35
Figura 40 - Servidor promovido a controlador de domínio ......................................................... 36
Figura 41 - Servidor para o SQL Server...................................................................................... 36
Figura 42 - Instalação do SQL Server 2012 Enterprise Edition .................................................. 37
Figura 43 - Seleção completa dos componentes a instalar .......................................................... 37
Figura 44 - Credenciais para uso nos serviços do SQL Server ................................................... 38
Figura 45 - Criar um login do grupo de administrador do VMM ............................................... 38
IV
Figura 46 - Atribuição de privilégios ao grupo de administradores do VMM ............................ 39
Figura 47 - Atribuição de permissões à base de dados 'master' .................................................. 39
Figura 48 - Atribuição de permissões à base de dados 'msdb' .................................................... 40
Figura 49 - Novo login para o grupo 'Admins VMM' ................................................................. 40
Figura 50 - Permissões para o grupo 'Admins VMM' para as BD's 'master' e 'msdb' ................. 41
Figura 51 - Novo login 'Admins VMM' configurado .................................................................. 41
Figura 52 - Criação do 2º disco ................................................................................................... 42
Figura 53 - Disco de dados criado e inicializado ........................................................................ 42
Figura 54 - Servidor para o System Center Virtual Machine Manager ....................................... 43
Figura 55 - Instalação do Microsoft System Center 2012 R2 Virtual Machine Manager ........... 43
Figura 56 - Ligação ao servidor SQL Server e criação da BD do VMM .................................... 44
Figura 57 - Criar objeto do tipo 'Container'................................................................................. 44
Figura 58 - Dar um nome ao objeto ............................................................................................ 45
Figura 59 - Dar permissões ao objeto .......................................................................................... 45
Figura 60 - Campo ‘distinguishedName' ..................................................................................... 46
Figura 61 - Configuração da conta de serviço e das 'keys' .......................................................... 46
Figura 62 - Instalação da role 'Hyper-V' e das respetivas ferramentas administrativas .............. 47
Figura 63 - Criação das Virtual Switches .................................................................................... 47
Figura 64 - Criação de um perfil de Hardware ............................................................................ 48
Figura 65 - Criação de um perfil de Sistema Operativo convidado ............................................ 48
Figura 66 - Adicionar previlégios de administração ao grupo 'Admins VMM' .......................... 49
Figura 67 - Criação de uma máquina cliente ............................................................................... 49
Figura 68 - Inicialização da máquina cliente............................................................................... 50
Figura 69 - Instalação do Windows 8.1 ....................................................................................... 50
Figura 70 - Criação de um template ............................................................................................ 51
Figura 71 - Criação da máquina cliente com base no template 'Windows 8.1' ........................... 51
Figura 72 - Conta Microsoft para acesso à SkyDrive ................................................................. 52
Figura 73 - Máquina cliente e acesso à base de dados ................................................................ 52
Figura 74 - Criação de utilizador ................................................................................................. 53
Figura 75 - Configuração do utilizador ....................................................................................... 53
Figura 76 - Permissões de execução ........................................................................................... 54
Figura 77 - Configuração de permissão de acesso remoto .......................................................... 55
Figura 78 - Ordem das placas de rede ......................................................................................... 55
Figura 79 - Visão geral da aplicação ........................................................................................... 56
Figura 80 - Menu 'File' da aplicação ........................................................................................... 56
Figura 81 - Ecrã principal em modo de administrador – Separador ‘Principal’.......................... 57
Figura 82 - Ecrã principal em modo de administrador – Separador ‘Ver’ .................................. 58
Figura 83 - Ecrã principal em modo de utilizador....................................................................... 59
Figura 84 - Janela de criação de novo livro................................................................................. 59
Figura 85 - Janela de criação de nova editora ............................................................................. 60
Figura 86 - Janela de criação de novo utilizador ......................................................................... 61
Figura 87 - Separador para a listagem de Livros......................................................................... 62
Figura 88 - Separador de Ferramentas para um registo selecionado ........................................... 63
Figura 89 - Separador de Ferramentas para dois ou mais registos selecionados ......................... 64
Figura 90 - Separador para a listagem de Editoras ...................................................................... 65
Figura 91 - Separador para a listagem de Utilizadores ............................................................... 66
Figura 92 - Separador para a listagem de Livros pesquisados .................................................... 67
Figura 93 - Janela de filtragem para a pesquisa .......................................................................... 68
V
Figura 94 - Janela de modificação de um livro selecionado ....................................................... 69
Figura 95 - Janela de confirmação de eliminação do registo ...................................................... 70
Figura 96 - Caixa de diálogo para obter o ficheiro a carregar ..................................................... 71
Figura 97 - Janela de pesquisa da diretoria destino do(s) ficheiro(s) a transferir ........................ 71
Figura 98 - Mensagem de sucesso de quantos ficheiros foram guardados .................................. 72
Figura 99 - Caixa de diálogo para obter a imagem da capa do livro ou documento ................... 72
Figura 100 - Janela de seleção de categoria ................................................................................ 73
Figura 101 - Menu de contexto com base na seleção da categoria ............................................. 74
Figura 102 - Menu de contexto com base na seleção de Livros ou documentos ........................ 75
Figura 103 - Painel de detalhes de um registo............................................................................. 76
Figura 104 - Imagem de capa do registo ..................................................................................... 76
Figura 105 - Imagem representativa de registo com ficheiro carregado ..................................... 76
Figura 106 - Diagrama geral da base de dados da aplicação ....................................................... 80
Figura 107 - Tabela de Livros ..................................................................................................... 81
Figura 108 - Tabela de Utilizadores ............................................................................................ 82
Figura 109 - Tabela de Tipos de Utilizadores ............................................................................. 83
Figura 110 - Tabela de Editoras .................................................................................................. 83
Figura 111 - Tabela de Categorias .............................................................................................. 84
Figura 112 - DataSets de acesso à base de dados por ADO.NET ............................................. 189
1
Resumo
Neste estado da arte vou abordar as tecnologias aplicadas neste projeto. Irá ser
desenvolvido um projeto onde irá ser criada uma Biblioteca Virtual com acesso a uma
base de dados, usando o potencial das novas tecnologias, tendo em conta as vantagens e
desvantagens.
Com o aparecimento da Internet, foram criadas novas tecnologias, tal como a Cloud
Computing (ou computação em nuvem), a virtualização, SQL1 e ADO.NET2. Essas
tecnologias permitiram a vários setores sociais e empresariais trabalharem
cooperativamente, tanto em instituições públicas como educacionais. São essas
tecnologias que vou abordar e usar neste projeto.
Cloud Computing é um modelo para permitir, a pedido, acesso à rede de forma
ubíqua, conveniente a uma pool compartilhada de recursos de computação configuráveis
(por exemplo, redes, servidores, armazenamento, aplicações e serviços) que podem ser
rapidamente fornecidos e liberados com esforço de gerenciamento mínimo ou interação
do provedor de serviço.
Virtualização é uma abstração representada por um recurso computacional que
oferece um ambiente completo, similar ao de uma máquina física, com sistema operativo,
aplicações e serviços de rede. É mais conhecida por máquina virtual.
O SQL (Structured Query Language) é uma linguagem de gestão e manipulação de
dados relacionais através de programas de SGBD (Sistema de Gestão de Base de Dados).
Esses sistemas permitem trabalhar vários tipos de bases de dados: SQL Server, Access,
Oracle, MySQL, etc.
O ADO.NET (ActiveX Data Objects .NET) é uma tecnologia baseada na plataforma
.NET através de um conjunto de classes. A estrutura dos seus componentes foi desenhada
para facilitar a manipulação e o tratamento de vários tipos de dados relacionais, XML e
dados de aplicações.
Palavras-chave: Computação em nuvem; virtualização; base de dados.
1 Linguagem de consulta estruturada (Structured Query Language) 2 Serviço de acesso a dados para programadores
2
Abtract
In this state of the art I will address the technologies applied in this project. A virtual
library with access to a database will be developed in a project, which will be created by
using the potential of the new technologies taking into account the pros and cons.
With the advent of the Internet, new technologies were created, such as cloud
computing, virtualization, SQL and ADO.NET. These technologies have enabled the
various social and business sectors to work cooperatively, both in public and educational
institutions. These are the technologies that I will address and use in this project.
Cloud Computing is a model to allow, on demand, ubiquitous and convenient
access to the network, to a shared pool of configurable computing resources (e.g.,
networks, servers, storage, applications and services) that can be rapidly provisioned and
released with minimal management effort or service provider interaction.
Virtualization is an abstraction represented by a computational resource that
provides a complete environment, similar to a physical machine, with operating system,
applications and network services. It is best known as a virtual machine.
SQL (Structured Query Language) is a management and manipulation language of
relational data through DBMS programs (Database Management System). These systems
allow you to work with various types of databases: SQL Server, Access, Oracle, MySQL,
etc.
The ADO.NET (ActiveX Data Objects .NET) is a technology based on the .NET
platform through a set of classes. The structure of the components was designed to
facilitate the handling and treatment of various types of relational data, XML and
applications data.
Keywords: Cloud Computing; virtualization; data base.
3
Introdução
“Uma biblioteca digital ou virtual é uma biblioteca em que uma proporção
significativa de recursos de informação se encontram disponíveis em formato digital (pdf,
doc, etc), acessível por meio de computadores. É importante considerar que o conceito de
biblioteca virtual está presente no efeito de integração da informática com as
comunicações, cujo expoente máximo é a internet.” (Alemán, 2010).
O presente estado da arte apresenta, para o projeto em curso, uma introdução das
tecnologias utilizadas e que tiram partido do potencial das comunicações em rede. As
tecnologias para o desenvolvimento deste projeto serão: Cloud Computing, virtualização,
SQL e ADO.NET. Será criada uma aplicação de uma biblioteca virtual que permitirá
interagir com máquinas virtuais onde estará a base de dados.
Neste trabalho abordarei os vários conceitos e a sua importância, expondo as
vantagens e as desvantagens.
4
ESTADO DA ARTE
Cloud Computing
1. Referencial teórico
Executar aplicações, guardar e aceder a dados armazenados na cloud, via internet,
numa componente de oferta de serviços, ofereceu várias vantagens após o aparecimento
do conceito de Cloud Computing (Armbrust, 2009).
Com o aparecimento do termo Cloud Computing numa palestra de Eric Schmidt,
diretor executivo da empresa Google, o mesmo falava sobre como a empresa descrevia a
sua abordagem do Software3 como um serviço. Atualmente, Cloud Computing, ou
Computação na Nuvem, traz profundas mudanças no mundo das tecnologias de
informação (Jozwiak & Bloor, 2011).
Segundo Dan C. Marinescu, “A computação em nuvem usa tecnologias da internet
para oferecer serviços elásticos. O termo "computação elástica" refere-se à capacidade de
adquirir dinamicamente os recursos de computação e suportar uma carga de trabalho
variável. Um provedor de serviço de nuvem mantém uma infraestrutura maciça para
apoiar os serviços elásticos“ (Marinescu, 2013).
No próximo ponto será abordado o conceito Cloud Computing. A sua importância
e a sua aplicação, expondo as vantagens e as desvantagens no uso deste tipo de serviços.
2. Conceito de Cloud
“Clouds são plataformas tecnológicas que aproveitam as inovações sofisticadas da
tecnologia e proporcionam ambientes altamente escaláveis e flexíveis que podem ser
remotamente utilizados por organizações numa poderosa infinidade de maneiras. Para
3 Sequência de instruções escritas para serem interpretadas por um computador com o objetivo de executar
tarefas específicas.
5
construir com sucesso, integrar-se, ou até mesmo criar um ambiente de nuvem requer uma
compreensão da sua mecânica interior, camadas de arquitetura e modelos, bem como uma
compreensão do negócio e fatores económicos que resultam da adoção e da utilização de
serviços baseados em nuvem no mundo real.” (Erl, Puttini, & Mahmood, 2013).
Cloud Computing não é mais do que ter à disposição uma capacidade de
computação flexível e que está disponível através de uma ligação à rede (Cooter, 2011).
Os serviços de Cloud são disponibilizados através de uma entidade que se
responsabiliza pelo processo de processamento e armazenamento dos dados, largura de
banda, fiabilidade e segurança (em datacenters criados para o efeito), e presta serviços,
alocando e liberando recursos, conforme as necessidades do utilizador. O utilizador pode
utilizar os serviços pagando apenas pelo que usa e gastar o menos possível, mas se no seu
negócio previr um pico de vendas, pode aumentar a capacidade de processamento e
largura de banda de modo a não perder clientes e voltar ao serviço que tinha após o pico.
O utilizador irá pagar mais nesse período de pico porque solicitou mais capacidade ou
processamento ou largura de banda (Bent & Steeg, 2012).
As organizações conseguem reconhecer que a Cloud Computing é um meio
lucrativo e que têm a tecnologia mais recente do mundo da computação. A cloud beneficia
as organizações a nível operacional, económico, na segurança e na facilidade na
colaboração (Rao, 2015).
Como qualquer outra tecnologia, o Cloud Computing tem as suas vantagens e
desvantagens no que toca às aplicações, negócios, pesquisas, desenvolvimentos ou outra
finalidade.
3. Vantagens da utilização do Cloud Computing
O benefício mais evidente será o da redução dos custos operacionais e de
manutenção com a utilização da computação em sistemas de nuvem. Esse benefício é
representado pelo ROI (Return Of Investment) que é a relação entre os lucros e os
prejuízos num investimento. As empresas ou organizações que utilizam os serviços de
cloud apenas pagam pelo software e infraestrutura que estão a utilizar. Esta é uma grande
vantagem para novas empresas ou organizações que estejam a entrar no mundo dos
negócios e não têm capital suficiente para investir em equipamento informático e serviços
6
administrativos. Para um operacional de uma empresa, o ter os seus dados e serviços
sempre disponíveis em qualquer lugar e momento, via internet, através de vários
dispositivos como portáteis, smartphones ou tablets também é uma vantagem a ter em
conta. Concentrando todos esses serviços e infraestruturas de TI4 em datacenters, também
otimiza consideravelmente a afetação de recursos e eficiência energética. Isso pode
reduzir bastante o impacto sobre o meio ambiente (Buyya, Vecchiola, & Selvi, 2013).
4. Desvantagens da utilização do Cloud Computing
Segundo Barry Sosinsky, existem muitas vantagens nos serviços disponibilizados
na nuvem, mas é necessário ter em conta que a privacidade e a segurança podem ser uma
desvantagem, apesar do esforço para garantir padrões de fiabilidade e que sejam
reconhecidos internacionalmente. Ainda não há muita clareza e consenso nos direitos e
deveres no que diz respeito às partes envolvidas no uso dos modelos de Cloud Computing.
Barry Sosinsky diz ainda que poderão existir necessidades de maior latência de rede ao
tentar transferir uma quantidade elevada de dados ou usar aplicações que, para a sua
execução necessitem de hardware robusto (Sosinsky, 2011).
Os serviços cloud também estão sujeitos às leis e são obrigados a atuar conforme a
legislação vigente em cada país onde se localizam os datacenters. Isso pode ter impacto
nos serviços de muitas empresas (Catteddu & Hogben, 2009).
4 Tecnologias de Informação
7
Virtualização
1. Referencial teórico
Podemos definir a virtualização atualmente como uma metodologia que permite a
divisão dos recursos de um computador entre múltiplos ambientes de execução. Peter
Baer Galvin refere que, num sistema virtualizado, temos um software host5 em execução
numa máquina física chamado Hypervisor6 ou Virtual Machine Monitor (VMM) e é
responsável pela criação de VM’s (Virtual Machines) que são ambientes simulados de
computação. Assim pode se executar Sistemas Operativos em máquinas virtuais como se
estivessem instalados numa máquina real (Galvin, 2009).
Segundo João Almeida da IBM, num artigo da Computer World, em outubro de
2011, ocorreu uma renovação de hardware antigo com o objetivo de renovar a
infraestrutura de TI (Almeida, 2011). Isto deve-se à evolução dos sistemas de hardware,
ao aumento da capacidade de processamento, memória e disco por forma a executar mais
tarefas em simultâneo e com um custo cada vez menor, fazendo com que a virtualização
aparecesse em maior escala nos últimos anos.
Pode dizer-se que a virtualização nasceu em 1959 com a publicação do artigo “Time
Sharing Processing in Large Fast Computers” numa conferência internacional de
processamento de informação que se realizou em Nova York. O artigo estava concentrado
no uso da multiprogramação7 e no conceito das máquinas de grande porte onde se poderia
utilizar melhor os recursos de hardware (Strachey, 1959).
A IBM introduziu posteriormente o conceito de multiprocessamento8 e memória
virtual9 como parte do sistema operativo nos mainframes. Isso permitiu que vários
processadores trabalhassem como um só, possibilitando a abstração e o mapeamento da
memoria real para memória virtual e a especificação de partições que eram utilizadas por
programas diferentes, surgindo assim as primeiras formas de virtualização.
5 Hospedeiro 6 Um monitor de máquinas virtuais que cria e executa máquinas virtuais 7 Técnica de desenvolvimento e execução de dois ou mais programas em simultâneo numa máquina 8 Capacidade de um sistema operacional executar simultaneamente dois ou mais processos 9 Técnica que usa a memória secundária como uma cache para armazenamento secundário
8
2. Vantagens da Virtualização
Na virtualização, o isolamento que se consegue ter entre as máquinas e o sistema
operativo anfitrião faz com que algumas tarefas arriscadas sejam seguras. Normalmente
a avaliação de novos sistemas, desenvolvimentos de software, testes com vírus e outras
ameaças significa sujeitar o computador a operações, onde nem sempre é possível reverter
os problemas (Goldberg, 1974). É também bom para a consolidação de servidores, reduzir
o consumo de energia elétrica em datacenters, menor produção de calor, espaço físico e
manutenção de equipamentos, com menos custos e menor degradação (Marshall, 2011).
A utilização da virtualização, tem-se relevado uma alternativa interessante em
diversos modelos da computação ao longo dos anos. Entre eles estão a consolidação e
centralização de servidores, otimizações de hardware e a segurança da informação. Os
administradores de TI das empresas beneficiam muito com as estruturas virtuais porque
destinam os recursos dos servidores estrategicamente conforme a necessidade do negócio
(Okano & Andrade, 2008).
Com a consolidação de servidores, as empresas reduzem o número de servidores
que necessitam de manutenção evitando custos administrativos e operacionais. Em vez
de utilizarem vários servidores com os respetivos sistemas operativos, utilizam um
servidor com máquinas virtuais e os respetivos sistemas operativos independentes com
aplicações e serviços instalados (Mann, 2006).
3. Desvantagens da Virtualização
Apesar de toda a publicidade sobre a virtualização, pode haver desvantagens ao
migrar para um ambiente virtualizado. As aplicações que são executadas num ambiente
físico usam mais recursos e não têm um melhor desempenho num ambiente virtualizado.
A não ser que a migração também inclua a renovação de novo hardware que seja mais
rápido e potente, as aplicações podem ter menor desempenho (Gilster, 2014).
Segundo Manoel Veras, “A virtualização inicialmente utilizou o conceito de
máquina virtual de processo. Uma máquina virtual de processo é uma aplicação que é
executada num sistema operacional A e que emula o comportamento do sistema
operacional B. Assim, aplicações desenvolvidas para o sistema operacional B podem ser
executadas num sistema operacional A. É importante salientar que essa técnica de
9
implementação permite que binários de um processador sejam interpretados e
substituídos por código equivalente de outro processador. Portanto, além de emular, o
sistema operacional, é possível emular processadores. As desvantagens dessa técnica são
basicamente duas: desempenho e desperdício de capacidade do hardware físico. O
desempenho é sacrificado, já que há uma tradução de um sistema para o outro. O
desperdício da capacidade física do hardware vem do fato que as máquinas virtuais de
processo oferecem dispositivos de I/O genéricos e simples e este fato sobrecarrega o
sistema operacional”. Manoel Veras diz ainda que “os monitores de máquinas virtuais
VMM (Virtual Machine Monitors) ou Hypervisors surgiram para resolver as
desvantagens das máquinas virtuais de processos. Eles são implementados como uma
camada de software entre o hardware e o sistema operacional, oferecendo uma máquina
virtual para o sistema operacional. São mais eficientes por tratar de outra forma os
dispositivos I/O” (Veras, 2011).
10
ADO.NET
1. Referencial teórico
Para Jayden Ky, o ADO.NET é uma plataforma de acesso e manipulação de dados
da Microsoft que suporta vários formatos de dados, incluindo dados guardados em bases
de dados relacionais ou como XML. Esta tecnologia tem semelhanças com a antiga
tecnologia ADO (Access Data Objects) mas pouco tem a ver com o seu antecessor. Existe
desde a versão 1.0 da plataforma .NET e está disponível para qualquer linguagem de
programação, incluindo C#. O ADO.NET disponibiliza uma maneira uniforme de aceder
a bases de dados relacionais diferentes. Cada uma usa o seu próprio protocolo e, sem o
uso do ADO.NET, poderá requerer escrever código diferente para cada tipo de base de
dados. O ADO.NET disponibiliza um conjunto de classes para diferentes tipos de
protocolos para acesso às bases de dados. Estas são chamadas de Data Providers10 (Ky,
2013).
O ADO.NET é uma coleção de classes que atuam como um intermediário de bases
de dados, tal como Access ou XML, e os consumidores de dados, tal como uma página
de ASP.NET (Active Server Page.NET) (Millington & Kauffman, 2009).
2. Características
A arquitetura do ADO.NET está separada em duas esferas fundamentais: conectado
e desconectado. A parte conectada representa os objetos que mantêm uma ligação para
interagir com a base de dados. A única maior exceção é o objeto DataAdapter que atua
como uma sentinela entre os modos conectado e desconectado (Malik, 2007).
Os objetos principais do modo conectado são: Connection, Transaction,
DataAdapter, Command, Parameter e DataReader.
Tipo de Objeto Descrição
Connection Possibilita a conexão com a base de dados.
10 Provedores de dados
11
Exemplos de objetos: OleDbConnection, SqlConnection,
OracleConnection e outros.
Transaction Possibilita a execução de um grupo de comandos como um grupo
ou como uma operação atómica. Se toda a operação correr bem as
alterações serão feitas na base de dados, se não correr bem, toda a
operação é desfeita.
Exemplos de objetos: OleDbTransaction, SqlTransaction,
OracleTransaction e outros.
DataAdapter Este objeto atua como um intermediário entre os objetos
conectados e desconectados do ADO.NET. Estabelece a conexão
ou, dada uma conexão estabelecida, tem informações suficientes
para lhe permitir compreender os dados de um objeto
desconectado e agir de acordo com o banco de dados de uma forma
pré-especificada.
Exemplos de objetos: OleDbDataAdapter, SqlDataAdapter,
OracleDataAdapter e outros.
Command Este objeto representa um comando executável na fonte de dados
subjacente. Este comando pode ou não retornar resultados e
podem ser usados para manipular, consultar, atualizar ou até
mesmo apagar os dados existentes. Este objeto também pode ser
usado para manipular estruturas de tabelas subjacentes.
Exemplos de objetos: OleDbCommand, SqlCommand,
OracleCommand e outros.
Parameter Um comando precisa de ser capaz de aceitar parâmetros. Isto
permite que os comandos sejam mais flexíveis e aceitem valores
de entrada e atuem em conformidade. Estes parâmetros podem ser
de entrada, de saída ou retornar valores de procedimentos
armazenados.
Exemplos de objetos: OleDbParameter, SqlParameter,
OracleParameter e outros.
DataReader Este objeto é o equivalente a um cursor somente de leitura ou
somente de encaminhamento firehose que lhe permite buscar
dados de um banco de dados a uma velocidade extremamente alta,
mas em um modo de forward-only e somente leitura.
Exemplos de objetos: OleDbDataReader, SqlDataReader,
OracleDataReader e outros.
12
Os objetos principais do modo desconectado são: DataSet, DataTable,
DataColumn, DataRow, DataView, Constraint e DataRelation.
Tipo de Objeto Descrição
DataSet Este objeto é o núcleo central do modo desconectado do
ADO.NET. Um DataSet também pode ser visto como uma coleção
lógica de DataTables e DataRelations.
Exemplos de objetos: OleDbDataSet, SqlDataSet, OracleDataSet
e outros.
DataTable Este objeto é muito similar a uma tabela de uma base de dados. É
composto por colunas (DataColumns), registos (DataRows) e
regras (Constraints).
Exemplos de objetos: OleDbDataTable, SqlDataTable,
OracleDataTable e outros.
DataColumn Este objeto representa a coluna de uma tabela.
Exemplos de objetos: OleDbDataColumn, SqlDataColumn,
OracleDataColumn e outros.
DataRow Este objeto representa uma linha de registos de uma tabela.
Exemplos de objetos: OleDbDataRow, SqlDataRow,
OracleDataRow e outros.
DataView Este objeto permite criar uma visualização de uma DataTable
baseado num filtro.
Exemplos de objetos: OleDbDataView, SqlDataView,
OracleDataView e outros.
Constraint Este objeto permite criar restrições de chaves estrangeiras
(ForeignKeyConstraint) e de valores únicos (UniqueConstraint)
baseados nos dados da tabela.
Exemplos de objetos: OleDbConstraint, SqlConstraint,
OracleConstraint e outros.
DataRelation Este objeto permite especificar relações entre várias tabelas e
validar dados entre tabelas.
13
Exemplos de objetos: OleDbDataRelation, SqlDataRelation,
OracleDataRelation e outros.
3. Vantagens do ADO.NET
Como está referenciado no livro “A Programmer’s Guide to ADO.NET in C#”, o
ADO.NET é uma plataforma com classes orientada a objetos que tem diferentes
provedores de dados com o mesmo modelo de programação. Cada um desses modelos
trabalha com protocolos de bases de dados diferentes mas funcionam da mesma forma,
apenas terá de alterar no código os namespaces11 (espaços de nomes) e as configurações
de conexão às mesmas. Se trabalha bem com um provedor de base de dados, por exemplo
SqlClient, trabalha também bem com outros (Chand & Gold, 2002).
O ADO.NET tira partido de todos os serviços fornecidos pela Framework12, tais
como gestão automática de memória, Garbage Collection13 entre outros, o que torna o
ADO.NET fácil de manipular e o programador não tem que se preocupar com a gestão
da memória usada pelo ADO.NET. Segundo Nuno Ferreira, as vantagens do ADO.NET
passam pela existência de um recurso importante para a criação de aplicações web e com
arquitetura multicamada, que é o suporte para base de dados desconectados. A grande
vantagem é o poder se ligar à base de dados apenas quando é necessário, os recursos
podem ser usados por outros utilizadores e aumenta a escalabilidade e desempenho das
aplicações (Ferreira, 2004).
4. Desvantagens do ADO.NET
Quando uma aplicação acede à base de dados em modo desconectado, os recursos
não são mantidos no servidor. O utilizador, ao alterar os dados, pode gerar conflitos uma
vez que esses dados podem ter sido já modificados por outros utilizadores. Outro
problema é a necessidade de haver constantes ligações à base de dados (Ferreira, 2004).
11 São usados para organizar as diversas classes na programação na plataforma .NET 12 Abstração que une códigos comuns entre vários projetos de software provendo uma funcionalidade
genérica 13 Gere a alocação e liberação de memória para a aplicação
14
SQL
1. Referencial teórico
As bases de dados surgiram nos anos 60 graças às investigações da IBM e outras
companhias. Essas investigações foram mais centradas na automação para escritórios,
automatização de armazenamento de dados e indexar tarefas que requeriam demasiado
trabalho manual. Um pioneiro no campo da tecnologia em bases de dados foi Charles W.
Bachman, que recebeu um prémio Turing em 1973. Embora a IBM tenha sido um líder
em investigações de bases de dados, a Honeywell Information Systems, Inc.,
disponibilizou uma versão comercial do produto no ano de 1976, baseado nos mesmos
princípios, mas foi desenhado e implementado separadamente da IBM. No princípio dos
anos 80, companhias como a IBM e a Oracle, construíram as primeiras bases de dados
baseadas no padrão SQL. A Oracle construiu a Oracle Version 2 e a IBM, mais tarde,
construiu a SQL/DS. Outras empresas viriam também a construir os seus próprios
sistemas com base no mesmo padrão (Wilton & Colby, 2005).
2. Vantagens do SQL
Segundo Paul Wilton e John Colby no livro “Beginning SQL”, a principal vantagem
é a rápida e eficiente obtenção dos dados. Os programas de gestão e manutenção das bases
de dados, os chamados DBMS (Database Management System), são aperfeiçoados de
forma a permitir a obtenção dos dados que queremos, e da maneira que queremos. As
bases de dados ajudam a organizar os dados de uma maneira lógica e permite separar os
dados em partes específicas. As bases de dados relacionais têm a vantagem adicional de
permitir que especifique o quão diferente os dados estão relacionados entre si. As regras
de consistência das bases de dados também são importantes para quando se adiciona,
modifica ou elimina dados. Assim pode-se minimizar redundâncias (Wilton & Colby,
2005).
O SQL é uma linguagem de alto nível que oferece um maior grau de abstração do
que as linguagens processuais. O programador pode assim especificar quais os dados
15
necessários, mas não precisa especificar como os obter. As aplicações escritas com SQL
podem ser facilmente executadas noutros sistemas. O SQL, como uma linguagem, é
independente na maneira como é implementada internamente e, embora seja simples e
fácil de aprender, consegue lidar com situações complexas. Uma consulta à base de dados
retorna o mesmo resultado, não olhando para como a otimização foi feita, com ou sem
índices. O SQL não é meramente uma linguagem de consultas, é também uma linguagem
que pode definir a estrutura e controlo de acesso aos dados, assim como inserir, modificar
ou eliminar dados (Leon & Leon, 1999).
3. Desvantagens do SQL
Christopher J. Date, no seu livro “Relational Database: Selected Writings”, referiu
que a linguagem SQL está longe de ser uma linguagem relacional pelo fato de não existir
ortogonalidade nas expressões, funções embutidas, variáveis indicadoras, constante
NULL14, referência a dados correntes, conjuntos vazios, falta de algumas funções,
definição formal da linguagem após a sua criação, não dá suporte a alguns aspetos do
modelo relacional (join15 explícito, domínios, etc.), discordância com as linguagens
hospedeiras, que são geralmente processuais e orientadas para registos e não para
conjuntos (Date, 1986).
Outro aspeto negativo envolve consultas em que os dados não tenham uma
descrição textual adequada. Consultas com referências a imagens só podem ser criadas
através de um texto que as identifique, através de uma descrição ou do nome de arquivo.
14 Representa um valor nulo 15 Junção de duas ou mais tabelas
16
Digital Library
A aplicação Digital Library foi desenvolvida com a intenção de proporcionar um
ambiente de biblioteca virtualizado, onde são guardados livros, imagens, artigos de jornal,
entre outros num formato digital.
Os utilizadores desta aplicação são configurados como administradores ou como
utilizadores da biblioteca virtual. Os utilizadores, ao iniciar a aplicação, são logo
apresentados com dois tipos de ambiente: acesso total à aplicação por parte dos
administradores e acesso restrito, com apenas opções de consulta e transferência de
ficheiros, por parte dos utilizadores.
Esta aplicação foi desenvolvida com o software Microsoft Visual Studio
Community 2015, na linguagem C# e o acesso à base de dados com a tecnologia
ADO.NET. Irá ser utilizada num ambiente de máquinas virtuais, servidores e clientes,
que serão explicadas detalhadamente no próximo capítulo.
As máquinas virtuais que fazem parte desta solução são as seguintes:
Um servidor Windows Server Standard Edition com o nome DC1. Este servidor
é o controlado do domínio e também é servidor de DHCP.
Um servidor Windows Server Datacenter Edition com o nome SQL. Este servidor
tem o software Microsoft SQL Server 2012 Enterprise Edition instalado, onde irá estar
alojada a base de dados da aplicação.
Um servidor Windows Server Datacenter Edition com o nome VMM. Este
servidor tem o Hyper-V instalado para … onde está instalado o System Center Virtual
Machine Manager para a gestão de servidores virtuais.
Uma máquina cliente com o Windows 8.1 Professional com o nome VMM com a
aplicação Digital Library instalada, onde os utilizadores fazem a consulta e transferência
dos ficheiros.
17
Criação das Máquinas Virtuais
1. Arranque por Disco Virtual VHD
O ambiente de virtualização foi criado num Windows Server 2012 R2 com arranque
por um disco virtual do tipo VHD.
Figura 1 - Disco VHD com Windows Server 2012 R2 exposto como disco Z
O menu de arranque foi configurado, utilizando o caminho Z:\Windows
Figura 2 - Comando de boot
De seguida foi colocado o sistema operativo nativo de fábrica como o Default.
Assim podemos escolher iniciar o computador tanto com o Windows pré-instalado,
18
neste caso o Windows 10, como com o Windows Server 2012 R2 que irá servir para a
criação do ambiente.
Figura 3 - Configuração de arranque de ambos os Sistemas Operativos
1. Configuração das Redes
A comunicação entre as máquinas foi configurada da seguinte forma:
Figura 4 - Configuração das Redes
Foram criados utilizadores de serviço para serem utilizados nas aplicações SQL
Server e no System Center Virtual Machine Manager.
Figura 5 - Utilizadores
19
2. Criação das máquinas virtuais
a) DC1 - Controlador de Domínio
Para a criação da máquina virtual que irá ser o controlador do domínio para este
ambiente, clicamos no botão “Create a new Virtual Machine” na aplicação VMware
Workstation 12.
Figura 6 - Consola VMware Workstation 12
A criação de máquinas neste ambiente (DC1 para o controlador de domínio, SQL
para o alojamento da base de dados da aplicação e VMM para a criação de máquinas
virtuais cliente), irá ser da seguinte forma, com a diferença da chave do produto, da versão
a instalar e da memória atribuída a cada máquina virtual.
Figura 7 - Criação em modo avançado para permitir configurar a máquina virtual
20
Figura 8 - Compatibilidade para o VMware WS 12
Figura 9 - Instalação através de uma imagem de disco do tipo ISO16
16 Uma imagem ISO é um sistema de ficheiros no formato de CD, DVD ou BD
21
Figura 10 - Inserção da chave do produto, a versão e as credenciais
Figura 11 - Atribuição do nome e da localização do controlador de domínio
22
Figura 12 - Tipo de Firmware17
Figura 13 - Quantidade de processadores e quantos cores por cada
17 Conjunto de instruções operacionais programadas direta e permanentemente no hardware
23
Figura 14 - Atribuição de memória
Figura 15 - Placa de rede em modo NAT para permitir acesso à rede externa
24
Figura 16 - Controlador SCSI
Figura 17 - Definir o tipo de disco
25
Figura 18 - Criar a máquina virtual a partir de um novo disco
Figura 19 - Tamanho do disco guardado como um único ficheiro
26
Figura 20 - Localização do disco virtual
Para o tamanho dos discos do controlador de domínio e do SQL Server atribuí 60GB
e, para o disco do servidor VMM, atribuí 100GB.
Figura 21 - Resumo das configurações da máquina DC1
27
Criada a máquina virtual, a mesma inicia e instala-se o Windows Server 2012 R2
Standard Edition. Após as atualizações do Windows Update, promove-se o servidor a
controlador de domínio. Para isso deve-se clicar em “Add roles and features”, na consola
do Server Manager (figura 20).
Figura 22 - Consola para a gestão do servidor DC1
Na janela “Add Roles and Features Wizard”, escolher “Role-based or feature-based
installation” como tipo de instalação, escolhe-se o servidor DC1 e a role “Active
Directory Domain Services”. Ao escolher essa role, aparece uma janela para a instalação
das “Remote Server Administration Tools”.
28
Figura 23 - Instalação da role Active Directory Domain Services
Figura 24 - Finalização da instalação da role
Para promover o servidor a controlador de domínio cliquei no link “Promote this
server to a domain controller”.
29
Figura 25 - Janela de alerta para promoção do servidor
No separador “Deployment Configuration”, escolher a opção “Add a new forest” e
especificar o nome do domínio “DigitalLib.local”.
Figura 26 - Adicionar uma nova floresta
30
No separador “Domain Controller Options” deixar os níveis de funcionalidade
com os valores “Windows Server 2012 R2” e colocar a password.
Figura 27 - Nível funcional da floresta e do domínio principal
Na próxima figura é mostrado o nome do domínio NetBIOS.
Figura 28 - Verificação do nome do domínio NetBIOS
31
Figura 29 - Verificação dos requisitos para a promoção a controlador de domínio
Após o término da configuração do Active Directory Domain Services, reinicia-se
a máquina virtual. Aguarda-se que a consola Server Manager abra e verifica-se que o
servidor já se encontra promovido a controlador do domínio “DigitalLib.local” (figura
28).
b) Instalação do servidor de DHCP
Figura 30 - Instalação da role "DHCP Server" e as ferramentas administrativas
32
Figura 31 - Instalação com sucesso
Figura 32 - Alerta para terminar a configuração do servidor DHCP
Cliquei em “Complete DHCP configuration” para terminar a configuração do
servidor DHCP (figura 30) e, para criar uma nova range de IP’s, comecei por dar um
nome.
Figura 33 - Assistente de criação de range de IP's
33
Figura 34 - Configuração dos IP's
Figura 35 - Intervalo de IP’s para distribuição
34
Figura 36 - Credenciais para o servidor DHCP usar na Active Directory
c) Criação das unidades organizacionais
Para a criação dos utilizadores de serviço para os servidores SQL e VMM, abre-se
a ferramenta “Active Directory Users and Computers” que se encontra na consola do
Server Manager, no menu Ferramentas.
Figura 37 - Utilizador de serviço para o SQL Server
35
Figura 38 - Utilizadores de serviço para o System Center Virtual Machine Manager
Figura 39 - Grupo de administração dos utilizadores de serviço
36
d) SQL – Servidor de base de dados
Figura 40 - Servidor promovido a controlador de domínio
Após criar o controlador de domínio, foi criada outra máquina com o nome SQL
com o Windows Server 2012 R2 Datacenter Edition para ser um servidor de base de
dados. Foi adicionado ao domínio “DigitalLib.local” e instalado o SQL Server 2012
Enterprise Edition.
Figura 41 - Servidor para o SQL Server
37
Figura 42 - Instalação do SQL Server 2012 Enterprise Edition
Figura 43 - Seleção completa dos componentes a instalar
38
Figura 44 - Credenciais para uso nos serviços do SQL Server
Figura 45 - Criar um login do grupo de administrador do VMM
39
Figura 46 - Atribuição de privilégios ao grupo de administradores do VMM
Figura 47 - Atribuição de permissões à base de dados 'master'
40
Figura 48 - Atribuição de permissões à base de dados 'msdb'
Figura 49 - Novo login para o grupo 'Admins VMM'
41
Figura 50 - Permissões para o grupo 'Admins VMM' para as BD's 'master' e 'msdb'
Figura 51 - Novo login 'Admins VMM' configurado
42
Foi adicionado mais um disco ao servidor SQL para o alojamento da base de
dados da aplicação.
Figura 52 - Criação do 2º disco
Figura 53 - Disco de dados criado e inicializado
43
e) VMM – Servidor de virtualização
Figura 54 - Servidor para o System Center Virtual Machine Manager
Após criar o servidor de base de dados, foi criada outra máquina com o nome VMM
com o Windows Server 2012 R2 Datacenter Edition, para ser um servidor de
virtualização. Foi adicionado ao domínio “DigitalLib.local” e instalado o System Center
Virtual Machine Manager.
Figura 55 - Instalação do Microsoft System Center 2012 R2 Virtual Machine Manager
44
Figura 56 - Ligação ao servidor SQL Server e criação da BD do VMM
No servidor DC1 (controlador de domínio) foi criado um objeto no Active Directory
Service Interface para usar uma distributed key na instalação do System Center 2012 R2
VMM.
Figura 57 - Criar objeto do tipo 'Container'
45
Figura 58 - Dar um nome ao objeto
Figura 59 - Dar permissões ao objeto
46
Figura 60 - Campo ‘distinguishedName'
Foi copiado o valor do atributo 'distinguishedName' para ser usado na instalação do
System Center 2012 R2 Virtual Machine Manager.
Figura 61 - Configuração da conta de serviço e das 'keys'
47
Figura 62 - Instalação da role 'Hyper-V' e das respetivas ferramentas administrativas
Na instalação da role ‘Hyper-V’ foram selecionadas as placas de rede
‘MGMTNET’ e ‘SQLNET’.
Figura 63 - Criação das Virtual Switches
48
Após a instalação da role ‘Hyper-V’, foi instalada a feature ‘Multipath I/O’.
Figura 64 - Criação de um perfil de Hardware
Figura 65 - Criação de um perfil de Sistema Operativo convidado
49
Para não dar erro na criação de uma máquina virtual, foram dadas permissões ao
grupo de administradores ‘Admins VMM’.
Figura 66 - Adicionar previlégios de administração ao grupo 'Admins VMM'
Depois foi criada uma máquina virtual com base no perfil de hardware
‘HW_Win8.1’.
Figura 67 - Criação de uma máquina cliente
50
f) Criação da máquina cliente
Após criar a máquina cliente Windows 8.1, a mesma foi iniciada e instalada com a
versão Professional (figura 66 e 67).
Figura 68 - Inicialização da máquina cliente
Figura 69 - Instalação do Windows 8.1
51
Desligou-se e criou-se uma máquina template a partir da máquina virtual ‘Windows
8.1’.
Figura 70 - Criação de um template
Com o template configurado, foi então criada uma máquina cliente onde irá ficar
alojada a aplicação da biblioteca digital.
Figura 71 - Criação da máquina cliente com base no template 'Windows 8.1'
52
Instalação e acesso à aplicação SkyDrive na máquina cliente (figura 70).
Figura 72 - Conta Microsoft para acesso à SkyDrive
A máquina cliente foi ligada ao domínio ‘DigitalLib.local’ e, na figura 71, foi
testada a ligação ao servidor de base de dados através de um ficheiro do tipo ‘Data Link’.
Foi colocado o nome do servidor, com acesso por autenticação integrada e com a base de
dados da Biblioteca Digital chamada ‘DigitalLib’.
O teste foi concluído com sucesso provando que a máquina cliente tem permissões
para interagir com a base de dados.
Figura 73 - Máquina cliente e acesso à base de dados
53
No Active Directory Users and Computers foi criado um utilizador chamado
‘celiofaustino’ (Célio Faustino) para acesso à máquina cliente, ao qual não foi adicionado
ao grupo de administradores.
Figura 74 - Criação de utilizador
Criação do ‘login’ de acesso à base de dados do utilizador ‘celiofaustino’ e respetiva
configuração.
Figura 75 - Configuração do utilizador
54
Foram dadas permissões de execução de operações na base de dados DigitalLib
para o grupo ‘Admins VMM’ e ‘celiofaustino’.
Figura 76 - Permissões de execução
Para se poder aceder à máquina cliente através da aplicação Remote Desktop
Connection, o grupo ‘Admins VMM’ e o utilizador ‘celiofaustino’ foram configurados
para permitir ligações remotas.
55
Figura 77 - Configuração de permissão de acesso remoto
Às placas de rede dos servidores SQL e VMM foram efetuadas as seguintes alterações:
Figura 78 - Ordem das placas de rede
56
3. Aplicação Digital Library 1.0
A aplicação é composta por várias janelas.
A janela principal é composta por 4 áreas distintas:
Figura 79 - Visão geral da aplicação
- Uma Ribbon (faixa) com o menu File, botões de manutenção, pesquisa e outros.
- Uma Treeview (à esquerda) onde são expostas as categorias e subcategorias
inseridas.
- Uma StatusBar (em baixo) onde são dadas algumas informações, nomeadamente
qual é o utilizador que está com sessão iniciada no momento e se é ou não administrador.
- E no centro onde irão se abrir as manutenções das várias tabelas.
No menu File estão os seguintes menus:
Figura 80 - Menu 'File' da aplicação
57
Menu Novo Livro – Cria um novo registo na tabela de livros. Ver anexo frmMain.cs
no bloco 203-255.
Menu Nova Editora – Cria um novo registo na tabela de editoras. Ver anexo
frmMain.cs no bloco 621-648.
Menu Novo Utilizador – Cria um novo registo na tabela de utilizadores. Ver anexo
frmMain.cs no bloco 723-751.
Menu Fechar Separador – Fecha um separador aberto. Ver anexo frmMain.cs no
bloco 480-493.
Menu Gestão de Livros – Abre um separador com a lista de livros mostrados pela
categoria selecionada à esquerda. Ver anexo frmMain.cs no bloco 1328-1391.
Menu Gestão de Editoras – Abre um separador com a lista de editoras. Ver anexo
frmMain.cs no bloco 1463-1498.
Menu Gestão de Utilizadores – Abre um separador com a lista de utilizadores com
acesso a esta aplicação. Ver anexo frmMain.cs no bloco 1505-1540.
Menu Sair – Sai da aplicação. Ver anexo frmMain.cs no bloco 951-958.
Figura 81 - Ecrã principal em modo de administrador – Separador ‘Principal’
Botão Novo Livro – Cria um novo registo na tabela de livros. Ver anexo frmMain.cs
no bloco 203-255.
58
Botão Nova Editora – Cria um novo registo na tabela de editoras. Ver anexo
frmMain.cs no bloco 621-648.
Botão Novo Utilizador – Cria um novo registo na tabela de utilizadores. Ver anexo
frmMain.cs no bloco 723-751.
Botão Fechar Separador – Fecha um separador aberto. Ver anexo frmMain.cs no
bloco 480-493.
Botão Gestão de Livros – Abre um separador com a lista de livros mostrados pela
categoria selecionada à esquerda. Ver anexo frmMain.cs no bloco 1328-1391.
Botão Gestão de Editoras – Abre um separador com a lista de editoras. Ver anexo
frmMain.cs no bloco 1463-1498.
Botão Gestão de Utilizadores – Abre um separador com a lista de utilizadores com
acesso a esta aplicação. Ver anexo frmMain.cs no bloco 1505-1540.
Botão Procurar – Abre um separador com a lista de livros pesquisados não tendo
em conta a categoria selecionada na lista à esquerda. Ver anexo frmMain.cs no bloco
1398-1456.
Figura 82 - Ecrã principal em modo de administrador – Separador ‘Ver’
Botão Ver Categorias – Mostra ou esconde o controlo TreeView onde são
mostradas as categorias (à esquerda). Ver anexo frmMain.cs no bloco 528-532.
59
Botão Ver Detalhes – Mostra ou esconde o painel de detalhes quando um separador
de livros ou uma pesquisa estiver aberta. Ver anexo frmMain.cs no bloco 533-548.
Botão Barra de Estado – Mostra ou esconde a barra de estado (em baixo). Ver anexo
frmMain.cs no bloco 616-620.
Figura 83 - Ecrã principal em modo de utilizador
Em modo de utilizador normal, o utilizador apenas tem acesso a visualizar os
registos de livros e/ou descarregar os respetivos livros (documentos PDF e outros
ficheiros). Os únicos botões a que o utilizador tem acesso são: o botão ‘Gestão de Livros’
e o botão ‘Procurar’. No separador ‘Ver’ o acesso é igual ao utilizador com acesso de
administração.
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
203-255.):
Figura 84 - Janela de criação de novo livro
60
Nesta janela são inseridos os valores de identificação de um novo livro ou outro
tipo de documento conforme o que é escolhido no campo Tipo.
Campo Referência – Insere-se a referência que se pretende dar ao registo.
Campo Título – Insere-se o título do documento.
Campo Autor – Insere-se o(s) autor(es) do documento.
Campo Tipo – Escolhe-se qual o tipo de registo. Pode ser escolhido entre os valores
existentes: ‘Livro’, ‘Link’, ‘Jornal’, ‘Revista’, ‘Imagem’ e ‘Manuscrito’. Caso o valor
escolhido seja ‘Livro’, o campo Editora fica disponível e o campo ‘Link’ fica
indisponível. Caso o valor escolhido seja ‘Link’, o campo Editora fica indisponível e o
campo Link fica disponível. Nos restantes valores os campos Editora e Link ficam
indisponíveis.
Campo Editora – Lista de editoras registadas.
Campo Link – Ligação de uma página web, por exemplo, de onde o documento
proveio.
Campo Data – Data em que o documento foi criado ou publicado.
Campo Categoria – Categoria a que pertence o documento.
Campo Resumo – Pequeno resumo do documento.
Botão - Serve para abrir a janela de criação de uma nova editora. Ver anexo
frmManBooks.cs no bloco 136-165.
Botão - Serve para selecionar uma categoria. Ver anexo frmManBooks.cs no
bloco 192-208.
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
621-648):
Figura 85 - Janela de criação de nova editora
61
Esta janela serve para adicionar uma nova editora.
Campo ID – Valor numérico de identificação do registo numerado de forma
automática pela base de dados.
Campo Editor – Nome da editora que se pretende criar.
Botão Adicionar – Cria uma nova editora baseado no valor inserido. Ver anexo
frmMain.cs no bloco 621-648.
Botão Cancelar – Cancela a operação.
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
723-751):
Figura 86 - Janela de criação de novo utilizador
Esta janela serve para adicionar um novo utilizador.
Campo ID – Valor numérico de identificação do registo numerado de forma
automática pela base de dados.
Campo Utilizador – Nome do utilizador no domínio. Tem de estar no formato
domínio\utilizador.
Campo Tipo – Tipo de utilizador. Se escolher o valor ‘Administrador’ o utilizador
não terá restrições na aplicação. Se escolher o valor ‘Utilizador’ o utilizador apenas
poderá consultar os documentos e transferir o ficheiro respetivo de cada documento.
Botão Adicionar – Cria um novo utilizador baseado nos valores inseridos. Ver
anexo frmMain.cs no bloco 723-751.
62
Botão Cancelar – Cancela a operação.
Ao clicar no botão aparece o separador Livros (ver anexo frmMain.cs no bloco
1328-1391):
Figura 87 - Separador para a listagem de Livros
O separador Livros serve para listar os documentos da categoria selecionada à
esquerda. Ver anexo frmMain.cs no bloco 2003-2013.
Coluna ID – Número único de identificação de cada registo.
Coluna Referência – Referência que se pretende dar ao documento.
Coluna Autor – Autor(es) do documento.
Coluna Editor – Editora que publicou o documento (caso seja um documento do
tipo ‘Livro’).
Coluna Tipo - Pode ser um dos seguintes valores: ‘Livro’, ‘Link’, ‘Jornal’,
‘Revista’, ‘Imagem’ ou ‘Manuscrito’.
Coluna Link – Caso o tipo de documento seja ‘Link’, o valor desta coluna será a
ligação, por exemplo, para uma página web.
Coluna Data – Data em que o documento foi criado ou publicado.
Coluna Categoria – Categoria a que o documento está associado.
Coluna Resumo – Pequeno resumo do documento.
63
Quando um documento está selecionado, o seguinte separador Ferramentas fica
disponível (ver anexo frmMain.cs na linha 1191):
Figura 88 - Separador de Ferramentas para um registo selecionado
Botão Novo Livro – Serve para criar um novo documento. Ver anexo frmMain.cs
no bloco 203-255.
Botão Modificar Livro – Serve para modificar um documento existente. Ver anexo
frmMain.cs no bloco 256-329.
Botão Remover Livro – Serve para eliminar um documento existente. Ver anexo
frmMain.cs no bloco 330-368.
Botão Carregar Ficheiro – Serve para carregar um ficheiro PDF ou de outro tipo
para o registo existente na base de dados. Ver anexo frmMain.cs no bloco 369-428.
Botão Transferir Ficheiro – Serve para transferir um ficheiro do registo existente,
da base de dados para o computador local. Ver anexo frmMain.cs no bloco 429-471.
Botão Capa do Livro – Serve para atribuir uma ilustração do documento. Ver anexo
frmMain.cs no bloco 494- 527.
Botão Mudar de Categoria – Serve para mover um documento de uma categoria
para outra. Ver anexo frmMain.cs no bloco 549-615.
64
Quando dois ou mais documentos estão selecionados, o seguinte separador
Ferramentas fica disponível (ver anexo frmMain.cs na linha 1193):
Figura 89 - Separador de Ferramentas para dois ou mais registos selecionados
Botão Novo Livro – Serve para criar um novo documento. Ver anexo frmMain.cs
no bloco 203-255.
Botão Modificar Livro – Este botão encontra-se indisponível para quando se tem
vários registos selecionados.
Botão Remover Livros – Serve para eliminar os documentos selecionados. Ver
anexo frmMain.cs no bloco 330-368.
Botão Carregar Ficheiro – Este botão encontra-se indisponível para quando se tem
vários registos selecionados.
Botão Transferir Ficheiros – Serve para transferir todos os ficheiros, dos registos
selecionados, da base de dados para uma única pasta do computador local. Ver anexo
frmMain.cs no bloco 429-471.
Botão Capa do Livro – Este botão encontra-se indisponível para quando se tem
vários registos selecionados.
Botão Mudar de Categoria – Serve para mover todos os documentos selecionados
de uma categoria para outra. Ver anexo frmMain.cs no bloco 549-615.
65
Ao clicar no botão aparece o separador Editoras (ver anexo frmMain.cs no
bloco 1463-1498):
Figura 90 - Separador para a listagem de Editoras
O separador Editoras serve para listar as editoras para usar nos documentos
registados.
Coluna ID – Número único de identificação de cada registo.
Coluna Editor – Nome da editora.
Campo Editora – Serve para escrever algo por forma a filtrar os registos na lista.
Botão Filtrar – Serve para filtrar os registos mostrados baseado no texto inserido no
campo Editora.
Botão Limpar – Serve para limpar o campo Editora e mostrar tudo novamente.
66
Ao clicar no botão aparece o separador Utilizadores (ver anexo frmMain.cs
no bloco 1505-1540):
Figura 91 - Separador para a listagem de Utilizadores
O separador Utilizadores serve para listar os utilizadores registados.
Coluna ID – Número único de identificação de cada registo.
Coluna Utilizador – Nome do utilizador no formato Domínio\Utilizador e tem de
ser inequívoco.
Coluna Tipo – Tipo de permissão que o utilizador tem na aplicação.
Campo Utilizador – Serve para escrever algo por forma a filtrar os registos na lista.
Campo Tipo – Serve para filtrar por tipos de utilizadores.
Botão Filtrar – Serve para filtrar os registos mostrados baseado no texto inserido
nos campos Utilizador e Tipo. Ver anexo ucUsers.cs no bloco 70-74.
Botão Limpar – Serve para limpar os campos Utilizador e Tipo, e mostrar tudo
novamente. Ver anexo ucUsers.cs no bloco 108-114.
67
Ao clicar no botão aparece o separador Pesquisar (ver anexo frmMain.cs no
bloco 1398-1456):
Figura 92 - Separador para a listagem de Livros pesquisados
O separador Pesquisa serve para listar todos os documentos pesquisados não tendo
em conta a categoria selecionada à esquerda. Caso não haja registos para o critério de
pesquisa, surge o texto ‘Não foram encontrados registos. Pesquise de novo.’. Ver anexo
ucBooks.cs na linha 162.
Coluna ID – Número único de identificação de cada registo.
Coluna Referência – Referência que se pretende dar ao documento.
Coluna Autor – Autor(es) do documento.
Coluna Editor – Editora que publicou o documento (caso seja um documento do
tipo ‘Livro’).
Coluna Tipo - Pode ser um dos seguintes valores: ‘Livro’, ‘Link’, ‘Jornal’,
‘Revista’, ‘Imagem’ ou ‘Manuscrito’.
Coluna Link – Caso o tipo de documento seja ‘Link’, o valor desta coluna será a
ligação, por exemplo, para uma página web.
Coluna Data – Data em que o documento foi criado ou publicado.
Coluna Categoria – Categoria a que o documento está associado.
Coluna Resumo – Pequeno resumo do documento.
68
Ao aparecer o separador ‘Pesquisar’, surge logo uma janela de filtragem dos vários
campos (ver anexo ucBooks.cs no bloco 344-383):
Figura 93 - Janela de filtragem para a pesquisa
Nesta janela são inseridos os valores para a filtragem de livros ou outro tipo de
documentos conforme o que é escolhido no campo ‘Tipo’.
Campo Referência – Insere-se a referência.
Campo Título – Insere-se o título do documento.
Campo Autor – Insere-se o(s) autor(es) do documento.
Campo Tipo – Escolhe-se qual o tipo de registo. Pode ser escolhido entre os valores
existentes: ‘Livro’, ‘Link’, ‘Jornal’, ‘Revista’, ‘Imagem’ e ‘Manuscrito’. Caso o valor
escolhido seja ‘Livro’, o campo Editora fica disponível e o campo ‘Link’ fica
indisponível. Caso o valor escolhido seja ‘Link’, o campo Editora fica indisponível e o
campo Link fica disponível. Nos restantes valores os campos Editora e Link ficam
indisponíveis.
Campo Editora – Lista de editoras registadas.
Campo Link – Ligação de uma página web, por exemplo, de onde o documento
proveio.
Campo Data – Data em que o documento foi criado ou publicado.
Campo Categoria – Categoria a que pertence o documento.
Campo Resumo – Pequeno resumo do documento.
69
Botão - Serve para selecionar uma categoria. Ver anexo frmManBooks.cs no
bloco 192-208.
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
256-329):
Figura 94 - Janela de modificação de um livro selecionado
Nesta janela são inseridos os valores de identificação do livro selecionado ou outro
tipo de documento conforme o que é escolhido no campo ‘Tipo’.
Campo Referência – Modifica-se a referência que se pretende dar ao registo.
Campo Título – Modifica -se o título do documento.
Campo Autor – Modifica -se o(s) autor(es) do documento.
Campo Tipo – Escolhe-se qual o tipo de registo. Pode ser escolhido entre os valores
existentes: ‘Livro’, ‘Link’, ‘Jornal’, ‘Revista’, ‘Imagem’ e ‘Manuscrito’. Caso o valor
escolhido seja ‘Livro’, o campo Editora fica disponível e o campo ‘Link’ fica
indisponível. Caso o valor escolhido seja ‘Link’, o campo Editora fica indisponível e o
campo Link fica disponível. Nos restantes valores os campos Editora e Link ficam
indisponíveis.
70
Campo Editora – Lista de editoras registadas.
Campo Link – Ligação de uma página web, por exemplo, de onde o documento
proveio.
Campo Data – Data em que o documento foi criado ou publicado.
Campo Categoria – Categoria a que pertence o documento.
Campo Resumo – Pequeno resumo do documento.
Botão - Serve para abrir a janela de criação de uma nova editora. Ver anexo
frmManBooks.cs no bloco 136-165.
Botão - Serve para selecionar uma categoria. Ver anexo frmManBooks.cs no
bloco 192-208.
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
330-368):
Figura 95 - Janela de confirmação de eliminação do registo
Nesta janela é solicitado ao utilizador para confirmar a eliminação do registo.
71
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
369-428):
Figura 96 - Caixa de diálogo para obter o ficheiro a carregar
Esta janela permite pesquisar no Windows Explorer pelo documento a carregar para
o registo.
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
429-471):
Figura 97 - Janela de pesquisa da diretoria destino do(s) ficheiro(s) a transferir
72
Após o sucesso de transferência do(s) ficheiro(s), irá aparecer a mensagem:
Figura 98 - Mensagem de sucesso de quantos ficheiros foram guardados
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
494-527):
Figura 99 - Caixa de diálogo para obter a imagem da capa do livro ou documento
73
Ao clicar no botão aparece a seguinte janela (ver anexo frmMain.cs no bloco
549-615):
Figura 100 - Janela de seleção de categoria
Esta janela serve para escolher uma outra categoria, por forma a mover um livro ou
documento para outra categoria.
No separador Ver, existem três botões para modificar o modo de visualização da
aplicação:
Ao clicar no botão o painel das categorias fica invisível. Ao clicar de novo no
botão o painel das categorias fica visível novamente.
Ao clicar no botão o painel dos detalhes no separador Livros ou Pesquisa fica
invisível. Ao clicar de novo no botão o painel dos detalhes no separador Livros ou
Pesquisa fica visível novamente.
74
Ao clicar no botão a barra de estado fica invisível. Ao clicar de novo no botão
a barra de estado fica visível novamente.
Ao clicar com o botão direito do rato no controlo das categorias, aparece o seguinte
menu:
Figura 101 - Menu de contexto com base na seleção da categoria
Menu Adicionar Categoria – Serve para adicionar uma categoria principal (fica na
raiz da árvore) (Ver anexo frmMain no bloco 831-857).
Menu Adicionar SubCategoria – Serve para adicionar uma subcategoria à categoria
selecionada (Ver anexo frmMain no bloco 858-885).
Menu Editar Categoria – Serve para editar a categoria selecionada (Ver anexo
frmMain no bloco 886-914).
Menu Remover Categoria – Serve para eliminar uma subcategoria selecionada.
Atenção que quando se remove uma categoria, todas as subcategorias são igualmente
removidas e todos os registos de livros ou documentos são recategorizados para (Sem
categoria) (Ver anexo frmMain no bloco 915-946).
75
Ao clicar com o botão direito do rato num registo da listagem dos livros ou das
pesquisas, aparece o seguinte menu:
Figura 102 - Menu de contexto com base na seleção de Livros ou documentos
Menu Modificar Livro – Serve para editar um livro ou documento selecionado. Ver
anexo frmMain.cs no bloco 256-329.
Menu Remover Livro – Serve para eliminar um livro ou documento selecionado.
Ver anexo frmMain.cs no bloco 330-368.
Menu Carregar Ficheiro – Serve para carregar um ficheiro para o livro ou
documento selecionado. Ver anexo frmMain.cs no bloco 369-428.
Menu Transferir ficheiro – Serve para transferir um ficheiro para uma diretoria do
computador local. Ver anexo frmMain.cs no bloco 429-471.
Menu Capa do Livro – Serve para atribuir uma imagem de capa do livro ou
documento. Ver anexo frmMain.cs no bloco 494- 527.
Menu Ver Detalhes – Serve para visualizar ou não o detalhe do registo selecionado.
Ver anexo frmMain.cs no bloco 533-548.
76
Ao clicar no botão o painel dos detalhes no separador Livros ou Pesquisa fica
visível.
Figura 103 - Painel de detalhes de um registo
O detalhe é composto por todos os campos de um registo, incluindo a imagem de
capa (figura 102) e se tem um ficheiro carregado na base de dados (figura 103).
Figura 104 - Imagem de capa do registo
Figura 105 - Imagem representativa de registo com
ficheiro carregado
77
Conclusão
A aplicação Digital Library foi desenvolvida com vista a apresentar uma forma
consistente de trabalhar, cooperativamente e em rede com a utilização das tecnologias de
informação. Cada livro ou documento, por ser digital, é muito mais fácil de aceder de
qualquer lugar e permite, de forma precisa, pesquisar a informação requerida com uma
rapidez superior a um livro tradicional.
Para a criação desta aplicação foi adicionada mais informação para uma melhor
organização e separação dos vários tipos de documentos a inserir nesta base de dados. A
separação por categorias permite ao utilizador encontrar o livro na secção à qual pertence
e assim filtrar com mais precisão.
Através da tecnologia de virtualização, pode-se reduzir os elevados custos
financeiros que a aquisição de hardware necessitaria com uma estrutura destas. As mais
recentes versões de software foram utilizadas, por forma a ter uma plataforma estável e
para que a aplicação pudesse ser executada em segurança.
78
Bibliografia
Alemán, P. (2010). Biblioteca Digital o Virtual.
Almeida, J. (2011). Virtualização de Servidores. Computer World.
Armbrust, M. (2009). Above the Clouds: A Berkeley View of Cloud Computing.
Bent, J. W., & Steeg, M. (2012). The Workbook Company.
Buyya, R., Vecchiola, C., & Selvi, S. (2013). Mastering Cloud Computing Foundations and
Applications Programming.
Catteddu, D., & Hogben, G. (2009). Cloud Computing - Benefits, risks and recomendations for
information security.
Chand, M., & Gold, M. (2002). A Programmer’s Guide to ADO.NET in C#.
Cooter, M. (2011). The Ultimate Guide to Cloud Computing. CloudPro.
Date, C. J. (1986). Relational Database: Selected Writings.
Erl, T., Puttini, R., & Mahmood, Z. (2013). Cloud Computing: Concepts, Technology &
Architecture.
Ferreira, N. (2004). ADO.NET.
Galvin, P. (2009). VMWare vSphere vs. Microsoft Hyper-V - A Technical Analysis. A CTI
Strategy WHite Paper.
Gilster, R. (2014). CompTIA Cloud+ CV0-001 In Depth.
Goldberg, R. (1974). Survey of Virtual Machine Research.
Joseph, R. (2007). "An Introduction to Mainframes".
Jozwiak, R., & Bloor, R. (2011). Moving to the Cloud with Pervasive PSQL.
Kline, K., & Kline, D. (2001). "SQL in a Nutshell - A Desktop Quick Reference". O'Reilly.
Ky, j. (2013). C#: A Beginner's Tutorial.
Leon, A., & Leon, M. (1999). SQL - A Complete Reference.
Malik, N. (2007). Pro ADO.NET 2.0.
Mann, A. (2006). Virtualization 101: Technologies, Benefits and Chalenges.
Marinescu, D. C. (2013). Cloud Computing - Theory and Practice.
Marshall, D. (2011). Virtualization Report. InfoWorld.
Millington, B., & Kauffman, J. (2009). Beginning ASP.NET 2.0 and Databases.
Okano, M., & Andrade, F. (2008). O Impacto da Virtualização nas Empresas.
Rao, M. (2015). Cloud Computing.
Sosinsky, B. (2011). Cloud Computing Bible.
Strachey, C. (1959). Time Sharing in Large Fast Computers.
79
Troelsen, A. (2012). "Pro C# 5.0 and the .NET 4.5 Framework". APress.
Trukhnov, A. K. (2008). "SQL Bible". John Wiley & Sons © 2003.
Veras, m. (2011). Virtualização - Componente Central do Datacenter.
Wilton, P., & Colby, J. (2005). Beginning SQL.
80
Anexos
a) SQL Server – Diagrama da base de dados
Figura 106 - Diagrama geral da base de dados da aplicação
81
b) SQL Server – Tabelas
Tabela de Livros
Figura 107 - Tabela de Livros
Campo Tipo de dados Descrição
id int Identificação inequívoca do registo Este campo é auto incremental do tipo número inteiro.
ref_code varchar(50) Referência do livro Este campo é do tipo texto com um máximo de 50 carateres.
Não suporta valores nulos.
title varchar(200) Título do livro Este campo é do tipo texto com um máximo de 200 carateres.
Não suporta valores nulos.
author varchar(50) Autor(es) do livro Este campo é do tipo texto com um máximo de 50 carateres.
Não suporta valores nulos.
editor int Editora do livro (se doc_type = 1 ‘Livro’) Este campo é do tipo número inteiro.
Chave estrangeira com a tabela t_publishers com o campo id.
doc_type int Tipo de documento Este campo é do tipo número inteiro.
doc_source varchar(500) Ligação Web (se doc_type = 2 ‘Link’)
82
Este campo é do tipo texto com um máximo de 500 carateres.
doc_date datetime Data do livro Este campo é do tipo data.
category int Categoria Este campo é do tipo número inteiro. Chave estrangeira com a tabela t_categories com o campo id
cover image Imagem representativa da capa do livro Este campo é do tipo image onde se podem guardar ficheiros.
file image Bytes do ficheiro carregado Este campo é do tipo image onde se podem guardar ficheiros.
file_name varchar(100) Nome do ficheiro carregado para posterior sugestão
de gravação Este campo é do tipo texto com um máximo de 100 carateres.
book_resume varchar(2000) Resumo do livro Este campo é do tipo texto com um máximo de 2000 carateres. Não suporta valores nulos.
Tabela de Utilizadores
Figura 108 - Tabela de Utilizadores
Campo Tipo de dados Descrição
id int Identificação inequívoca do registo Este campo é auto incremental do tipo número inteiro.
username varchar(50) Nome do utilizador no formato domínio\utilizador Este campo é do tipo texto com um máximo de 50 carateres.
Não suporta valores nulos.
type int Tipo de utilizador Este campo é do tipo número inteiro.
Chave estrangeira com a tabela t_usertypes com o campo id.
Não suporta valores nulos.
83
Tabela de Tipos de Utilizadores
Figura 109 - Tabela de Tipos de Utilizadores
Campo Tipo de dados Descrição
id int Identificação inequívoca do registo Este campo é auto incremental do tipo número inteiro.
type varchar(50) Tipo de utilizador Este campo é do tipo texto com um máximo de 50 carateres.
Não suporta valores nulos.
Tabela de Editoras
Figura 110 - Tabela de Editoras
Campo Tipo de dados Descrição
id int Identificação inequívoca do registo Este campo é auto incremental do tipo número inteiro.
editor varchar(80) Nome da editora Este campo é do tipo texto com um máximo de 80 carateres.
Não suporta valores nulos.
84
Tabela de Categorias
Figura 111 - Tabela de Categorias
Campo Tipo de dados Descrição
id int Identificação inequívoca do registo Este campo é auto incremental do tipo número inteiro.
id_parent int Identificação da categoria pai Este campo é do tipo número inteiro.
path varchar(50) Nome da categoria Este campo é do tipo texto com um máximo de 50 carateres.
Não suporta valores nulos.
c) Visual Studio Community 2015 - Código fonte da aplicação em C# .NET
Neste ponto segue-se o código em C# .Net, usado para criar esta aplicação.
Classe - category_info.cs 1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text; 5
6 namespace CeliSoft.Software
7 {
8 /// <summary>
9 /// category_info
10 /// Serve para ser usada nos items da treeview das categorias
11 /// </summary>
12 public class category_info
13 {
14 #region Variables
15 private int _id;
16 private int _id_parent;
17 private string _path;
85
18 #endregion 19
20 #region Properties
21 public int id
22 {
23 get { return _id; }
24 set { _id = value; }
25 }
26 public int id_parent
27 {
28 get { return _id_parent; }
29 set { _id_parent = value; }
30 }
31 public string path
32 {
33 get { return _path; }
34 set { _path = value; }
35 }
36 #endregion 37
38 #region Constructor
39 /// <summary>
40 /// Construtor
41 /// </summary>
42 /// <param name="id">id da categoria</param>
43 /// <param name="id_parent">id da categoria 'pai'</param>
44 /// <param name="path">categoria</param>
45 public category_info(int id, int id_parent, string path)
46 {
47 _id = id;
48 _id_parent = id_parent;
49 _path = path;
50 }
51 #endregion
52 }
53 }
Classe - ComboBoxItem.cs 1 namespace CeliSoft.Software
2 {
3 /// <summary>
4 /// ComboBoxItem
5 /// Serve para ser usada nos items de uma combobox
6 /// </summary>
7 public class ComboBoxItem
8 {
9 #region Variables
10 private int _ID;
11 private string _Text;
12 #endregion 13
14 #region Properties
86
15 public int ID
16 {
17 get { return _ID; }
18 set { _ID = value; }
19 }
20 public string Text
21 {
22 get { return _Text; }
23 set { _Text = value; }
24 }
25 #endregion 26
27 #region Constructors
28 /// <summary>
29 /// Construtor sem argumentos
30 /// </summary>
31 public ComboBoxItem()
32 { 33
34 }
35 /// <summary>
36 /// Construtor com argumentos de início
37 /// </summary>
38 /// <param name="id">id do item</param>
39 /// <param name="text">texto do item</param>
40 public ComboBoxItem(int id, string text)
41 {
42 _ID = id;
43 _Text = text;
44 }
45 #endregion 46
47 #region Override Methods
48 /// <summary>
49 /// Override do método ToString()
50 /// </summary>
51 /// <returns></returns>
52 public override string ToString()
53 {
54 return _Text;
55 }
56 #endregion
57 }
58 }
Classe - SelectedEventArgs.cs 1 namespace CeliSoft.Software
2 {
3 /// <summary>
4 /// SelectedEventArgs
5 /// Serve para usar nos eventos dos items selecionados da
DataGridView
87
6 /// </summary>
7 public class SelectedEventArgs
8 {
9 #region Variables
10 private bool _Selected;
11 private int _SelectedIndex;
12 #endregion 13
14 #region Properties
15 public bool Selected
16 {
17 get { return _Selected; }
18 set { _Selected = value; }
19 }
20 public int SelectedIndex
21 {
22 get { return _SelectedIndex; }
23 set { _SelectedIndex = value; }
24 }
25 #endregion 26
27 #region Constructors
28 /// <summary>
29 /// Construtor
30 /// </summary>
31 public SelectedEventArgs()
32 { 33
34 }
35 /// <summary>
36 /// Construtor
37 /// </summary>
38 /// <param name="selected">Se o item da DataGridView está
selecionado</param>
39 /// <param name="selectedIndex">Qual é o índice do item
selecionado</param>
40 public SelectedEventArgs(bool selected, int selectedIndex)
41 {
42 this.Selected = selected;
43 this.SelectedIndex = selectedIndex;
44 }
45 #endregion
46 }
47 }
Formulário - frmMain.cs 1 using System;
2 using System.Drawing;
3 using System.Windows.Forms;
4 using RibbonLib.Controls;
5 using RibbonLib.Interop;
6 using System.Threading;
88
7 using System.ComponentModel;
8 using System.IO; 9
10 namespace CeliSoft.Software
11 {
12 /// <summary>
13 /// frmMain
14 /// Janela principal da aplicação
15 /// </summary>
16 public partial class frmMain : Form
17 {
18 #region Window Initializing
19 /// <summary>
20 /// Constructor
21 /// </summary>
22 public frmMain()
23 {
24 InitializeComponent(); 25
26 // Mostrar a form 'Splash Screen'
27 frmSplash f_splash = new frmSplash();
28 f_splash.ShowDialog(this);
29 f_splash.Close();
30 f_splash.Dispose(); 31
32 // Inicializar os controlos de contexto da Ribbon
33 _ribbonBooksContextMenuStrip = new
RibbonContextMenuStrip(ribbon1,
(uint)RibbonMarkupCommands.cmdBooksContextMap);
34 _ribbonCategoriesContextMenuStrip = new
RibbonContextMenuStrip(ribbon1,
(uint)RibbonMarkupCommands.cmdCategoriesContextMap);
35 _ribbonEditorsContextMenuStrip = new
RibbonContextMenuStrip(ribbon1,
(uint)RibbonMarkupCommands.cmdEditorsContextMap);
36 }
37 #endregion 38
39 #region Variables
40 // Variáveis de acesso à base de dados com a tabela de
categorias
41 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta = new
DS_SQLAccessTableAdapters.CategoriesTableAdapter();
42 DS_SQLAccess.CategoriesDataTable dt = null;
43 #endregion 44
45 #region Ribbon Controls Variables
46 // Ribbon Commands
47 private RibbonButton _cmdButtonNewBook;
48 private RibbonButton _cmdButtonChangeBook;
49 private RibbonButton _cmdButtonDeleteBook;
50 private RibbonButton _cmdButtonUploadBook;
51 private RibbonButton _cmdButtonDownloadBook;
89
52 private RibbonButton _cmdButtonSearch;
53 private RibbonButton _cmdButtonManageBooks;
54 private RibbonButton _cmdButtonManagePublishers;
55 private RibbonButton _cmdButtonManageUsers;
56 private RibbonButton _cmdButtonCloseTab;
57 private RibbonButton _cmdButtonCoverImage;
58 private RibbonToggleButton _cmdButtonViewCategories;
59 private RibbonToggleButton _cmdButtonViewDetails;
60 private RibbonButton _cmdButtonChangeBookCategory;
61 private RibbonToggleButton _cmdButtonViewStatusBar;
62 private RibbonButton _cmdButtonAddRootCategory;
63 private RibbonButton _cmdButtonAddChildCategory;
64 private RibbonButton _cmdButtonEditCategory;
65 private RibbonButton _cmdButtonRemoveCategory;
66 private RibbonButton _cmdButtonNewEditor;
67 private RibbonButton _cmdButtonChangeEditor;
68 private RibbonButton _cmdButtonDeleteEditor;
69 private RibbonButton _cmdButtonDownloadBooks;
70 private RibbonButton _cmdButtonNewUser;
71 private RibbonButton _cmdButtonChangeUser;
72 private RibbonButton _cmdButtonDeleteUser;
73 private RibbonButton _cmdButtonDeleteBooks;
74 private RibbonButton _cmdButtonExit; 75
76 // RibbonTab Groups
77 private RibbonTabGroup _cmdTabHome;
78 private RibbonTabGroup _cmdTabSelectedBook;
79 private RibbonTabGroup _cmdTabView;
80 private RibbonTabGroup _cmdTabSelectedEditor;
81 private RibbonTabGroup _cmdTabSelectedBooks;
82 private RibbonTabGroup _cmdTabSelectedCategory;
83 private RibbonTabGroup _cmdTabSelectedUser; 84
85 // Ribbon TabGroup Groups
86 private RibbonTabGroup _cmdTabGroupSelectedBookTools;
87 private RibbonTabGroup _cmdTabGroupSelectedEditorTools;
88 private RibbonTabGroup _cmdTabGroupSelectedBooksTools;
89 private RibbonTabGroup _cmdTabGroupSelectedCategoriesTools;
90 private RibbonTabGroup _cmdTabGroupSelectedUsersTools; 91
92 // Ribbon Group Groups
93 private RibbonGroup _cmdGroupBooks;
94 private RibbonGroup _cmdGroupDownUpLoad;
95 private RibbonGroup _cmdGroupCloseSearch;
96 private RibbonGroup _cmdGroupMaintenances;
97 private RibbonGroup _cmdGroupTabs;
98 private RibbonGroup _cmdGroupCover;
99 private RibbonGroup _cmdGroupVisualization;
100 private RibbonGroup _cmdGroupChangeCategory;
101 private RibbonGroup _cmdGroupEditors;
102 private RibbonGroup _cmdGroupAddButtons;
103 private RibbonGroup _cmdGroupUsers; 104
90
105 // Ribbon Recent Items
106 private RibbonRecentItems _cmdRecentItems; 107
108 // Ribbon Context Menus
109 public RibbonContextMenuStrip _ribbonBooksContextMenuStrip;
110 public RibbonContextMenuStrip
_ribbonCategoriesContextMenuStrip;
111 public RibbonContextMenuStrip _ribbonEditorsContextMenuStrip;
112 #endregion 113
114 #region Enums Code
115 // Ribbon Commands IDs enum
116 public enum RibbonMarkupCommands : uint
117 {
118 // Commands
119 cmdButtonNewBook = 1001,
120 cmdButtonChangeBook = 1002,
121 cmdButtonDeleteBook = 1003,
122 cmdButtonUploadBook = 1004,
123 cmdButtonDownloadBook = 1005,
124 cmdButtonSearch = 1006,
125 cmdButtonManageBooks = 1007,
126 cmdButtonManagePublishers = 1008,
127 cmdButtonManageUsers = 1010,
128 cmdButtonCloseTab = 1011,
129 cmdButtonCoverImage = 1012,
130 cmdButtonViewCategories = 1013,
131 cmdButtonViewDetails = 1014,
132 cmdButtonChangeBookCategory = 1015,
133 cmdButtonViewStatusBar = 1016, 134
135 cmdButtonAddRootCategory = 1017,
136 cmdButtonAddChildCategory = 1018,
137 cmdButtonEditCategory = 1019,
138 cmdButtonRemoveCategory = 1020,
139 cmdButtonNewEditor = 1021,
140 cmdButtonChangeEditor = 1022,
141 cmdButtonDeleteEditor = 1023,
142 cmdButtonDownloadBooks = 1024, 143
144 cmdButtonNewUser = 1028,
145 cmdButtonChangeUser = 1029,
146 cmdButtonDeleteUser = 1030,
147 cmdButtonDeleteBooks = 1031, 148
149 cmdButtonExit = 1099, 150
151 // Tab Groups
152 cmdTabHome = 2001,
153 cmdTabSelectedBook = 2002,
154 cmdTabView = 2003,
155 cmdTabSelectedEditor = 2004,
156 cmdTabSelectedBooks = 2005,
91
157 cmdTabSelectedCategory = 2006,
158 cmdTabSelectedUser = 2007, 159
160 // TabGroup Groups
161 cmdTabGroupSelectedBookTools = 2010,
162 cmdTabGroupSelectedEditorTools = 2011,
163 cmdTabGroupSelectedBooksTools = 2012,
164 cmdTabGroupSelectedCategoriesTools = 2013,
165 cmdTabGroupSelectedUsersTools = 2014, 166
167 // Group Groups
168 cmdGroupBooks = 3001,
169 cmdGroupDownUpLoad = 303,
170 //cmdGroupSearch = 3004,
171 cmdGroupCloseSearch = 3005,
172 cmdGroupMaintenances = 3006,
173 cmdGroupTabs = 3007,
174 cmdGroupCover = 3008,
175 cmdGroupVisualization = 3009,
176 cmdGroupChangeCategory = 3010,
177 cmdGroupEditors = 3011,
178 cmdGroupAddButtons = 3012,
179 cmdGroupUsers= 3013, 180
181 // Recent Items
182 cmdRecentItems = 9000, 183
184 cmdQAT = 10,
185 cmdCustomizeQAT = 11,
186 cmdBooksContextMap = 12,
187 cmdCategoriesContextMap = 13,
188 cmdEditorsContextMap = 14,
189 cmdUsersContextMap = 15
190 }
191 // Enum de verificação de qual separador é qual
192 public enum enmTabsMode
193 {
194 [Description("Books")] Books,
195 [Description("Search")] Search,
196 [Description("Editors")] Editors,
197 [Description("Users")] Users,
198 }
199 #endregion 200
201 #region Ribbon Controls Events
202 // Ribbon Commands Methods
203 private void _cmdButtonNewBook_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
204 {
205 string currentMode = string.Empty;
206 ucBooks uc_Books = null;
207 DataGridView dgvBooks = null; 208
92
209 if (tabs.SelectedTab != null)
210 {
211 currentMode = tabs.SelectedTab.Tag.ToString();
212 uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
213 dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks"));
214 } 215
216 category_info cat_info =
((category_info)tvCategories.SelectedNode.Tag); 217
218 // Criar um novo livro
219 frmManBooks f_newBook = new frmManBooks(cat_info);
220 f_newBook.Icon = Properties.Resources.books_pastel;
221 f_newBook.Text = "Adicionar Livro";
222 f_newBook.btnOK.Text = "Adicionar";
223 if (f_newBook.ShowDialog() == DialogResult.OK)
224 {
225 cat_info.id = f_newBook.idCategory;
226 cat_info.path = f_newBook.textCategory;
227 cat_info.id_parent = -1; 228
229 DS_SQLAccessTableAdapters.BooksTableAdapter ta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
230 DS_SQLAccess.BooksDataTable dt =
ta.GetData_Books(null, null, null, null, null, null, null, null, null, null); 231
232 DS_SQLAccess.BooksRow new_row = dt.NewBooksRow(); 233
234 new_row.ref_code = f_newBook.txtReference.Text;
235 new_row.title = f_newBook.txtTitle.Text;
236 new_row.author = f_newBook.txtAuthor.Text;
237 if (f_newBook.cmbPublishers.SelectedIndex > 0)
238 new_row.editor =
((ComboBoxItem)f_newBook.cmbPublishers.SelectedItem).ID;
239 new_row.doc_type =
((ComboBoxItem)f_newBook.cmbDocTypes.SelectedItem).ID;
240 if (string.IsNullOrEmpty(f_newBook.txtDocSource.Text)
== false)
241 new_row.doc_source = f_newBook.txtDocSource.Text;
242 new_row.doc_date = f_newBook.dtpDocDate.Value;
243 new_row.category = cat_info.id;
244 new_row.book_resume = f_newBook.txtResume.Text;
245 dt.Rows.Add(new_row); 246
247 int ret = ta.Update(dt);
248 if (ret == 1)
249 {
250 // Recarregar os livros
251 if (uc_Books != null) uc_Books.LoadBooks();
252 if (dgvBooks != null)
Utils.SelectDataGridViewRow(dgvBooks, new_row.id);
93
253 }
254 }
255 }
256 private void _cmdButtonChangeBook_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
257 {
258 ucBooks uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, "uc_Books"));
259 DataGridView dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks"));
260 int id_book =
Convert.ToInt32(dgvBooks.SelectedRows[0].Cells[0].Value); 261
262 if (dgvBooks.SelectedRows.Count == 1)
263 {
264 int id =
Convert.ToInt32(dgvBooks.SelectedRows[0].Cells[0].Value.ToString());
265 int id_category =
Convert.ToInt32(dgvBooks.SelectedRows[0].Cells[8].Value.ToString());
266 string category_fullpath = string.Empty; 267
268
DS_SQLAccessTableAdapters.Categories_GetCategoriesPathTableAdapter ta2 = new
DS_SQLAccessTableAdapters.Categories_GetCategoriesPathTableAdapter();
269 DS_SQLAccess.Categories_GetCategoriesPathDataTable dt2
= ta2.GetData_GetCategoriesPath(id_category); 270
271 DS_SQLAccess.Categories_GetCategoriesPathRow row2 =
((DS_SQLAccess.Categories_GetCategoriesPathRow)dt2.Rows[0]); 272
273 if (row2 != null)
274 category_fullpath = row2.fullpath; 275
276 category_info cat_info =
Utils.GetCategoryByID(id_category); 277
278 // Editar um livro
279 frmManBooks f_editBook = new frmManBooks(cat_info);
280 f_editBook.Icon = Properties.Resources.books_pastel;
281 f_editBook.Text = "Editar Livro"; 282
283 f_editBook.txtReference.Text =
dgvBooks.SelectedRows[0].Cells[1].Value.ToString();
284 f_editBook.txtTitle.Text =
dgvBooks.SelectedRows[0].Cells[2].Value.ToString();
285 f_editBook.txtAuthor.Text =
dgvBooks.SelectedRows[0].Cells[3].Value.ToString();
286 Utils.SelectComboboxItem(f_editBook.cmbDocTypes,
dgvBooks.SelectedRows[0].Cells[5].Value.ToString());
287 Utils.SelectComboboxItem(f_editBook.cmbPublishers,
dgvBooks.SelectedRows[0].Cells[4].Value.ToString());
288 f_editBook.txtDocSource.Text =
dgvBooks.SelectedRows[0].Cells[6].Value.ToString();
94
289 if (dgvBooks.SelectedRows[0].Cells[7].Value !=
DBNull.Value)
290 f_editBook.dtpDocDate.Value =
Convert.ToDateTime(dgvBooks.SelectedRows[0].Cells[7].Value.ToString());
291 f_editBook.txtResume.Text =
dgvBooks.SelectedRows[0].Cells[10].Value.ToString();
292 f_editBook.idCategory = id_category;
293 f_editBook.textCategory =
Utils.GetCategoryTextByID(f_editBook.idCategory);
294 f_editBook.category_fullpath = category_fullpath;
295 f_editBook.txtCategory.Text = f_editBook.textCategory; 296
297 f_editBook.btnOK.Text = "Editar";
298 if (f_editBook.ShowDialog() == DialogResult.OK)
299 {
300 DS_SQLAccessTableAdapters.BooksTableAdapter ta =
new DS_SQLAccessTableAdapters.BooksTableAdapter();
301 DS_SQLAccess.BooksDataTable dt =
ta.GetData_Books(id, null, null, null, null, null, null, null, null, null); 302
303 DS_SQLAccess.BooksRow edit_row =
((DS_SQLAccess.BooksRow)dt.Rows[0]); 304
305 edit_row.ref_code = f_editBook.txtReference.Text;
306 edit_row.title = f_editBook.txtTitle.Text;
307 edit_row.author = f_editBook.txtAuthor.Text;
308 if (f_editBook.cmbPublishers.SelectedIndex > 0)
309 edit_row.editor =
((ComboBoxItem)f_editBook.cmbPublishers.SelectedItem).ID;
310 edit_row.doc_type =
((ComboBoxItem)f_editBook.cmbDocTypes.SelectedItem).ID;
311 if
(string.IsNullOrEmpty(f_editBook.txtDocSource.Text) == false)
312 edit_row.doc_source =
f_editBook.txtDocSource.Text;
313 edit_row.doc_date = f_editBook.dtpDocDate.Value;
314 edit_row.category = f_editBook.idCategory;
315 edit_row.book_resume = f_editBook.txtResume.Text; 316
317 int ret = ta.Update(edit_row);
318 if (ret == 1)
319 {
320 if (uc_Books != null)
321 {
322 // Recarregar os livros
323 uc_Books.LoadBooks(); 324
Utils.SelectDataGridViewRow(uc_Books.dgvBooks, id);
325 }
326 }
327 }
328 }
329 }
95
330 private void _cmdButtonDeleteBook_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
331 {
332 ucBooks uc_Books = ((ucBooks)Utils.FindControl(tabs,
"uc_Books"));
333 DataGridView dgvBooks =
((DataGridView)Utils.FindControl(tabs, "dgvBooks")); 334
335 int count_selected_books = dgvBooks.SelectedRows.Count; 336
337 string esse = (count_selected_books == 1 ? string.Empty :
"s");
338 DialogResult resp = MessageBox.Show("Deseja remover o" +
esse + " livro" + esse + " selecionado" + esse + " ?", "Remover Livro" +
esse, MessageBoxButtons.YesNo, MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2); 339
340 // Eliminar um livro
341 if (resp == DialogResult.Yes)
342 {
343 DS_SQLAccessTableAdapters.BooksTableAdapter ta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
344 DS_SQLAccess.BooksDataTable dt = null; 345
346 bool deleted = false;
347 foreach (DataGridViewRow dgv_row in
dgvBooks.SelectedRows)
348 {
349 int id_book =
Convert.ToInt32(dgv_row.Cells[0].Value);
350 dt = ta.GetData_Books(id_book, null, null, null,
null, null, null, null, null, null); 351
352 if (dt.Rows.Count == 1)
353 {
354 DS_SQLAccess.BooksRow del_row =
((DS_SQLAccess.BooksRow)dt.Rows[0]);
355 del_row.Delete(); 356
357 int ret = ta.Update(del_row);
358 if (ret == 1)
359 {
360 deleted = true;
361 }
362 }
363 } 364
365 // Recarregar os livros
366 if (deleted) uc_Books.LoadBooks();
367 }
368 }
369 private void _cmdButtonUploadBook_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
370 {
96
371 string currentMode = string.Empty;
372 ucBooks uc_Books = null;
373 DataGridView dgvBooks = null; 374
375 if (tabs.SelectedTab != null)
376 {
377 currentMode = tabs.SelectedTab.Tag.ToString();
378 uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
379 dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks"));
380 } 381
382 //Ler o ficheiro obtido do disco
383 string filename = string.Empty;
384 byte[] pdfbyte = Utils.ObterBytesFicheiro(null,
Utils.FiltrosSaveAs, "Obter ficheiro", out filename); 385
386 //Se o ficheiro foi lido
387 if (pdfbyte != null)
388 {
389 //Obter o ID do livro selecionado
390 DataGridViewRow selected_row =
dgvBooks.SelectedRows[0];
391 int id = Convert.ToInt32(selected_row.Cells[0].Value); 392
393 //Ligar à BD por um TableAdapter
394 DS_SQLAccessTableAdapters.BooksTableAdapter tbta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
395 tbta.Connection.ConnectionString =
Utils.GetDBConnectionString(); 396
397 //Carregar a tabela
398 DS_SQLAccess.BooksDataTable tbdt =
tbta.GetData_Books(id, null, null, null, null, null, null, null, null, null); 399
400 //Se encontrou o registo
401 if (tbdt != null && tbdt.Rows.Count > 0)
402 {
403 DS_SQLAccess.BooksRow row =
((DS_SQLAccess.BooksRow)tbdt.Rows[0]);
404 if (row != null)
405 {
406 //Atribuir o ficheiro PDF ao campo
407 row.file = pdfbyte;
408 row.file_name = Path.GetFileName(filename); 409
410 //Atualizar a base de dados
411 int ret = tbta.Update(row);
412 if (ret == 1)
413 {
414 //Disponibilizar o botão de Download do
97
415 _cmdButtonDownloadBook.Enabled = true; 416
417 uc_Books.LoadBooks(); 418
Utils.SelectDataGridViewRow(uc_Books.dgvBooks, id);
419 }
420 }
421 }
422 } 423
424 EnableControls(); 425
426 //Libertar memória
427 pdfbyte = null;
428 }
429 private void _cmdButtonDownloadBook_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
430 {
431 string folder_path = string.Empty; 432
433 FolderBrowserDialog bfd = new FolderBrowserDialog();
434 bfd.Description = "Selecionar a pasta de destino dos
ficheiros";
435 bfd.SelectedPath = Application.StartupPath;
436 bfd.ShowNewFolderButton = true; 437
438 if (bfd.ShowDialog() == DialogResult.OK)
439 {
440 folder_path = bfd.SelectedPath; 441
442 ucBooks uc_Books = ((ucBooks)Utils.FindControl(tabs,
"uc_Books"));
443 DataGridView dgvBooks =
((DataGridView)Utils.FindControl(tabs, "dgvBooks")); 444
445 int files_saved = 0;
446 // Transferir todos os ficheiros de todos os livros
selecionados
447 foreach (DataGridViewRow rowSelected in
dgvBooks.SelectedRows)
448 {
449 int id_book =
Convert.ToInt32(rowSelected.Cells[0].Value); 450
451 DS_SQLAccessTableAdapters.BooksTableAdapter ta =
new DS_SQLAccessTableAdapters.BooksTableAdapter();
452 DS_SQLAccess.BooksDataTable dt =
ta.GetData_Books(id_book, null, null, null, null, null, null, null, null,
null); 453
454 byte[] file = null;
455 string filename = string.Empty;
456 DS_SQLAccess.BooksRow row_book =
((DS_SQLAccess.BooksRow)dt.Rows[0]);
98
457 file = row_book.file; 458
459 Guid guid = Guid.NewGuid();
460 if (row_book.Isfile_nameNull())
461 filename = guid.ToString().Replace("{",
string.Empty).Replace("}", string.Empty).Replace("-", string.Empty) + ".ext";
462 else
463 filename = row_book.file_name; 464
465 Utils.ConverterBytesEmFicheiro(folder_path + @"\"
+ filename, file);
466 files_saved++;
467 } 468
469 MessageBox.Show("Ficheiros guardados: " +
files_saved.ToString(), "Ficheiros guardados", MessageBoxButtons.OK,
(files_saved == 0 ? MessageBoxIcon.Exclamation :
MessageBoxIcon.Information));
470 }
471 }
472 private void _cmdButtonManageBooks_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
473 {
474 OpenBooksPage(enmTabsMode.Books);
475 }
476 private void _cmdButtonManagePublishers_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
477 {
478 OpenEditorsPage();
479 }
480 private void _cmdButtonCloseTab_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
481 {
482 UnSelectContextTab(); 483
484 if (tabs.TabPages.Count > 0)
485 {
486 string tagCurrentTab = (tabs.SelectedTab.Tag != null ?
tabs.SelectedTab.Tag.ToString() : string.Empty); 487
488 // Fechar separador atual
489 Utils.RemovingTab = tagCurrentTab; 490
tabs.TabPages.Remove(tabs.TabPages[tabs.SelectedIndex]);
491 TabClosed(tabs, null);
492 }
493 }
494 private void _cmdButtonCoverImage_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
495 {
496 // Obter uma imagem para a capa do livro 497
498 DataGridViewRow selected_row =
Utils.GetSelectedRow(tabs.TabPages);
99
499 string filename = null;
500 byte[] bytes = Utils.ObterBytesFicheiro(null, "Ficheiros
de Imagens (*.png; *.jpg; *.bmp)|*.png; *.jpg; *.bmp|All Files (*.*|*.*)",
"Selecionar Capa do Livro '" + selected_row.Cells[2].Value.ToString() + "'",
out filename); 501
502 if (bytes != null && bytes.Length > 0)
503 {
504 int id = Convert.ToInt32(selected_row.Cells[0].Value);
505 DS_SQLAccessTableAdapters.BooksTableAdapter ta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
506 DS_SQLAccess.BooksDataTable dt = ta.GetData_Books(id,
null, null, null, null, null, null, null, null, null); 507
508 DS_SQLAccess.BooksRow row_edit =
((DS_SQLAccess.BooksRow)dt.Rows[0]); 509
510 if (row_edit != null)
511 {
512 row_edit.cover = bytes; 513
514 int ret = ta.Update(row_edit);
515 if (ret == 1)
516 {
517 ucBooks uc_sb =
(ucBooks)Utils.FindControl((Control)tabs, "uc_Books");
518 if (uc_sb != null)
519 {
520 uc_sb.category =
((category_info)tvCategories.SelectedNode.Tag).id;
521 uc_sb.LoadBooks(); 522
Utils.SelectDataGridViewRow(uc_sb.dgvBooks, id);
523 }
524 }
525 }
526 }
527 }
528 private void _cmdButtonViewCategories_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
529 {
530 // Mostrar ou não as categorias
531 splitContainerMain.Panel1Collapsed =
!_cmdButtonViewCategories.BooleanValue;
532 }
533 private void _cmdButtonViewDetails_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
534 {
535 if (tabs.SelectedTab != null)
536 {
537 string currentMode = tabs.SelectedTab.Tag.ToString();
538 ucBooks uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
100
539 DataGridView dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks")); 540
541 if (uc_Books != null)
542 {
543 // Mostrar ou não as os detalhes do livro
selecionado
544 uc_Books.pnlDetails.Visible =
_cmdButtonViewDetails.BooleanValue;
545 uc_Books.pnlDetails.Refresh();
546 }
547 }
548 }
549 private void _cmdButtonChangeBookCategory_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
550 {
551 //Alterar a categoria do(s) livro(s) 552
553 ribbon1.Cursor = Cursors.WaitCursor;
554 Application.DoEvents(); 555
556 Thread.Sleep(200); 557
558 category_info cat_info =
((category_info)tvCategories.SelectedNode.Tag); 559
560 string category_fullpath = string.Empty; 561
562
DS_SQLAccessTableAdapters.Categories_GetCategoriesPathTableAdapter ta2 = new
DS_SQLAccessTableAdapters.Categories_GetCategoriesPathTableAdapter();
563 DS_SQLAccess.Categories_GetCategoriesPathDataTable dt2 =
ta2.GetData_GetCategoriesPath(cat_info.id); 564
565 DS_SQLAccess.Categories_GetCategoriesPathRow row2 =
((DS_SQLAccess.Categories_GetCategoriesPathRow)dt2.Rows[0]); 566
567 if (row2 != null)
568 category_fullpath = row2.fullpath; 569
570 string currentMode = tabs.SelectedTab.Tag.ToString();
571 ucBooks uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
572 DataGridView dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks")); 573
574 frmSelectCategory f_select = new
frmSelectCategory(cat_info.id);
575 f_select.category_path = category_fullpath;
576 f_select.f_main = this; 577
578 if (f_select.ShowDialog() == DialogResult.OK)
579 {
101
580 int list_changed = 0;
581 int id_book_changed = 0;
582 foreach (DataGridViewRow rowSelected in
dgvBooks.SelectedRows)
583 {
584 int id_book =
Convert.ToInt32(rowSelected.Cells[0].Value); 585
586 DS_SQLAccessTableAdapters.BooksTableAdapter ta =
new DS_SQLAccessTableAdapters.BooksTableAdapter();
587 DS_SQLAccess.BooksDataTable dt =
ta.GetData_Books(id_book, null, null, null, null, null, null, null, null,
null); 588
589 int idCategory = f_select.selected_id;
590 string textCategory = f_select.selected_category; 591
592 DS_SQLAccess.BooksRow row_category =
((DS_SQLAccess.BooksRow)dt.Rows[0]);
593 row_category.category = idCategory; 594
595 int ret = ta.Update(row_category);
596 if (ret == 1)
597 {
598 list_changed++;
599 id_book_changed = id_book;
600 }
601 } 602
603 if (list_changed > 0)
604 {
605 // Recarregar os livros
606 uc_Books.LoadBooks(); 607
608 if (list_changed == 1)
609 Utils.SelectDataGridViewRow(dgvBooks,
id_book_changed);
610 }
611 } 612
613 ribbon1.Cursor = Cursors.Default;
614 Application.DoEvents();
615 }
616 private void _cmdButtonViewStatusBar_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
617 {
618 // Mostrar ou não a barra de estado
619 statusStrip1.Visible =
_cmdButtonViewStatusBar.BooleanValue;
620 }
621 private void _cmdButtonNewEditor_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
622 {
102
623 ucEditors uc_Editors = ((ucEditors)Utils.FindControl(tabs,
"uc_Editors"));
624 DataGridView dgvEditors =
((DataGridView)Utils.FindControl(tabs, "dgvEditors")); 625
626 // Criar uma nova editora
627 frmManEditors f_newEditor = new frmManEditors();
628 f_newEditor.Text = "Adicionar Editora";
629 f_newEditor.btnOK.Text = "Adicionar";
630 if (f_newEditor.ShowDialog() == DialogResult.OK)
631 {
632 DS_SQLAccessTableAdapters.EditorsTableAdapter ta = new
DS_SQLAccessTableAdapters.EditorsTableAdapter();
633 DS_SQLAccess.EditorsDataTable dt =
ta.GetData_Editors(null, null); 634
635 DS_SQLAccess.EditorsRow new_row = dt.NewEditorsRow(); 636
637 new_row.editor = f_newEditor.txtEditor.Text;
638 dt.Rows.Add(new_row); 639
640 int ret = ta.Update(dt);
641 if (ret == 1)
642 {
643 // Recarregar as editoras
644 if (uc_Editors != null) uc_Editors.LoadEditors();
645 if (dgvEditors != null)
Utils.SelectDataGridViewRow(dgvEditors, new_row.id);
646 }
647 }
648 }
649 private void _cmdButtonChangeEditor_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
650 {
651 ucEditors uc_Editors = ((ucEditors)Utils.FindControl(tabs,
"uc_Editors"));
652 DataGridView dgvEditors =
((DataGridView)Utils.FindControl(tabs, "dgvEditors"));
653 int id_Editor =
Convert.ToInt32(dgvEditors.SelectedRows[0].Cells[0].Value); 654
655 if (dgvEditors.SelectedRows.Count == 1)
656 {
657 int id =
Convert.ToInt32(dgvEditors.SelectedRows[0].Cells[0].Value.ToString()); 658
659 // Editar uma categoria selecionada
660 frmManEditors f_editEditor = new frmManEditors();
661 f_editEditor.txtID.Text = id_Editor.ToString();
662 f_editEditor.Text = "Editar Editora"; 663
664 f_editEditor.txtEditor.Text =
dgvEditors.SelectedRows[0].Cells[1].Value.ToString(); 665
103
666 f_editEditor.btnOK.Text = "Editar";
667 if (f_editEditor.ShowDialog() == DialogResult.OK)
668 {
669 DS_SQLAccessTableAdapters.EditorsTableAdapter ta =
new DS_SQLAccessTableAdapters.EditorsTableAdapter();
670 DS_SQLAccess.EditorsDataTable dt =
ta.GetData_Editors(id, null); 671
672 DS_SQLAccess.EditorsRow edit_row =
((DS_SQLAccess.EditorsRow)dt.Rows[0]); 673
674 edit_row.editor = f_editEditor.txtEditor.Text; 675
676 int ret = ta.Update(edit_row);
677 if (ret == 1)
678 {
679 // Recarregar as editoras
680 if (uc_Editors != null)
681 uc_Editors.LoadEditors();
682 }
683 }
684 }
685 }
686 private void _cmdButtonDeleteEditor_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
687 {
688 ucEditors uc_Editors = ((ucEditors)Utils.FindControl(tabs,
"uc_Editors"));
689 DataGridView dgvEditors =
((DataGridView)Utils.FindControl(tabs, "dgvEditors")); 690
691 int count_selected_editors =
dgvEditors.SelectedRows.Count; 692
693 DialogResult resp = MessageBox.Show("Deseja remover a
editora selecionada ?", "Remover Editora", MessageBoxButtons.YesNo,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button2); 694
695 // Eliminar a editora selecionada
696 if (resp == DialogResult.Yes)
697 {
698 DS_SQLAccessTableAdapters.EditorsTableAdapter ta = new
DS_SQLAccessTableAdapters.EditorsTableAdapter();
699 DS_SQLAccess.EditorsDataTable dt = null; 700
701 int id_editor =
Convert.ToInt32(dgvEditors.SelectedRows[0].Cells[0].Value);
702 dt = ta.GetData_Editors(id_editor, null); 703
704 if (dt.Rows.Count == 1)
705 {
706 DS_SQLAccess.EditorsRow del_row =
((DS_SQLAccess.EditorsRow)dt.Rows[0]);
707 del_row.Delete();
104
708
709 int ret = ta.Update(del_row);
710 if (ret == 1)
711 {
712 // Recarregar as editoras
713 if (uc_Editors != null)
714 uc_Editors.LoadEditors();
715 }
716 }
717 }
718 }
719 private void _cmdButtonManageUsers_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
720 {
721 OpenUsersPage();
722 }
723 private void _cmdButtonNewUser_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
724 {
725 ucUsers uc_Users = ((ucUsers)Utils.FindControl(tabs,
"uc_Users"));
726 DataGridView dgvUsers =
((DataGridView)Utils.FindControl(tabs, "dgvUsers")); 727
728 // Criar um novo utilizador
729 frmManUsers f_newUser = new frmManUsers();
730 f_newUser.Text = "Adicionar Utilizador";
731 f_newUser.btnOK.Text = "Adicionar";
732 if (f_newUser.ShowDialog() == DialogResult.OK)
733 {
734 DS_SQLAccessTableAdapters.UsersTableAdapter ta = new
DS_SQLAccessTableAdapters.UsersTableAdapter();
735 DS_SQLAccess.UsersDataTable dt =
ta.GetData_Users(null, null, null); 736
737 DS_SQLAccess.UsersRow new_row = dt.NewUsersRow(); 738
739 new_row.username = f_newUser.txtUsername.Text;
740 new_row.type =
((ComboBoxItem)f_newUser.cmbUserType.SelectedItem).ID;
741 dt.Rows.Add(new_row); 742
743 int ret = ta.Update(dt);
744 if (ret == 1)
745 {
746 // Recarregar os utilizadores
747 if (uc_Users != null) uc_Users.LoadUsers();
748 if (dgvUsers != null)
Utils.SelectDataGridViewRow(dgvUsers, new_row.id);
749 }
750 }
751 }
105
752 private void _cmdButtonChangeUser_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
753 {
754 ucUsers uc_Users = ((ucUsers)Utils.FindControl(tabs,
"uc_Users"));
755 DataGridView dgvUsers =
((DataGridView)Utils.FindControl(tabs, "dgvUsers"));
756 int id_User =
Convert.ToInt32(dgvUsers.SelectedRows[0].Cells[0].Value); 757
758 if (dgvUsers.SelectedRows.Count == 1)
759 {
760 int id =
Convert.ToInt32(dgvUsers.SelectedRows[0].Cells[0].Value.ToString()); 761
762 // Editar o utilizador selecionado
763 frmManUsers f_editUser = new frmManUsers();
764 f_editUser.txtID.Text = id_User.ToString();
765 f_editUser.Text = "Editar Utilizador"; 766
767 f_editUser.txtUsername.Text =
dgvUsers.SelectedRows[0].Cells[1].Value.ToString();
768 Utils.SelectComboboxItem(f_editUser.cmbUserType,
dgvUsers.SelectedRows[0].Cells[2].Value.ToString()); 769
770 f_editUser.btnOK.Text = "Editar";
771 if (f_editUser.ShowDialog() == DialogResult.OK)
772 {
773 DS_SQLAccessTableAdapters.UsersTableAdapter ta =
new DS_SQLAccessTableAdapters.UsersTableAdapter();
774 DS_SQLAccess.UsersDataTable dt =
ta.GetData_Users(id, null, null); 775
776 DS_SQLAccess.UsersRow edit_row =
((DS_SQLAccess.UsersRow)dt.Rows[0]); 777
778 edit_row.username = f_editUser.txtUsername.Text; 779
780 int ret = ta.Update(edit_row);
781 if (ret == 1)
782 {
783 // Recarregar os utilizadores
784 if (uc_Users != null)
785 uc_Users.LoadUsers();
786 }
787 }
788 }
789 }
790 private void _cmdButtonDeleteUser_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
791 {
792 ucUsers uc_Users = ((ucUsers)Utils.FindControl(tabs,
"uc_Users"));
106
793 DataGridView dgvUsers =
((DataGridView)Utils.FindControl(tabs, "dgvUsers")); 794
795 int count_selected_Users = dgvUsers.SelectedRows.Count; 796
797 DialogResult resp = MessageBox.Show("Deseja remover o
utilizador selecionado ?", "Remover Utilizador", MessageBoxButtons.YesNo,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button2); 798
799 // Eliminar o utilizador selecionado
800 if (resp == DialogResult.Yes)
801 {
802 DS_SQLAccessTableAdapters.UsersTableAdapter ta = new
DS_SQLAccessTableAdapters.UsersTableAdapter();
803 DS_SQLAccess.UsersDataTable dt = null; 804
805 int id_user =
Convert.ToInt32(dgvUsers.SelectedRows[0].Cells[0].Value);
806 dt = ta.GetData_Users(id_user, null, null); 807
808 if (dt.Rows.Count == 1)
809 {
810 DS_SQLAccess.UsersRow del_row =
((DS_SQLAccess.UsersRow)dt.Rows[0]);
811 del_row.Delete(); 812
813 int ret = ta.Update(del_row);
814 if (ret == 1)
815 {
816 // Recarregar os utilizadores
817 if (uc_Users != null)
818 uc_Users.LoadUsers();
819 }
820 }
821 }
822 }
823 private void _cmdButtonDownloadBooks_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
824 { 825
_cmdButtonDownloadBook_ExecuteEvent(_cmdButtonDownloadBook, e);
826 }
827 private void _cmdButtonDeleteBooks_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
828 {
829 _cmdButtonDeleteBook_ExecuteEvent(_cmdButtonDeleteBooks,
e);
830 }
831 private void _cmdButtonAddRootCategory_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
832 {
833 // Adicionar categoria
834 frmManCategories f_manCateg = new frmManCategories();
835 f_manCateg.Text = "Adicionar Categoria";
107
836 f_manCateg.btnOK.Text = "Adicionar";
837 if (f_manCateg.ShowDialog() == DialogResult.OK)
838 {
839 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta =
new DS_SQLAccessTableAdapters.CategoriesTableAdapter();
840 DS_SQLAccess.CategoriesDataTable dt =
ta.GetData_Categories(null, -1, null); 841
842 DS_SQLAccess.CategoriesRow new_row =
dt.NewCategoriesRow(); 843
844 new_row.id_parent = -1;
845 new_row.path = f_manCateg.txtCategory.Text;
846 dt.Rows.Add(new_row); 847
848 int ret = ta.Update(dt);
849 if (ret == 1)
850 {
851 // Recarregar Categorias
852 string category_fullpath =
tvCategories.SelectedNode.FullPath;
853 LoadCategories(tvCategories, -1);
854 Utils.ExpandTreeByFullPath(this, tvCategories,
category_fullpath);
855 }
856 }
857 }
858 private void _cmdButtonAddChildCategory_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
859 {
860 // Adicionar subcategoria
861 frmManCategories f_manCateg = new frmManCategories();
862 category_info cat_info =
((category_info)tvCategories.SelectedNode.Tag);
863 f_manCateg.Text = "Adicionar Sub-Categoria";
864 f_manCateg.btnOK.Text = "Adicionar";
865 if (f_manCateg.ShowDialog() == DialogResult.OK)
866 {
867 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta =
new DS_SQLAccessTableAdapters.CategoriesTableAdapter();
868 DS_SQLAccess.CategoriesDataTable dt =
ta.GetData_Categories(null, cat_info.id, null); 869
870 DS_SQLAccess.CategoriesRow new_row =
dt.NewCategoriesRow(); 871
872 new_row.id_parent = cat_info.id;
873 new_row.path = f_manCateg.txtCategory.Text;
874 dt.Rows.Add(new_row); 875
876 int ret = ta.Update(dt);
877 if (ret == 1)
878 {
879 // Recarregar Categorias
108
880 string category_fullpath =
tvCategories.SelectedNode.FullPath;
881 LoadCategories(tvCategories, -1);
882 Utils.ExpandTreeByFullPath(this, tvCategories,
category_fullpath);
883 }
884 }
885 }
886 private void _cmdButtonEditCategory_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
887 {
888 // Editar (sub)categoria
889 frmManCategories f_manCateg = new frmManCategories();
890 category_info cat_info =
((category_info)tvCategories.SelectedNode.Tag);
891 f_manCateg.txtCategory.Text = cat_info.path;
892 f_manCateg.Text = "Editar " + (cat_info.id_parent == -1 ?
"" : "Sub-") + "Categoria";
893 f_manCateg.btnOK.Text = "Editar";
894 if (f_manCateg.ShowDialog() == DialogResult.OK)
895 {
896 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta =
new DS_SQLAccessTableAdapters.CategoriesTableAdapter();
897 DS_SQLAccess.CategoriesDataTable dt =
ta.GetData_Categories(cat_info.id, cat_info.id_parent, null); 898
899 DS_SQLAccess.CategoriesRow edit_row =
((DS_SQLAccess.CategoriesRow)dt.Rows[0]); 900
901 edit_row.id = cat_info.id;
902 edit_row.id_parent = cat_info.id_parent;
903 edit_row.path = f_manCateg.txtCategory.Text; 904
905 int ret = ta.Update(edit_row);
906 if (ret == 1)
907 {
908 // Recarregar Categorias
909 string category_fullpath =
tvCategories.SelectedNode.FullPath;
910 LoadCategories(tvCategories, -1);
911 Utils.ExpandTreeByFullPath(this, tvCategories,
category_fullpath);
912 }
913 }
914 }
915 private void _cmdButtonRemoveCategory_ExecuteEvent(object
sender, RibbonLib.Controls.Events.ExecuteEventArgs e)
916 {
917 string currentMode = tabs.SelectedTab.Tag.ToString();
918 ucBooks uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search"))); 919
109
920 category_info cat_info =
((category_info)tvCategories.SelectedNode.Tag); 921
922 DialogResult resp = MessageBox.Show("Deseja remover a
categoria selecionada ?\r\n\r\nATENÇÃO: Os livros que constem nestas
categorias (e sub-categorias) serão associados à categoria (Sem categoria)",
"Remover Categoria", MessageBoxButtons.YesNo, MessageBoxIcon.Question,
MessageBoxDefaultButton.Button2); 923
924 // Eliminar a categoria selecionada
925 if (resp == DialogResult.Yes)
926 {
927 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta =
new DS_SQLAccessTableAdapters.CategoriesTableAdapter();
928 DS_SQLAccess.CategoriesDataTable dt =
ta.GetData_Categories(cat_info.id, null, null); 929
930 DS_SQLAccess.CategoriesRow delete_row =
((DS_SQLAccess.CategoriesRow)dt.Rows[0]); 931
932 delete_row.Delete(); 933
934 int ret = ta.Update(delete_row);
935 if (ret == 1)
936 {
937 // Recarregar Categorias
938 LoadCategories(tvCategories, -1); 939
940 uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
941 bool hasItemSelected =
uc_Books.dgvBooks.SelectedRows.Count > 0;
942 uc_Books.LoadBooks();
943 if (!hasItemSelected)
uc_Books.dgvBooks.ClearSelection();
944 }
945 }
946 }
947 private void _cmdButtonSearch_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
948 {
949 OpenBooksSearchPage();
950 }
951 private void _cmdButtonExit_ExecuteEvent(object sender,
RibbonLib.Controls.Events.ExecuteEventArgs e)
952 {
953 // Close form asynchronously since we are in a ribbon
event
954 // handler, so the ribbon is still in use, and calling
Close
955 // will eventually call _ribbon.DestroyFramework(), which
is
956 // a big no-no, if you still use the ribbon.
110
957 this.BeginInvoke(new MethodInvoker(this.Close));
958 }
959 #endregion 960
961 #region Window Methods
962 /// <summary>
963 /// Window Load Method
964 /// </summary>
965 /// <param name="sender"></param>
966 /// <param name="e"></param>
967 private void frmMain_Load(object sender, EventArgs e)
968 {
969 //Atribuir a versão à barra de título da aplicação
970 this.Text += " - Versão " + Utils.ProductVersion; 971
972 // Iniciar sessão
973 LoginWithCurrentWindowsUser(); 974
975 // Initialize Ribbon Variables
976 InitializeRibbonVariables(); 977
978 // Disponibilizar ou não os controlos
979 EnableControls(); 980
981 // Load categories
982 LoadCategories(tvCategories, -1); 983
984 if (tvCategories.Nodes.Count > 0)
985 tvCategories.SelectedNode = tvCategories.Nodes[0];
986 }
987 #endregion 988
989 #region Methods
990 /// <summary>
991 /// Código para disponibilizar ou não controlos com base
no flluxo ou tipo de utilizador
992 /// </summary>
993 private void EnableControls()
994 {
995 ucBooks uc_Books = null;
996 DataGridView dgvBooks = null; 997
998 if (tabs.TabPages.Count > 0)
999 {
1000 TabPage tabPage = tabs.SelectedTab;
1001 string currentMode = string.Empty;
1002 if (tabPage != null)
1003 {
1004 currentMode = tabs.SelectedTab.Tag.ToString();
1005 uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
111
1006 dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks"));
1007 }
1008 } 1009
1010 bool books_or_search = false;
1011 if (uc_Books != null)
1012 {
1013 books_or_search = true;
1014 } 1015
1016 if (_cmdButtonViewDetails != null)
1017 {
1018 _cmdButtonViewDetails.Enabled = books_or_search;
1019 if (tvCategories.SelectedNode != null &&
typeof(category_info).IsAssignableFrom(tvCategories.SelectedNode.Tag.GetType(
)))
1020 {
1021 _cmdButtonAddChildCategory.Enabled =
((category_info)tvCategories.SelectedNode.Tag).id != 1;
1022 _cmdButtonEditCategory.Enabled =
((category_info)tvCategories.SelectedNode.Tag).id != 1;
1023 _cmdButtonRemoveCategory.Enabled =
((category_info)tvCategories.SelectedNode.Tag).id != 1;
1024 }
1025 else
1026 {
1027 _cmdButtonAddChildCategory.Enabled = false;
1028 _cmdButtonEditCategory.Enabled = false;
1029 _cmdButtonRemoveCategory.Enabled = false;
1030 }
1031 } 1032
1033 // Se fôr apenas utilizador
1034 if (Utils.CurrentUserType == 2)
1035 {
1036 _cmdButtonNewBook.Enabled = false;
1037 _cmdButtonChangeBook.Enabled = false;
1038 _cmdButtonDeleteBook.Enabled = false;
1039 _cmdButtonUploadBook.Enabled = false;
1040 _cmdButtonManagePublishers.Enabled = false;
1041 _cmdButtonManageUsers.Enabled = false;
1042 _cmdButtonCoverImage.Enabled = false;
1043 _cmdButtonChangeBookCategory.Enabled = false;
1044 _cmdButtonAddRootCategory.Enabled = false;
1045 _cmdButtonAddChildCategory.Enabled = false;
1046 _cmdButtonEditCategory.Enabled = false;
1047 _cmdButtonRemoveCategory.Enabled = false;
1048 _cmdButtonNewEditor.Enabled = false;
1049 _cmdButtonChangeEditor.Enabled = false;
1050 _cmdButtonDeleteEditor.Enabled = false;
1051 _cmdButtonNewUser.Enabled = false;
1052 _cmdButtonChangeUser.Enabled = false;
112
1053 _cmdButtonDeleteUser.Enabled = false;
1054 _cmdButtonDeleteBooks.Enabled = false; 1055
1056 _ribbonCategoriesContextMenuStrip.Enabled = false;
1057 _ribbonEditorsContextMenuStrip.Enabled = false;
1058 } 1059
1060 DS_SQLAccessTableAdapters.BooksTableAdapter ta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
1061 DS_SQLAccess.BooksDataTable dt = ta.GetData_Books(null,
null, null, null, null, null, null, null, null, null); 1062
1063 DS_SQLAccessTableAdapters.UsersTableAdapter ta2 = new
DS_SQLAccessTableAdapters.UsersTableAdapter();
1064 DS_SQLAccess.UsersDataTable dt2 = ta2.GetData_Users(null,
null, null); 1065
1066 // Procura de quantos livros e utilizadores existem na
base de dados
1067 int book_count = dt.Rows.Count;
1068 int user_count = dt2.Rows.Count; 1069
1070 tssMessages.Text = string.Format("Livros encontrados: {0}
/ Utilizadores registados: {1}", book_count, user_count);
1071 } 1072
1073 /// <summary>
1074 /// Inicialização das variáveis da Ribbon
1075 /// </summary>
1076 private void InitializeRibbonVariables()
1077 {
1078 // Commands
1079 _cmdButtonNewBook = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonNewBook);
1080 _cmdButtonNewBook.ExecuteEvent +=
_cmdButtonNewBook_ExecuteEvent;
1081 _cmdButtonChangeBook = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonChangeBook);
1082 _cmdButtonChangeBook.ExecuteEvent +=
_cmdButtonChangeBook_ExecuteEvent;
1083 _cmdButtonDeleteBook = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonDeleteBook);
1084 _cmdButtonDeleteBook.ExecuteEvent +=
_cmdButtonDeleteBook_ExecuteEvent;
1085 _cmdButtonUploadBook = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonUploadBook);
1086 _cmdButtonUploadBook.ExecuteEvent +=
_cmdButtonUploadBook_ExecuteEvent;
1087 _cmdButtonDownloadBook = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonDownloadBook);
1088 _cmdButtonDownloadBook.ExecuteEvent +=
_cmdButtonDownloadBook_ExecuteEvent;
1089 _cmdButtonDownloadBook.Enabled = false;
113
1090 _cmdButtonSearch = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonSearch);
1091 _cmdButtonSearch.ExecuteEvent +=
_cmdButtonSearch_ExecuteEvent;
1092 _cmdButtonManageBooks = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonManageBooks);
1093 _cmdButtonManageBooks.ExecuteEvent +=
_cmdButtonManageBooks_ExecuteEvent;
1094 _cmdButtonManagePublishers = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonManagePublishers);
1095 _cmdButtonManagePublishers.ExecuteEvent +=
_cmdButtonManagePublishers_ExecuteEvent;
1096 _cmdButtonManageUsers = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonManageUsers);
1097 _cmdButtonManageUsers.ExecuteEvent +=
_cmdButtonManageUsers_ExecuteEvent;
1098 _cmdButtonCloseTab = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonCloseTab);
1099 _cmdButtonCloseTab.Enabled = false;
1100 _cmdButtonCloseTab.ExecuteEvent +=
_cmdButtonCloseTab_ExecuteEvent;
1101 _cmdButtonCoverImage = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonCoverImage);
1102 _cmdButtonCoverImage.ExecuteEvent +=
_cmdButtonCoverImage_ExecuteEvent;
1103 _cmdButtonViewCategories = new RibbonToggleButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonViewCategories);
1104 _cmdButtonViewCategories.ExecuteEvent +=
_cmdButtonViewCategories_ExecuteEvent;
1105 _cmdButtonViewCategories.BooleanValue = true;
1106 _cmdButtonViewDetails = new RibbonToggleButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonViewDetails);
1107 _cmdButtonViewDetails.ExecuteEvent +=
_cmdButtonViewDetails_ExecuteEvent;
1108 _cmdButtonViewDetails.BooleanValue = true;
1109 _cmdButtonChangeBookCategory = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonChangeBookCategory);
1110 _cmdButtonChangeBookCategory.ExecuteEvent +=
_cmdButtonChangeBookCategory_ExecuteEvent;
1111 _cmdButtonViewStatusBar = new RibbonToggleButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonViewStatusBar);
1112 _cmdButtonViewStatusBar.BooleanValue = true;
1113 _cmdButtonViewStatusBar.ExecuteEvent +=
_cmdButtonViewStatusBar_ExecuteEvent;
1114 _cmdButtonNewEditor = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonNewEditor);
1115 _cmdButtonNewEditor.ExecuteEvent +=
_cmdButtonNewEditor_ExecuteEvent;
1116 _cmdButtonChangeEditor = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonChangeEditor);
1117 _cmdButtonChangeEditor.ExecuteEvent +=
_cmdButtonChangeEditor_ExecuteEvent;
1118 _cmdButtonDeleteEditor = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonDeleteEditor);
114
1119 _cmdButtonDeleteEditor.ExecuteEvent +=
_cmdButtonDeleteEditor_ExecuteEvent;
1120 _cmdButtonDownloadBooks = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonDownloadBooks);
1121 _cmdButtonDownloadBooks.ExecuteEvent +=
_cmdButtonDownloadBooks_ExecuteEvent;
1122 _cmdButtonNewUser = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonNewUser);
1123 _cmdButtonNewUser.ExecuteEvent +=
_cmdButtonNewUser_ExecuteEvent;
1124 _cmdButtonChangeUser = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonChangeUser);
1125 _cmdButtonChangeUser.ExecuteEvent +=
_cmdButtonChangeUser_ExecuteEvent;
1126 _cmdButtonDeleteUser = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonDeleteUser);
1127 _cmdButtonDeleteUser.ExecuteEvent +=
_cmdButtonDeleteUser_ExecuteEvent;
1128 _cmdButtonDeleteBooks = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonDeleteBooks);
1129 _cmdButtonDeleteBooks.ExecuteEvent +=
_cmdButtonDeleteBooks_ExecuteEvent; 1130
1131 _cmdButtonAddRootCategory = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonAddRootCategory);
1132 _cmdButtonAddRootCategory.ExecuteEvent +=
_cmdButtonAddRootCategory_ExecuteEvent;
1133 _cmdButtonAddChildCategory = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonAddChildCategory);
1134 _cmdButtonAddChildCategory.ExecuteEvent +=
_cmdButtonAddChildCategory_ExecuteEvent;
1135 _cmdButtonEditCategory = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonEditCategory);
1136 _cmdButtonEditCategory.ExecuteEvent +=
_cmdButtonEditCategory_ExecuteEvent;
1137 _cmdButtonRemoveCategory = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonRemoveCategory);
1138 _cmdButtonRemoveCategory.ExecuteEvent +=
_cmdButtonRemoveCategory_ExecuteEvent; 1139
1140 _cmdButtonExit = new RibbonButton(ribbon1,
(uint)RibbonMarkupCommands.cmdButtonExit);
1141 _cmdButtonExit.ExecuteEvent +=
_cmdButtonExit_ExecuteEvent; 1142
1143 // Tab Groups
1144 _cmdTabHome = new RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabHome);
1145 _cmdTabSelectedBook = new RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabSelectedBook);
1146 _cmdTabView = new RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabView);
1147 _cmdTabSelectedEditor = new RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabSelectedEditor);
115
1148 _cmdTabSelectedBooks = new RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabSelectedBooks);
1149 _cmdTabSelectedCategory = new RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabSelectedCategory);
1150 _cmdTabSelectedUser = new RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabSelectedUser); 1151
1152 // TabGroup Groups
1153 _cmdTabGroupSelectedBookTools = new
RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabGroupSelectedBookTools);
1154 _cmdTabGroupSelectedEditorTools = new
RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabGroupSelectedEditorTools);
1155 _cmdTabGroupSelectedBooksTools = new
RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabGroupSelectedBooksTools);
1156 _cmdTabGroupSelectedCategoriesTools = new
RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabGroupSelectedCategoriesTools);
1157 _cmdTabGroupSelectedUsersTools = new
RibbonTabGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdTabGroupSelectedUsersTools); 1158
1159 // Group Groups
1160 _cmdGroupBooks = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupBooks);
1161 _cmdGroupDownUpLoad = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupDownUpLoad);
1162 _cmdGroupCloseSearch = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupCloseSearch);
1163 _cmdGroupMaintenances = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupMaintenances);
1164 _cmdGroupTabs = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupTabs);
1165 _cmdGroupCover = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupCover);
1166 _cmdGroupVisualization = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupVisualization);
1167 _cmdGroupChangeCategory = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupChangeCategory);
1168 _cmdGroupEditors = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupEditors);
1169 _cmdGroupAddButtons = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupAddButtons);
1170 _cmdGroupUsers = new RibbonGroup(ribbon1,
(uint)RibbonMarkupCommands.cmdGroupUsers); 1171
1172 // Recent Items
1173 _cmdRecentItems = new RibbonRecentItems(ribbon1,
(uint)RibbonMarkupCommands.cmdRecentItems);
1174 } 1175
1176 /// <summary>
116
1177 /// Métodos de quando um item foi selecionado na
DataGridView 'dgvBooks'
1178 /// </summary>
1179 /// <param name="sender"></param>
1180 /// <param name="e"></param>
1181 private void uc_Books_ItemSelected(object sender,
SelectedEventArgs e)
1182 {
1183 ucBooks uc_Books = ((ucBooks)sender);
1184 DataGridView dgvBooks = uc_Books.dgvBooks; 1185
1186 UnSelectContextTab(); 1187
1188 if (e.Selected)
1189 {
1190 if (dgvBooks.SelectedRows.Count == 1)
1191 _cmdTabGroupSelectedBookTools.ContextAvailable =
ContextAvailability.Active;
1192 else
1193 _cmdTabGroupSelectedBooksTools.ContextAvailable =
ContextAvailability.Active;
1194 } 1195
1196 if (dgvBooks != null && dgvBooks.SelectedRows.Count == 1)
1197 {
1198 //Obter o ID do livro selecionado
1199 DataGridViewRow selected_row =
((DataGridViewRow)dgvBooks.SelectedRows[0]);
1200 int id = Convert.ToInt32(selected_row.Cells[0].Value); 1201
1202 DS_SQLAccessTableAdapters.BooksTableAdapter ta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
1203 DS_SQLAccess.BooksDataTable dt = ta.GetData_Books(id,
null, null, null, null, null, null, null, null, null); 1204
1205 DS_SQLAccess.BooksRow row_book =
((DS_SQLAccess.BooksRow)dt.Rows[0]); 1206
1207 if (dgvBooks.SelectedRows.Count == 1)
1208 {
1209 if (row_book != null)
1210 _cmdButtonDownloadBook.Enabled =
!row_book.IsfileNull();
1211 else
1212 _cmdButtonDownloadBook.Enabled = true;
1213 }
1214 else
1215 _cmdButtonDownloadBook.Enabled = false;
1216 } 1217
1218 _cmdButtonChangeBook.Enabled =
(dgvBooks.SelectedRows.Count == 1);
1219 _cmdButtonUploadBook.Enabled =
(dgvBooks.SelectedRows.Count == 1);
117
1220 _cmdButtonCoverImage.Enabled =
(dgvBooks.SelectedRows.Count == 1); 1221
1222 EnableControls();
1223 } 1224
1225 /// <summary>
1226 /// Métodos de quando um item foi selecionado na
DataGridView 'dgvSearch'
1227 /// </summary>
1228 /// <param name="sender"></param>
1229 /// <param name="e"></param>
1230 private void uc_Search_ItemSelected(object sender,
SelectedEventArgs e)
1231 {
1232 ucBooks uc_Books = ((ucBooks)sender);
1233 DataGridView dgvBooks = uc_Books.dgvBooks; 1234
1235 UnSelectContextTab(); 1236
1237 if (e.Selected)
1238 {
1239 if (dgvBooks.SelectedRows.Count == 1)
1240 _cmdTabGroupSelectedBookTools.ContextAvailable =
ContextAvailability.Active;
1241 else
1242 _cmdTabGroupSelectedBooksTools.ContextAvailable =
ContextAvailability.Active;
1243 } 1244
1245 if (dgvBooks != null && dgvBooks.SelectedRows.Count == 1)
1246 {
1247 //Obter o ID do livro selecionado
1248 DataGridViewRow selected_row =
((DataGridViewRow)dgvBooks.SelectedRows[0]);
1249 int id = Convert.ToInt32(selected_row.Cells[0].Value); 1250
1251 DS_SQLAccessTableAdapters.BooksTableAdapter ta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
1252 DS_SQLAccess.BooksDataTable dt = ta.GetData_Books(id,
null, null, null, null, null, null, null, null, null); 1253
1254 DS_SQLAccess.BooksRow row_book =
((DS_SQLAccess.BooksRow)dt.Rows[0]); 1255
1256 if (dgvBooks.SelectedRows.Count == 1)
1257 {
1258 if (row_book != null)
1259 _cmdButtonDownloadBook.Enabled =
!row_book.IsfileNull();
1260 else
1261 _cmdButtonDownloadBook.Enabled = true;
1262 }
1263 else
118
1264 _cmdButtonDownloadBook.Enabled = false;
1265 } 1266
1267 _cmdButtonChangeBook.Enabled =
(dgvBooks.SelectedRows.Count == 1);
1268 _cmdButtonUploadBook.Enabled =
(dgvBooks.SelectedRows.Count == 1);
1269 _cmdButtonCoverImage.Enabled =
(dgvBooks.SelectedRows.Count == 1); 1270
1271 TabPage tab_search = tabs.SelectedTab;
1272 tab_search.Text = "Pesquisa" + (uc_Books.filtered ? "
(filtrado)" : string.Empty); 1273
1274 EnableControls();
1275 } 1276
1277 /// <summary>
1278 /// Métodos de quando um item foi selecionado na
DataGridView 'dgvEditors'
1279 /// </summary>
1280 /// <param name="sender"></param>
1281 /// <param name="e"></param>
1282 private void uc_Editors_ItemSelected(object sender,
SelectedEventArgs e)
1283 {
1284 ucEditors uc_Editors = ((ucEditors)sender);
1285 DataGridView dgvEditors =
((DataGridView)Utils.FindControl(tabs, "dgvEditors")); 1286
1287 UnSelectContextTab(); 1288
1289 if (e.Selected)
1290 _cmdTabGroupSelectedEditorTools.ContextAvailable =
ContextAvailability.Active; 1291
1292 _cmdButtonChangeEditor.Enabled =
(dgvEditors.SelectedRows.Count == 1);
1293 _cmdButtonDeleteEditor.Enabled =
(dgvEditors.SelectedRows.Count == 1); 1294
1295 EnableControls();
1296 } 1297
1298 /// <summary>
1299 /// Métodos de quando um item foi selecionado na
DataGridView 'dgvUsers'
1300 /// </summary>
1301 /// <param name="sender"></param>
1302 /// <param name="e"></param>
1303 private void uc_Users_ItemSelected(object sender,
SelectedEventArgs e)
1304 {
1305 ucUsers uc_Users = ((ucUsers)sender);
119
1306 DataGridView dgvUsers =
((DataGridView)Utils.FindControl(tabs, "dgvUsers")); 1307
1308 UnSelectContextTab(); 1309
1310 if (e.Selected)
1311 _cmdTabGroupSelectedUsersTools.ContextAvailable =
ContextAvailability.Active; 1312
1313 int id_selected = -1;
1314 if (dgvUsers.SelectedRows.Count == 1)
1315 id_selected =
Convert.ToInt32(dgvUsers.SelectedRows[0].Cells[0].Value); 1316
1317 _cmdButtonChangeUser.Enabled =
(dgvUsers.SelectedRows.Count == 1) && (id_selected != 1);
1318 _cmdButtonDeleteUser.Enabled =
(dgvUsers.SelectedRows.Count == 1) && (id_selected != 1); 1319
1320 EnableControls();
1321 } 1322
1323 /// <summary>
1324 /// Abrir o separador dos livros
1325 /// </summary>
1326 /// <param name="sender"></param>
1327 /// <param name="e"></param>
1328 private void OpenBooksPage(enmTabsMode booksMode)
1329 {
1330 bool searchPageFound = false;
1331 foreach (TabPage tpSearch in tabs.TabPages)
1332 {
1333 if (tpSearch.Tag != null)
1334 {
1335 if (tpSearch.Tag.ToString() ==
Utils.GetEnumDescription(enmTabsMode.Books))
1336 {
1337 tabs.SelectedTab = tpSearch;
1338 searchPageFound = true;
1339 break;
1340 }
1341 }
1342 } 1343
1344 if (!searchPageFound)
1345 {
1346 TabPage tab_search = new TabPage();
1347 tabs.TabPages.Add(tab_search);
1348 tabs.Visible = (tabs.TabPages.Count != 0);
1349 _cmdButtonCloseTab.Enabled = tabs.Visible;
1350 picAboutBox.Visible = !tabs.Visible;
1351 tab_search.ImageIndex = 0;
120
1352 tab_search.Font = new Font(tab_search.Font.FontFamily,
(float)11.25);
1353 tab_search.Text = "Livros";
1354 tab_search.Tag =
Utils.GetEnumDescription(enmTabsMode.Books);
1355 tab_search.BackColor = Color.FromArgb(0, 252, 252,
252);
1356 if (tvCategories.SelectedNode == null)
1357 tvCategories.SelectedNode = tvCategories.Nodes[0];
1358 ucBooks uc_Books = new ucBooks();
1359 if (_cmdButtonViewDetails.BooleanValue == true)
1360 {
1361 uc_Books.pnlDetails.Visible = true;
1362 uc_Books.pnlDetails.Refresh();
1363 }
1364 uc_Books.category =
((category_info)tvCategories.SelectedNode.Tag).id;
1365 uc_Books.Name = "uc_Books";
1366 uc_Books.Dock = DockStyle.Fill;
1367 uc_Books.ItemSelected += uc_Books_ItemSelected;
1368 uc_Books.dgvBooks.MouseClick += dgvBooks_MouseClick;
1369 tab_search.Controls.Add(uc_Books);
1370 tabs.SelectedTab = tab_search;
1371 }
1372 else
1373 {
1374 TabPage tab_search = tabs.SelectedTab;
1375 ucBooks uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab,
Utils.GetEnumDescription(enmTabsMode.Books))); 1376
1377 if (uc_Books != null)
1378 {
1379 uc_Books.category =
((category_info)tvCategories.SelectedNode.Tag).id;
1380 tab_search.Text = "Livros"; 1381
1382 if (_cmdButtonViewDetails.BooleanValue == true)
1383 {
1384 uc_Books.pnlDetails.Visible = true;
1385 uc_Books.pnlDetails.Refresh();
1386 }
1387 }
1388 } 1389
1390 EnableControls();
1391 } 1392
1393 /// <summary>
1394 /// Abrir o separador da pesquisa dos livros
1395 /// </summary>
1396 /// <param name="sender"></param>
1397 /// <param name="e"></param>
121
1398 private void OpenBooksSearchPage()
1399 {
1400 bool searchPageFound = false;
1401 foreach (TabPage tpSearch in tabs.TabPages)
1402 {
1403 if (tpSearch.Tag != null)
1404 {
1405 if (tpSearch.Tag.ToString() ==
Utils.GetEnumDescription(enmTabsMode.Search))
1406 {
1407 tabs.SelectedTab = tpSearch;
1408 searchPageFound = true;
1409 break;
1410 }
1411 }
1412 } 1413
1414 if (!searchPageFound)
1415 {
1416 TabPage tab_search = new TabPage();
1417 tabs.TabPages.Add(tab_search);
1418 tabs.Visible = (tabs.TabPages.Count != 0);
1419 _cmdButtonCloseTab.Enabled = tabs.Visible;
1420 picAboutBox.Visible = !tabs.Visible;
1421 tab_search.ImageIndex = 3;
1422 tab_search.Font = new Font(tab_search.Font.FontFamily,
(float)11.25);
1423 tab_search.Tag =
Utils.GetEnumDescription(enmTabsMode.Search);
1424 tab_search.BackColor = Color.FromArgb(0, 252, 252,
252);
1425 if (tvCategories.SelectedNode == null)
1426 tvCategories.SelectedNode = tvCategories.Nodes[0];
1427 ucBooks uc_Books = new ucBooks();
1428 uc_Books.category = null;
1429 //tab_search.Text = "Pesquisa";
1430 tab_search.Text = "Pesquisa" + (uc_Books.filtered ? "
(filtrado)" : string.Empty);
1431 uc_Books.Name = "uc_Search";
1432 uc_Books.Dock = DockStyle.Fill;
1433 uc_Books.ItemSelected += uc_Search_ItemSelected;
1434 uc_Books.dgvBooks.MouseClick += dgvSearch_MouseClick;
1435 uc_Books.SearchNow = true;
1436 tab_search.Controls.Add(uc_Books);
1437 tabs.SelectedTab = tab_search;
1438 }
1439 else
1440 {
1441 TabPage tab_search = tabs.SelectedTab; 1442
1443 string currentMode = tabs.SelectedTab.Tag.ToString();
122
1444 ucBooks uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search"))); 1445
1446 if (uc_Books != null)
1447 {
1448 uc_Books.category = null;
1449 //tab_search.Text = "Pesquisa";
1450 tab_search.Text = "Pesquisa" + (uc_Books.filtered
? " (filtrado)" : string.Empty);
1451 uc_Books.SearchNow = true;
1452 }
1453 } 1454
1455 EnableControls();
1456 } 1457
1458 /// <summary>
1459 /// Abrir o separador das editoras
1460 /// </summary>
1461 /// <param name="sender"></param>
1462 /// <param name="e"></param>
1463 private void OpenEditorsPage()
1464 {
1465 bool editorPageFound = false;
1466 foreach (TabPage tpEditors in tabs.TabPages)
1467 {
1468 if (tpEditors.Tag != null && tpEditors.Tag.ToString()
== Utils.GetEnumDescription(enmTabsMode.Editors))
1469 {
1470 tabs.SelectedTab = tpEditors;
1471 editorPageFound = true;
1472 break;
1473 }
1474 } 1475
1476 if (!editorPageFound)
1477 {
1478 TabPage tab_editors = new TabPage();
1479 tabs.TabPages.Add(tab_editors);
1480 tabs.Visible = (tabs.TabPages.Count != 0);
1481 _cmdButtonCloseTab.Enabled = tabs.Visible;
1482 picAboutBox.Visible = !tabs.Visible;
1483 tab_editors.ImageIndex = 1;
1484 tab_editors.Font = new
Font(tab_editors.Font.FontFamily, (float)11.25);
1485 tab_editors.Text = "Editoras";
1486 tab_editors.Tag =
Utils.GetEnumDescription(enmTabsMode.Editors);
1487 tab_editors.BackColor = Color.FromArgb(0, 252, 252,
252);
1488 ucEditors uc_editors = new ucEditors();
1489 uc_editors.Name = "uc_Editors";
123
1490 uc_editors.Dock = DockStyle.Fill;
1491 uc_editors.ItemSelected += uc_Editors_ItemSelected;
1492 uc_editors.dgvEditors.MouseClick +=
dgvEditors_MouseClick;
1493 tab_editors.Controls.Add(uc_editors);
1494 tabs.SelectedTab = tab_editors;
1495 } 1496
1497 EnableControls();
1498 } 1499
1500 /// <summary>
1501 /// Abrir o separador dos utilizadores
1502 /// </summary>
1503 /// <param name="sender"></param>
1504 /// <param name="e"></param>
1505 private void OpenUsersPage()
1506 {
1507 bool userPageFound = false;
1508 foreach (TabPage tpUsers in tabs.TabPages)
1509 {
1510 if (tpUsers.Tag != null && tpUsers.Tag.ToString() ==
Utils.GetEnumDescription(enmTabsMode.Users))
1511 {
1512 tabs.SelectedTab = tpUsers;
1513 userPageFound = true;
1514 break;
1515 }
1516 } 1517
1518 if (!userPageFound)
1519 {
1520 TabPage tab_users = new TabPage();
1521 tabs.TabPages.Add(tab_users);
1522 tabs.Visible = (tabs.TabPages.Count != 0);
1523 _cmdButtonCloseTab.Enabled = tabs.Visible;
1524 picAboutBox.Visible = !tabs.Visible;
1525 tab_users.ImageIndex = 2;
1526 tab_users.Font = new Font(tab_users.Font.FontFamily,
(float)11.25);
1527 tab_users.Text = "Utilizadores";
1528 tab_users.Tag =
Utils.GetEnumDescription(enmTabsMode.Users);
1529 tab_users.BackColor = Color.FromArgb(0, 252, 252,
252);
1530 ucUsers uc_users = new ucUsers();
1531 uc_users.Name = "uc_Users";
1532 uc_users.Dock = DockStyle.Fill;
1533 uc_users.ItemSelected += uc_Users_ItemSelected;
1534 uc_users.dgvUsers.MouseClick += dgvUsers_MouseClick;
1535 tab_users.Controls.Add(uc_users);
1536 tabs.SelectedTab = tab_users;
1537 }
124
1538
1539 EnableControls();
1540 } 1541
1542 /// <summary>
1543 /// Carregar as categorias da base de dados
1544 /// </summary>
1545 /// <param name="sender"></param>
1546 /// <param name="e"></param>
1547 private void LoadCategories(object obj, int parent_id)
1548 {
1549 Application.DoEvents(); 1550
1551 Thread.Sleep(100); 1552
1553 dt = ta.GetData_Categories(null, parent_id, null); 1554
1555 if (dt.Rows.Count == 0)
1556 {
1557 if (typeof(TreeNode).IsAssignableFrom(obj.GetType()))
1558 ((TreeNode)obj).Collapse();
1559 } 1560
1561 if (typeof(TreeView).IsAssignableFrom(obj.GetType()))
1562 ((TreeView)obj).Nodes.Clear();
1563 if (typeof(TreeNode).IsAssignableFrom(obj.GetType()))
1564 ((TreeNode)obj).Nodes.Clear(); 1565
1566 foreach (DS_SQLAccess.CategoriesRow row in dt.Rows)
1567 {
1568 TreeNode node = null;
1569 TreeNode node_load = new TreeNode("A carregar..."); 1570
1571 if (typeof(TreeView).IsAssignableFrom(obj.GetType()))
1572 node = ((TreeView)obj).Nodes.Add(row.path);
1573 if (typeof(TreeNode).IsAssignableFrom(obj.GetType()))
1574 node = ((TreeNode)obj).Nodes.Add(row.path); 1575
1576 node.ImageIndex = 1;
1577 node.SelectedImageIndex = 1; 1578
1579 node_load.Tag = "loading";
1580 node_load.ForeColor = Color.FromArgb(143, 156, 171);
1581 if (row.id > 1)
1582 node.Nodes.Add(node_load);
1583 else
1584 {
1585 node.ImageIndex = 3;
1586 node.SelectedImageIndex = 3;
1587 }
1588 node.Tag = new category_info(row.id, row.id_parent,
row.path);
1589 } 1590
125
1591 EnableControls();
1592 } 1593
1594 /// <summary>
1595 /// Iniciar sessão com o utilizador que está 'logado' no
Windows
1596 /// </summary>
1597 /// <param name="sender"></param>
1598 /// <param name="e"></param>
1599 private void LoginWithCurrentWindowsUser()
1600 {
1601 string loggedUser = Environment.UserDomainName + @"\" +
Environment.UserName; 1602
1603 try
1604 {
1605 DS_SQLAccessTableAdapters.UsersTableAdapter ta = new
DS_SQLAccessTableAdapters.UsersTableAdapter();
1606 ta.Connection.ConnectionString =
Utils.GetDBConnectionString();
1607 DS_SQLAccess.UsersDataTable dt =
ta.GetData_Users(null, loggedUser, null); 1608
1609 if (dt.Rows.Count == 1)
1610 {
1611 DS_SQLAccess.UsersRow userRow =
((DS_SQLAccess.UsersRow)dt.Rows[0]); 1612
1613 DS_SQLAccessTableAdapters.UsersTableAdapter ta2 =
new DS_SQLAccessTableAdapters.UsersTableAdapter();
1614 ta2.Connection.ConnectionString =
Utils.GetDBConnectionString();
1615 DS_SQLAccess.UsersDataTable dt2 =
ta2.GetData_Users(userRow.id, null, null); 1616
1617 //Atribuir as informações do utilizador às
variáveis globais
1618 Utils.CurrentUsernameID = userRow.id;
1619 Utils.CurrentUsername = userRow.username;
1620 Utils.CurrentUserType = userRow.type; 1621
1622 tssUserType.Text = Utils.CurrentUsername + " " +
(Utils.CurrentUserType == 1 ? "(Administrador)" : "(Utilizador)");
1623 }
1624 else
1625 {
1626 //Erro a iniciar sessão / Utilizador ou password
errados
1627 DialogResult result = MessageBox.Show("Erro ao
iniciar sessão\r\n\r\nO utilizador " + Utils.CurrentUsername + " não tem
permissão para utilizar esta aplicação", "Sem acesso", MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
1628 Environment.Exit(0);
1629 }
126
1630 }
1631 catch (Exception ex)
1632 {
1633 MessageBox.Show("Erro no início de sessão.\r\nErro: "
+ ex.Message, "Erro ao iniciar sessão", MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
1634 }
1635 } 1636
1637 /// <summary>
1638 /// Indisponibilizar todos os separadores de contexto da
Ribbon
1639 /// </summary>
1640 /// <param name="sender"></param>
1641 /// <param name="e"></param>
1642 private void UnSelectContextTab()
1643 {
1644 _cmdTabGroupSelectedBooksTools.ContextAvailable =
ContextAvailability.NotAvailable;
1645 _cmdTabGroupSelectedBookTools.ContextAvailable =
ContextAvailability.NotAvailable;
1646 _cmdTabGroupSelectedCategoriesTools.ContextAvailable =
ContextAvailability.NotAvailable;
1647 _cmdTabGroupSelectedEditorTools.ContextAvailable =
ContextAvailability.NotAvailable;
1648 _cmdTabGroupSelectedUsersTools.ContextAvailable =
ContextAvailability.NotAvailable;
1649 } 1650
1651 /// <summary>
1652 /// Quando um separador foi fechado
1653 /// </summary>
1654 /// <param name="sender"></param>
1655 /// <param name="e"></param>
1656 private void TabClosed(object sender,
TabControlCancelEventArgs e)
1657 {
1658 tabs.Visible = (tabs.TabPages.Count != 0);
1659 _cmdButtonCloseTab.Enabled = tabs.Visible; 1660
1661 picAboutBox.Visible = !tabs.Visible;
1662 } 1663
1664 /// <summary>
1665 /// Quando um nó da Treeview é expandido
1666 /// </summary>
1667 public void AfterExpand(TreeNode node)
1668 {
1669 bool collapsed = false;
1670 if (node.Nodes.Count == 1 && node.Nodes[0].Tag.ToString()
== "loading")
1671 {
1672 LoadCategories(node, ((category_info)node.Tag).id);
127
1673 if (node.Nodes.Count == 0)
1674 {
1675 node.Expand();
1676 node.Collapse();
1677 collapsed = true;
1678 }
1679 } 1680
1681 if (collapsed)
1682 {
1683 node.ImageIndex = 1;
1684 node.SelectedImageIndex = 1;
1685 }
1686 else
1687 {
1688 node.ImageIndex = 2;
1689 node.SelectedImageIndex = 2;
1690 } 1691
1692 EnableControls();
1693 }
1694 #endregion 1695
1696 #region Controls Methods
1697 /// <summary>
1698 /// Quando se mudou de separador selecionado
1699 /// </summary>
1700 /// <param name="sender"></param>
1701 /// <param name="e"></param>
1702 private void tabs_SelectedIndexChanged(object sender,
EventArgs e)
1703 {
1704 string currentMode = string.Empty;
1705 ucBooks uc_Books = null;
1706 ucEditors uc_Editors = null;
1707 ucUsers uc_Users = null;
1708 DataGridView dgvBooks = null;
1709 DataGridView dgvEditors = null;
1710 DataGridView dgvUsers = null; 1711
1712 UnSelectContextTab(); 1713
1714 TabPage tpage = tabs.SelectedTab;
1715 if (tpage != null && tpage.Tag != null)
1716 {
1717 currentMode = tabs.SelectedTab.Tag.ToString(); 1718
1719 if ((tpage.Tag.ToString() ==
Utils.GetEnumDescription(enmTabsMode.Books)))
1720 {
1721 uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
128
1722 bool hasItemSelected =
uc_Books.dgvBooks.SelectedRows.Count > 0;
1723 uc_Books.LoadBooks();
1724 if (!hasItemSelected)
uc_Books.dgvBooks.ClearSelection(); 1725
1726 if (_cmdButtonViewDetails.BooleanValue == true)
1727 {
1728 uc_Books.pnlDetails.Visible = true;
1729 uc_Books.pnlDetails.Refresh();
1730 } 1731
1732 dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks"));
1733 if (dgvBooks != null)
1734 {
1735 if (dgvBooks.SelectedRows.Count > 0)
1736 {
1737 if (dgvBooks.SelectedRows.Count > 1) 1738
_cmdTabGroupSelectedBooksTools.ContextAvailable = ContextAvailability.Active;
1739 else 1740
_cmdTabGroupSelectedBookTools.ContextAvailable = ContextAvailability.Active;
1741 }
1742 }
1743 }
1744 else if ((tpage.Tag.ToString() ==
Utils.GetEnumDescription(enmTabsMode.Search)))
1745 {
1746 uc_Books =
((ucBooks)Utils.FindControl(tabs.SelectedTab, (currentMode ==
Utils.GetEnumDescription(enmTabsMode.Books) ? "uc_Books" : "uc_Search")));
1747 uc_Books.LoadBooks(); 1748
1749 if (_cmdButtonViewDetails.BooleanValue == true)
1750 {
1751 uc_Books.pnlDetails.Visible = true;
1752 uc_Books.pnlDetails.Refresh();
1753 } 1754
1755 dgvBooks =
((DataGridView)Utils.FindControl(tabs.SelectedTab, "dgvBooks"));
1756 if (dgvBooks != null)
1757 {
1758 if (dgvBooks.SelectedRows.Count > 0)
1759 {
1760 if (dgvBooks.SelectedRows.Count > 1) 1761
_cmdTabGroupSelectedBooksTools.ContextAvailable = ContextAvailability.Active;
1762 else 1763
_cmdTabGroupSelectedBookTools.ContextAvailable = ContextAvailability.Active;
1764 }
129
1765 }
1766 }
1767 else if ((tpage.Tag.ToString() ==
Utils.GetEnumDescription(enmTabsMode.Editors)))
1768 {
1769 uc_Editors =
((ucEditors)Utils.FindControl(tabs.SelectedTab, "uc_Editors")); 1770
1771 bool hasItemSelected =
uc_Editors.dgvEditors.SelectedRows.Count > 0;
1772 uc_Editors.LoadEditors();
1773 if (!hasItemSelected)
uc_Editors.dgvEditors.ClearSelection(); 1774
1775 dgvEditors =
((DataGridView)Utils.FindControl(tabs, "dgvEditors"));
1776 if (dgvEditors != null)
1777 {
1778 if (dgvEditors.SelectedRows.Count >= 1) 1779
_cmdTabGroupSelectedEditorTools.ContextAvailable =
ContextAvailability.Active;
1780 }
1781 }
1782 else if ((tpage.Tag.ToString() ==
Utils.GetEnumDescription(enmTabsMode.Users)))
1783 {
1784 uc_Users =
((ucUsers)Utils.FindControl(tabs.SelectedTab, "uc_Users")); 1785
1786 bool hasItemSelected =
uc_Users.dgvUsers.SelectedRows.Count > 0;
1787 uc_Users.LoadUsers();
1788 if (!hasItemSelected)
uc_Users.dgvUsers.ClearSelection(); 1789
1790 dgvUsers = ((DataGridView)Utils.FindControl(tabs,
"dgvUsers"));
1791 if (dgvUsers != null)
1792 {
1793 if (dgvUsers.SelectedRows.Count >= 1) 1794
_cmdTabGroupSelectedUsersTools.ContextAvailable = ContextAvailability.Active;
1795 }
1796 }
1797 } 1798
1799 EnableControls();
1800 } 1801
1802 /// <summary>
1803 /// Quando se redimensionou
1804 /// </summary>
1805 /// <param name="sender"></param>
130
1806 /// <param name="e"></param>
1807 private void frmMain_Resize(object sender, EventArgs e)
1808 {
1809 // Maximum splitter for Panel1
1810 splitContainerMain.Panel1MinSize = 250;
1811 if (this.WindowState != FormWindowState.Minimized)
1812 splitContainerMain.Panel2MinSize =
(splitContainerMain.Width / 2 - 2); 1813
1814 EnableControls();
1815 } 1816
1817 /// <summary>
1818 /// Quando se clica com o rato na dgvBooks
1819 /// </summary>
1820 /// <param name="sender"></param>
1821 /// <param name="e"></param>
1822 private void dgvBooks_MouseClick(object sender, MouseEventArgs
e)
1823 {
1824 if (e.Button == MouseButtons.Right)
1825 {
1826 DataGridView dgv = ((DataGridView)sender);
1827 if (dgv != null)
1828 {
1829 System.Drawing.Point p =
dgv.PointToScreen(e.Location);
1830 DataGridView.HitTestInfo dgviti = dgv.HitTest(e.X,
e.Y); 1831
1832 if (dgviti.ColumnIndex >= 0 && dgviti.RowIndex >=
0)
1833 {
1834 dgv.ClearSelection();
1835 dgv.Rows[dgviti.RowIndex].Selected = true;
1836 dgv.Rows[dgviti.RowIndex].Cells[0].Selected =
true;
1837 } 1838
1839 if (dgv.SelectedRows.Count == 1)
1840 { 1841
ribbon1.ShowContextPopup((uint)RibbonMarkupCommands.cmdBooksContextMap, p.X,
p.Y);
1842 }
1843 }
1844 } 1845
1846 EnableControls();
1847 } 1848
1849 /// <summary>
1850 /// Quando se clica com o rato na dgvSearch
1851 /// </summary>
131
1852 /// <param name="sender"></param>
1853 /// <param name="e"></param>
1854 private void dgvSearch_MouseClick(object sender,
MouseEventArgs e)
1855 {
1856 if (e.Button == MouseButtons.Right)
1857 {
1858 DataGridView dgv = ((DataGridView)sender);
1859 if (dgv != null)
1860 {
1861 System.Drawing.Point p =
dgv.PointToScreen(e.Location);
1862 DataGridView.HitTestInfo dgviti = dgv.HitTest(e.X,
e.Y); 1863
1864 if (dgviti.ColumnIndex >= 0 && dgviti.RowIndex >=
0)
1865 {
1866 dgv.ClearSelection();
1867 dgv.Rows[dgviti.RowIndex].Selected = true;
1868 dgv.Rows[dgviti.RowIndex].Cells[0].Selected =
true;
1869 } 1870
1871 if (dgv.SelectedRows.Count == 1)
1872 { 1873
ribbon1.ShowContextPopup((uint)RibbonMarkupCommands.cmdBooksContextMap, p.X,
p.Y);
1874 }
1875 }
1876 } 1877
1878 EnableControls();
1879 } 1880
1881 /// <summary>
1882 /// Quando se clica com o rato na dgvEditors
1883 /// </summary>
1884 /// <param name="sender"></param>
1885 /// <param name="e"></param>
1886 private void dgvEditors_MouseClick(object sender,
MouseEventArgs e)
1887 {
1888 if (e.Button == MouseButtons.Right)
1889 {
1890 DataGridView dgv = ((DataGridView)sender);
1891 if (dgv != null)
1892 {
1893 System.Drawing.Point p =
dgv.PointToScreen(e.Location);
1894 DataGridView.HitTestInfo dgviti = dgv.HitTest(e.X,
e.Y); 1895
132
1896 if (dgviti.ColumnIndex >= 0 && dgviti.RowIndex >=
0)
1897 {
1898 dgv.ClearSelection();
1899 dgv.Rows[dgviti.RowIndex].Selected = true;
1900 dgv.Rows[dgviti.RowIndex].Cells[0].Selected =
true;
1901 } 1902
1903 if (dgv.SelectedRows.Count == 1)
1904 { 1905
ribbon1.ShowContextPopup((uint)RibbonMarkupCommands.cmdEditorsContextMap,
p.X, p.Y);
1906 }
1907 }
1908 } 1909
1910 EnableControls();
1911 } 1912
1913 /// <summary>
1914 /// Quando se clica com o rato na dgvUsers
1915 /// </summary>
1916 /// <param name="sender"></param>
1917 /// <param name="e"></param>
1918 private void dgvUsers_MouseClick(object sender, MouseEventArgs
e)
1919 {
1920 if (e.Button == MouseButtons.Right)
1921 {
1922 DataGridView dgv = ((DataGridView)sender);
1923 if (dgv != null)
1924 {
1925 System.Drawing.Point p =
dgv.PointToScreen(e.Location);
1926 DataGridView.HitTestInfo dgviti = dgv.HitTest(e.X,
e.Y); 1927
1928 if (dgviti.ColumnIndex >= 0 && dgviti.RowIndex >=
0)
1929 {
1930 dgv.ClearSelection();
1931 dgv.Rows[dgviti.RowIndex].Selected = true;
1932 dgv.Rows[dgviti.RowIndex].Cells[0].Selected =
true;
1933 } 1934
1935 if (dgv.SelectedRows.Count == 1)
1936 { 1937
ribbon1.ShowContextPopup((uint)RibbonMarkupCommands.cmdUsersContextMap, p.X,
p.Y);
1938 }
133
1939 }
1940 } 1941
1942 EnableControls();
1943 } 1944
1945 /// <summary>
1946 /// Quando se expande um nó da treeview
1947 /// </summary>
1948 /// <param name="sender"></param>
1949 /// <param name="e"></param>
1950 private void tvCategories_AfterExpand(object sender,
TreeViewEventArgs e)
1951 {
1952 AfterExpand(e.Node);
1953 } 1954
1955 /// <summary>
1956 /// Quando se colapsa um nó da treeview
1957 /// </summary>
1958 /// <param name="sender"></param>
1959 /// <param name="e"></param>
1960 private void tvCategories_AfterCollapse(object sender,
TreeViewEventArgs e)
1961 {
1962 e.Node.ImageIndex = 1;
1963 e.Node.SelectedImageIndex = 1; 1964
1965 EnableControls();
1966 } 1967
1968 /// <summary>
1969 /// Quando se clica com o rato na treeview
1970 /// </summary>
1971 /// <param name="sender"></param>
1972 /// <param name="e"></param>
1973 private void tvCategories_MouseUp(object sender,
MouseEventArgs e)
1974 {
1975 if (e.Button == MouseButtons.Right)
1976 {
1977 TreeView tv = ((TreeView)sender);
1978 System.Drawing.Point p; 1979
1980 p = tv.PointToScreen(e.Location); 1981
1982 TreeViewHitTestInfo tviti = tv.HitTest(e.X, e.Y); 1983
1984 tv.SelectedNode = tviti.Node; 1985
1986 bool buttonsEnabled = (tviti.Node != null);
1987 //Habilitar ou desabilitar os menus: Add Child
Category, Edit Category e Remove Category
134
1988 _cmdButtonAddChildCategory.Enabled = buttonsEnabled;
1989 _cmdButtonEditCategory.Enabled = buttonsEnabled;
1990 _cmdButtonRemoveCategory.Enabled = buttonsEnabled; 1991
1992
ribbon1.ShowContextPopup((uint)RibbonMarkupCommands.cmdCategoriesContextMap,
p.X, p.Y);
1993 } 1994
1995 EnableControls();
1996 } 1997
1998 /// <summary>
1999 /// Quando se seleciona num nó da Treeview
2000 /// </summary>
2001 /// <param name="sender"></param>
2002 /// <param name="e"></param>
2003 private void tvCategories_AfterSelect(object sender,
TreeViewEventArgs e)
2004 {
2005 ucBooks uc_Books = ((ucBooks)Utils.FindControl(tabs,
"uc_Books"));
2006 if (uc_Books != null && tvCategories.SelectedNode != null
&&
typeof(category_info).IsAssignableFrom(tvCategories.SelectedNode.Tag.GetType(
)))
2007 {
2008 uc_Books.category =
((category_info)tvCategories.SelectedNode.Tag).id;
2009 uc_Books.LoadBooks();
2010 } 2011
2012 EnableControls();
2013 } 2014
2015 /// <summary>
2016 /// Quando se clica numa tecla do teclado 'frmMain'
2017 /// </summary>
2018 /// <param name="sender"></param>
2019 /// <param name="e"></param>
2020 private void frmMain_KeyDown(object sender, KeyEventArgs e)
2021 {
2022 if (e.Control && e.KeyCode == Keys.W)
2023 {
2024 e.Handled = e.SuppressKeyPress = true;
2025 _cmdButtonCloseTab_ExecuteEvent(_cmdButtonCloseTab,
null);
2026 } 2027
2028 EnableControls();
2029 } 2030
2031 /// <summary>
2032 /// Quando se clica numa tecla do teclado 'tvCategories'
135
2033 /// </summary>
2034 /// <param name="sender"></param>
2035 /// <param name="e"></param>
2036 private void tvCategories_KeyDown(object sender, KeyEventArgs
e)
2037 {
2038 if (e.KeyCode == Keys.F5)
2039 {
2040 e.Handled = e.SuppressKeyPress = true;
2041 string category_fullpath =
tvCategories.SelectedNode.FullPath;
2042 LoadCategories(tvCategories, -1);
2043 Utils.ExpandTreeByFullPath(this, tvCategories,
category_fullpath);
2044 } 2045
2046 EnableControls();
2047 }
2048 #endregion
2049 }
2050 }
Formulário - frmManBooks.cs 1 using System;
2 using System.Windows.Forms; 3
4 namespace CeliSoft.Software
5 {
6 /// <summary>
7 /// frmManBooks
8 /// Janela de manutenção (e pesquisa) de livros
9 /// </summary>
10 public partial class frmManBooks : Form
11 {
12 #region Variables
13 private int _idCategory = -1;
14 private string _textCategory = string.Empty;
15 private string _category_fullpath = string.Empty;
16 private bool _SearchNow;
17 #endregion 18
19 #region Properties
20 public int idCategory
21 {
22 get { return _idCategory; }
23 set { _idCategory = value; }
24 }
25 public string textCategory
26 {
27 get { return _textCategory; }
28 set { _textCategory = value; }
29 }
136
30 public string category_fullpath
31 {
32 get { return _category_fullpath; }
33 set { _category_fullpath = value; }
34 }
35 public bool SearchNow
36 {
37 get
38 {
39 return _SearchNow;
40 }
41 set
42 {
43 dtpDocDate.ShowCheckBox = value;
44 _SearchNow = value;
45 }
46 }
47 #endregion 48
49 #region Window Constructors
50 /// <summary>
51 /// Construtor
52 /// </summary>
53 public frmManBooks()
54 {
55 InitializeComponent(); 56
57 LoadPublishers();
58 LoadDocTypes();
59 } 60
61 /// <summary>
62 /// Construtor
63 /// </summary>
64 /// <param name="cat_info"></param>
65 public frmManBooks(category_info cat_info)
66 {
67 InitializeComponent(); 68
69 if (cat_info != null)
70 {
71 _idCategory = cat_info.id;
72 _textCategory = cat_info.path;
73 } 74
75 LoadPublishers();
76 LoadDocTypes(); 77
78 txtCategory.Text = _textCategory;
79 }
80 #endregion 81
82 #region Window Load
137
83 /// <summary>
84 /// Window Load Method
85 /// </summary>
86 /// <param name="sender"></param>
87 /// <param name="e"></param>
88 private void frmManBooks_Load(object sender, EventArgs e)
89 { 90
91 if (_SearchNow)
92 {
93 cmbPublishers.Width = cmbDocTypes.Width;
94 btnNewPublisher.Visible = false;
95 }
96 }
97 #endregion 98
99 #region Methods
100 /// <summary>
101 /// Carregamento das editoras
102 /// </summary>
103 private void LoadPublishers()
104 {
105 DS_SQLAccessTableAdapters.EditorsTableAdapter ta = new
DS_SQLAccessTableAdapters.EditorsTableAdapter();
106 DS_SQLAccess.EditorsDataTable dt = ta.GetData_Editors(null,
null); 107
108 cmbPublishers.Items.Clear();
109 cmbPublishers.Items.Add(new ComboBoxItem(-1, ""));
110 cmbPublishers.SelectedIndex = 0;
111 foreach (DS_SQLAccess.EditorsRow row in dt.Rows)
112 cmbPublishers.Items.Add(new ComboBoxItem(row.id,
row.editor));
113 } 114
115 /// <summary>
116 /// Carregamento dos tipos de documentos
117 /// </summary>
118 private void LoadDocTypes()
119 {
120 int[] doc_types_ids = { 1, 2, 3, 4, 5, 6 };
121 string[] doc_types = { "Livro", "Link", "Jornal", "Revista",
"Imagem", "Manuscrito" }; 122
123 cmbDocTypes.Items.Clear();
124 for (int i = 0; i < doc_types_ids.Length; i++)
125 cmbDocTypes.Items.Add(new ComboBoxItem(doc_types_ids[i],
doc_types[i]));
126 cmbDocTypes.SelectedIndex = 0;
127 }
128 #endregion 129
130 #region Controls Methods
138
131 /// <summary>
132 /// Botão de criação de uma nova editora
133 /// </summary>
134 /// <param name="sender"></param>
135 /// <param name="e"></param>
136 private void btnManage_Click(object sender, EventArgs e)
137 {
138 frmManEditors f_editors = new frmManEditors();
139 f_editors.Text = "Adicionar Editor";
140 f_editors.txtEditor.Focus();
141 f_editors.btnOK.Text = "Adicionar";
142 if (f_editors.ShowDialog() == DialogResult.OK)
143 {
144 DS_SQLAccessTableAdapters.EditorsTableAdapter ta = new
DS_SQLAccessTableAdapters.EditorsTableAdapter();
145 DS_SQLAccess.EditorsDataTable dt =
ta.GetData_Editors(null, null); 146
147 DS_SQLAccess.EditorsRow new_row = dt.NewEditorsRow();
148 new_row.editor = f_editors.txtEditor.Text; 149
150 dt.Rows.Add(new_row); 151
152 int ret = ta.Update(dt); 153
154 if (ret == 1)
155 {
156 int old_ID = -1;
157 if (cmbPublishers.SelectedItem != null)
158 old_ID =
((ComboBoxItem)cmbPublishers.SelectedItem).ID; 159
160 LoadPublishers(); 161
162 Utils.SelectComboboxItem(cmbPublishers, new_row.id);
163 }
164 }
165 } 166
167 /// <summary>
168 /// Quando se muda de tipo de documento na combo
169 /// </summary>
170 /// <param name="sender"></param>
171 /// <param name="e"></param>
172 private void cmbDocTypes_SelectedIndexChanged(object sender,
EventArgs e)
173 {
174 int docTypeSelected =
((ComboBoxItem)cmbDocTypes.SelectedItem).ID; 175
176 cmbPublishers.Enabled = (docTypeSelected == 1);
177 txtDocSource.Enabled = (docTypeSelected == 2); 178
179 btnNewPublisher.Enabled = cmbPublishers.Enabled;
139
180
181 if (docTypeSelected != 1)
182 cmbPublishers.SelectedIndex = -1;
183 if (docTypeSelected != 2)
184 txtDocSource.Text = string.Empty;
185 } 186
187 /// <summary>
188 /// Quando se deseja mudar de categoria
189 /// </summary>
190 /// <param name="sender"></param>
191 /// <param name="e"></param>
192 private void btnSelectCategory_Click(object sender, EventArgs e)
193 {
194 frmSelectCategory f_select = new frmSelectCategory(); 195
196 f_select.category_path = category_fullpath;
197 Utils.ExpandTreeByFullPath(((frmMain)this.Owner),
f_select.tvCategories, category_fullpath); 198
199 if (f_select.ShowDialog() == DialogResult.OK)
200 {
201 idCategory = f_select.selected_id;
202 textCategory = f_select.selected_category; 203
204 txtCategory.Text = f_select.selected_category; 205
206 category_fullpath =
f_select.tvCategories.SelectedNode.FullPath;
207 }
208 } 209
210 /// <summary>
211 /// Botão de efetivar a operação
212 /// </summary>
213 /// <param name="sender"></param>
214 /// <param name="e"></param>
215 private void btnOK_Click(object sender, EventArgs e)
216 {
217 // Obrigatoriedade de preenchimento de campos 218
219 int docTypeSelected = -1;
220 int editorSelected = -1; 221
222 if (SearchNow == false)
223 {
224 docTypeSelected =
((ComboBoxItem)cmbDocTypes.SelectedItem).ID; 225
226 if (cmbPublishers.SelectedItem != null)
227 editorSelected =
((ComboBoxItem)cmbPublishers.SelectedItem).ID; 228
229 if (string.IsNullOrEmpty(txtReference.Text) ||
140
230 string.IsNullOrEmpty(txtTitle.Text) ||
231 string.IsNullOrEmpty(txtAuthor.Text) ||
232 (docTypeSelected == 1 && cmbPublishers.SelectedIndex
== 0) ||
233 (docTypeSelected == 2 &&
string.IsNullOrEmpty(txtDocSource.Text)) ||
234 idCategory == -1 ||
235 string.IsNullOrEmpty(txtResume.Text))
236 {
237 MessageBox.Show("Tem de preencher os campos em
falta.", "Novo Livro", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
238 DialogResult = DialogResult.None;
239 return;
240 }
241 }
242 } 243
244 /// <summary>
245 /// Foco no campo Resumo
246 /// </summary>
247 /// <param name="sender"></param>
248 /// <param name="e"></param>
249 private void txtResume_Enter(object sender, EventArgs e)
250 {
251 this.AcceptButton = null;
252 } 253
254 /// <summary>
255 /// Perda de foco do campo Resumo
256 /// </summary>
257 /// <param name="sender"></param>
258 /// <param name="e"></param>
259 private void txtResume_Leave(object sender, EventArgs e)
260 {
261 this.AcceptButton = btnOK;
262 }
263 #endregion
264 }
265 }
Formulário - frmManCategories.cs 1 using System;
2 using System.Collections.Generic;
3 using System.ComponentModel;
4 using System.Data;
5 using System.Drawing;
6 using System.Linq;
7 using System.Text;
8 using System.Windows.Forms; 9
10 namespace CeliSoft.Software
11 {
141
12 /// <summary>
13 /// frmManCategories
14 /// Janela de manutenção de categorias
15 /// </summary>
16 public partial class frmManCategories : Form
17 {
18 #region Window Constructor
19 public frmManCategories()
20 {
21 InitializeComponent();
22 }
23 #endregion 24
25 #region Controls Methods
26 private void btnOK_Click(object sender, EventArgs e)
27 {
28 // Obrigatoriedade de preenchimento de campos
29 if (string.IsNullOrEmpty(txtCategory.Text))
30 {
31 MessageBox.Show("O campo 'Categoria' tem de estar
preenchido.", "Nova Categoria", MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
32 DialogResult = DialogResult.None;
33 return;
34 }
35 }
36 #endregion
37 }
38 }
Formulário - frmManEditors.cs 1 using System;
2 using System.Windows.Forms; 3
4 namespace CeliSoft.Software
5 {
6 /// <summary>
7 /// frmManEditors
8 /// Janela de manutenção de editoras
9 /// </summary>
10 public partial class frmManEditors : Form
11 {
12 #region Window Constructor
13 public frmManEditors()
14 {
15 InitializeComponent();
16 }
17 #endregion 18
19 #region Controls Methods
20 private void btnOK_Click(object sender, EventArgs e)
21 {
142
22 // Obrigatoriedade de preenchimento de campos
23 if (string.IsNullOrEmpty(txtEditor.Text))
24 {
25 MessageBox.Show("O campo 'Editora' tem de estar
preenchido.", "Nova Editora", MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
26 DialogResult = DialogResult.None;
27 return;
28 }
29 }
30 #endregion
31 }
32 }
Formulário - frmManUsers.cs 1 using System;
2 using System.Collections.Generic;
3 using System.ComponentModel;
4 using System.Data;
5 using System.Drawing;
6 using System.Linq;
7 using System.Text;
8 using System.Windows.Forms; 9
10 namespace CeliSoft.Software 11 {
12 /// <summary>
13 /// frmManUsers
14 /// Janela de manutenção de utilizadores
15 /// </summary>
16 public partial class frmManUsers : Form
17 {
18 #region Window Constructor
19 public frmManUsers()
20 {
21 InitializeComponent(); 22
23 LoadUserTypes();
24 }
25 #endregion 26
27 #region Methods
28 public void LoadUserTypes()
29 {
30 int[] doc_types_ids = { 1, 2 };
31 string[] doc_types = { "Administrador", "Utilizador" }; 32
33 cmbUserType.Items.Clear();
34 for (int i = 0; i < doc_types_ids.Length; i++)
35 cmbUserType.Items.Add(new ComboBoxItem(doc_types_ids[i],
doc_types[i]));
36 cmbUserType.SelectedIndex = 0;
143
37 }
38 #endregion 39
40 #region Controls Methods
41 private void btnOK_Click(object sender, EventArgs e)
42 {
43 // Obrigatoriedade de preenchimento de campos 44
45 if (txtUsername.Text.IndexOf(@"\") < 0)
46 {
47 MessageBox.Show("O campo 'Utilizador' tem de ser um
utilizador de domínio com o formato Domínio\\Utilizador.", "Novo Utilizador",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
48 DialogResult = DialogResult.None;
49 return;
50 } 51
52 DS_SQLAccessTableAdapters.UsersTableAdapter ta = new
DS_SQLAccessTableAdapters.UsersTableAdapter();
53 DS_SQLAccess.UsersDataTable dt = ta.GetData_Users(null,
txtUsername.Text, null); 54
55 if (dt.Rows.Count > 0)
56 {
57 MessageBox.Show("O utilizador '" + txtUsername.Text + "'
já se encontra registado.", "Novo Utilizador", MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
58 DialogResult = DialogResult.None;
59 return;
60 }
61 }
62 #endregion
63 }
64 }
Formulário - frmSelectCategory.cs 1 using System.Drawing;
2 using System.Threading;
3 using System.Windows.Forms; 4
5 namespace CeliSoft.Software
6 {
7 /// <summary>
8 /// frmSelectCategory
9 /// Janela de seleção de categoria
10 /// </summary>
11 public partial class frmSelectCategory : Form
12 {
13 #region Variables
14 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta = new
DS_SQLAccessTableAdapters.CategoriesTableAdapter();
15 DS_SQLAccess.CategoriesDataTable dt = null; 16
144
17 private int _selected_id;
18 private string _selected_category;
19 private string _category_path;
20 public frmMain f_main;
21 #endregion 22
23 #region Properties
24 public int selected_id
25 {
26 get { return _selected_id; }
27 set { _selected_id = value; }
28 }
29 public string selected_category
30 {
31 get { return _selected_category; }
32 set { _selected_category = value; }
33 }
34 public string category_path
35 {
36 get { return _category_path; }
37 set { _category_path = value; }
38 }
39 #endregion 40
41 #region Window Constructors
42 public frmSelectCategory()
43 {
44 InitializeComponent(); 45
46 InitializeWindow(null);
47 }
48 public frmSelectCategory(int selected_id)
49 {
50 InitializeComponent(); 51
52 InitializeWindow(selected_id);
53 }
54 #endregion 55
56 #region Methods
57 public void InitializeWindow(int? selected_id)
58 {
59 if (selected_id != null)
60 { 61
DS_SQLAccessTableAdapters.Categories_GetCategoriesPathTableAdapter ta = new
DS_SQLAccessTableAdapters.Categories_GetCategoriesPathTableAdapter();
62 DS_SQLAccess.Categories_GetCategoriesPathDataTable dt =
ta.GetData_GetCategoriesPath(selected_id); 63
64 DS_SQLAccess.Categories_GetCategoriesPathRow row =
((DS_SQLAccess.Categories_GetCategoriesPathRow)dt.Rows[0]); 65
145
66 if (row != null)
67 {
68 category_path = row.fullpath;
69 }
70 }
71 }
72 private void LoadCategories(object obj, int parent_id)
73 {
74 Application.DoEvents(); 75
76 Thread.Sleep(500); 77
78 dt = ta.GetData_Categories(null, parent_id, null); 79
80 if (dt.Rows.Count == 0)
81 {
82 if (typeof(TreeNode).IsAssignableFrom(obj.GetType()))
83 ((TreeNode)obj).Collapse();
84 } 85
86 if (typeof(TreeView).IsAssignableFrom(obj.GetType()))
87 ((TreeView)obj).Nodes.Clear();
88 if (typeof(TreeNode).IsAssignableFrom(obj.GetType()))
89 ((TreeNode)obj).Nodes.Clear(); 90
91 foreach (DS_SQLAccess.CategoriesRow row in dt.Rows)
92 {
93 TreeNode node = null;
94 TreeNode node_load = new TreeNode("A carregar..."); 95
96 if (typeof(TreeView).IsAssignableFrom(obj.GetType()))
97 node = ((TreeView)obj).Nodes.Add(row.path);
98 if (typeof(TreeNode).IsAssignableFrom(obj.GetType()))
99 node = ((TreeNode)obj).Nodes.Add(row.path); 100
101 node.ImageIndex = 1;
102 node.SelectedImageIndex = 1; 103
104 node_load.Tag = "loading";
105 node_load.ForeColor = Color.FromArgb(143, 156, 171);
106 if (row.id > 1)
107 node.Nodes.Add(node_load);
108 else
109 {
110 node.ImageIndex = 3;
111 node.SelectedImageIndex = 3;
112 } 113
114 node.Tag = new category_info(row.id, row.id_parent,
row.path); 115
116 if (category_path != null)
117 {
146
118 if (category_path.IndexOf(@"\") > 0)
119 {
120 if (row.path == category_path.Substring(0,
category_path.IndexOf(@"\")))
121 {
122 category_path =
category_path.Substring(category_path.IndexOf(@"\") + 1);
123 node.Expand();
124 }
125 }
126 else
127 {
128 if (row.path == category_path)
129 tvCategories.SelectedNode = node;
130 }
131 }
132 }
133 }
134 #endregion 135
136 #region Control Methods
137 /// <summary>
138 /// Quando se expande um nó da treeview de categorias
139 /// </summary>
140 /// <param name="sender"></param>
141 /// <param name="e"></param>
142 private void tvCategories_AfterExpand(object sender,
TreeViewEventArgs e)
143 {
144 bool collapsed = false;
145 if (e.Node.Nodes.Count == 1 &&
e.Node.Nodes[0].Tag.ToString() == "loading")
146 {
147 LoadCategories(e.Node, ((category_info)e.Node.Tag).id);
148 if (e.Node.Nodes.Count == 0)
149 {
150 e.Node.Expand();
151 e.Node.Collapse();
152 collapsed = true;
153 }
154 } 155
156 if (collapsed)
157 {
158 e.Node.ImageIndex = 1;
159 e.Node.SelectedImageIndex = 1;
160 }
161 else
162 {
163 e.Node.ImageIndex = 2;
164 e.Node.SelectedImageIndex = 2;
165 }
166 }
147
167
168 /// <summary>
169 /// Quando se colapsa um nó da treeview de categorias
170 /// </summary>
171 /// <param name="sender"></param>
172 /// <param name="e"></param>
173 private void tvCategories_AfterCollapse(object sender,
TreeViewEventArgs e)
174 {
175 e.Node.ImageIndex = 1;
176 e.Node.SelectedImageIndex = 1;
177 } 178
179 /// <summary>
180 /// Quando se clica com o rato na treeview de categorias
181 /// </summary>
182 /// <param name="sender"></param>
183 /// <param name="e"></param>
184 private void tvCategories_MouseUp(object sender, MouseEventArgs
e)
185 {
186 if (e.Button == MouseButtons.Right)
187 {
188 TreeView tv = ((TreeView)sender);
189 System.Drawing.Point p; 190
191 p = tv.PointToScreen(e.Location); 192
193 TreeViewHitTestInfo tviti = tv.HitTest(e.X, e.Y); 194
195 tv.SelectedNode = tviti.Node;
196 }
197 } 198
199 /// <summary>
200 /// Quando se seleciona um nó da treeview de categorias
201 /// </summary>
202 /// <param name="sender"></param>
203 /// <param name="e"></param>
204 private void tvCategories_AfterSelect(object sender,
TreeViewEventArgs e)
205 {
206 selected_id = -1;
207 selected_category = string.Empty; 208
209 if (tvCategories.SelectedNode != null)
210 {
211 if
(typeof(category_info).IsAssignableFrom(tvCategories.SelectedNode.Tag.GetType
()))
212 {
213 category_info cat_info =
((category_info)tvCategories.SelectedNode.Tag);
148
214 selected_id = cat_info.id;
215 selected_category = cat_info.path;
216 }
217 }
218 } 219
220 /// <summary>
221 /// Carregamento da Janela
222 /// </summary>
223 /// <param name="sender"></param>
224 /// <param name="e"></param>
225 private void frmSelectCategory_Load(object sender,
System.EventArgs e)
226 {
227 Application.DoEvents(); 228
229 // Load categories
230 LoadCategories(tvCategories, -1); 231
232 Utils.ExpandTreeByFullPath(f_main, tvCategories,
category_path);
233 }
234 #endregion
235 }
236 }
Formulário - frmSplash.cs 1 using System;
2 using System.Drawing;
3 using System.Windows.Forms;
4 using System.Drawing.Text; 5
6 namespace CeliSoft.Software
7 {
8 /// <summary>
9 /// frmSplash
10 /// Serve para mostrar um primeiro logotipo antes da aplicação em
si iniciar
11 /// </summary>
12 public partial class frmSplash : Form
13 {
14 #region Window Constructor
15 public frmSplash()
16 {
17 InitializeComponent(); 18
19 // Imagema desenhar
20 Image img =
(Image)Properties.Resources.DigitalLibrary_SplashScreen; 21
22 // Iniciar um objeto de desenho
23 Graphics grf = Graphics.FromImage(img);
149
24 grf.SmoothingMode =
System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
25 grf.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
26 grf.DrawImage(img, new Point(0, 0)); 27
28 // Desenhar o texto da versão
29 SizeF versionSize = grf.MeasureString("Versão: " +
Utils.ProductVersion, new Font("Segoe UI", 15, FontStyle.Bold));
30 float x = 360;
31 float y = 154;
32 grf.DrawString("Versão: " + Utils.ProductVersion, new
Font("Segoe UI", 15, FontStyle.Bold), Brushes.White, new PointF(x + 1, y +
1));
33 grf.DrawString("Versão: " + Utils.ProductVersion, new
Font("Segoe UI", 15, FontStyle.Bold), Brushes.Black, new PointF(x, y)); 34
35 // Inicializar a form que possibilita a transparência da
janela
36 alphaFormTransformer1.BackgroundImage = img;
37 alphaFormTransformer1.TransformForm(255); 38
39 // Libertação de memória
40 img.Dispose();
41 img = null;
42 }
43 #endregion 44
45 #region Controls Methods
46 private void tmrClose_Tick(object sender, EventArgs e)
47 {
48 // Passados os x segundos, fechar esta janela
49 this.Close();
50 }
51 #endregion
52 }
53 }
Classe - RibbonContextMenuStrip.cs 1 using RibbonLib;
2 using System.ComponentModel;
3 using System.Windows.Forms; 4
5 namespace CeliSoft.Software
6 {
7 /// <summary>
8 /// RibbonContextMenuStrip
9 /// Serve para possibilitar usar os menus de contexto da Ribbon
10 /// </summary>
11 public class RibbonContextMenuStrip : ContextMenuStrip
12 {
13 #region Variables
14 private uint _contextPopupID;
150
15 private Ribbon _ribbon;
16 #endregion 17
18 #region Class Constructor
19 public RibbonContextMenuStrip(Ribbon ribbon, uint contextPopupID)
20 : base()
21 {
22 _contextPopupID = contextPopupID;
23 _ribbon = ribbon;
24 }
25 #endregion 26
27 #region Override OnOpening
28 protected override void OnOpening(CancelEventArgs e)
29 {
30 _ribbon.ShowContextPopup(_contextPopupID, Cursor.Position.X,
Cursor.Position.Y);
31 e.Cancel = true;
32 }
33 #endregion
34 }
35 }
Controlo - ucBooks.cs 1 using System;
2 using System.Drawing;
3 using System.Windows.Forms; 4
5 namespace CeliSoft.Software
6 {
7 /// <summary>
8 /// Controlo ucBooks
9 /// Serve para listar e tratar dos registos dos livros
10 /// </summary>
11 public partial class ucBooks : UserControl
12 {
13 // A delegate type for hooking up change notifications.
14 public delegate void SelectedItemEventHandler(object sender,
SelectedEventArgs e); 15
16 #region Variables
17 public event SelectedItemEventHandler ItemSelected; 18
19 public bool loading_datagrid = true; 20
21 private string _reference = null;
22 private string _title = null;
23 private string _author = null;
24 private int? _publisher = null;
25 private int? _doc_type = null;
26 private string _doc_source = null;
27 private DateTime? _doc_date = null;
151
28 private int? _category = null;
29 private string _resume = null;
30 private bool _SearchNow; 31
32 private Image _selectedCover;
33 private byte[] _selectedFile;
34 private bool _hasFile;
35 private bool _filtered; 36
37 string ids = string.Empty;
38 #endregion 39
40 #region Properties
41 public string reference
42 {
43 get { return _reference; }
44 set { _reference = value; }
45 }
46 public string title
47 {
48 get { return _title; }
49 set { _title = value; }
50 }
51 public string author
52 {
53 get { return _author; }
54 set { _author = value; }
55 }
56 public int? publisher
57 {
58 get { return _publisher; }
59 set { _publisher = value; }
60 }
61 public int? doc_type
62 {
63 get { return _doc_type; }
64 set { _doc_type = value; }
65 }
66 public string doc_source
67 {
68 get { return _doc_source; }
69 set { _doc_source = value; }
70 }
71 public DateTime? doc_date
72 {
73 get { return _doc_date; }
74 set { _doc_date = value; }
75 }
76 public int? category
77 {
78 get { return _category; }
79 set { _category = value; }
80 }
152
81 public string resume
82 {
83 get { return _resume; }
84 set { _resume = value; }
85 }
86 public bool SearchNow
87 {
88 get
89 {
90 return _SearchNow;
91 }
92 set
93 {
94 tmrOpenSearch.Enabled = value;
95 _SearchNow = value;
96 }
97 } 98
99 private bool GetIfFiltered
100 {
101 get
102 {
103 return reference != null ||
104 title != null ||
105 author != null ||
106 publisher != null ||
107 doc_type != null ||
108 doc_source != null ||
109 doc_date != null ||
110 category != null ||
111 resume != null;
112 }
113 } 114
115 public Image selectedCover
116 {
117 get { return _selectedCover; }
118 set { _selectedCover = value; }
119 }
120 public byte[] selectedFile
121 {
122 get { return _selectedFile; }
123 set { _selectedFile = value; }
124 }
125 public bool hasFile
126 {
127 get { return _hasFile; }
128 set { _hasFile = value; }
129 }
130 public bool filtered
131 {
132 get { return _filtered; }
133 set { _filtered = value; }
153
134 }
135 #endregion 136
137 #region Window Constructor
138 /// <summary>
139 /// Constructor
140 /// </summary>
141 public ucBooks()
142 {
143 InitializeComponent();
144 }
145 #endregion 146
147 #region Methods
148 /// <summary>
149 /// Carregar Livros
150 /// </summary>
151 public void LoadBooks()
152 {
153 DS_SQLAccessTableAdapters.Books_SearchTableAdapter ta = new
DS_SQLAccessTableAdapters.Books_SearchTableAdapter();
154 DS_SQLAccess.Books_SearchDataTable dt =
ta.GetData_BooksSearch(reference, title, author, publisher, doc_type,
doc_source, doc_date, category, resume); 155
156 dgvBooks.DataSource = dt; 157
158 dgvBooks.Columns[8].Visible = false; 159
160 if (SearchNow)
161 {
162 lblNoRowsFound.Text = "Não foram encontrados
registos.\r\nPesquise de novo.";
163 lblNoRowsFound.Visible = (dt.Rows.Count == 0);
164 }
165 }
166 #endregion 167
168 #region Controls Methods
169 /// <summary>
170 /// Window Load Method
171 /// </summary>
172 /// <param name="sender"></param>
173 /// <param name="e"></param>
174 private void ucSearchBooks_Load(object sender, EventArgs e)
175 {
176 LoadBooks(); 177
178 picCover.Image = (Image)Properties.Resources.NoBookCover; 179
180 tmrOpenSearch.Enabled = true;
181 } 182
154
183 /// <summary>
184 /// Quando se clica com o rato na datagridview dgvBooks
185 /// </summary>
186 /// <param name="sender"></param>
187 /// <param name="e"></param>
188 private void dgvBooks_MouseUp(object sender, MouseEventArgs e)
189 {
190 if (dgvBooks.HitTest(e.X, e.Y).ColumnIndex < 0 &&
191 dgvBooks.HitTest(e.X, e.Y).RowIndex < 0)
192 {
193 dgvBooks.ClearSelection();
194 }
195 } 196
197 /// <summary>
198 /// Quando se muda de seleção de items na datagridview
dgvBooks
199 /// </summary>
200 /// <param name="sender"></param>
201 /// <param name="e"></param>
202 private void dgvBooks_SelectionChanged(object sender, EventArgs
e)
203 {
204 bool selected = (dgvBooks.SelectedRows.Count >= 1); 205
206 if (ItemSelected != null) // && !(Utils.RemovingTab ==
Utils.GetEnumDescription(frmMain.enmTabsMode.Books)))
207 ItemSelected(this, new SelectedEventArgs(selected,
(selected ? dgvBooks.SelectedRows[0].Index : -1))); 208
209 _hasFile = false;
210 if (selected)
211 {
212 //Obter o ID do livro selecionado
213 DataGridViewRow selected_row =
((DataGridViewRow)dgvBooks.SelectedRows[0]);
214 int id = Convert.ToInt32(selected_row.Cells[0].Value); 215
216 DS_SQLAccessTableAdapters.BooksTableAdapter ta = new
DS_SQLAccessTableAdapters.BooksTableAdapter();
217 DS_SQLAccess.BooksDataTable dt = ta.GetData_Books(id,
null, null, null, null, null, null, null, null, null); 218
219 DS_SQLAccess.BooksRow row_book =
((DS_SQLAccess.BooksRow)dt.Rows[0]); 220
221 if (row_book.IscoverNull() == false)
222 {
223 Image img =
Utils.ObterImagemDeArrayBytes(row_book.cover);
224 _selectedCover = img;
225 }
226 else
155
227 {
228 _selectedCover = Properties.Resources.NoBookCover;
229 } 230
231 if (row_book.IsfileNull() == false)
232 _hasFile = row_book.file.Length > 0; 233
234 lblReference.Text = row_book.ref_code;
235 lblTitle.Text = row_book.title;
236 lblAuthor.Text = row_book.author;
237 lblDocType.Text =
Utils.GetDocTypeTextByID(row_book.doc_type);
238 lblCategory.Text =
Utils.GetCategoryTextByID(row_book.category);
239 lblEditor.Text = (row_book.IseditorNull() ? string.Empty
: Utils.GetEditorTextByID(row_book.editor));
240 lblDocSource.Text = (row_book.Isdoc_sourceNull() ?
string.Empty : row_book.doc_source);
241 lblDocDate.Text = string.Format("{0:dd-MM-yyyy}",
row_book.doc_date);
242 lblResume.Text = row_book.book_resume;
243 }
244 else
245 {
246 _selectedCover = Properties.Resources.NoBookCover; 247
248 lblReference.Text = string.Empty;
249 lblTitle.Text = string.Empty;
250 lblAuthor.Text = string.Empty;
251 lblDocType.Text = string.Empty;
252 lblCategory.Text = string.Empty;
253 lblEditor.Text = string.Empty;
254 lblDocSource.Text = string.Empty;
255 lblDocDate.Text = string.Empty;
256 lblResume.Text = string.Empty;
257 } 258
259 picCover.Image = _selectedCover;
260 picHasFile.Visible = _hasFile; 261
262 pnlDetails.Refresh();
263 } 264
265 /// <summary>
266 /// Quando se ordena por coluna na datagridview dgvBooks
267 /// </summary>
268 /// <param name="sender"></param>
269 /// <param name="e"></param>
270 private void dgvBooks_ColumnHeaderMouseClick(object sender,
DataGridViewCellMouseEventArgs e)
271 {
272 dgvBooks.ClearSelection();
273 foreach (DataGridViewRow row in dgvBooks.Rows)
156
274 {
275 if (ids == (row.Cells[0].Value.ToString() +
276 row.Cells[1].Value.ToString() +
277 row.Cells[2].Value.ToString() +
278 row.Cells[3].Value.ToString()))
279 {
280 row.Cells[1].Selected = true;
281 row.Selected = true;
282 }
283 }
284 } 285
286 /// <summary>
287 /// Quando se clica com o rato na datagridview dgvBooks
288 /// </summary>
289 /// <param name="sender"></param>
290 /// <param name="e"></param>
291 private void dgvBooks_MouseDown(object sender, MouseEventArgs e)
292 {
293 if (dgvBooks.SelectedRows.Count > 0)
294 {
295 ids = dgvBooks.SelectedRows[0].Cells[0].Value.ToString()
+
296 dgvBooks.SelectedRows[0].Cells[1].Value.ToString()
+
297 dgvBooks.SelectedRows[0].Cells[2].Value.ToString()
+ 298
dgvBooks.SelectedRows[0].Cells[3].Value.ToString();
299 }
300 } 301
302 /// <summary>
303 /// Quando se clica com o teclado na datagridview dgvBooks
304 /// </summary>
305 /// <param name="sender"></param>
306 /// <param name="e"></param>
307 private void dgvBooks_KeyDown(object sender, KeyEventArgs e)
308 {
309 switch (e.KeyCode)
310 {
311 case Keys.F5:
312 LoadBooks();
313 break;
314 default:
315 break;
316 }
317 } 318
319 /// <summary>
320 /// Quando a datagridview dgvBooks terminou o carregamento
321 /// </summary>
322 /// <param name="sender"></param>
157
323 /// <param name="e"></param>
324 private void dgvBooks_DataBindingComplete(object sender,
DataGridViewBindingCompleteEventArgs e)
325 {
326 loading_datagrid = false;
327 } 328
329 /// <summary>
330 /// Quando o controlo redimensionou
331 /// </summary>
332 /// <param name="sender"></param>
333 /// <param name="e"></param>
334 private void ucBooks_Resize(object sender, EventArgs e)
335 {
336 pnlDetails.Refresh();
337 } 338
339 /// <summary>
340 /// Quando a pesquisa for chamada, abrir a janela de
filtragem
341 /// </summary>
342 /// <param name="sender"></param>
343 /// <param name="e"></param>
344 private void tmrOpenSearch_Tick(object sender, EventArgs e)
345 {
346 tmrOpenSearch.Enabled = false;
347 if (SearchNow)
348 {
349 frmManBooks f_newBook = new frmManBooks();
350 f_newBook.Icon = Properties.Resources.Search;
351 f_newBook.Text = "Procurar Livros";
352 f_newBook.btnOK.Text = "Procurar";
353 f_newBook.SearchNow = true;
354 f_newBook.cmbDocTypes.Items.Insert(0, new ComboBoxItem(-
1, ""));
355 f_newBook.cmbDocTypes.SelectedIndex = 0;
356 if (f_newBook.ShowDialog() == DialogResult.OK)
357 {
358 if
(string.IsNullOrEmpty(f_newBook.txtReference.Text) == false) reference = "%"
+ f_newBook.txtReference.Text + "%";
359 if (string.IsNullOrEmpty(f_newBook.txtTitle.Text) ==
false) title = "%" + f_newBook.txtTitle.Text + "%";
360 if (string.IsNullOrEmpty(f_newBook.txtAuthor.Text)
== false) author = "%" + f_newBook.txtAuthor.Text + "%";
361 if (f_newBook.cmbPublishers.SelectedItem != null &&
((ComboBoxItem)f_newBook.cmbPublishers.SelectedItem).ID >= 0) publisher =
((ComboBoxItem)f_newBook.cmbPublishers.SelectedItem).ID;
362 if (f_newBook.cmbDocTypes.SelectedItem != null &&
((ComboBoxItem)f_newBook.cmbDocTypes.SelectedItem).ID >= 0) doc_type =
((ComboBoxItem)f_newBook.cmbDocTypes.SelectedItem).ID;
158
363 if
(string.IsNullOrEmpty(f_newBook.txtDocSource.Text) == false) doc_source = "%"
+ f_newBook.txtDocSource.Text + "%";
364 if (f_newBook.dtpDocDate.Checked) doc_date =
f_newBook.dtpDocDate.Value;
365 if (f_newBook.idCategory > -1) category =
f_newBook.idCategory;
366 if (string.IsNullOrEmpty(f_newBook.txtResume.Text)
== false) resume = "%" + f_newBook.txtResume.Text + "%"; 367
368 filtered = GetIfFiltered; 369
370 LoadBooks(); 371
372 reference = null;
373 title = null;
374 author = null;
375 publisher = null;
376 doc_type = null;
377 doc_source = null;
378 doc_date = null;
379 category = null;
380 resume = null;
381 }
382 }
383 }
384 #endregion
385 }
386 }
Controlo - ucEditors.cs 1 using System;
2 using System.Collections.Generic;
3 using System.ComponentModel;
4 using System.Drawing;
5 using System.Data;
6 using System.Linq;
7 using System.Text;
8 using System.Windows.Forms; 9
10 namespace CeliSoft.Software
11 {
12 /// <summary>
13 /// Controlo ucEditors
14 /// Serve para listar e tratar dos registos das editoras
15 /// </summary>
16 public partial class ucEditors : UserControl
17 {
18 // A delegate type for hooking up change notifications.
19 public delegate void SelectedItemEventHandler(object sender,
SelectedEventArgs e); 20
159
21 #region Variables
22 public event SelectedItemEventHandler ItemSelected; 23
24 string ids = string.Empty;
25 #endregion 26
27 #region Window Constructor
28 /// <summary>
29 /// Constructor
30 /// </summary>
31 public ucEditors()
32 {
33 InitializeComponent();
34 }
35 #endregion 36
37 #region Methods
38 public void LoadEditors()
39 {
40 string editor = (txtEditor.Text.Trim() == string.Empty ?
null : "%" + txtEditor.Text + "%"); 41
42 DS_SQLAccessTableAdapters.EditorsSearchTableAdapter ta = new
DS_SQLAccessTableAdapters.EditorsSearchTableAdapter();
43 DS_SQLAccess.EditorsSearchDataTable dt =
ta.GetData_EditorsSearch(editor); 44
45 dgvEditors.DataSource = dt;
46 }
47 #endregion 48
49 #region Controls Methods
50 /// <summary>
51 /// Filtragem das editoras
52 /// </summary>
53 /// <param name="sender"></param>
54 /// <param name="e"></param>
55 private void btnSearch_Click(object sender, EventArgs e)
56 {
57 LoadEditors();
58 btnClearSearch.Enabled = true;
59 } 60
61 /// <summary>
62 /// Quando se clica com o rato na datagridview dgvSearch
63 /// </summary>
64 /// <param name="sender"></param>
65 /// <param name="e"></param>
66 private void dgvEditors_MouseUp(object sender, MouseEventArgs e)
67 {
68 if (dgvEditors.HitTest(e.X, e.Y).ColumnIndex < 0 &&
69 dgvEditors.HitTest(e.X, e.Y).RowIndex < 0)
70 {
160
71 dgvEditors.ClearSelection();
72 }
73 } 74
75 /// <summary>
76 /// Quando se muda de seleção de items na datagridview
dgvSearch
77 /// </summary>
78 /// <param name="sender"></param>
79 /// <param name="e"></param>
80 private void dgvEditors_SelectionChanged(object sender,
EventArgs e)
81 {
82 bool selected = (dgvEditors.SelectedRows.Count >= 1); 83
84 if (ItemSelected != null && !(Utils.RemovingTab ==
Utils.GetEnumDescription(frmMain.enmTabsMode.Editors)))
85 ItemSelected(this, new SelectedEventArgs(selected,
(selected? dgvEditors.SelectedRows[0].Index : -1)));
86 } 87
88 /// <summary>
89 /// Quando se deseja limpar o filtro
90 /// </summary>
91 /// <param name="sender"></param>
92 /// <param name="e"></param>
93 private void btnClearSearch_Click(object sender, EventArgs e)
94 {
95 txtEditor.Text = string.Empty;
96 btnSearch_Click(btnSearch, null);
97 btnClearSearch.Enabled = false;
98 } 99
100 /// <summary>
101 /// Quando se carrega todo o código inicial
102 /// </summary>
103 /// <param name="sender"></param>
104 /// <param name="e"></param>
105 private void ucEditors_Load(object sender, EventArgs e)
106 {
107 LoadEditors();
108 } 109
110 /// <summary>
111 /// Quando se ordena por coluna na datagridview dgvSearch
112 /// </summary>
113 /// <param name="sender"></param>
114 /// <param name="e"></param>
115 private void dgvEditors_ColumnHeaderMouseClick(object sender,
DataGridViewCellMouseEventArgs e)
116 {
117 dgvEditors.ClearSelection();
118 foreach (DataGridViewRow row in dgvEditors.Rows)
161
119 {
120 if (ids == (row.Cells[0].Value.ToString() +
121 row.Cells[1].Value.ToString()))
122 {
123 row.Cells[1].Selected = true;
124 row.Selected = true;
125 }
126 }
127 } 128
129 /// <summary>
130 /// Quando se clica com o rato na datagridview dgvSearch
131 /// </summary>
132 /// <param name="sender"></param>
133 /// <param name="e"></param>
134 private void dgvEditors_MouseDown(object sender, MouseEventArgs
e)
135 {
136 if (dgvEditors.SelectedRows.Count > 0)
137 {
138 ids =
dgvEditors.SelectedRows[0].Cells[0].Value.ToString() + 139
dgvEditors.SelectedRows[0].Cells[1].Value.ToString();
140 }
141 } 142
143 /// <summary>
144 /// Quando se clica com o teclado na datagridview dgvSearch
145 /// </summary>
146 /// <param name="sender"></param>
147 /// <param name="e"></param>
148 private void dgvEditors_KeyDown(object sender, KeyEventArgs e)
149 {
150 switch (e.KeyCode)
151 {
152 case Keys.F5:
153 LoadEditors();
154 break;
155 default:
156 break;
157 }
158 }
159 #endregion
160 }
161 }
Controlo - ucUsers.cs 1 using System;
2 using System.Windows.Forms; 3
4 namespace CeliSoft.Software
162
5 {
6 /// <summary>
7 /// Controlo ucUsers
8 /// Serve para listar e tratar dos registos dos utilizadores
9 /// </summary>
10 public partial class ucUsers : UserControl
11 {
12 // A delegate type for hooking up change notifications.
13 public delegate void SelectedItemEventHandler(object sender,
SelectedEventArgs e); 14
15 #region Variables
16 public event SelectedItemEventHandler ItemSelected; 17
18 string ids = string.Empty;
19 #endregion 20
21 #region Window Constructor
22 /// <summary>
23 /// Constructor
24 /// </summary>
25 public ucUsers()
26 {
27 InitializeComponent();
28 }
29 #endregion 30
31 #region Methods
32 /// <summary>
33 /// Carregamento dos utilizadores
34 /// </summary>
35 public void LoadUsers()
36 {
37 string user = (txtUsername.Text.Trim() == string.Empty ?
null : "%" + txtUsername.Text + "%");
38 int? type = null; 39
40 if (cmbUserType.SelectedIndex > 0)
41 type = ((ComboBoxItem)cmbUserType.SelectedItem).ID; 42
43 DS_SQLAccessTableAdapters.UsersSearchTableAdapter ta = new
DS_SQLAccessTableAdapters.UsersSearchTableAdapter();
44 DS_SQLAccess.UsersSearchDataTable dt =
ta.GetData_UsersSearch(user, type); 45
46 dgvUsers.DataSource = dt;
47 } 48
49 /// <summary>
50 /// Carregamento dos tipos de utilizadores
51 /// </summary>
52 public void LoadUserTypes()
53 {
163
54 int[] doc_types_ids = { 0, 1, 2 };
55 string[] doc_types = { "", "Administrador", "Utilizador" }; 56
57 cmbUserType.Items.Clear();
58 for (int i = 0; i < doc_types_ids.Length; i++)
59 cmbUserType.Items.Add(new ComboBoxItem(doc_types_ids[i],
doc_types[i]));
60 cmbUserType.SelectedIndex = 0;
61 }
62 #endregion 63
64 #region Methods
65 /// <summary>
66 /// Filtrar dos utilizadores
67 /// </summary>
68 /// <param name="sender"></param>
69 /// <param name="e"></param>
70 private void btnSearch_Click(object sender, EventArgs e)
71 {
72 LoadUsers();
73 btnClearSearch.Enabled = true;
74 } 75
76 /// <summary>
77 /// Quando se clica com o rato na datagridview dgvUsers
78 /// </summary>
79 /// <param name="sender"></param>
80 /// <param name="e"></param>
81 private void dgvUsers_MouseUp(object sender, MouseEventArgs e)
82 {
83 if (dgvUsers.HitTest(e.X, e.Y).ColumnIndex < 0 &&
84 dgvUsers.HitTest(e.X, e.Y).RowIndex < 0)
85 {
86 dgvUsers.ClearSelection();
87 }
88 } 89
90 /// <summary>
91 /// Quando se muda de seleção de items na datagridview
dgvSearch
92 /// </summary>
93 /// <param name="sender"></param>
94 /// <param name="e"></param>
95 private void dgvUsers_SelectionChanged(object sender, EventArgs
e)
96 {
97 bool selected = (dgvUsers.SelectedRows.Count >= 1); 98
99 if (ItemSelected != null && !(Utils.RemovingTab ==
Utils.GetEnumDescription(frmMain.enmTabsMode.Users)))
100 ItemSelected(this, new SelectedEventArgs(selected,
(selected ? dgvUsers.SelectedRows[0].Index : -1)));
101 }
164
102
103 /// <summary>
104 /// Quando se deseja limpar o filtro
105 /// </summary>
106 /// <param name="sender"></param>
107 /// <param name="e"></param>
108 private void btnClearSearch_Click(object sender, EventArgs e)
109 {
110 txtUsername.Text = string.Empty;
111 cmbUserType.SelectedIndex = 0;
112 btnSearch_Click(btnSearch, null);
113 btnClearSearch.Enabled = false;
114 } 115
116 /// <summary>
117 /// Quando se carrega todo o código inicial
118 /// </summary>
119 /// <param name="sender"></param>
120 /// <param name="e"></param>
121 private void ucUsers_Load(object sender, EventArgs e)
122 {
123 LoadUserTypes();
124 LoadUsers();
125 } 126
127 /// <summary>
128 /// Quando se ordena por coluna na datagridview dgvSearch
129 /// </summary>
130 /// <param name="sender"></param>
131 /// <param name="e"></param>
132 private void dgvUsers_ColumnHeaderMouseClick(object sender,
DataGridViewCellMouseEventArgs e)
133 {
134 dgvUsers.ClearSelection();
135 foreach (DataGridViewRow row in dgvUsers.Rows)
136 {
137 if (ids == (row.Cells[0].Value.ToString() +
138 row.Cells[1].Value.ToString()))
139 {
140 row.Cells[1].Selected = true;
141 row.Selected = true;
142 }
143 }
144 } 145
146 /// <summary>
147 /// Quando se clica com o rato na datagridview dgvSearch
148 /// </summary>
149 /// <param name="sender"></param>
150 /// <param name="e"></param>
151 private void dgvUsers_MouseDown(object sender, MouseEventArgs e)
152 {
153 if (dgvUsers.SelectedRows.Count > 0)
165
154 {
155 ids = dgvUsers.SelectedRows[0].Cells[0].Value.ToString()
+ 156
dgvUsers.SelectedRows[0].Cells[1].Value.ToString();
157 }
158 } 159
160 /// <summary>
161 /// Quando se clica com o teclado na datagridview dgvSearch
162 /// </summary>
163 /// <param name="sender"></param>
164 /// <param name="e"></param>
165 private void dgvUsers_KeyDown(object sender, KeyEventArgs e)
166 {
167 switch (e.KeyCode)
168 {
169 case Keys.F5:
170 LoadUsers();
171 break;
172 default:
173 break;
174 }
175 }
176 #endregion
177 }
178 }
Classe - Utils.cs 1 using System;
2 using System.Collections.Generic;
3 using System.ComponentModel;
4 using System.Configuration;
5 using System.Drawing;
6 using System.IO;
7 using System.Linq;
8 using System.Reflection;
9 using System.Text;
10 using System.Threading;
11 using System.Windows.Forms; 12
13 namespace CeliSoft.Software
14 {
15 public static class Utils
16 {
17 #region Variables
18 private static int _CurrentUsernameID;
19 private static string _CurrentUsername;
20 private static int _CurrentUserType;
21 private static string _FiltrosSaveAs = "Adobe PDF
(*.pdf)|*.pdf|Imagens (*.png; *.jpg; *.gif; *.bmp)|*.png; *.jpg; *.gif;
*.bmp|Microsoft Office (*.doc; *.docx; *.xls; *.xlsx; *.ppt; *.pptx)|*.doc;
166
*.docx; *.xls; *.xlsx; *.ppt; *.pptx|Texto (*.txt)|*.txt|Desenvolvimento
(*.sln; *.cs; *.vb)|*.sln; *.cs; *.vb|Web (*.htm; *.html; *.css; *.vbs;
*.js)|*.htm; *.html; *.css; *.vbs; *.js|Todos os Ficheiros (*.*)|(*.*)"; 22
23 public static string RemovingTab = string.Empty;
24 #endregion 25
26 #region Properties
27 public static int CurrentUsernameID
28 {
29 get { return _CurrentUsernameID; }
30 set { _CurrentUsernameID = value; }
31 }
32 public static string CurrentUsername
33 {
34 get { return _CurrentUsername; }
35 set { _CurrentUsername = value; }
36 }
37 public static int CurrentUserType
38 {
39 get { return _CurrentUserType; }
40 set { _CurrentUserType = value; }
41 }
42 public static string FiltrosSaveAs
43 {
44 get { return _FiltrosSaveAs; }
45 set { _FiltrosSaveAs = value; }
46 }
47 #endregion 48
49 #region Methods
50 /// <summary>
51 /// Selecionar uma combobox por ID
52 /// </summary>
53 /// <param name="cbox"></param>
54 /// <param name="id"></param>
55 public static void SelectComboboxItem(ComboBox cbox, int id)
56 {
57 foreach (ComboBoxItem itm in cbox.Items)
58 {
59 if (itm.ID == id)
60 {
61 cbox.SelectedItem = itm;
62 break;
63 }
64 }
65 } 66
67 /// <summary>
68 /// Selecionar uma combobox por Text
69 /// </summary>
70 /// <param name="cbox"></param>
71 /// <param name="text"></param>
167
72 public static void SelectComboboxItem(ComboBox cbox, string
text)
73 {
74 foreach (ComboBoxItem itm in cbox.Items)
75 {
76 if (itm.Text == text)
77 {
78 cbox.SelectedItem = itm;
79 break;
80 }
81 }
82 } 83
84 /// <summary>
85 /// Selecionar uma datagridview by value
86 /// </summary>
87 /// <param name="dgv"></param>
88 /// <param name="value"></param>
89 public static void SelectDataGridViewRow(DataGridView dgv,
object value)
90 {
91 foreach (DataGridViewRow row in dgv.Rows)
92 {
93 if (row.Cells[0].Value.ToString() == value.ToString())
94 {
95 dgv.ClearSelection();
96 row.Selected = true;
97 row.Cells[0].Selected = true;
98 }
99 }
100 } 101
102 /// <summary>
103 /// Function to get the connection string
104 /// </summary>
105 /// <returns></returns>
106 public static string GetDBConnectionString()
107 {
108 return
ConfigurationManager.ConnectionStrings["CeliSoft.Software.Properties.Settings
.DigitalLibConnectionString"].ConnectionString;
109 } 110
111 /// <summary>
112 /// Função para obter os bytes de uma imagem
113 /// </summary>
114 /// <param name="caminho"></param>
115 /// <param name="filtro"></param>
116 /// <param name="titulo"></param>
117 /// <param name="filename"></param>
118 /// <returns></returns>
119 internal static byte[] ObterBytesFicheiro(string caminho, string
filtro, string titulo, out string filename)
168
120 {
121 byte[] picbyte = null;
122 bool askForImage = (caminho == null); 123
124 filename = null; 125
126 if (askForImage)
127 {
128 //Abrir a janela de procura da imagem se a imagepath =
null
129 OpenFileDialog ofd = new OpenFileDialog();
130 ofd.CheckFileExists = true;
131 ofd.Filter = filtro;
132 ofd.Title = titulo;
133 if (ofd.ShowDialog() == DialogResult.OK)
134 {
135 //Obter o caminho do ficheiro
136 caminho = ofd.FileName;
137 filename = ofd.FileName;
138 }
139 } 140
141 //Se a variável imagepath não for nula nem vazia
142 if (caminho != null && caminho != string.Empty)
143 {
144 //Obter o caminho completo da imagem
145 caminho = System.IO.Path.GetFullPath(caminho);
146 //Retirar alguma configuração de caminho relativo
147 caminho = caminho.Replace(@"~\", string.Empty); 148
149 //Abrir a imagem e lê-la para o array de bytes
150 FileStream fs;
151 fs = new FileStream(caminho, FileMode.Open,
FileAccess.Read); 152
153 picbyte = new byte[fs.Length]; 154
155 fs.Read(picbyte, 0, System.Convert.ToInt32(fs.Length));
156 fs.Close();
157 }
158 //Retornar o array de bytes
159 return picbyte;
160 } 161
162 /// <summary>
163 /// Função para obter uma imagem através de um array de
bytes
164 /// </summary>
165 /// <param name="array_bytes"></param>
166 /// <returns></returns>
167 internal static Image ObterImagemDeArrayBytes(byte[]
array_bytes)
168 {
169
169 MemoryStream ms = new MemoryStream(array_bytes);
170 Image returnImage = Image.FromStream(ms);
171 return returnImage;
172 } 173
174 /// <summary>
175 /// Função para gravar uma imagem em disco através de um
array de bytes
176 /// </summary>
177 /// <param name="ficheiro"></param>
178 /// <param name="array_bytes"></param>
179 /// <returns></returns>
180 internal static bool ConverterBytesEmFicheiro(string ficheiro,
byte[] array_bytes)
181 {
182 try
183 {
184 //Abrir ficheiro para escrita
185 System.IO.FileStream _FileStream =
186 new System.IO.FileStream(ficheiro,
System.IO.FileMode.Create,
187 System.IO.FileAccess.Write);
188 //Escreve um bloco de bytes usando os dados do array de
bytes
189 _FileStream.Write(array_bytes, 0, array_bytes.Length); 190
191 //Fechar o ficheiro
192 _FileStream.Close(); 193
194 return true;
195 }
196 catch (Exception _Exception)
197 {
198 //Erro
199 Console.WriteLine("Exception caught in process: {0}",
200 _Exception.ToString());
201 } 202
203 //Ocorreu um erro. Retornar false
204 return false;
205 } 206
207 /// <summary>
208 /// Obter o registo selecionado
209 /// </summary>
210 /// <param name="tabPages"></param>
211 /// <returns></returns>
212 public static DataGridViewRow
GetSelectedRow(TabControl.TabPageCollection tabPages)
213 {
214 foreach (TabPage tPage in tabPages)
215 {
216 if (tPage.Tag != null)
170
217 {
218 if (tPage.Tag.ToString() ==
GetEnumDescription(frmMain.enmTabsMode.Books) ||
219 tPage.Tag.ToString() ==
GetEnumDescription(frmMain.enmTabsMode.Search))
220 {
221 DataGridView dgv =
(DataGridView)FindControl((Control)tPage, "dgvBooks"); 222
223 if (dgv != null)
224 {
225 if (dgv.SelectedRows.Count == 1)
226 {
227 return dgv.SelectedRows[0];
228 }
229 }
230 }
231 }
232 }
233 return null;
234 } 235
236 /// <summary>
237 /// Procurar um controlo recursivamente por nome numa Form
238 /// </summary>
239 /// <param name="form"></param>
240 /// <param name="name"></param>
241 /// <returns></returns>
242 public static Control FindControl(Form form, string name)
243 {
244 foreach (Control ctrl in form.Controls)
245 {
246 Control ctrl_out = FindControl(ctrl, name);
247 if (ctrl.Name == name)
248 {
249 return ctrl;
250 }
251 if (ctrl_out != null && ctrl_out.Name == name)
252 {
253 return ctrl_out;
254 }
255 }
256 return null;
257 } 258
259 /// <summary>
260 /// Procurar um controlo recursivamente por nome numa Form
261 /// </summary>
262 /// <param name="form"></param>
263 /// <param name="name"></param>
264 /// <returns></returns>
265 public static Control FindControl(Control control, string name)
266 {
171
267 foreach (Control ctrl in control.Controls)
268 {
269 Control ctrl_out = FindControl(ctrl, name);
270 if (ctrl.Name == name)
271 {
272 return ctrl;
273 }
274 if (ctrl_out != null && ctrl_out.Name == name)
275 {
276 return ctrl_out;
277 }
278 }
279 return null;
280 } 281
282 /// <summary>
283 /// Obter a descrição em texto do enum selecionado
284 /// </summary>
285 /// <param name="value"></param>
286 /// <returns></returns>
287 public static string GetEnumDescription(Enum value)
288 {
289 FieldInfo fi = value.GetType().GetField(value.ToString()); 290
291 DescriptionAttribute[] attributes = 292
(DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute),
false); 293
294 if (attributes != null && attributes.Length > 0)
295 return attributes[0].Description;
296 else
297 return value.ToString();
298 } 299
300 /// <summary>
301 /// Obter o texto da categoria por ID
302 /// </summary>
303 /// <param name="idCategory"></param>
304 /// <returns></returns>
305 public static string GetCategoryTextByID(int idCategory)
306 {
307 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta = new
DS_SQLAccessTableAdapters.CategoriesTableAdapter();
308 DS_SQLAccess.CategoriesDataTable dt =
ta.GetData_Categories(idCategory, null, null); 309
310 if (dt.Rows.Count == 1)
311 {
312 DS_SQLAccess.CategoriesRow row =
((DS_SQLAccess.CategoriesRow)dt.Rows[0]);
313 return row.path;
314 }
172
315
316 return null;
317 } 318
319 /// <summary>
320 /// Obter a class category_info da categoria por ID
321 /// </summary>
322 /// <param name="idCategory"></param>
323 /// <returns></returns>
324 public static category_info GetCategoryByID(int idCategory)
325 {
326 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta = new
DS_SQLAccessTableAdapters.CategoriesTableAdapter();
327 DS_SQLAccess.CategoriesDataTable dt =
ta.GetData_Categories(idCategory, null, null); 328
329 if (dt.Rows.Count == 1)
330 {
331 DS_SQLAccess.CategoriesRow row =
((DS_SQLAccess.CategoriesRow)dt.Rows[0]);
332 int? id_book = null;
333 return new category_info(row.id, row.id_parent,
row.path);
334 } 335
336 return null;
337 } 338
339 /// <summary>
340 /// Obter a class category_info da categoria por ID
341 /// </summary>
342 /// <param name="idCategory"></param>
343 /// <returns></returns>
344 public static int GetCategoryIDByText(string category_text)
345 {
346 string[] fullpath = category_text.Split(@"\".ToCharArray()); 347
348 DS_SQLAccessTableAdapters.CategoriesTableAdapter ta = new
DS_SQLAccessTableAdapters.CategoriesTableAdapter();
349 DS_SQLAccess.CategoriesDataTable dt =
ta.GetData_Categories(null, null, fullpath[fullpath.Length - 1]); 350
351 if (dt.Rows.Count == 1)
352 {
353 DS_SQLAccess.CategoriesRow row =
((DS_SQLAccess.CategoriesRow)dt.Rows[0]);
354 return row.id;
355 } 356
357 return -1;
358 } 359
360 /// <summary>
361 /// Obter a nome da editora por ID
173
362 /// </summary>
363 /// <param name="idEditor"></param>
364 /// <returns></returns>
365 public static string GetEditorTextByID(int idEditor)
366 {
367 DS_SQLAccessTableAdapters.EditorsTableAdapter ta = new
DS_SQLAccessTableAdapters.EditorsTableAdapter();
368 DS_SQLAccess.EditorsDataTable dt =
ta.GetData_Editors(idEditor, null); 369
370 if (dt.Rows.Count == 1)
371 {
372 DS_SQLAccess.EditorsRow row =
((DS_SQLAccess.EditorsRow)dt.Rows[0]);
373 return row.editor;
374 } 375
376 return null;
377 } 378
379 /// <summary>
380 /// Obter o tipo de documento por ID
381 /// </summary>
382 /// <param name="idDocType"></param>
383 /// <returns></returns>
384 public static string GetDocTypeTextByID(int idDocType)
385 {
386 int[] doc_types_ids = { 1, 2, 3, 4, 5, 6 };
387 string[] doc_types = { "Livro", "Link", "Jornal", "Revista",
"Imagem", "Manuscrito" }; 388
389 int index = 0;
390 foreach (int doc_type_id in doc_types_ids)
391 {
392 if (doc_type_id == idDocType)
393 {
394 return doc_types[index];
395 }
396 index++;
397 }
398 return null;
399 } 400
401 /// <summary>
402 /// Versão deste produto
403 /// </summary>
404 public static string ProductVersion
405 {
406 get
407 {
408 string prodVers =
Application.ProductVersion.TrimEnd(".0".ToCharArray());
174
409 return (prodVers.IndexOf(".") > 0 ? prodVers : prodVers
+ ".0");
410 }
411 } 412
413 /// <summary>
414 /// Expandir a treeview por um caminho completo
415 /// </summary>
416 /// <param name="tv"></param>
417 /// <param name="category_path"></param>
418 public static void ExpandTreeByFullPath(frmMain frm, TreeView
tv, string category_path)
419 {
420 if (string.IsNullOrEmpty(category_path) == false)
421 {
422 string[] items =
category_path.Split(@"\".ToCharArray()); 423
424 int level = 0;
425 foreach (string item in items)
426 {
427 if (level == 0)
428 SelectCategoryInNodes(frm, tv, tv.Nodes, item);
429 else
430 SelectCategoryInNodes(frm, tv,
tv.SelectedNode.Nodes, item);
431 level++;
432 }
433 }
434 } 435
436 /// <summary>
437 /// Selecionar a treeview pelo nó selecionado e por um nome
438 /// </summary>
439 /// <param name="tv"></param>
440 /// <param name="nodes"></param>
441 /// <param name="name"></param>
442 private static void SelectCategoryInNodes(frmMain frm, TreeView
tv, TreeNodeCollection nodes, string name)
443 {
444 foreach (TreeNode node in nodes)
445 {
446 if (node.Text == name)
447 {
448 tv.SelectedNode = node;
449 tv.SelectedNode.Expand();
450 if (frm != null) frm.AfterExpand(node);
451 break;
452 }
453 }
454 }
455 #endregion
456 }
175
457 }
Configuração da Ribbon - RibbonMarkup.xml 1 <Application xmlns="http://schemas.microsoft.com/windows/2009/Ribbon">
2 <Application.Commands> 3
4 <Command Name="cmdApplicationMenu" Id="1000" LabelTitle="Ficheiro"
/> 5
6 <!-- FILE GROUP -->
7 <Command Id="1001" Name="cmdButtonNewBook"
8 LabelTitle="&Novo Livro"
9 LabelDescription="Novo Livro"
10 TooltipTitle="Novo Livro (Ctrl+N)"
11 TooltipDescription="Novo livro"
12 Keytip="L">
13 <Command.LargeImages>
14 <Image>Res/book_pastel_add_32x32.bmp</Image>
15 </Command.LargeImages>
16 <Command.SmallImages>
17 <Image>Res/book_pastel_add_16x16.bmp</Image>
18 </Command.SmallImages>
19 </Command>
20 <Command Id="1002" Name="cmdButtonChangeBook"
21 LabelTitle="&Modificar Livro"
22 LabelDescription="Modificar Livro"
23 TooltipTitle="Modificar Livro"
24 TooltipDescription="Modificar Livro na base de dados"
25 Keytip="M">
26 <Command.LargeImages>
27 <Image>Res/book_pastel_edit_32x32.bmp</Image>
28 </Command.LargeImages>
29 <Command.SmallImages>
30 <Image>Res/book_pastel_edit_16x16.bmp</Image>
31 </Command.SmallImages>
32 </Command>
33 <Command Id="1003" Name="cmdButtonDeleteBook"
34 LabelTitle="&Remover Livro"
35 LabelDescription="Remover Livro"
36 TooltipTitle="Remover Livro"
37 TooltipDescription="Remover Livro da base de dados"
38 Keytip="R">
39 <Command.LargeImages>
40 <Image>Res/book_pastel_delete_32x32.bmp</Image>
41 </Command.LargeImages>
42 <Command.SmallImages>
43 <Image>Res/book_pastel_delete_16x16.bmp</Image>
44 </Command.SmallImages>
45 </Command>
46 <Command Id="1004" Name="cmdButtonUploadBook"
47 LabelTitle="&Carregar Ficheiro"
48 LabelDescription="Carregar Ficheiro"
176
49 TooltipTitle="Carregar Ficheiro"
50 TooltipDescription="Carregar Ficheiro para a base de dados"
51 Keytip="U">
52 <Command.LargeImages>
53 <Image>Res/FileDatabase_Upload_32x32.bmp</Image>
54 </Command.LargeImages>
55 <Command.SmallImages>
56 <Image>Res/FileDatabase_Upload_16x16.bmp</Image>
57 </Command.SmallImages>
58 </Command>
59 <Command Id="1005" Name="cmdButtonDownloadBook"
60 LabelTitle="Transferir Ficheiro"
61 LabelDescription="Transferir Ficheiro"
62 TooltipTitle="Transferir Ficheiro"
63 TooltipDescription="Transferir Ficheiro para a base de dados"
64 Keytip="T">
65 <Command.LargeImages>
66 <Image>Res/FileDatabase_Download_32x32.bmp</Image>
67 </Command.LargeImages>
68 <Command.SmallImages>
69 <Image>Res/FileDatabase_Download_16x16.bmp</Image>
70 </Command.SmallImages>
71 </Command>
72 <Command Id="1006" Name="cmdButtonSearch"
73 LabelTitle="&Procurar"
74 LabelDescription="Procurar Livro"
75 TooltipTitle="Procurar Livro"
76 TooltipDescription="Procurar Livro"
77 Keytip="P">
78 <Command.LargeImages>
79 <Image>Res/Search_32x32.bmp</Image>
80 </Command.LargeImages>
81 <Command.SmallImages>
82 <Image>Res/Search_16x16.bmp</Image>
83 </Command.SmallImages>
84 </Command>
85 <Command Id="1007" Name="cmdButtonManageBooks"
86 LabelTitle="Gestão de Liv&ros"
87 LabelDescription="Gestão de Livros"
88 TooltipTitle="Gestão de Livros"
89 TooltipDescription="Gestão de Livros"
90 Keytip="R">
91 <Command.LargeImages>
92 <Image>Res/DigitalLibrary_Books_Pastel_32x32.bmp</Image>
93 </Command.LargeImages>
94 <Command.SmallImages>
95 <Image>Res/DigitalLibrary_Books_Pastel_16x16.bmp</Image>
96 </Command.SmallImages>
97 </Command>
98 <Command Id="1008" Name="cmdButtonManagePublishers"
99 LabelTitle="Gestão de E&ditoras"
100 LabelDescription="Gestão de Editoras"
101 TooltipTitle="Gestão de Editoras"
177
102 TooltipDescription="Gestão de Editoras"
103 Keytip="D">
104 <Command.LargeImages>
105 <Image>Res/Editors_32x32.bmp</Image>
106 </Command.LargeImages>
107 <Command.SmallImages>
108 <Image>Res/Editors_16x16.bmp</Image>
109 </Command.SmallImages>
110 </Command>
111 <Command Id="1010" Name="cmdButtonManageUsers"
112 LabelTitle="Gestão de Ut&ilizadores"
113 LabelDescription="Gestão de Utilizadores"
114 TooltipTitle="Gestão de Utilizadores"
115 TooltipDescription="Gestão de Utilizadores"
116 Keytip="I">
117 <Command.LargeImages>
118 <Image>Res/Users_32x32.bmp</Image>
119 </Command.LargeImages>
120 <Command.SmallImages>
121 <Image>Res/Users_16x16.bmp</Image>
122 </Command.SmallImages>
123 </Command>
124 <Command Id="1011" Name="cmdButtonCloseTab"
125 LabelTitle="&Fechar Separador"
126 LabelDescription="Fechar Separador"
127 TooltipTitle="Fechar Separador"
128 TooltipDescription="Fechar Separador"
129 Keytip="F">
130 <Command.LargeImages>
131 <Image>Res/Tabs_Close_32x32.bmp</Image>
132 </Command.LargeImages>
133 <Command.SmallImages>
134 <Image>Res/Tabs_Close_16x16.bmp</Image>
135 </Command.SmallImages>
136 </Command>
137 <Command Id="1012" Name="cmdButtonCoverImage"
138 LabelTitle="Capa do &Livro"
139 LabelDescription="Capa do Livro"
140 TooltipTitle="Capa do Livro"
141 TooltipDescription="Capa do Livro"
142 Keytip="F">
143 <Command.LargeImages>
144 <Image>Res/book_white_cover_32x32.bmp</Image>
145 </Command.LargeImages>
146 <Command.SmallImages>
147 <Image>Res/book_white_cover_16x16.bmp</Image>
148 </Command.SmallImages>
149 </Command>
150 <Command Id="1013" Name="cmdButtonViewCategories"
151 LabelTitle="Ver &Categorias"
152 LabelDescription="Ver Categorias"
153 TooltipTitle="Ver Categorias"
154 TooltipDescription="Ver Categorias"
178
155 Keytip="C">
156 <Command.LargeImages>
157 <Image>Res/app_left_side_32x32.bmp</Image>
158 </Command.LargeImages>
159 <Command.SmallImages>
160 <Image>Res/app_left_side_16x16.bmp</Image>
161 </Command.SmallImages>
162 </Command>
163 <Command Id="1014" Name="cmdButtonViewDetails"
164 LabelTitle="Ver &Detalhes"
165 LabelDescription="Ver Detalhes"
166 TooltipTitle="Ver Detalhes"
167 TooltipDescription="Ver Detalhes"
168 Keytip="D">
169 <Command.LargeImages>
170 <Image>Res/app_right_side_details_32x32.bmp</Image>
171 </Command.LargeImages>
172 <Command.SmallImages>
173 <Image>Res/app_right_side_details_16x16.bmp</Image>
174 </Command.SmallImages>
175 </Command>
176 <Command Id="1015" Name="cmdButtonChangeBookCategory"
177 LabelTitle="Mud&ar de Categoria"
178 LabelDescription="Mudar da categoria do livro selecionado"
179 TooltipTitle="Mudar de Categoria"
180 TooltipDescription="Mudar a categoria do livro selecionado"
181 Keytip="A">
182 <Command.LargeImages>
183 <Image>Res/Category_Change_32x32.bmp</Image>
184 </Command.LargeImages>
185 <Command.SmallImages>
186 <Image>Res/Category_Change_16x16.bmp</Image>
187 </Command.SmallImages>
188 </Command>
189 <Command Id="1016" Name="cmdButtonViewStatusBar"
190 LabelTitle="&Barra de Estado"
191 LabelDescription="Barra de Estado"
192 TooltipTitle="Barra de Estado"
193 TooltipDescription="Barra de Estado"
194 Keytip="B">
195 <Command.LargeImages>
196 <Image>Res/app_statusbar_32x32.bmp</Image>
197 </Command.LargeImages>
198 <Command.SmallImages>
199 <Image>Res/app_statusbar_16x16.bmp</Image>
200 </Command.SmallImages>
201 </Command>
202 <Command Id="1017" Name="cmdButtonAddRootCategory"
203 LabelTitle="&Adicionar Categoria"
204 LabelDescription="Adicionar Categoria"
205 TooltipTitle="Adicionar Categoria"
206 TooltipDescription="Adicionar Categoria"
207 Keytip="A">
179
208 <Command.LargeImages>
209 <Image>Res/AddCategory_32x32.bmp</Image>
210 </Command.LargeImages>
211 <Command.SmallImages>
212 <Image>Res/AddCategory_16x16.bmp</Image>
213 </Command.SmallImages>
214 </Command>
215 <Command Id="1018" Name="cmdButtonAddChildCategory"
216 LabelTitle="Adicionar &Sub Categoria"
217 LabelDescription="Adicionar Sub Categoria"
218 TooltipTitle="Adicionar Sub Categoria"
219 TooltipDescription="Adicionar Sub Categoria"
220 Keytip="S">
221 <Command.LargeImages>
222 <Image>Res/AddSubCategory_32x32.bmp</Image>
223 </Command.LargeImages>
224 <Command.SmallImages>
225 <Image>Res/AddSubCategory_16x16.bmp</Image>
226 </Command.SmallImages>
227 </Command>
228 <Command Id="1019" Name="cmdButtonEditCategory"
229 LabelTitle="&Editar Categoria"
230 LabelDescription="Editar Categoria"
231 TooltipTitle="Editar Categoria"
232 TooltipDescription="Editar Categoria"
233 Keytip="E">
234 <Command.LargeImages>
235 <Image>Res/EditCategory_32x32.bmp</Image>
236 </Command.LargeImages>
237 <Command.SmallImages>
238 <Image>Res/EditCategory_16x16.bmp</Image>
239 </Command.SmallImages>
240 </Command>
241 <Command Id="1020" Name="cmdButtonRemoveCategory"
242 LabelTitle="&Remover Categoria"
243 LabelDescription="Remover Categoria"
244 TooltipTitle="Remover Categoria"
245 TooltipDescription="Remover Categoria"
246 Keytip="R">
247 <Command.LargeImages>
248 <Image>Res/RemoveCategory_32x32.bmp</Image>
249 </Command.LargeImages>
250 <Command.SmallImages>
251 <Image>Res/RemoveCategory_16x16.bmp</Image>
252 </Command.SmallImages>
253 </Command>
254 <Command Id="1021" Name="cmdButtonNewEditor"
255 LabelTitle="&Nova Editora"
256 LabelDescription="Nova Editora"
257 TooltipTitle="Nova Editora"
258 TooltipDescription="Nova Editora"
259 Keytip="E">
260 <Command.LargeImages>
180
261 <Image>Res/Editors_add_32x32.bmp</Image>
262 </Command.LargeImages>
263 <Command.SmallImages>
264 <Image>Res/Editors_add_16x16.bmp</Image>
265 </Command.SmallImages>
266 </Command>
267 <Command Id="1022" Name="cmdButtonChangeEditor"
268 LabelTitle="&Modificar Editora"
269 LabelDescription="Modificar Editora"
270 TooltipTitle="Modificar Editora"
271 TooltipDescription="Modificar Editora"
272 Keytip="M">
273 <Command.LargeImages>
274 <Image>Res/Editors_edit_32x32.bmp</Image>
275 </Command.LargeImages>
276 <Command.SmallImages>
277 <Image>Res/Editors_edit_16x16.bmp</Image>
278 </Command.SmallImages>
279 </Command>
280 <Command Id="1023" Name="cmdButtonDeleteEditor"
281 LabelTitle="&Remover Editora"
282 LabelDescription="Remover Editora"
283 TooltipTitle="Remover Editora"
284 TooltipDescription="Remover Editora"
285 Keytip="R">
286 <Command.LargeImages>
287 <Image>Res/Editors_delete_32x32.bmp</Image>
288 </Command.LargeImages>
289 <Command.SmallImages>
290 <Image>Res/Editors_delete_16x16.bmp</Image>
291 </Command.SmallImages>
292 </Command>
293 <Command Id="1024" Name="cmdButtonDownloadBooks"
294 LabelTitle="Transferir Ficheiros"
295 LabelDescription="Transferir Ficheiros"
296 TooltipTitle="Transferir Ficheiros"
297 TooltipDescription="Transferir Ficheiros para a base de dados"
298 Keytip="T">
299 <Command.LargeImages>
300 <Image>Res/FileDatabase_Download_32x32.bmp</Image>
301 </Command.LargeImages>
302 <Command.SmallImages>
303 <Image>Res/FileDatabase_Download_16x16.bmp</Image>
304 </Command.SmallImages>
305 </Command>
306 <Command Id="1028" Name="cmdButtonNewUser"
307 LabelTitle="Novo &Utilizador"
308 LabelDescription="Novo Utilizador"
309 TooltipTitle="Novo Utilizador"
310 TooltipDescription="Novo Utilizador"
311 Keytip="U">
312 <Command.LargeImages>
313 <Image>Res/People Users_Add_32x32.bmp</Image>
181
314 </Command.LargeImages>
315 <Command.SmallImages>
316 <Image>Res/People Users_Add_16x16.bmp</Image>
317 </Command.SmallImages>
318 </Command>
319 <Command Id="1029" Name="cmdButtonChangeUser"
320 LabelTitle="&Modificar Utilizador"
321 LabelDescription="Modificar Utilizador"
322 TooltipTitle="Modificar Utilizador"
323 TooltipDescription="Modificar Utilizador"
324 Keytip="M">
325 <Command.LargeImages>
326 <Image>Res/People Users_Edit_32x32.bmp</Image>
327 </Command.LargeImages>
328 <Command.SmallImages>
329 <Image>Res/People Users_Edit_16x16.bmp</Image>
330 </Command.SmallImages>
331 </Command>
332 <Command Id="1030" Name="cmdButtonDeleteUser"
333 LabelTitle="&Remover Utilizador"
334 LabelDescription="Remover Utilizador"
335 TooltipTitle="Remover Utilizador"
336 TooltipDescription="Remover Utilizador"
337 Keytip="R">
338 <Command.LargeImages>
339 <Image>Res/People Users_Delete_32x32.bmp</Image>
340 </Command.LargeImages>
341 <Command.SmallImages>
342 <Image>Res/People Users_Delete_16x16.bmp</Image>
343 </Command.SmallImages>
344 </Command>
345 <Command Id="1031" Name="cmdButtonDeleteBooks"
346 LabelTitle="&Remover Livros"
347 LabelDescription="Remover Livros"
348 TooltipTitle="Remover Livros"
349 TooltipDescription="Remover Livros da base de dados"
350 Keytip="R">
351 <Command.LargeImages>
352 <Image>Res/book_pastel_delete_32x32.bmp</Image>
353 </Command.LargeImages>
354 <Command.SmallImages>
355 <Image>Res/book_pastel_delete_16x16.bmp</Image>
356 </Command.SmallImages>
357 </Command>
358 <!-- FILE GROUP --> 359
360 <Command Id="1099" Name="cmdButtonExit"
361 LabelTitle="&Sair"
362 LabelDescription="Sair da aplicação"
363 TooltipTitle="Sair"
364 TooltipDescription="Sair da aplicação."
365 Keytip="S">
366 <Command.LargeImages>
182
367 <Image>Res/Exit_32.bmp</Image>
368 </Command.LargeImages>
369 <Command.SmallImages>
370 <Image>Res/Exit_16.bmp</Image>
371 </Command.SmallImages>
372 </Command> 373
374 <!-- TABS GROUP -->
375 <Command Id="2001" Name="cmdTabHome"
376 LabelTitle="Principal"
377 Keytip="P">
378 </Command>
379 <Command Id="2002" Name="cmdTabSelectedBook"
380 LabelTitle="Livro Selecionado"
381 Keytip="L">
382 </Command>
383 <Command Id="2003" Name="cmdTabView"
384 LabelTitle="Ver"
385 Keytip="V">
386 </Command>
387 <Command Id="2004" Name="cmdTabSelectedEditor"
388 LabelTitle="Editora Selecionada"
389 Keytip="E">
390 </Command>
391 <Command Id="2005" Name="cmdTabSelectedBooks"
392 LabelTitle="Livros Selecionados"
393 Keytip="L">
394 </Command>
395 <Command Id="2007" Name="cmdTabSelectedUser"
396 LabelTitle="Utilizador Selecionado"
397 Keytip="U">
398 </Command>
399 <!-- TABS GROUP --> 400
401 <!-- TABSGROUP CONTEXT GROUP -->
402 <Command Id="2010" Name="cmdTabGroupSelectedBookTools"
403 LabelTitle="Ferramentas"
404 Keytip="F">
405 </Command>
406 <Command Id="2011" Name="cmdTabGroupSelectedEditorTools"
407 LabelTitle="Ferramentas"
408 Keytip="F">
409 </Command>
410 <Command Id="2012" Name="cmdTabGroupSelectedBooksTools"
411 LabelTitle="Ferramentas"
412 Keytip="F">
413 </Command>
414 <Command Id="2014" Name="cmdTabGroupSelectedUsersTools"
415 LabelTitle="Ferramentas"
416 Keytip="F">
417 </Command>
418 <!-- TABSGROUP CONTEXT GROUP --> 419
183
420 <!-- GROUPS GROUP -->
421 <Command Id="3001" Name="cmdGroupBooks"
422 LabelTitle="Livros"
423 Keytip="L">
424 </Command>
425 <Command Id="3003" Name="cmdGroupDownUpLoad"
426 LabelTitle="Carregar/Transferir"
427 Keytip="T">
428 </Command>
429 <Command Id="3004" Name="cmdGroupSearch"
430 LabelTitle="Procura de Livros"
431 Keytip="P">
432 </Command>
433 <Command Id="3005" Name="cmdGroupCloseSearch"
434 LabelTitle="Fechar Procura"
435 Keytip="F">
436 </Command>
437 <Command Id="3006" Name="cmdGroupMaintenances"
438 LabelTitle="Manutenções"
439 Keytip="M">
440 </Command>
441 <Command Id="3007" Name="cmdGroupTabs"
442 LabelTitle="Separadores"
443 Keytip="S">
444 </Command>
445 <Command Id="3008" Name="cmdGroupCover"
446 LabelTitle="Capa do Ficheiro"
447 Keytip="C">
448 </Command>
449 <Command Id="3009" Name="cmdGroupVisualization"
450 LabelTitle="Visualização"
451 Keytip="V">
452 </Command>
453 <Command Id="3010" Name="cmdGroupChangeCategory"
454 LabelTitle="Categorias"
455 Keytip="C">
456 </Command>
457 <Command Id="3011" Name="cmdGroupEditors"
458 LabelTitle="Editoras"
459 Keytip="E">
460 </Command>
461 <Command Id="3012" Name="cmdGroupAddButtons"
462 LabelTitle="Adicionar"
463 Keytip="A">
464 </Command>
465 <Command Id="3013" Name="cmdGroupUsers"
466 LabelTitle="Utilizadores"
467 Keytip="U">
468 </Command>
469 <!-- GROUPS GROUP --> 470
471 <Command Id="10" Name="cmdQAT"></Command>
472 <Command Id="11" Name="cmdCustomizeQAT"></Command>
184
473 <Command Id="12" Name="cmdBooksContextMap"></Command>
474 <Command Id="13" Name="cmdCategoriesContextMap"></Command>
475 <Command Id="14" Name="cmdEditorsContextMap"></Command>
476 <Command Id="15" Name="cmdUsersContextMap"></Command> 477
478 <Command Name="cmdRecentItems" Id="9000" LabelTitle=" "
479 LabelDescription="Livros adicionados ou editados recentemente"
480 TooltipTitle="Livros adicionados ou editados recentemente"
481 TooltipDescription="Livros adicionados ou editados
recentemente"
482 Keytip="T" /> 483
484 </Application.Commands> 485
486 <Application.Views>
487 <ContextPopup>
488 <ContextPopup.ContextMenus>
489 <ContextMenu Name="SelectedBookContextMenu">
490 <MenuGroup>
491 <Button CommandName="cmdButtonChangeBook" />
492 <Button CommandName="cmdButtonDeleteBook" />
493 </MenuGroup>
494 <MenuGroup>
495 <Button CommandName="cmdButtonUploadBook" />
496 <Button CommandName="cmdButtonDownloadBook" />
497 </MenuGroup>
498 <MenuGroup>
499 <Button CommandName="cmdButtonCoverImage" />
500 </MenuGroup>
501 <MenuGroup>
502 <ToggleButton CommandName="cmdButtonViewDetails" />
503 </MenuGroup>
504 </ContextMenu>
505 <ContextMenu Name="CategoriesContextMenu">
506 <MenuGroup>
507 <Button CommandName="cmdButtonAddRootCategory" />
508 <Button CommandName="cmdButtonAddChildCategory" />
509 </MenuGroup>
510 <MenuGroup>
511 <Button CommandName="cmdButtonEditCategory" />
512 </MenuGroup>
513 <MenuGroup>
514 <Button CommandName="cmdButtonRemoveCategory" />
515 </MenuGroup>
516 </ContextMenu>
517 <ContextMenu Name="EditorsContextMenu">
518 <MenuGroup>
519 <Button CommandName="cmdButtonChangeEditor" />
520 <Button CommandName="cmdButtonDeleteEditor" />
521 </MenuGroup>
522 </ContextMenu>
523 <ContextMenu Name="UsersContextMenu">
524 <MenuGroup>
185
525 <Button CommandName="cmdButtonChangeUser" />
526 <Button CommandName="cmdButtonDeleteUser" />
527 </MenuGroup>
528 </ContextMenu>
529 </ContextPopup.ContextMenus>
530 <ContextPopup.ContextMaps>
531 <ContextMap CommandName="cmdBooksContextMap"
ContextMenu="SelectedBookContextMenu" />
532 <ContextMap CommandName="cmdCategoriesContextMap"
ContextMenu="CategoriesContextMenu" />
533 <ContextMap CommandName="cmdEditorsContextMap"
ContextMenu="EditorsContextMenu" />
534 <ContextMap CommandName="cmdUsersContextMap"
ContextMenu="UsersContextMenu" />
535 </ContextPopup.ContextMaps>
536 </ContextPopup> 537
538 <Ribbon>
539 <Ribbon.QuickAccessToolbar>
540 <QuickAccessToolbar CommandName="cmdQAT"
CustomizeCommandName="cmdCustomizeQAT">
541 <QuickAccessToolbar.ApplicationDefaults>
542 <Button CommandName="cmdButtonManageBooks"
ApplicationDefaults.IsChecked="true" />
543 <Button CommandName="cmdButtonManagePublishers"
ApplicationDefaults.IsChecked="true" />
544 <Button CommandName="cmdButtonManageUsers"
ApplicationDefaults.IsChecked="true" />
545 <Button CommandName="cmdButtonNewBook"
ApplicationDefaults.IsChecked="true" />
546 </QuickAccessToolbar.ApplicationDefaults>
547 </QuickAccessToolbar>
548 </Ribbon.QuickAccessToolbar>
549 <Ribbon.ContextualTabs>
550 <TabGroup CommandName="cmdTabGroupSelectedBookTools">
551 <Tab CommandName="cmdTabSelectedBook">
552 <Group CommandName="cmdGroupBooks"
SizeDefinition="ThreeButtons">
553 <Button CommandName="cmdButtonNewBook" />
554 <Button CommandName="cmdButtonChangeBook" />
555 <Button CommandName="cmdButtonDeleteBook" />
556 </Group>
557 <Group CommandName="cmdGroupDownUpLoad"
SizeDefinition="TwoButtons">
558 <Button CommandName="cmdButtonUploadBook" />
559 <Button CommandName="cmdButtonDownloadBook" />
560 </Group>
561 <Group CommandName="cmdGroupCover"
SizeDefinition="OneButton">
562 <Button CommandName="cmdButtonCoverImage" />
563 </Group>
564 <Group CommandName="cmdGroupChangeCategory"
SizeDefinition="OneButton">
186
565 <Button CommandName="cmdButtonChangeBookCategory" />
566 </Group>
567 </Tab>
568 </TabGroup>
569 <TabGroup CommandName="cmdTabGroupSelectedBooksTools">
570 <Tab CommandName="cmdTabSelectedBooks">
571 <Group CommandName="cmdGroupBooks"
SizeDefinition="ThreeButtons">
572 <Button CommandName="cmdButtonNewBook" />
573 <Button CommandName="cmdButtonChangeBook" />
574 <Button CommandName="cmdButtonDeleteBooks" />
575 </Group>
576 <Group CommandName="cmdGroupDownUpLoad"
SizeDefinition="TwoButtons">
577 <Button CommandName="cmdButtonUploadBook" />
578 <Button CommandName="cmdButtonDownloadBooks" />
579 </Group>
580 <Group CommandName="cmdGroupCover"
SizeDefinition="OneButton">
581 <Button CommandName="cmdButtonCoverImage" />
582 </Group>
583 <Group CommandName="cmdGroupChangeCategory"
SizeDefinition="OneButton">
584 <Button CommandName="cmdButtonChangeBookCategory" />
585 </Group>
586 </Tab>
587 </TabGroup>
588 <TabGroup CommandName="cmdTabGroupSelectedEditorTools">
589 <Tab CommandName="cmdTabSelectedEditor">
590 <Group CommandName="cmdGroupEditors"
SizeDefinition="ThreeButtons">
591 <Button CommandName="cmdButtonNewEditor" />
592 <Button CommandName="cmdButtonChangeEditor" />
593 <Button CommandName="cmdButtonDeleteEditor" />
594 </Group>
595 </Tab>
596 </TabGroup>
597 <TabGroup CommandName="cmdTabGroupSelectedUsersTools">
598 <Tab CommandName="cmdTabSelectedUser">
599 <Group CommandName="cmdGroupUsers"
SizeDefinition="ThreeButtons">
600 <Button CommandName="cmdButtonNewUser" />
601 <Button CommandName="cmdButtonChangeUser" />
602 <Button CommandName="cmdButtonDeleteUser" />
603 </Group>
604 </Tab>
605 </TabGroup>
606 </Ribbon.ContextualTabs>
607 <Ribbon.Tabs>
608 <Tab CommandName="cmdTabHome">
609 <Group CommandName="cmdGroupAddButtons"
SizeDefinition="ThreeButtons">
610 <Button CommandName="cmdButtonNewBook" />
187
611 <Button CommandName="cmdButtonNewEditor" />
612 <Button CommandName="cmdButtonNewUser" />
613 </Group>
614 <Group CommandName="cmdGroupTabs" SizeDefinition="OneButton">
615 <Button CommandName="cmdButtonCloseTab" />
616 </Group>
617 <Group CommandName="cmdGroupMaintenances"
SizeDefinition="ThreeButtons">
618 <Button CommandName="cmdButtonManageBooks" />
619 <Button CommandName="cmdButtonManagePublishers" />
620 <Button CommandName="cmdButtonManageUsers" />
621 </Group>
622 <Group CommandName="cmdGroupSearch"
SizeDefinition="OneButton">
623 <Button CommandName="cmdButtonSearch" />
624 </Group>
625 </Tab>
626 <Tab CommandName="cmdTabView">
627 <Group CommandName="cmdGroupVisualization"
SizeDefinition="ThreeButtons">
628 <ToggleButton CommandName="cmdButtonViewCategories" />
629 <ToggleButton CommandName="cmdButtonViewDetails" />
630 <ToggleButton CommandName="cmdButtonViewStatusBar" />
631 </Group>
632 </Tab>
633 </Ribbon.Tabs>
634 <Ribbon.ApplicationMenu>
635 <ApplicationMenu CommandName="cmdApplicationMenu">
636 <ApplicationMenu.RecentItems>
637 <RecentItems CommandName="cmdRecentItems"
EnablePinning="true" MaxCount="20" />
638 </ApplicationMenu.RecentItems>
639 <MenuGroup>
640 <Button CommandName="cmdButtonNewBook" />
641 <Button CommandName="cmdButtonNewEditor" />
642 <Button CommandName="cmdButtonNewUser" />
643 </MenuGroup>
644 <MenuGroup>
645 <Button CommandName="cmdButtonCloseTab" />
646 </MenuGroup>
647 <MenuGroup>
648 <Button CommandName="cmdButtonManageBooks" />
649 <Button CommandName="cmdButtonManagePublishers" />
650 <Button CommandName="cmdButtonManageUsers" />
651 </MenuGroup>
652 <MenuGroup>
653 <Button CommandName="cmdButtonExit" />
654 </MenuGroup>
655 </ApplicationMenu>
656 </Ribbon.ApplicationMenu>
657 </Ribbon>
658 </Application.Views>
659 </Application>
188
189
d) Visual Studio Community 2015 - Acesso ao SQL Server
DS_SQLAccess.xsd
Figura 112 - DataSets de acesso à base de dados por ADO.NET