public static void Imprimir(Entidades.Álbum.Álbum álbum, ItensImpressão itens)
        {
            using (PrintDocument documento = new PrintDocument())
            {
                documento.DocumentName = "Álbum " + álbum.Nome;

                using (PrintDialog dlg = new PrintDialog())
                {
                    dlg.AllowCurrentPage = false;
                    dlg.AllowSelection = false;
                    dlg.AllowSomePages = true;
                    dlg.UseEXDialog = true;
                    dlg.Document = documento;

                    if (dlg.ShowDialog() == DialogResult.OK)
                    {
                        ControleImpressão ctrl = new ControleImpressão(álbum, itens);

                        ctrl.página = new Página(
                                documento.PrinterSettings.DefaultPageSettings.PrintableArea.Width / 100f,
                                documento.PrinterSettings.DefaultPageSettings.PrintableArea.Height / 100f,
                                4, 5);
            
                        ctrl.daPágina = dlg.PrinterSettings.FromPage;
                        ctrl.atéPágina = dlg.PrinterSettings.ToPage != 0 ?
                            dlg.PrinterSettings.ToPage : int.MaxValue;

                        documento.PrintPage += new PrintPageEventHandler(ctrl.ImprimirPágina);
                        documento.Print();
                    }
                }
            }
        }
        protected override void CalcularDimensõesitem(Graphics g, out SizeF itemDimensões, out SizeF fotoDimensões, float alturaCabeçalho, ItensImpressão itens)
		{
			itemDimensões = new SizeF(
				largura / Colunas - (Colunas - 1) * EspaçamentoMínimo,
				alturaItem);

			if (alturaItem <= 0)
				itemDimensões.Height = (int) ((float) itemDimensões.Width * (3f / 4f)) + 70;

			fotoDimensões = new SizeF(
				itemDimensões.Width, itemDimensões.Height - (int) Math.Ceiling(g.MeasureString("TjçÇÁÃ", Fonte).Height * linhasTexto));
		}
        private ControleImpressão(Entidades.Álbum.Álbum álbum, ItensImpressão itens)
        {
            List<Foto> listaFotos;

            this.álbum = álbum;
            this.itens = itens;

            if ((itens & ItensImpressão.ForaDeLinha) == 0)
            {
                listaFotos = new List<Foto>();

                foreach (Foto foto in álbum.Fotos)
                    if (!foto.ObterMercadoria().ForaDeLinha)
                        listaFotos.Add(foto);
            }
            else
                listaFotos = new List<Foto>(álbum.Fotos);

            listaFotos.Sort();

            fotos = listaFotos.ToArray();
        }
Example #4
0
		/// <summary>
		/// Imprime item
		/// </summary>
		protected virtual void ImprimirItem(Graphics g, Foto foto, PointF posiçãoAtual, ItensImpressão itens)
		{
			float y = posiçãoAtual.Y;

			// Desenhar foto
			if ((itens & ItensImpressão.Foto) > 0)
			{
				SizeF tamanho;

				if (foto.Imagem.Width / (double)foto.Imagem.Height >= fotoDimensões.Width / (double)fotoDimensões.Height)
					tamanho = new SizeF(fotoDimensões.Width, (float)((float) fotoDimensões.Width * (float) foto.Imagem.Height)/(float)foto.Imagem.Width);
				else
					tamanho = new SizeF((float)((float) foto.Imagem.Width * (float) fotoDimensões.Height / (float) foto.Imagem.Height), fotoDimensões.Height);

#if DEBUG
                if (tamanho.Width > fotoDimensões.Width)
                    throw new Exception("Largura maior que tamanho máximo.");

                if (tamanho.Height > fotoDimensões.Height)
                    throw new Exception("Altura maior que tamanho máximo.");
#endif

				g.DrawImage(foto.Imagem,
					posiçãoAtual.X + (fotoDimensões.Width - tamanho.Width) / 2,
					posiçãoAtual.Y + (fotoDimensões.Height - tamanho.Height) / 2,
					tamanho.Width,
					tamanho.Height);

				y += fotoDimensões.Height;
                y += espaçamentoTexto;
			}

            Entidades.Mercadoria.Mercadoria mercadoria = null;

            if ((itens & (ItensImpressão.RequerMercadoria | ItensImpressão.Referência)) > 0)
                mercadoria = foto.ObterMercadoria();

			// Desenhar referência
            if ((itens & ItensImpressão.Referência) > 0)
                DesenharStringCentralizada(g, foto.ReferênciaFormatada + "-" + mercadoria.Dígito.ToString(), posiçãoAtual.X, ref y, itemDimensões.Width);

            if ((itens & ItensImpressão.FaixaGrupo) > 0)
            {
                string str = "";

                if (mercadoria.Grupo.HasValue)
                    str = string.Format("{0}-{1}", mercadoria.Faixa, mercadoria.Grupo.Value);
                else
                    str = mercadoria.Faixa;

                if ((itens & ItensImpressão.Peso) > 0 && mercadoria.DePeso)
                {
                    if (str.Length > 0)
                        str += " - ";

                    str += string.Format("9{0:###0.0}9", mercadoria.Peso);
                }

                if ((itens & ItensImpressão.Índice) > 0)
                {
                    if (str.Length > 0)
                        str += " - ";

                    str += string.Format(" {0:###,###,##0.00}", mercadoria.ÍndiceArredondado);
                }

                DesenharStringCentralizada(g, str, posiçãoAtual.X, ref y, itemDimensões.Width);
            }
            else if ((itens & ItensImpressão.Peso) > 0 && mercadoria.DePeso)
            {
                string str;

                str = string.Format("9{0:###0.0}9", mercadoria.Peso);

                if (str.Length > 0)
                    str += " - ";

                if ((itens & ItensImpressão.Índice) > 0)
                {
                    if (str.Length > 0)
                        str += " - ";

                    str += string.Format(" {0:###,###,##0.00}", mercadoria.ÍndiceArredondado);
                }

                DesenharStringCentralizada(g, str, posiçãoAtual.X, ref y, itemDimensões.Width);
            }
            else if ((itens & ItensImpressão.Índice) > 0 && mercadoria.ÍndiceArredondado > 0)
            {
                DesenharStringCentralizada(g, string.Format("{0:###,###,##0.00}", mercadoria.ÍndiceArredondado), posiçãoAtual.X, ref y, itemDimensões.Width);
            }

            // Desenhar descrição
            if ((itens & ItensImpressão.Descrição) > 0)
                DesenharStringCentralizada(g, foto.Descrição, posiçãoAtual.X, ref y, itemDimensões.Width);

            if ((itens & ItensImpressão.DescriçãoMercadoria) > 0)
            {
                string str = mercadoria.Descrição.Trim();
                bool formatar = true;

                foreach (char c in str)
                    formatar &= !char.IsLower(c);

                if (formatar)
                    str = Apresentação.Pessoa.FormatadorNome.FormatarTexto(str);

                DesenharStringCentralizada(g, str, posiçãoAtual.X, ref y, itemDimensões.Width);
            }

            // Desenhar fornecedor
            MercadoriaFornecedor fornecedor = Entidades.Mercadoria.MercadoriaFornecedor.ObterFornecedor(mercadoria.ReferênciaNumérica);

            if (fornecedor != null)
            {
                if ((itens & ItensImpressão.Fornecedor) > 0)
                    DesenharStringCentralizada(g, (fornecedor != null ? fornecedor.FornecedorCódigo.ToString() : ""), posiçãoAtual.X, ref y, itemDimensões.Width);

                if ((itens & ItensImpressão.FornecedorReferência) > 0)
                    DesenharStringCentralizada(g, (!String.IsNullOrEmpty(fornecedor.ReferênciaFornecedorComFFL) ? fornecedor.ReferênciaFornecedorComFFL : ""), posiçãoAtual.X, ref y, itemDimensões.Width);
            }
        }
Example #5
0
		/// <summary>
		/// Imprime cabeçalho do papel
		/// </summary>
		/// <returns>Linha para iniciar impressão de itens</returns>
		protected virtual float ImprimirCabeçalho(Graphics g, string título, ItensImpressão itens)
		{
            float y, pulo;
            SizeF tamanho;

            tamanho = g.MeasureString(título, fonteTítulo);

            if (fundoCabeçalho != null && (itens & ItensImpressão.Logotipo) > 0)
            {
                g.DrawImageUnscaled(fundoCabeçalho, 0, 0);
                y = (fundoCabeçalho.Height / fundoCabeçalho.VerticalResolution - tamanho.Height) / 2;
                pulo = Math.Max(y + tamanho.Height, fundoCabeçalho.Height / fundoCabeçalho.VerticalResolution);
            }
            else
            {
                y = 0;
                pulo = tamanho.Height;
            }

            g.DrawString(título, fonteTítulo, Brushes.Black, new PointF((páginaDimensões.Width - tamanho.Width) / 2, y));

            return pulo;
		}
Example #6
0
		/// <summary>
		/// Imprime conjunto de fotos
		/// </summary>
		/// <param name="fotos">Fotos a serem impressas</param>
		/// <param name="itens">itens a serem impressos</param>
        /// <param name="primeira">Primeira foto a ser impressa.</param>
        /// <returns>Última foto impressa.</returns>
		public int Imprimir(Graphics g, string título, Entidades.Álbum.Foto [] fotos, ItensImpressão itens, int primeira)
		{
			PointF posiçãoAtual = new PointF(margemEsquerda, 0);
            int último = -1;

            g.PageUnit = GraphicsUnit.Inch;

            Apresentação.Pessoa.FormatadorNome.CarregarConstantes();

			// Imprimir fundo
			ImprimirFundo(g);
			
			// Imprimir cabeçalho
			posiçãoAtual.Y = ImprimirCabeçalho(g, título, itens) + margemCabeçalho;

            CalcularDimensõesitem(g, out itemDimensões, out fotoDimensões, posiçãoAtual.Y, itens);

            if (fotos != null)
				for (int i = 0; i < linhas && i * colunas < fotos.Length - primeira; i++)
				{
					for (int j = 0; j < colunas && i * colunas + j < fotos.Length - primeira; j++)
					{
                        último = primeira + i * colunas + j;

						Foto foto = fotos[último];

						ImprimirItem(g, foto, posiçãoAtual, itens);

						posiçãoAtual.X += itemDimensões.Width + espaçamentoMínimo;
					}

					posiçãoAtual.Y += itemDimensões.Height + espaçamentoMínimo;
					posiçãoAtual.X = margemEsquerda;
				}

            último++;

			ImprimirRodapé(g);
            return último;
		}
Example #7
0
		/// <summary>
		/// Calcula dimensões para os itens
		/// </summary>
		protected virtual void CalcularDimensõesitem(Graphics g, out SizeF itemDimensões, out SizeF fotoDimensões, float alturaCabeçalho, ItensImpressão itens)
		{
            SizeF tamanhoTexto = g.MeasureString("TjçÇÁÃ", fonte);
            
			itemDimensões = new SizeF(
				(páginaDimensões.Width - margemEsquerda - margemDireita - (colunas  - 1) * espaçamentoMínimo) / colunas,
				(páginaDimensões.Height - alturaCabeçalho - margemRodapé - margemCabeçalho - (linhas - 1) * espaçamentoMínimo) / linhas);

            linhasTexto = 0;

            if ((itens & ItensImpressão.Descrição) > 0)
                linhasTexto++;

            if ((itens & ItensImpressão.Fornecedor) > 0)
                linhasTexto++;

            if ((itens & ItensImpressão.Referência) > 0)
                linhasTexto++;

            if ((itens & ItensImpressão.DescriçãoMercadoria) > 0)
                linhasTexto++;

            if ((itens & (ItensImpressão.FaixaGrupo | ItensImpressão.Índice | ItensImpressão.Peso)) > 0)
                linhasTexto++;

            if ((itens & ItensImpressão.FornecedorReferência) > 0)
                linhasTexto++;

			fotoDimensões = new SizeF(
                itemDimensões.Width, itemDimensões.Height - tamanhoTexto.Height * linhasTexto - espaçamentoTexto);

            if (fotoDimensões.Height <= 0 || fotoDimensões.Width <= 0)
                throw new Exception("Dimensões muito pequenas para impressão.");
		}