OpenXLSX
v0.3.2
OpenXLSX é uma biblioteca C ++ para leitura, escrita, criação e modificação de arquivos Microsoft Excel®, com o formato .xlsx.
Como diz o título - o mais recente "versão" mostrado em https://github.com/troldal/openxlsx/releases é de 2021-11-06 e severamente desatualizado - puxe/faça o download da versão mais recente do SW diretamente do repositório em seu estado atual. Link para aqueles que não querem usar git : https://github.com/troldal/openxlsx/archive/refs/heads/master.zip
Revise o Código XLDATETIME em resposta ao #299 e corrigiu um bug que eu acho que posso ter me apresentado. Desculpas, as datas agora devem construir corretamente a partir de double , struct tm e time_t e converter de volta para a struct tm .
O histórico de alterações é encontrado no log de alterações detalhado.
Hoje, os recursos da filial de desenvolvimento finalmente chegaram à filial principal :) Para obter detalhes, consulte o log de alterações detalhadas abaixo.
Resumindo:
OpenXLSX/headers/XLStyles.hpp : xlstyles Class (e muitas subclasses) foi adicionado, fornecendo acesso quase completo a todos os recursos de formatação do Excel.OpenXLSX/headers/XLMergeCells.hpp e XLSheet.hpp : a classe XLMergeCells é acessível através do XLWorksheet para criar/excluir mesclar mesclarExamples/Demo10.cpp demonstra como os estilos e fusão são usados Nota: A seção que é desativada com testBasics = false quebrará a planilha do Excel resultante, se ativada, o único objetivo é demonstrar acesso a todas as novas classes e métodos. Se você quiser usá -los, certifique -se de usá -los corretamenteNote on XLNumberFormat(s) : Contrary to all other XLStyles elements, these do not use an index within the XML as the referrable ID (XLCellFormat::setNumberFormatId), but instead a user-defined ID that can be set via XLNumberFormat::setNumberFormatId - and for an XLCellFormat, can be set to either a self-defined number format ID, or to a format Predefinido por MS. Geralmente, para formatos personalizados, é recomendável usar IDs> 100.
Na lista de tarefas:
Há alguns dias, finalmente tive tempo para aprender funcionalidade Git suficiente para poder trabalhar com ramos. Por isso, criei uma filial de desenvolvimento com os recursos mais recentes que mencionei em algumas solicitações / problemas de tração. Sinta -se à vontade para dar uma olhada. Dessa forma, você não precisa esperar até que o repositório principal seja atualizado.
Fechou uma infinidade de solicitações de tração que foram implementadas na atualização de maio de 2024, implementou mais dois editoriais do PR #246 e #253.
Após um longo período de inatividade, decidi retomar o desenvolvimento do OpenXLSX. O código foi limpo e um número significativo de bugs foi corrigido. A biblioteca foi testada no Windows, MacOS e Linux e deve funcionar em todas as plataformas.
Gostaria de agradecer sinceramente a todas as pessoas que contribuíram para o projeto, relatando bugs, sugerindo recursos ou enviando solicitações de puxão. Eu também gostaria de agradecer a todas as pessoas que estrelaram o projeto e que demonstraram interesse no projeto.
Em particular, gostaria de agradecer a Lars Uffmann (https://codeberg.org/lars_uffmann/) por suas contribuições para o projeto. Lars gastou tempo e esforço significativos na limpeza do código, corrigindo bugs e implementando novos recursos. Sem a ajuda dele, o projeto não estaria no estado de que é hoje.
Muitas linguagens de programação têm a capacidade de modificar arquivos do Excel, nativamente ou na forma de bibliotecas de código aberto. Isso inclui Python, Java e C#. Para C ++, no entanto, as coisas estão mais dispersas. Embora existam algumas bibliotecas, elas geralmente são menos maduras e têm um conjunto de recursos menores do que para outros idiomas.
Como não há biblioteca de código aberto que atenda totalmente às minhas necessidades, decidi desenvolver a biblioteca OpenXLSX.
A ambição é que o OpenXLSX deve poder ler, escrever, criar e modificar arquivos do Excel (dados e formatação) e fazê -lo com o mínimo possível de dependências. Atualmente, o OpenXLSX depende das seguintes bibliotecas de terceiros:
Essas bibliotecas são todas apenas para cabeçalho e incluídas no repositório, ou seja, não é necessário baixar e construir separadamente.
Além disso, o foco foi colocado na velocidade , não no uso da memória (embora haja opções para reduzir o uso da memória, ao custo da velocidade; mais sobre isso mais tarde).
O OpenXLSX foi testado nas seguintes plataformas/compiladores. Observe que A '-' não significa que o OpenXLSX não funciona; Significa apenas que não foi testado:
| GCC | Clang | Msvc | |
|---|---|---|---|
| Windows | Mingw | Mingw | + |
| Cygwin | - | - | N / D |
| Macos | + | + | N / D |
| Linux | + | + | N / D |
As versões do compilador a seguir devem poder compilar o OpenXLSX sem erros:
O CLANG 7 deve ser capaz de compilar o OpenXLSX, mas aparentemente há um bug na implementação do Variant STD ::, que causa erros do compilador.
O Visual Studio 2017 também deve funcionar, mas não foi testado.
O OpenXLSX usa o CMake como sistema de construção (ou gerador de sistema de construção, para ser exato). Portanto, você deve instalar o cmake primeiro, a fim de criar o OpenXLSX. Você pode encontrar instruções de instalação em www.cmake.org.
A biblioteca OpenXLSX está localizada no subdiretório OpenXLSX para este repositório. O subdiretório OpenXLSX é um projeto de CMake independente; Se você usar o CMake para seu próprio projeto, poderá adicionar a pasta OpenXLSX como um subdiretório ao seu próprio projeto. Como alternativa, você pode usar o CMake para gerar arquivos ou arquivos de projeto para uma cadeia de ferramentas de sua escolha. Ambos os métodos são descritos a seguir.
De longe, a maneira mais fácil de usar o OpenXLSX em seu próprio projeto é usar o CMake e adicionar a pasta OpenXLSX como um subdiretório à árvore de origem do seu próprio projeto. Vários Projetos de CMake de Apoio de Vários IDE, principalmente o Visual Studio 2019, o JetBrains Clion e o QT Creator. Se estiver usando o Visual Studio, você deve selecionar especificamente o 'CMake Project' ao criar um novo projeto.
O principal benefício de incluir a biblioteca OpenXLSX como uma subpasta de origem é que não há necessidade de localizar os arquivos da biblioteca e do cabeçalho especificamente; Cmake cuidará disso para você. Além disso, a biblioteca será construída usando a mesma configuração (depuração, liberação etc.) que seu projeto. Em particular, este é um benefício no Windows, onde não é possível usar bibliotecas de liberação em um projeto de depuração (e vice -versa) quando os objetos STL estão sendo passados pela interface da biblioteca, como estão no OpenXLSX. Ao incluir a fonte OpenXLSX, isso não será um problema.
Ao usar o comando add_subdirectory() no arquivo cmakelists.txt para o seu projeto, você pode ter acesso aos cabeçalhos e arquivos da biblioteca do OpenXLSX. O OpenXLSX pode gerar uma biblioteca compartilhada ou uma biblioteca estática. Por padrão, ele produzirá uma biblioteca compartilhada, mas você pode alterá -lo no arquivo OpenXLSX Cmakelists.txt. A biblioteca está localizada em um espaço de nome chamado OpenXLSX; Portanto, o nome completo da biblioteca é OpenXLSX::OpenXLSX .
O snippet a seguir é um arquivo mínimo cmakelists.txt para seu próprio projeto, que inclui o OpenXLSX como um subdiretório. Observe que o local de saída dos binários está definido como um diretório comum. No Linux e MacOS, isso não é realmente necessário, mas no Windows, isso facilitará sua vida, pois você precisaria copiar o arquivo de biblioteca compartilhado OpenXLSX para o local do seu executável para ser executado.
cmake_minimum_required ( VERSION 3.15)
project (MyProject)
set (CMAKE_CXX_STANDARD 17)
# Set the build output location to a common directory
set ( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} / output )
set ( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} / output )
set ( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR} / output )
add_subdirectory (OpenXLSX)
add_executable (MyProject main.cpp)
target_link_libraries (MyProject OpenXLSX::OpenXLSX)Usando o exposto, você poderá compilar e executar o código a seguir, que gerará um novo arquivo do Excel chamado 'spreadsheet.xlsx':
# include < OpenXLSX.hpp >
using namespace OpenXLSX ;
int main () {
XLDocument doc;
doc. create ( " Spreadsheet.xlsx " );
auto wks = doc. workbook (). worksheet ( " Sheet1 " );
wks. cell ( " A1 " ). value () = " Hello, OpenXLSX! " ;
doc. save ();
return 0 ;
}Se você deseja produzir os binários do OpenXLSX e incluí -los em seu projeto, isso pode ser feito usando o CMake e uma cadeia de ferramentas do compilador de sua escolha.
A partir da linha de comando, navegue pelo subdiretório OpenXLSX da raiz do projeto e execute os seguintes comandos:
mkdir build
cd build
cmake ..
O último comando configurará o projeto. Isso configurará o projeto usando a cadeia de ferramentas padrão. Se você deseja especificar a cadeia de ferramentas, digite cmake -G "<toolchain>" .. com <toolchain> sendo a cadeia de ferramentas que você deseja usar, por exemplo, "Unix Makefiles", "Ninja", "Xcode" ou "Visual Studio 16 2019". Consulte a documentação do CMake para obter detalhes.
Finalmente, você pode construir a biblioteca usando o comando:
cmake --build . --target OpenXLSX --config Release
Você pode alterar os argumentos --target e --config para o que deseja usar.
Quando construído, você pode instalá -lo usando o seguinte comando:
cmake --install .
Este comando instalará os arquivos da biblioteca e do cabeçalho no local padrão em sua plataforma (geralmente/usr/local/on Linux e MacOS e C: Arquivos de Programas no Windows). Você pode definir um local diferente usando o argumento -prefixo.
Observe que, dependendo da plataforma, pode não ser possível instalar as bibliotecas de depuração e liberação. No Linux e MacOS, esse não é um grande problema, pois as bibliotecas de liberação podem ser usadas para executáveis de depuração e liberação. Não é assim para o Windows, onde a configuração da biblioteca deve ser a mesma que para a ligação executável. Por esse motivo, no Windows, é muito mais fácil incluir apenas a pasta de origem OpenXLSX como um subdiretório ao seu projeto CMake; Isso economizará muitas dores de cabeça.
OpenXLSX ainda está em andamento. A seguir, é apresentada uma lista de recursos que foram implementados e devem estar funcionando corretamente:
Recursos relacionados à formatação, gráficos e números não foram implementados e não estão planejados para estar no futuro próximo.
Deve -se notar que a criação de objetos const xldocument, atualmente não está funcionando!
A tabela abaixo é a saída de uma referência (usando a biblioteca do Google Benchmark), que mostra que o acesso a leitura/gravação pode ser feito a uma taxa de cerca de 4.000.000 de células por segundo. Os números de ponto flutuante são um pouco mais baixos, devido à conversão para/de strings no arquivo .xml.
Run on (16 X 2300 MHz CPU s)
CPU Caches:
L1 Data 32 KiB (x8)
L1 Instruction 32 KiB (x8)
L2 Unified 256 KiB (x8)
L3 Unified 16384 KiB (x1)
Load Average: 2.46, 2.25, 2.19
---------------------------------------------------------------------------
Benchmark Time CPU Iterations UserCounters...
---------------------------------------------------------------------------
BM_WriteStrings 2484 ms 2482 ms 1 items=8.38861M items_per_second=3.37956M/s
BM_WriteIntegers 1949 ms 1949 ms 1 items=8.38861M items_per_second=4.30485M/s
BM_WriteFloats 4720 ms 4719 ms 1 items=8.38861M items_per_second=1.77767M/s
BM_WriteBools 2167 ms 2166 ms 1 items=8.38861M items_per_second=3.87247M/s
BM_ReadStrings 1883 ms 1882 ms 1 items=8.38861M items_per_second=4.45776M/s
BM_ReadIntegers 1641 ms 1641 ms 1 items=8.38861M items_per_second=5.11252M/s
BM_ReadFloats 4173 ms 4172 ms 1 items=8.38861M items_per_second=2.01078M/s
BM_ReadBools 1898 ms 1898 ms 1 items=8.38861M items_per_second=4.4205M/s
Um arquivo .xlsx é essencialmente um monte de arquivos .xml em um arquivo .zip. Internamente, o OpenXLSX usa a biblioteca Miniz para compactar/descomprimir o arquivo .zip, e acontece que o Miniz tem um limite superior em relação aos tamanhos dos arquivos que ele pode lidar.
O tamanho máximo permitido do arquivo para um arquivo em um arquivo (ou seja, entrada em um arquivo .zip, não o próprio arquivo) é de 4 GB (não compactado). Geralmente, o maior arquivo em um arquivo/arquivo .xlsx será os arquivos .xml que contêm os dados da planilha. Ou seja, os dados da planilha não podem exceder 4 GB. O que isso se traduz em termos de linhas e colunas depende muito do tipo de dados, mas 1.048.576 linhas x 128 colunas preenchidas com números inteiros de 4 dígitos levarão aprox. 4GB. O tamanho do arquivo comprimido também depende dos dados mantidos na planilha, bem como do algoritmo de compactação usado, mas uma pasta de trabalho com uma única planilha de 4 GB geralmente terá um tamanho compactado de 300-350 MB.
A limitação de 4 GB está relacionada apenas a uma única entrada em um arquivo, não no tamanho total do arquivo. Isso significa que, se um arquivo contém várias entradas com um tamanho de 4 GB, o Miniz ainda poderá lidar com isso. Para o OpenXLSX, isso significa que uma pasta de trabalho com várias planilhas grandes ainda pode ser aberta.
O OpenXLSX usa a biblioteca Pugixml para analisar e manipular arquivos .xml no arquivo .xlsx. O Pugixml é um analisador DOM, que lê todo o documento .xml inteiro na memória. Isso torna incrivelmente rápido a análise e a manipulação.
No entanto, todas as opções têm consequências, e o uso de um analisador DOM também pode exigir muita memória. Para pequenas planilhas, não deve ser um problema, mas se você precisar manipular grandes planilhas, poderá precisar de muita memória.
A tabela abaixo fornece uma indicação de quantas colunas de dados podem ser tratadas pelo OpenXLSX (assumindo 1.048.576 linhas):
| Colunas | |
|---|---|
| 8 GB RAM | 8-16 |
| 16 GB RAM | 32-64 |
| 32 GB RAM | 128-256 |
Sua milhagem pode variar. O desempenho do OpenXLSX dependerá do tipo de dados na planilha.
Observe também que é recomendável usar o OpenXLSX no modo de 64 bits. Embora possa ser facilmente usado no modo de 32 bits, ele pode acessar apenas 4 GB de RAM, o que limitará severamente a utilidade ao lidar com grandes planilhas.
Se o consumo de memória for um problema para você, você poderá criar a biblioteca OpenXLSX no modo compacto (procure o Enable_compact_mode no arquivo cmakelists.txt), que ativará o modo compacto do PUGIXML. O OpenXLSX usará menos memória, mas também será mais lento. Veja mais detalhes na documentação do Pugixml aqui. Um caso de teste executado na VM Linux com RAM de 8 GB revelou que o OpenXLSX poderia lidar com uma planilha com 1.048.576 linhas x 32 colunas no modo compacto, contra 1.048.576 linhas x 16 colunas no modo de default.
De longe, a maior parte das perguntas que recebo sobre o OpenXLSX no GitHub está relacionada ao Unicode. Aparentemente, é (e compreensivelmente) uma fonte de grande confusão para muitas pessoas.
No início, decidi que o OpenXLSX deveria se concentrar na parte do Excel e não ser um utilitário de codificação/conversão de texto também. Portanto, toda a entrada/saída de texto no OpenXLSX deve estar na codificação UTF-8 ... caso contrário, não funcionará conforme o esperado. Também pode ser necessário que os arquivos de código-fonte sejam salvos no formato UTF-8. Se, por exemplo, um arquivo de origem for salvo no formato UTF-16, qualquer string literais também estará no UTF-16. Portanto, se você tiver alguma string codificada literais no seu código-fonte, o arquivo de origem também deverá ser salvo no formato UTF-8.
Todas as manipulações de string e uso no OpenXLSX usam a string C ++ STD ::, que é codificando agnóstico, mas pode ser facilmente usada para a codificação UTF-8. Além disso, o Excel usa a codificação UTF-8 internamente (na verdade, pode ser possível usar outras codificações, mas não tenho certeza disso).
Pelo motivo acima, se você trabalha com outras codificações de texto, precisará se converter para/para/para UTF-8 . Existem várias opções (por exemplo, boost.nowide ou boost.text). Internamente, o OpenXLSX usa o boost.nowide; Ele possui vários recursos úteis para abrir arquivos e converter entre Std :: String e STD :: WSTRING ETC. Também sugerirei que você assista à apresentação de James McNellis no CPPCON 2014 e leia o blog de Joel Spolsky.
O Unicode no Windows é particularmente desafiador. Embora o UTF-8 seja bem suportado no Linux e MacOS, o suporte no Windows é mais limitado. Por exemplo, a saída de caracteres não-ASCII (por exemplo, caracteres chineses ou japoneses) para a janela do terminal parecerá sem sentido. Como mencionado, às vezes você também precisa estar atento à codificação do texto dos próprios arquivos de origem. Alguns usuários tiveram problemas com o travamento do OpenXLSX ao abrir/criar arquivos .xlsx com nomes de arquivos não-ASCII, onde acabou que o código-fonte do programa de teste estava em uma codificação não UTF-8 e, portanto, a sequência de entrada para o OpenXLSX também não era do UTF-8. Para permanecer sã, eu recomendo que os arquivos de código-fonte estejam sempre nos arquivos UTF-8; Todos os IDE que eu conheço podem lidar com arquivos de código-fonte na codificação UTF-8. Bem -vindo ao maravilhoso mundo do Unicode no Windows?
Um arquivo do Excel é essencialmente apenas um monte de arquivos .xml embrulhados em um arquivo .zip. O OpenXLSX usa uma biblioteca de terceiros para extrair os arquivos .xml do arquivo .zip. A biblioteca padrão usada pelo OpenXLSX é Zippy, que é um invólucro orientado a objetos em torno do miniz. A biblioteca Miniz é rápida e é somente para cabeçalho, ideal para o OpenXLSX.
No entanto, é possível usar uma biblioteca ZIP diferente, se você quiser. Em casos raros, você pode ter problemas de estabilidade com Miniz. Nesses casos, pode ser útil tentar uma biblioteca postal diferente.
Usar a biblioteca Zippy/Miniz não requer esforços especiais; Ele funcionará diretamente fora da caixa. O uso de uma biblioteca postal diferente, no entanto, exigirá algum trabalho.
Para usar uma biblioteca ZIP diferente, você deve criar uma classe de wrapper que esteja em conformidade com a interface especificada pela classe Iziparchive. Observe que isso é implementado usando o apagamento do tipo , o que significa que nenhuma herança é necessária; A classe só precisa ter uma interface em conformidade, isso é tudo. Depois disso, forneça um objeto da classe e forneça -o ao construtor OpenXLSX.
Para ver um exemplo de como isso é feito, dê uma olhada na Demo1a na pasta Exemplos. Este exemplo usa uma classe chamada CustomZip (usando libzip como biblioteca ZIP) que pode ser encontrada em exemplos/externo/customzip. Para criar o programa de exemplo, verifique se o libzip (e suas dependências) está instalado no seu computador e ative a opção Openxlsx_enable_libzip no arquivo cmakelists.txt na raiz do OpenXLSX.
Como mencionado, o programa Demo1a Exemplo usa Libzip. Libzip é uma biblioteca muito estável e amplamente utilizada. No entanto, minha experiência é que ela é bastante lenta para arquivos ZIP grandes, como planilhas grandes. Por esse motivo, o Libzip pode não ser a solução ideal, mas é útil para mostrar como uma biblioteca ZIP diferente pode ser usada.
Na pasta 'Exemplos', você encontrará vários programas de exemplo, que ilustram como usar o OpenXLSX. Estudar esses programas de exemplo é a melhor maneira de aprender a usar o OpenXLSX. Os programas de exemplo são anotados, por isso deve ser relativamente fácil entender o que está acontecendo.
O OpenXLSX agora pode usar outras bibliotecas ZIP que a biblioteca Zippy/Miniz padrão. Veja Demo1a como um exemplo de como é feito
Esta versão inclui faixas de linha e iteradores. Ele também suporta a atribuição de contêineres de valores celulares para objetos XLROW. Isso é significativamente mais rápido (até X2) do que usar intervalos celulares ou acessar células por referências de células.
A arquitetura interna do OpenXLSX foi significativamente redesenhada desde a versão anterior. O motivo é que a biblioteca estava se transformando em uma grande bola de lama, e era cada vez mais difícil adicionar recursos e corrigir bugs. Com a nova arquitetura, (espero) será mais fácil de gerenciar e adicionar novos recursos.
Devido ao re-design da arquitetura, existem algumas alterações na interface pública. Essas mudanças, no entanto, não são significativas e devem ser fáceis de atualizar:
Sei que essas mudanças podem causar problemas para alguns usuários. Por esse motivo, a versão anterior do OpenXLSX pode ser encontrada no ramo "Legacy" deste repositório. No entanto, recomendo fortemente que você faça a transição para a nova versão.
Parece que o MS Office não tolera nenhum nós XML de formatação antes do nó <mergeCells> XML - para se livrar de uma mensagem de erro conforme, o mais recente comprometimento modifica a função XLSheet::merges para inserir um nó recém <mergeCells> <sheetData>
Esses padrões ausentes podem levar a erros de acompanhamento quando qualquer índice de estilo desta célula foi posteriormente assumido válido para acessar o referido estilo por índice (exceção se o índice não estivesse em um intervalo válido). Todos os índices de estilo disponíveis em um formato de célula agora são zero (sem suposições, qual o estilo com o índice 0 pode ser configurado, pois, normalmente são os padrões - se você deseja ter certeza, forneça uma célula com um formato conhecido como modelo de cópia do XLCELLFORMATS :: Create).
XLDocument.hpp : Adicionado showWarnings() (configuração padrão) e suppressWarnings()XLStyles.hpp : Adicionado parâmetro suppressWarnings ao construtor (padrão: false )XLDocument::open : Se suppressWarnings() foi chamado, suprimem avisos sobre os arquivos XML de comentários ignorados e itens de pasta de trabalho não atendidosXLDocument::open : m_suppressWarnings A configuração é encaminhada para o construtor XLSTYLESXLException.hpp : Adicionado #include <string>XLDocument::open criará um relacionamento ausente na pasta de trabalho em _rels/.rels se, e somente se, uma pasta de trabalho com o caminho padrão xl/workbook.xml existir no arquivoXLDocument::create e XLDocument::saveAs FUNCIONS interfaces, mas os marcou como [[deprecated]] . As novas interfaces requerem especificação explícita de XLForceOverwrite ou XLDoNotOverwrite . Uma vez que as definições de função depreciada possam ser removidas, XLDoNotOverwrite poderá se tornar o novo comportamento padrãoOpenXLSX/external/nowide/nowideDemo0 / manteve -o no Makefile como um veículo de testeNotes atualizadasScripts criada com xml-format.sh (linha XML, útil para analisar o conteúdo do ZIP XLSX em um editor de texto)make-gnu.sh para Scripts/make-gnu.shScripts/cmake-cleanup.sh para preparar (não executar!) Comandos que removem todos os arquivos temporários gerados pelo cmakeScripts/demos-cleanup.sh para remover todos os arquivos XLSX criados pelas demosvoid setSavingDeclaration(XLXmlSavingDeclaration const& savingDeclaration) usando class XLXmlSavingDeclaration (definido em XLXmlData.hpp ) que pode ser usado para aprovar uma versão XML personalizada, codificando a propriedade StandalOne para PugixmlNotes/todo-list.txt XLWorksheet agora permite acessar um objeto que gerencia as faixas celulares mescladas da planilha da planilha
XLMergeCells XLWorksheet::merges() - Acesse a classe XLMerGecells para a planilha diretamentevoid mergeCells(XLCellRange const& rangeToMerge, bool emptyHiddenCells = false) - Merge células definidas por Rangetomergevoid mergeCells(const std::string& rangeReference, bool emptyHiddenCells = false) - Mesclar células definidas por rangeReferencevoid unmergeCells(XLCellRange const& rangeToUnmerge) - Células UMirge definidas por RangeTounmergevoid unmergeCells(const std::string& rangeReference) - células unmirge definidas pela Rangereference XLMergeCells : Métodos adicionados
int32_t XLMergeCells::findMerge(const std::string& reference) - Encontre uma referência de correspondência de mesclagembool mergeExists(const std::string& reference) - Teste se existe uma fusão com referênciaint32_t XLMergeCells::findMergeByCell(const std::string& cellRef) - Encontre uma mesclagem contendo std :: string belrefint32_t XLMergeCells::findMergeByCell(XLCellReference cellRef) - encontre uma mesclagem contendo xlcellReference belrefsize_t count() - Obtenha a contagem de fusão definida na planilhaconst char* merge(int32_t index) - Obtenha string de referência de mesclagem no índiceconst char* operator[](int32_t index) - Sobrecarga de operador [] como um atalho para :: Mesclarint32_t appendMerge(const std::string& reference) - defina uma nova mesclavoid deleteMerge(int32_t index) - Exclua a mesclagem com o índice fornecido da planilha (= células unmirge), invocada por XLWorksheet :: UMERGECELLS Adicionado exemplo de uso dessa funcionalidade ao Demo10.cpp
XLDocument::open agora ignorará as subpastas desconhecidas (elas permanecem não modificadas e não acessíveis no zíper na memória e permanecem no arquivo ao salvar). Isso impede que seja lançar uma exceção para qualquer arquivo XLSX escrito por um aplicativo "criativo" que adicionou itens desconhecidos a esta bibliotecaconstexpr de const unsigned int pugi_parse_settings e moveu -o para XLDocument.hpp para que a const fique disponível para xlstyles e xlsharedstringsXLStyles - A interface pode ser encontrada no OpenXLSX/headers/XLStyles.hppExamples/Demo10.cpp demonstra o uso do novo XLSTYLES & CELL MUGGING FUNCIONALIDADEXLCellIterator não criativo: agora pode iterar em um intervalo e testar XLCellIterator::cellExists antes de acessá-lo. Isso permite pular células inexistentes sem criá-las.workbook##.xml , namespaces XML e identificadores aleatórios de 64 bits (relacionamento)xl/workbook.xml ) é aceita agora se for referenciado corretamente em _rels/.relsbool OpenXLSX::enable_xml_namespaces() deve ser usado para ativar o suporte ao namespace antes de abrir um documento usando por exemplo, um espaço para nome x (como assim: <x:row r="1"> ) em todos os lugaresinsert_child_before("x:row", curRow ) no nó <y:sheetData> despotará o x: e inserir um elemento de linha <y:row>OpenXLSX/headers/XLXmlParser.hpp ) Tomar como um último argumento opcional e bool force_ns que - se true - respeitará um espaço para nome passar na função para a criação/acesso dos nó. Um Helper const bool OpenXLSX::XLForceNamespace = true está disponível para legibilidade do códigoXMLNode::insert_child_before("x:row", curRow, XLForceNamespace) no nó <y:sheetData> como acima, inserirá um elemento de linha chamado x:rowid="rId##" onde ## é o número da sequência e, quando um novo componente é adicionado à pasta de trabalho, um novo ID de relacionamento é determinado pela obtenção do valor mais alto existente dentro da pasta de trabalho e adicionando +1 a ele. Durante a investigação de [#254], foi encontrado uma pasta de trabalho para usar (aparentemente) números inteiros aleatórios de 64 bits, armazenados na forma r:id="Rxx" , com xx sendo uma representação hexadecimal de um número inteiro de 64 bits.OpenXLSX::UseRandomIDs() deve ser chamado para alternar a funcionalidade de ID antes de abrir esse documentoOpenXLSX::UseSequentialIDs() pode ser usado para restaurar a funcionalidade de ID de relacionamento padrão (sequencial) Nota em enable_xml_namespaces : O suporte ao namespace é transparente e pode ser usado com documentos que não usam esses espaços de nome. No entanto, pode ter um pequeno impacto de desempenho (<5%) em grandes pastas de trabalho e, portanto, é opcional para ativar.
Cuidado com UseRandomIDs : Esteja ciente de que um modo misto, onde um documento é aberto com suporte de ID aleatório e outro sem IDs de relacionamento seqüencial, não é suportado por enquanto. Se você precisar trabalhar com documentos de diferentes tipos, sempre configure o comportamento desejado do ID do relacionamento para o próximo documento, trabalhe com isso, feche -o e altere a configuração do ID do relacionamento antes de abrir o próximo documento.
Desconsidere os exemplos/Demo0.cpp e exemplos/Demo9.cpp por enquanto (o Demo0 é trivial e foi usado para testar o suporte da pasta de trabalho não padrão, e o Demo9 requer uma revisão com melhores comentários). O Demo9 mostra como usar o novo XLCELLASSIGNABLE para copiar o conteúdo da célula assign (como o Excel Copy & Polar).
XLCellIterator não cria mais células vazias apenas para iterar sobre elas e fornece ::cellExists() para testar se a célula atualmente apontada já está na planilha XML, antes de acessá-laXLStylesXLWorksheet agora fornece suporte XLMergeCells para mesclagem / intervalos celularesDemo10.cpp tem muitos exemplos sobre como usar a nova funcionalidade XLSTYLEScustomXml etc no arquivo XLSXXLProperties.cpp XLAppProperties to create <TitlesOfParts> and <HeadingPairs> nodes (and subnodes) if missing, added method alignWorksheets , called by XLDocument::open to ensure that all worksheets listed in the workbook xml are also accounted for in docProps/app.xml .XLProperties.cpp prettyInsertXmlNodeBefore , maybe this can eventually become a global function, paired with a TBW function prettyInsertXmlNodeAfter , and could be used by all classes, cleaning up the code for whitespace support substantially.XLProperties.cpp for <HeadingPairs> subnodes: pairCount -> pairValueParent , pairCountValue -> pairValue Code refactored in XLDocument::open to read the shared strings table while consistently ignoring phonetic tags, which were previously only ignored if the very first child of an <si> tag was a phonetic tag. Will now be ignored anywhere before, after or in between text <t> and rich text <r> tags.
Included a "dumb" fallback solution in XLRelationships.cpp GetTypeFromString to support previously unknown relationship domains, eg type="http://purl.oclc.org/ooxml/officeDocument/relationships/worksheet" . Altered behavior will initially test against the hardcoded relationship domains, and if that test fails to identify a relationship type string, the type string will be searched for an occurrence of /relationships/ and if that substring is found, the type detection fallback will try to evaluate the relationship type based on the substring starting with /relationships/ , ignoring the domain. For the above example, that would result in a test of typeString.substr( comparePos ) == "/relationships/worksheet" , where comparePos == 41 (the position at which substring /relationships/ begins).
In anticipation of a potential future need for a similar "dumb" fallback solution, repeating hardcoded strings in XLContentTypes.cpp GetTypeFromString were also replaced with string constants.
Updated .gitignore to a more generic version that excludes everything and explicitly re-includes all desired files.
BinaryAsHexString : replaced char array with std::string, as ISO C++ standard does not permit variable size arraysRand64 : added explicit type cast, as bitwise shift-left does not do integer promotion to long on the left operand-Wpedantic -Wextra and removed all previously disabled flags after below patchesf( param ) -> f(param) , a[ index ] -> a[index] and if( condition ) -> if (condition) )warning: enumerated and non-enumerated type in conditional expression [-Wextra]void ZipArchive::Save(std::ostream& stream)void ZipArchive::ExtractDir(const std::string& dir, const std::string& dest)void ZipArchive::ExtractAll(const std::string& dest)-Wunused-function by pragma for functions fileExists and isDirectoryuint32_t (was uint64_t ). CAUTION : there is no validity check on the underlying XML (nor was there ever one in case a value was inconsistent with OpenXLSX::MAX_ROWS)-Wsign-comparebool endReached() to eliminate -Wignored-qualifiers (ignored because const on trivial return types accomplishes nothing)OpenXLSX::ignore template, can be used to suppress -Wunused-parameter and -Wunused-variable like so: OpenXLSX::ignore(unusedValue)-Wunused-parameter#pragma warning lines in another pragma to disable -Wunknown-pragmas (on gcc/g++)#pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wunknown-pragmas" // disable warning about below #pragma warning being unknown# pragma /* offending lines go here */#pragma GCC diagnostic popzippy.hppIZipArchive.hppXLCell.hppXLCellIterator.hppXLCellRange.hppXLCellReference.hppXLCellValue.hppXLColor.hppXLColumn.hppXLCommandQuery.hppXLContentTypes.hppXLDateTime.hppXLDocument.hppXLException.hppXLFormula.hppXLMergeCells.hppXLProperties.hppXLRelationships.hppXLRowData.hppXLRow.hppXLSharedStrings.hppXLSheet.hppXLStyles.hppXLWorkbook.hppXLXmlData.hppXLXmlFile.hppXLZipArchive.hppExamples/Demo5.cpp<Properties> (document) element, was previously wrongly appended to headingPairs/xl/worksheets/sheet* , /xl/sharedStrings.xml , /xl/styles.xml , /xl/theme/theme* ) and otherwise ignored. This fixes an issue when the workbook contains /xl/pivotCache/ and /xl/pivotTables/ entries until support for those is implemented (if ever ;P)<cols> element obtained via a rowNode parent's parentstd::vector< XLStyleIndex > m_columnStyles , and a method fetchColumnStyles that will populate the vector so that it can be passed to the XLCellIterator constructorXLCellIterator::cellExists() without creating the XML for the cell.<font><scheme val="major"/></font> )<font><vertAlign val="subscript"/></font> )<fills><fill><gradientFill>...</gradientFill></fill>...</fills> are now supportedPlease refer to Demo10 and XLStyles.hpp on how to set cell formatting. Resumidamente:
