/// <summary>
		/// Constrói configuração para um formato já existente
		/// </summary>
		/// <param name="formato">Formato a ser editado</param>
		public ConfigurarEtiqueta(EtiquetaFormato formato)
		{
			InitializeComponent();

			labelLayout.Items.Add(layoutEtiqueta);

			CarregarFormato(formato);
		}
		/// <summary>
		/// Constrói nova janela de seleção de impressão
		/// </summary>
		/// <param name="etiquetas">Etiquetas a serem impressas</param>
		public ImprimirEscolha(EtiquetaFormato [] etiquetas, CalcularEtiquetas cálculo)
		{
			// This call is required by the Windows Form Designer.
			InitializeComponent();

			Etiquetas = etiquetas;
			this.cálculo = cálculo;
		}
		/// <summary>
		/// Constrói a configuração padrão
		/// </summary>
		public ConfigurarEtiqueta()
		{
			// This call is required by the Windows Form Designer.
			InitializeComponent();

			labelLayout.Items.Add(layoutEtiqueta);

			formato = null;
		}
		/// <summary>
		/// Carrega formato de etiqueta
		/// </summary>
		/// <param name="formato">Formato a ser editado</param>
		private void CarregarFormato(EtiquetaFormato formato)
		{
			XmlDocument      doc;
			this.formato = formato;

			doc = new XmlDocument();

			doc.LoadXml(formato.Configuração);

			labelLayout.Items.Clear();
			labelLayout.ImportType(typeof(Entidades.Mercadoria.Mercadoria));
			labelLayout.LoadFromXml(doc, false);
			
			layoutDesign.Layout = labelLayout.Items[0];

			layoutEtiqueta.Dispose();
			layoutEtiqueta = labelLayout.Items[0];
		}
		/// <summary>
		/// Ocorre ao solicitar salvamento da configuração
		/// </summary>
		private void opçãoSalvar_Click(object sender, System.EventArgs e)
		{
			string configuração;

			configuração = GerarConfiguração();

			// Mostrar janela para salvar configuração
			using (SalvarConfiguração dlg = new SalvarConfiguração())
			{
				bool loop;

				if (formato != null)
					dlg.Formato = formato.Formato;

				do
				{
					loop = false;

					if (dlg.ShowDialog(this.ParentForm) == DialogResult.OK)
					{
						// Verificar se é um novo formato
						if (formato == null || formato.Formato != dlg.Formato)
						{
							try
							{
								formato = EtiquetaFormato.Cadastrar(dlg.Formato, configuração);
							}
							catch (Acesso.Comum.Exceções.EntidadeJáExistente exceção)
							{
								switch (MessageBox.Show(this.ParentForm,
									"Este formato já existe, deseja sobrescrevê-lo?",
									"Configuração de etiqueta",
									MessageBoxButtons.YesNoCancel,
									MessageBoxIcon.Question,
									MessageBoxDefaultButton.Button2))
								{
									case DialogResult.Yes:
										((EtiquetaFormato) exceção.Entidade).Atualizar();
										break;

									case DialogResult.No:
										loop = true;
										break;

									case DialogResult.Cancel:
										return;
								}
							}
						}
						else // Formato já existe
						{
							formato.Configuração = configuração;
							formato.Atualizar();
						}
					}
				} while (loop);
			}

			SubstituirBase(new ListaEtiquetas());
		}
		/// <summary>
		/// Cadastra um formato de etiqueta no banco de dados
		/// </summary>
		/// <param name="formato">Formato a ser cadastrado</param>
		/// <param name="configuração">Configuração do formato</param>
		/// <returns>Entidade construída</returns>
		public static EtiquetaFormato Cadastrar(string formato, string configuração)
		{
			EtiquetaFormato nova;

			nova = new EtiquetaFormato(formato);
			nova.configuracao = configuração;

			nova.Cadastrar();

			return nova;
		}
		/// <summary>
		/// Mostra formatos na ListView
		/// </summary>
		private void MostrarFormatos(EtiquetaFormato [] todosFormatos)
		{
			listViewFormatos.Items.Clear();
			formatos.Clear();

			foreach (EtiquetaFormato formato in todosFormatos)
			{
				ListViewItem linha;

				linha = new ListViewItem();
				linha.Text = formato.Formato;

				linha.SubItems.Add(formato.Autor);
				linha.SubItems.Add(formato.Data.ToShortDateString());

				listViewFormatos.Items.Add(linha);

				formatos[linha] = formato;
			}
		}
Exemple #8
0
		/// <summary>
		/// Imprime etiquetas
		/// </summary>
		/// <param name="etiquetas">Etiquetas a serem impressas</param>
		/// <param name="layout">Layout de etiquetas</param>
		private void ImprimirEtiquetas(EtiquetaFormato [] etiquetas, LabelLayout layout)
		{
            ArrayList saquinhosImpressos = new ArrayList();

			int deEtiqueta, atéEtiqueta;	// Seleção de etiquetas a serem impressas
			int nEtiquetas;					// Total de etiquetas a serem impressas
			int etiquetasPágina;			// Etiquetas por página
			int iEtiqueta;					// Iterador

			nEtiquetas      = CalcularNúmeroEtiquetas(etiquetas);
			etiquetasPágina = layout.LabelsPerPage;

			printDlg.PrinterSettings.MaximumPage = (int) Math.Ceiling(nEtiquetas / (float) etiquetasPágina);
			printDlg.PrinterSettings.MinimumPage = 1;
			printDlg.PrinterSettings.DefaultPageSettings.PaperSize = layout.PaperSize;
			printDlg.PrinterSettings.FromPage = 1;
			printDlg.PrinterSettings.ToPage = printDlg.PrinterSettings.MaximumPage;

			if (printDlg.ShowDialog(this.ParentForm) != DialogResult.OK)
			{
				MessageBox.Show(this, "Impressão cancelada pelo usuário", "Impressão", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);	
				return;
			}

			aguardeImpressão = new Aguarde(
					   "Preparando impressão...",
					   2 + printDlg.PrinterSettings.ToPage - printDlg.PrinterSettings.FromPage,
					   "Imprimindo etiquetas",
					   "Aguarde enquanto o sistema imprime as etiquetas solicitadas.");

			// Mostrar janela de espera
            aguardeImpressão.Abrir();
			
			aguardeImpressão.Tag = 0;			// Usado para numeração de página

			try
			{
				// Preparar impressão
				layout.Document = printDoc;
				deEtiqueta      = (printDlg.PrinterSettings.FromPage - 1) * etiquetasPágina;
				atéEtiqueta     = (printDlg.PrinterSettings.ToPage) * etiquetasPágina - 1;
				iEtiqueta       = 0;

				// Inserir objetos de impressão
				layout.Objects = new ArrayList();

				// Atualizando dados
				aguardeImpressão.Passo("Sincronizando dados com o banco de dados");
				bandeja.AtualizaObjetosInstrínsecosDosSaquinhos();

				// Formata a impressão
				aguardeImpressão.Passo("Formatando dados para impressão de etiquetas");
 
				foreach (SaquinhoEtiqueta saquinho in bandeja)
				{
					/* Verificar se saquinho contém formato a ser
						* impresso. Não é a melhor implementação,
						* porém o número de formatos é bem pequeno,
						* levando a um pior desempenho caso utilizado
						* busca binária, já que deve ordenar os itens.
						*/
					for (int i = 0; i < etiquetas.Length; i++)
						if (saquinho.Etiqueta == etiquetas[i])
						{
#if DEBUG
                            if (saquinho.Mercadoria == null)
                                throw new NullReferenceException("Mercadoria de saquinho está nula!");
#endif
							if (iEtiqueta >= deEtiqueta && iEtiqueta <= atéEtiqueta)
							{
								layout.Objects.Add(
									new RepeatedObject(
									layout.Items[i],
									saquinho.Mercadoria,
									( Convert.ToInt32(saquinho.Quantidade) > atéEtiqueta - iEtiqueta + 1
									? atéEtiqueta - iEtiqueta + 1
									: Convert.ToInt32(saquinho.Quantidade))));

                                saquinho.Impresso = true;

                                if (saquinhosImpressos.Contains(saquinho)) throw new Exception("Lista ja contem o item de etiqueta");
                                saquinhosImpressos.Add(saquinho);
							}
							else if (iEtiqueta <= atéEtiqueta && iEtiqueta + saquinho.Quantidade >= deEtiqueta)
							{
								layout.Objects.Add(
									new RepeatedObject(
									layout.Items[i],
									saquinho.Mercadoria,
									Convert.ToInt32(saquinho.Quantidade) - (deEtiqueta - iEtiqueta) > atéEtiqueta - iEtiqueta + 1
									? atéEtiqueta - iEtiqueta + 1
									: Convert.ToInt32(saquinho.Quantidade) - (deEtiqueta - iEtiqueta)));

                                saquinho.Impresso = true;

                                if (saquinhosImpressos.Contains(saquinho)) throw new Exception("Lista ja contem o item de etiqueta");
                                saquinhosImpressos.Add(saquinho);
							}

							iEtiqueta += Convert.ToInt32(saquinho.Quantidade);
						}
				}

				bool loop;

				do
				{
#if !DEBUG
					try
#endif
				{
					printDoc.Print();

					loop = false;
				}
#if !DEBUG
					catch (Exception e)
					{
						loop = MessageBox.Show(
							this.ParentForm,
							"Não foi possível imprimir o documento. Verifique se a impressora está ligada e conectada corretamente ao computador.",
							"Impressão de etiquetas - " + e.Message,
							MessageBoxButtons.RetryCancel) == DialogResult.Retry;

						if (loop)
						{
							printDlg.AllowSomePages = false;
							printDlg.ShowDialog(this.ParentForm);
						}
					}
#endif
				} while (loop);
			}
			finally
			{
				layout.Dispose();
                aguardeImpressão.Close();
                aguardeImpressão.Dispose();
                aguardeImpressão = null;
			}

            bandeja.FoiImpresso(saquinhosImpressos);

            opçãoImprimir.Enabled = true;
		}
Exemple #9
0
		/// <summary>
		/// Calcula o número de etiquetas para os
		/// formatos selecionados
		/// </summary>
		/// <param name="etiquetas">Formatos de etiquetas selecionados</param>
		public int CalcularNúmeroEtiquetas(EtiquetaFormato [] etiquetas)
		{
			int quantidade = 0;

			foreach (SaquinhoEtiqueta saquinho in bandeja)
			{
				for (int i = 0; i < etiquetas.Length; i++)
					if (saquinho.Etiqueta == etiquetas[i])
						quantidade += Convert.ToInt32(saquinho.Quantidade);
			}

			return quantidade;
		}
 /// <summary>
 /// Constrói um saquinho a ser usado no cofre
 /// </summary>
 /// <param name="mercadoriaPresenteNoSaquinho">Mercadoria</param>
 /// <param name="quantidadeMercadoriasNoSaquinho">Quantidade</param>
 /// <param name="etiqueta">Formato da etiqueta</param>
 public SaquinhoEtiqueta(Entidades.Mercadoria.Mercadoria mercadoriaPresenteNoSaquinho, double quantidadeMercadoriasNoSaquinho, EtiquetaFormato etiqueta)
     : base(mercadoriaPresenteNoSaquinho, quantidadeMercadoriasNoSaquinho)
 {
     this.etiqueta = etiqueta;
 }