Criar documentos do OneNote (.ONE) programaticamente em C#

Aspose.Note para .NET é uma API de manipulação de documentos do OneNote rica em recursos que permite criar, ler e converter documentos do OneNote programaticamente usando C# ou VB.NET. Em um artigo anterior, abordamos como usar o Aspose.Note para .NET para converter, ler e analisar documentos do OneNote. Hoje, veremos como criar documentos do OneNote do zero usando C#.

O MS OneNote oferece uma maneira de organizar e gerenciar as informações na forma de notas digitais (.ONE). As páginas nos documentos do OneNote são usadas para conter o conteúdo definido pelo usuário que pode consistir em texto, tabelas, imagens, listas etc. Neste artigo, abordaremos todos os aspectos básicos da criação de páginas e seu conteúdo em documentos do OneNote .

• Criar um documento vazio do OneNote
• Adicionar páginas ao documento do OneNote
• Inserir imagens em documentos do OneNote
• Adicionar tabela em documentos do OneNote
• Adicionar marcas em documentos do OneNote
• Inserir hiperlinks em documentos do OneNote

Criar documento do OneNote (.ONE) usando C#

Vamos começar criando um documento vazio do OneNote com apenas um título de página. A seguir estão as etapas para criar o documento do OneNote com uma página vazia e salvá-lo como arquivo .one.

• Crie uma instância da classe Document.
• Crie uma nova página inicializando o objeto Page com o objeto da classe Document.
• Defina o título da página usando a propriedade Page.Title.
• Chame o método Document.AppendChild() e passe o objeto Page.
• Por fim, salve o documento do OneNote usando o método Document.Save().

O exemplo de código a seguir mostra como criar um documento vazio do OneNote usando C#.

// O caminho para o diretório de documentos.
string dataDir = RunExamples.GetDataDir_LoadingAndSaving();

// Crie um objeto da classe Document
Document doc = new Aspose.Note.Document();
// Inicializar objeto de classe Page
Aspose.Note.Page page = new Aspose.Note.Page(doc);

// Estilo padrão para todo o texto no documento.
ParagraphStyle textStyle = new ParagraphStyle { FontColor = Color.Black, FontName = "Arial", FontSize = 10 };
// Definir propriedades do título da página
page.Title = new Title(doc)
{
    TitleText = new RichText(doc) { Text = "Title text.", ParagraphStyle = textStyle },
    TitleDate = new RichText(doc) { Text = new DateTime(2011, 11, 11).ToString("D", CultureInfo.InvariantCulture), ParagraphStyle = textStyle },
    TitleTime = new RichText(doc) { Text = "12:34", ParagraphStyle = textStyle }
};
// Anexar nó de página no documento
doc.AppendChildLast(page);

dataDir = dataDir + "CreateDocWithPageTitle_out.one";
// Salvar documento do OneNote
doc.Save(dataDir);

Adicionar páginas ao documento do OneNote usando C#

Nesta seção, daremos um passo à frente e adicionaremos texto à página no documento do OneNote. Uma página no documento do OneNote pode ser a página principal ou uma subpágina. Por exemplo, você está criando um relatório anual que contém ainda as subseções dos relatórios mensais. Nesse caso, você pode colocar a descrição do relatório na página principal e os relatórios mensais nas subpáginas. No documento do OneNote, isso pode ser tratado usando os níveis de página.

A seguir estão as etapas para criar páginas no documento do OneNote.

• Crie um novo documento do OneNote usando a classe Document.
• Crie novas páginas para o documento e defina seu nível usando a classe Page.
• Use as classes Outline e OutlineElement para criar notas.
• Adicione notas às páginas usando o método Page.AppendChildLast().
• Adicione páginas ao documento do OneNote usando o método Document.AppendChildLast().
• Salve o documento usando o método Document.Save().

O exemplo de código a seguir mostra como criar e adicionar páginas a documentos do OneNote usando C#.

// O caminho para o diretório de documentos.
string dataDir = RunExamples.GetDataDir_Pages();

// Crie um objeto da classe Document
Document doc = new Document();
// Inicialize o objeto da classe Page e defina seu nível
Aspose.Note.Page page1 = new Aspose.Note.Page(doc) { Level = 1 };
// Inicialize o objeto da classe Page e defina seu nível
Aspose.Note.Page page2 = new Aspose.Note.Page(doc) { Level = 2 };
// Inicialize o objeto da classe Page e defina seu nível
Aspose.Note.Page page3 = new Aspose.Note.Page(doc) { Level = 1 };

/*---------- Adding nodes to first Page ----------*/
Outline outline = new Outline(doc);
OutlineElement outlineElem = new OutlineElement(doc);
ParagraphStyle textStyle = new ParagraphStyle { FontColor = Color.Black, FontName = "Arial", FontSize = 10 };
RichText text = new RichText(doc) { Text = "First page.", ParagraphStyle = textStyle };
outlineElem.AppendChildLast(text);
outline.AppendChildLast(outlineElem);
page1.AppendChildLast(outline);

/*---------- Adding nodes to second Page ----------*/
var outline2 = new Outline(doc);
var outlineElem2 = new OutlineElement(doc);
var textStyle2 = new ParagraphStyle { FontColor = Color.Black, FontName = "Arial", FontSize = 10 };
var text2 = new RichText(doc) { Text = "Second page.", ParagraphStyle = textStyle2 };
outlineElem2.AppendChildLast(text2);
outline2.AppendChildLast(outlineElem2);
page2.AppendChildLast(outline2);

/*---------- Adding nodes to third Page ----------*/
var outline3 = new Outline(doc);
var outlineElem3 = new OutlineElement(doc);
var textStyle3 = new ParagraphStyle { FontColor = Color.Black, FontName = "Arial", FontSize = 10 };
var text3 = new RichText(doc) { Text = "Third page.", ParagraphStyle = textStyle3 };
outlineElem3.AppendChildLast(text3);
outline3.AppendChildLast(outlineElem3);
page3.AppendChildLast(outline3);

/*---------- Add pages to the OneNote Document ----------*/
doc.AppendChildLast(page1);
doc.AppendChildLast(page2);
doc.AppendChildLast(page3);

dataDir = dataDir + "CreateDocWithRootAndSubPages_out.one";
// Salvar documento do OneNote
doc.Save(dataDir);

Inserir imagens no documento do OneNote usando C#

Você também pode inserir imagens nas páginas do OneNote. A seguir estão as etapas para criar um documento do OneNote com imagens.

• Crie uma instância da classe Document para um novo documento do OneNote.
• Use a classe Page para criar uma nova página para o documento.
• Crie uma nova instância da classe Image e inicialize-a com o caminho da imagem.
• Adicione uma imagem à página usando o método OutlineElement.AppendChildLast().
• Adicione a página ao documento usando o método Document.AppendChildLast().
• Salve o documento do OneNote.

O exemplo de código a seguir mostra como inserir imagens no documento do OneNote usando C#.

// O caminho para o diretório de documentos.
string dataDir = RunExamples.GetDataDir_Images();

// Crie um objeto da classe Document
Document doc = new Document();
// Inicializar objeto de classe Page
Aspose.Note.Page page = new Aspose.Note.Page(doc);
// Inicialize o objeto da classe Outline e defina as propriedades de deslocamento
Outline outline = new Outline(doc) { VerticalOffset = 0, HorizontalOffset = 0 };
// Inicializar o objeto da classe OutlineElement
OutlineElement outlineElem = new OutlineElement(doc);
// Carregue uma imagem pelo caminho do arquivo.
Aspose.Note.Image image = new Aspose.Note.Image(doc, dataDir + "image.jpg");
// Definir alinhamento de imagem
image.Alignment = HorizontalAlignment.Right;
// Adicionar imagem
outlineElem.AppendChildLast(image);
// Adicionar elementos de contorno
outline.AppendChildLast(outlineElem);
// Adicionar nó de estrutura de tópicos
page.AppendChildLast(outline);
// Adicionar nó de página
doc.AppendChildLast(page);

dataDir = dataDir + "BuildDocAndInsertImage_out.one";
// Salvar documento do OneNote
doc.Save(dataDir);

Adicionar tabelas ao documento do OneNote usando C#

As tabelas são uma ótima maneira de organizar e resumir os dados na forma de linhas e colunas. Juntamente com a organização eficiente, as tabelas permitem localizar os dados desejados rapidamente. Os documentos do OneNote também oferecem suporte a tabelas. A seguir estão as etapas para adicionar tabelas em documentos do OneNote.

• Crie um novo documento do OneNote usando a classe Document.
• Crie uma nova página usando a classe Page.
• Adicione uma nova linha de tabela e células de tabela usando as classes TableRow e TableCell, respectivamente.
• Insira elementos nas células da tabela usando o método TableCell.AppendChildLast.
• Adicione células à linha da tabela usando o método TableRow.AppendChildLast().
• Crie uma instância da classe Table e adicione a linha da tabela a ela.
• Adicione a tabela à página usando as classes OutlineElement e Outline.
• Adicione a página ao documento e salve o documento usando o método Document.Save().

O exemplo de código a seguir mostra como adicionar uma tabela ao documento do OneNote usando C#.

// O caminho para o diretório de documentos.
string dataDir = RunExamples.GetDataDir_Tables();

// Crie um objeto da classe Document
Document doc = new Document();
// Inicializar objeto de classe Page
Aspose.Note.Page page = new Aspose.Note.Page(doc);

// Inicialize o objeto da classe TableRow
TableRow row1 = new TableRow(doc);
// Inicializar objetos da classe TableCell
TableCell cell11 = new TableCell(doc);
TableCell cell12 = new TableCell(doc);
TableCell cell13 = new TableCell(doc);

// Anexar elementos de contorno na célula da tabela
cell11.AppendChildLast(GetOutlineElementWithText(doc, "cell_1.1"));
cell12.AppendChildLast(GetOutlineElementWithText(doc, "cell_1.2"));
cell13.AppendChildLast(GetOutlineElementWithText(doc, "cell_1.3"));
// Células da tabela para linhas
row1.AppendChildLast(cell11);
row1.AppendChildLast(cell12);
row1.AppendChildLast(cell13);

// Inicialize o objeto da classe TableRow
TableRow row2 = new TableRow(doc);
// inicializar objetos da classe TableCell
TableCell cell21 = new TableCell(doc);
TableCell cell22 = new TableCell(doc);
TableCell cell23 = new TableCell(doc);

// Anexar elementos de contorno na célula da tabela
cell21.AppendChildLast(GetOutlineElementWithText(doc, "cell_2.1"));
cell22.AppendChildLast(GetOutlineElementWithText(doc, "cell_2.2"));
cell23.AppendChildLast(GetOutlineElementWithText(doc, "cell_2.3"));

// Anexar células da tabela às linhas
row2.AppendChildLast(cell21);
row2.AppendChildLast(cell22);
row2.AppendChildLast(cell23);

// Inicialize o objeto da classe Table e defina as larguras das colunas
Table table = new Table(doc)
{
    IsBordersVisible = true,
    Columns = { new TableColumn { Width = 200 }, new TableColumn { Width = 200 }, new TableColumn { Width = 200 } }
};
// Anexar linhas da tabela à tabela
table.AppendChildLast(row1);
table.AppendChildLast(row2);

// Inicializar objeto de contorno
Outline outline = new Outline(doc);
// Inicializar o objeto OutlineElement
OutlineElement outlineElem = new OutlineElement(doc);
// Adicionar tabela ao nó do elemento de contorno
outlineElem.AppendChildLast(table);
// Adicionar elemento de contorno ao contorno
outline.AppendChildLast(outlineElem);
// Adicionar contorno ao nó da página
page.AppendChildLast(outline);
// Adicionar página ao nó do documento
doc.AppendChildLast(page);
dataDir = dataDir + "InsertTable_out.one";
doc.Save(dataDir);

Inserir marcas no documento do OneNote usando C#

As marcas são usadas para categorizar ou priorizar as anotações em documentos do OneNote. Você pode aplicar tags ao texto ou parágrafo para localizar ou filtrar rapidamente as notas relacionadas. A seguir estão as etapas para criar e adicionar marcas em documentos do OneNote.

• Crie uma instância da classe Document.
• Crie uma nova página usando a classe Page.
• Inicialize os objetos Outline e OutlineElement.
• Crie um novo objeto RichText e defina seu texto e outras propriedades.
• Adicione uma tag ao texto usando o método RichText.Tags.Add().
• Anexar texto à página.
• Adicione página ao documento do OneNote e salve-o.

O exemplo de código a seguir mostra como adicionar marcas ao texto em documentos do OneNote usando C#.

// O caminho para o diretório de documentos.
string dataDir = RunExamples.GetDataDir_Tags();

// Crie um objeto da classe Document
Document doc = new Document();
// Inicializar objeto de classe Page
Aspose.Note.Page page = new Aspose.Note.Page(doc);
// Inicializar o objeto da classe Outline
Outline outline = new Outline(doc);
// Inicializar o objeto da classe OutlineElement
OutlineElement outlineElem = new OutlineElement(doc);
ParagraphStyle textStyle = new ParagraphStyle { FontColor = Color.Black, FontName = "Arial", FontSize = 10 };
RichText text = new RichText(doc) { Text = "OneNote text.", ParagraphStyle = textStyle };
text.Tags.Add(new NoteTag
{
    Icon = TagIcon.YellowStar,
});

// Adicionar nó de texto
outlineElem.AppendChildLast(text);
// Adicionar nó de elemento de contorno
outline.AppendChildLast(outlineElem);
// Adicionar nó de contorno
page.AppendChildLast(outline);
// Adicionar nó de página
doc.AppendChildLast(page);

dataDir = dataDir + "AddTextNodeWithTag_out.one";
// Salvar documento do OneNote
doc.Save(dataDir);

Inserir hiperlinks no documento do OneNote usando C#

Por último, mas não menos importante, vamos ver como inserir hiperlinks para os documentos do OneNote usando as etapas a seguir.

• Crie uma instância da classe Document.
• Crie uma nova página para o documento usando a classe Page.
• Defina o estilo de texto do hiperlink e sua URL usando a classe TextStyle.
• Crie uma instância da classe RichText, adicione seu texto e inicialize-o com o estilo de texto criado anteriormente para o hiperlink.
• Adicione texto à página do documento do OneNote.
• Salve o documento como arquivo .one.

O exemplo de código a seguir mostra como inserir um hiperlink para o documento do OneNote usando C#.

// O caminho para o diretório de documentos.
string dataDir = RunExamples.GetDataDir_Tasks();

// Crie um objeto da classe Document
Document doc = new Document();
// Inicializar objeto de classe Page
Aspose.Note.Page page = new Aspose.Note.Page(doc);
// Inicializar o objeto da classe Title
Title title = new Title(doc);

ParagraphStyle defaultTextStyle = new ParagraphStyle
{
    FontName = "Arial",
    FontSize = 10,
    FontColor = SystemColors.WindowText
};
RichText titleText = new RichText(doc)
{
    Text = "Title!",
    ParagraphStyle = defaultTextStyle
};
Outline outline = new Outline(doc)
{
    MaxWidth = 200,
    MaxHeight = 200,
    VerticalOffset = 100,
    HorizontalOffset = 100
};
OutlineElement outlineElem = new OutlineElement(doc);
TextStyle textStyleRed = new TextStyle
{
    FontColor = Color.Red,
    FontName = "Arial",
    FontSize = 10,
    RunIndex = 8//this style will be applied to 0-7 characters.
};
TextStyle textStyleHyperlink = new TextStyle
{
    RunIndex = 17,//this style will be applied to 8-16 characters.
    IsHyperlink = true,
    HyperlinkAddress = "www.google.com"
};
RichText text = new RichText(doc)
{
    Text = "This is hyperlink. This text is not a hyperlink.",
    ParagraphStyle = defaultTextStyle,
    Styles = { textStyleRed, textStyleHyperlink }
};

title.TitleText = titleText;
page.Title = title;
outlineElem.AppendChildLast(text);
// Adicionar elementos de contorno
outline.AppendChildLast(outlineElem);
// Adicionar nó de estrutura de tópicos
page.AppendChildLast(outline);
// Adicionar nó de página
doc.AppendChildLast(page);

dataDir = dataDir + "AddHyperlink_out.one";
// Salvar documento do OneNote
doc.Save(dataDir);

Conclusão

Neste artigo, você aprendeu como criar documentos do OneNote (.ONE) do zero usando C#. Além disso, o artigo também abordou como inserir páginas, imagens, tabelas, marcas e hiperlinks para os documentos do OneNote programaticamente. Você pode explorar outros recursos interessantes do Aspose.Note para .NET usando a documentação.

Artigos relacionados

• Converter e ler arquivos do Microsoft OneNote usando C#