DocumentServer-v-9.2.0/core/MsBinaryFile/XlsFile/Converter/XlsConverter.cpp

/*
 * (c) Copyright Ascensio System SIA 2010-2023
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */
#include "XlsConverter.h"

#include "../Format/Binary/CompoundFile.h"
#include "../Format/Binary/CFStreamCacheReader.h"

#include "../Format/Logic/GlobalWorkbookInfo.h"
#include "../Format/Logic/WorkbookStreamObject.h"
#include "../Format/Logic/WorksheetSubstream.h"
#include "../Format/Logic/GlobalsSubstream.h"
#include "../Format/Logic/ChartSheetSubstream.h"
#include "../Format/Logic/MacroSheetSubstream.h"
#include "../Format/Logic/EncryptionStream.h"

#include "../Format/Logic/BinProcessor.h"
#include "../../Common/SummaryInformation/PropertySetStream.h"

#include "../Format/Logic/Biff_unions/FORMATTING.h"
#include "../Format/Logic/Biff_unions/THEME.h"
#include "../Format/Logic/Biff_unions/GLOBALS.h"
#include "../Format/Logic/Biff_unions/COLUMNS.h"
#include "../Format/Logic/Biff_unions/SHAREDSTRINGS.h"
#include "../Format/Logic/Biff_unions/HLINK.h"
#include "../Format/Logic/Biff_unions/LBL.h"
#include "../Format/Logic/Biff_unions/OBJECTS.h"
#include "../Format/Logic/Biff_unions/MSODRAWINGGROUP.h"
#include "../Format/Logic/Biff_unions/OBJ.h"
#include "../Format/Logic/Biff_unions/IMDATAOBJECT.h"
#include "../Format/Logic/Biff_unions/TEXTOBJECT.h"
#include "../Format/Logic/Biff_unions/CHART.h"
#include "../Format/Logic/Biff_unions/BACKGROUND.h"
#include "../Format/Logic/Biff_unions/PIVOTVIEW.h"
#include "../Format/Logic/Biff_unions/PIVOTCACHE.h"
#include "../Format/Logic/Biff_unions/PIVOTCACHEDEFINITION.h"
#include "../Format/Logic/Biff_unions/SUPBOOK.h"
#include "../Format/Logic/Biff_unions/QUERYTABLE.h"
#include "../Format/Logic/Biff_unions/FEAT.h"
#include "../Format/Logic/Biff_unions/FEAT11.h"

#include "../Format/Logic/Biff_records/BkHim.h"
#include "../Format/Logic/Biff_records/HLink.h"
#include "../Format/Logic/Biff_records/MsoDrawingGroup.h"
#include "../Format/Logic/Biff_records/MsoDrawing.h"
#include "../Format/Logic/Biff_records/Obj.h"
#include "../Format/Logic/Biff_records/TxO.h"
#include "../Format/Logic/Biff_records/IMDATA.h"
#include "../Format/Logic/Biff_records/Note.h"
#include "../Format/Logic/Biff_records/WsBool.h"
#include "../Format/Logic/Biff_records/Theme.h"
#include "../Format/Logic/Biff_records/Format.h"
#include "../Format/Logic/Biff_records/CalcMode.h"

#include "../Format/Logic/Biff_structures/URLMoniker.h"
#include "../Format/Logic/Biff_structures/FileMoniker.h"

#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtBStoreContainer.h"
#include "../Format/Logic/Biff_structures/ODRAW/SimpleOfficeArtContainers.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtFOPT.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtFOPTE.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtTertiaryFOPT.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtFSP.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtBlip.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtFSPGR.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtClientAnchorSheet.h"
#include "../Format/Logic/Biff_structures/ODRAW/OfficeArtClientAnchorHF.h"

#include "xlsx_conversion_context.h"
#include "xlsx_package.h"

#include "../../Common/Utils/simple_xml_writer.h"
#include "../../../OOXML/Base/Unit.h"

#include "../../../DesktopEditor/common/File.h"
#include "../../../DesktopEditor/raster/BgraFrame.h"

#include <boost/make_shared.hpp>

#if !defined(_WIN32) && !defined(_WIN64)

    typedef struct tagBITMAPINFOHEADER
    {
            _UINT32      biSize;
            _INT32       biWidth;
            _INT32       biHeight;
            _UINT16       biPlanes;
            _UINT16       biBitCount;
            _UINT32      biCompression;
            _UINT32      biSizeImage;
            _INT32       biXPelsPerMeter;
            _INT32       biYPelsPerMeter;
            _UINT32      biClrUsed;
            _UINT32      biClrImportant;
    } BITMAPINFOHEADER;

typedef struct tagBITMAPCOREHEADER {
        _UINT32   bcSize;                 /* used to get to color table */
        _UINT16    bcWidth;
        _UINT16    bcHeight;
        _UINT16    bcPlanes;
        _UINT16    bcBitCount;
} BITMAPCOREHEADER;
#endif
XlsConverter::XlsConverter() 
{
	output_document		= NULL;
	xlsx_context		= NULL;
	
	is_older_version	= false;
	is_encrypted		= false;
}

XlsConverter::XlsConverter(const std::wstring & xlsFileName, const std::wstring & xlsxFilePath, const std::wstring & password, const std::wstring & fontsPath, const std::wstring & tempPath, const int lcid_user, bool & bMacros) 
{
	xlsx_path			= xlsxFilePath;
	output_document		= NULL;
	xlsx_context		= NULL;
	
	is_older_version	= false;
	is_encrypted		= false;
	output_document		= new oox::package::xlsx_document();

	_UINT16 workbook_code_page = XLS::WorkbookStreamObject::DefaultCodePage;
	
	try
	{
		xls_file = boost::shared_ptr<XLS::CompoundFile>(new XLS::CompoundFile(xlsFileName, XLS::CompoundFile::cf_ReadMode));

		if (xls_file->isError())
		{
			xls_global_info = boost::shared_ptr<XLS::GlobalWorkbookInfo>(new XLS::GlobalWorkbookInfo(workbook_code_page, this));
			
			xls_global_info->lcid_user = lcid_user;
			xls_global_info->fontsDirectory = fontsPath;
			xls_global_info->password = password;
			xls_global_info->tempDirectory = tempPath;
			xls_global_info->CodePage = 0;
			xls_global_info->Version = 0;

			XLS::GlobalWorkbookInfo::_sheet_info sheet_info;
			xls_global_info->sheets_info.push_back(sheet_info);

			XLS::StreamCacheReaderPtr file_reader(new XLS::FileStreamCacheReader(xlsFileName, xls_global_info));
			xls_document = boost::shared_ptr<XLS::WorkbookStreamObject>(new XLS::WorkbookStreamObject(workbook_code_page));
		
			XLS::BinReaderProcessor proc(file_reader, xls_document.get(), true);
			
			XLS::BaseObjectPtr stream = XLS::BaseObjectPtr(new XLS::WorksheetSubstream(0));
            if (proc.mandatory(*stream.get()))
			{
				XLS::WorksheetSubstream *worksheet = dynamic_cast<XLS::WorksheetSubstream*>(stream.get());
				XLS::WorkbookStreamObject *workbook = dynamic_cast<XLS::WorkbookStreamObject*>(xls_document.get());
				if (workbook)
				{
					workbook->m_arWorksheetSubstream.push_back(stream);

					workbook->m_GlobalsSubstream = XLS::BaseObjectPtr(new XLS::GlobalsSubstream(0));

					XLS::GlobalsSubstream* globals = dynamic_cast<XLS::GlobalsSubstream*>(workbook->m_GlobalsSubstream.get());
					if (globals)
					{
						globals->m_Formating = worksheet->m_Formating;
						globals->UpdateXFC();						
					}
				}
			}
			else
			{		
				return;
			}
		}
		else
		{
			OLEPS::PropertySetStream summary_stream;
			
			summary_stream.read(xls_file->getNamedStream(L"SummaryInformation"));
			summary_stream.read(xls_file->getNamedStream(L"DocumentSummaryInformation"), true);

			workbook_code_page = summary_stream.GetCodePage();
				
			output_document->get_docProps_files().set_app_content(summary_stream.GetApp());
			output_document->get_docProps_files().set_core_content(summary_stream.GetCore());
//--------------------------------------------------------------------------------------------------------------------
			if(  0/*error*/ == workbook_code_page)//|| 65001 /*UTF-8*/ == workbook_code_page || 1200/* UTF-16 */ == workbook_code_page
			{
				workbook_code_page = XLS::WorkbookStreamObject::DefaultCodePage;
			}

			xls_global_info = boost::shared_ptr<XLS::GlobalWorkbookInfo>(new XLS::GlobalWorkbookInfo(workbook_code_page, this));
			
			xls_global_info->lcid_user		= lcid_user;
			xls_global_info->fontsDirectory = fontsPath;
			xls_global_info->password		= password;
			xls_global_info->tempDirectory	= tempPath;
//--------------------------------------------------------------------------------------------------------------------
			XLS::StreamCacheReaderPtr workbook_stream(new XLS::CFStreamCacheReader(xls_file->getWorkbookStream(), xls_global_info));
			xls_document = boost::shared_ptr<XLS::WorkbookStreamObject>(new XLS::WorkbookStreamObject(workbook_code_page));		
			
			XLS::BinReaderProcessor workbook_proc(workbook_stream, xls_document.get() , true);
			if (false == workbook_proc.mandatory(*xls_document.get()))
			{
				// test open list
				xls_file->getWorkbookStream()->seekFromBegin(0);
				XLS::StreamCacheReaderPtr worksheet_stream(new XLS::CFStreamCacheReader(xls_file->getWorkbookStream(), xls_global_info));
				
				XLS::BaseObjectPtr worksheet_object = XLS::BaseObjectPtr(new XLS::WorksheetSubstream(0));				
				XLS::BinReaderProcessor worksheet_proc(worksheet_stream, xls_document.get(), true);
				if (worksheet_proc.mandatory(*worksheet_object.get()))
				{
					XLS::WorksheetSubstream* worksheet = dynamic_cast<XLS::WorksheetSubstream*>(worksheet_object.get());
					XLS::WorkbookStreamObject* workbook = dynamic_cast<XLS::WorkbookStreamObject*>(xls_document.get());
					if (workbook)
					{
						workbook->m_arWorksheetSubstream.push_back(worksheet_object);

						workbook->m_GlobalsSubstream = XLS::BaseObjectPtr(new XLS::GlobalsSubstream(0));

						XLS::GlobalsSubstream* globals = dynamic_cast<XLS::GlobalsSubstream*>(workbook->m_GlobalsSubstream.get());
						if (globals)
						{
							globals->m_Formating = worksheet->m_Formating;
							globals->UpdateXFC();
						}
					}
				}
				else
				{
					return; //error
				}
			}

			if (xls_global_info->decryptor)
			{
				is_encrypted = true;
				if (xls_global_info->decryptor->IsVerify() == false) return;
			}
//--------------------------------------------------------------------------------------------------------------------
			XLS::EncryptionSummaryStream encryption_summary(xls_file->getNamedStream(L"encryption"), xls_global_info->decryptor);
//--------------------------------------------------------------------------------------------------------------------
			if (xls_file->storage_->isDirectory(L"_SX_DB_CUR"))
			{
				std::list<std::wstring> listStream = xls_file->storage_->entries(L"_SX_DB_CUR");

				int last_index = 0;
				for (std::list<std::wstring>::iterator it = listStream.begin(); it != listStream.end(); ++it)
				{
					XLS::CFStreamPtr pivot_cache_stream = xls_file->getNamedStream(L"_SX_DB_CUR/" + *it);
					
					if (!pivot_cache_stream) continue;
					//if (pivot_cache_stream->getStreamSize() < 1) continue;

					XLS::StreamCacheReaderPtr pivot_cache_reader(new XLS::CFStreamCacheReader(pivot_cache_stream, xls_global_info));

					XLS::BaseObjectPtr pivot_cache = boost::shared_ptr<XLS::PIVOTCACHE>(new XLS::PIVOTCACHE());
					
					XLS::BinReaderProcessor proc(pivot_cache_reader , pivot_cache.get(), true);
					proc.mandatory(*pivot_cache.get());

					int index = XmlUtils::GetHex(*it); //hexadecimal digits uniquely identifying

					xls_global_info->mapPivotCacheStream.insert(std::make_pair(index, pivot_cache));

					last_index = index;
				}
			}
			if (bMacros)
			{
				if (xls_file->storage_->isDirectory(L"_VBA_PROJECT_CUR"))
				{
					// if false == global_info_->bVbaProjectExist ??

					std::wstring xl_path = xlsx_path + FILE_SEPARATOR_STR + L"xl";
					NSDirectory::CreateDirectory(xl_path.c_str());

					std::wstring sVbaProjectFile = xl_path + FILE_SEPARATOR_STR + L"vbaProject.bin";

					POLE::Storage *storageVbaProject = new POLE::Storage(sVbaProjectFile.c_str());

					if ((storageVbaProject) && (storageVbaProject->open(true, true)))
					{
						xls_file->copy(0, L"_VBA_PROJECT_CUR/", storageVbaProject, false);

						storageVbaProject->close();
						delete storageVbaProject;

						output_document->get_xl_files().add_vba_project();
					}
				}
				else if (xls_global_info->bMacrosExist)
					output_document->get_xl_files().set_macros_enabled();
				else 
					bMacros = false;
			}

			XLS::CFStreamPtr controls = xls_file->getNamedStream(L"Ctls");
			if(controls)
			{
				unsigned long size = controls->getStreamSize();
				boost::shared_array<BYTE> buffer(new BYTE[size]);
				
				controls->read(buffer.get(), size);

				xls_global_info->controls_data = std::make_pair(buffer, size);			
			}
			else
			{
				xls_global_info->controls_data = encryption_summary.GetStream(L"Ctls");
			}
			XLS::CFStreamPtr listdata = xls_file->getNamedStream(L"List Data");
			if(listdata)
			{
				unsigned long size = listdata->getStreamSize();
				boost::shared_array<BYTE> buffer(new BYTE[size]);
				
				listdata->read(buffer.get(), size);

				xls_global_info->listdata_data = std::make_pair(buffer, size);			
			}
			else
			{
				xls_global_info->listdata_data = encryption_summary.GetStream(L"List Data");
			}
			if (xls_file->storage_->isDirectory(L"MsoDataStore"))
			{
				std::list<std::wstring> msoStores = xls_file->storage_->entries(L"MsoDataStore");

				int index = 0;
				for (std::list<std::wstring>::iterator it = msoStores.begin(); it != msoStores.end(); ++it)
				{
					XLS::CFStreamPtr item_stream  = xls_file->getNamedStream(L"MsoDataStore/" + *it + L"/Item");
					XLS::CFStreamPtr props_stream = xls_file->getNamedStream(L"MsoDataStore/" + *it + L"/Properties");

					if (!item_stream || !props_stream) continue;
					
					unsigned long item_size = item_stream->getStreamSize();
					unsigned long props_size = props_stream->getStreamSize();

					oox::package::customXml_content_ptr content = oox::package::customXml_content::create();
		
					char *item_buffer = new char[item_size];
					if (item_buffer)
					{
						item_stream->read(item_buffer, item_size);				
						content->set_item(item_buffer, item_size);
						delete []item_buffer;
					}
					char *props_buffer = new char[props_size];

					if (props_buffer)
					{
						props_stream->read(props_buffer, props_size);
						content->set_props(props_buffer, props_size);
						delete []props_buffer;
					}
					output_document->add_customXml(content);	
				}
			}
			XLS::CFStreamPtr toolbar_data = xls_file->getNamedStream(L"XCB");
			if(toolbar_data)
			{
				std::wstring xl_path = xlsx_path + FILE_SEPARATOR_STR + L"xl";	
				NSDirectory::CreateDirectory(xl_path.c_str());

				std::wstring sToolbarsFile = xl_path + FILE_SEPARATOR_STR + L"attachedToolbars.bin";
	
				NSFile::CFileBinary file;
				if (file.CreateFileW(sToolbarsFile))
				{
					unsigned long size = toolbar_data->getStreamSize();
					boost::shared_array<BYTE> buffer(new BYTE[size]);
					
					toolbar_data->read(buffer.get(), size);
					file.WriteFile(buffer.get(), size);
					file.CloseFile();

					output_document->get_xl_files().add_attachedToolbars();
				}
			}
		}
	}
	catch(...)
	{
		return;
	}

	if (xls_global_info->Version < 0x0600) 
	{
		std::wstring sVer = STR::int2hex_wstr(xls_global_info->Version);
		Log::error("Version xls is old !!! - " + std::string(sVer.begin(), sVer.end()));
		is_older_version = true;
	}	
    xlsx_context = new oox::xlsx_conversion_context(output_document);
}

XlsConverter::~XlsConverter() 
{
	if (xlsx_context)		delete xlsx_context;
	if (output_document)	delete output_document;
}

bool XlsConverter::isError()
{
	if (!xlsx_context)		return true;
	if (!output_document)	return true;

	return false;
}

void XlsConverter::write()
{
	if (!output_document)return;
	
	output_document->write(xlsx_path);

	delete output_document; output_document = NULL;
}

void XlsConverter::convertDocument()
{
    if (!xls_document)     return;
    if (!output_document)   return;
    if (!xlsx_context)       return;

	xlsx_context->start_document();

	convert((XLS::WorkbookStreamObject*)xls_document.get());

	xlsx_context->end_document();
}

void XlsConverter::convert(XLS::BaseObject	*xls_unknown)
{
	if (xls_unknown == NULL) return;

	XLS::ElementType type = xls_unknown->get_type();

	switch (type)
	{
	case XLS::typeHLINK:
		{
			XLS::HLINK * hlink = dynamic_cast<XLS::HLINK*>(xls_unknown);
			convert(hlink);
		}break;
	case XLS::typeLBL:	
		{
			XLS::LBL * lbl = dynamic_cast<XLS::LBL*>(xls_unknown);
			convert(lbl);
		}break;
	case XLS::typeOBJECTS:
		{
			XLS::OBJECTS * obj = dynamic_cast<XLS::OBJECTS*>(xls_unknown);
			convert(obj, NULL);
		}break;
	case XLS::typeTxO:
		{
			XLS::TxO * txo = dynamic_cast<XLS::TxO*>(xls_unknown);
			convert(txo);
		}break;
	case XLS::typeObj:
		{
			XLS::Obj * obj = dynamic_cast<XLS::Obj*>(xls_unknown);
			convert(obj);
		}break;
	case XLS::typeAnyObject:	
	default:
		{
			for (std::list<XLS::BaseObjectPtr>::iterator it = xls_unknown->elements_.begin(); it != xls_unknown->elements_.end(); ++it)
			{
				(*it)->serialize(xlsx_context->current_sheet().sheetData());
			}
		}
	}

}

void XlsConverter::convert(XLS::WorkbookStreamObject* woorkbook)
{
	if (woorkbook == NULL) return;

	convert(dynamic_cast<XLS::GlobalsSubstream*>(woorkbook->m_GlobalsSubstream.get()));

    for (size_t i = 0 ; i < woorkbook->m_arWorksheetSubstream.size(); i++)
	{
		xlsx_context->start_sheet();
			convert(dynamic_cast<XLS::WorksheetSubstream*>(woorkbook->m_arWorksheetSubstream[i].get()));
		xlsx_context->end_sheet();
	}
	for (size_t i = 0 ; i < woorkbook->m_arChartSheetSubstream.size(); i++)
	{
		xlsx_context->start_sheet();
			convert_chart_sheet(dynamic_cast<XLS::ChartSheetSubstream*>(woorkbook->m_arChartSheetSubstream[i].get()));
		xlsx_context->end_sheet();
	}
	for (size_t i = 0 ; i < woorkbook->m_arMacroSheetSubstream.size(); i++)
	{
		xlsx_context->start_sheet();
			convert(dynamic_cast<XLS::MacroSheetSubstream*>(woorkbook->m_arMacroSheetSubstream[i].get()));
		xlsx_context->end_sheet();
	}

	for (std::list<XLS::BaseObjectPtr>::iterator it = woorkbook->elements_.begin(); it != woorkbook->elements_.end(); ++it)
	{
		convert(it->get());
	}

	xlsx_context->add_connections(xls_global_info->connections_stream.str());
}

void XlsConverter::convert_common (XLS::CommonSubstream* sheet)
{
	if (sheet == NULL) return;
	
	xls_global_info->current_sheet = sheet->ws_index_ + 1; 
		
	XLS::GLOBALS *globals = dynamic_cast<XLS::GLOBALS *>(sheet->m_GLOBALS.get());
	
	if (globals)
	{
		globals->serialize_formatPr(xlsx_context->current_sheet().sheetFormat());
		
		if (xlsx_context->workbook_calcpr().rdbuf()->in_avail() == 0)
			globals->serialize_calcPr(xlsx_context->workbook_calcpr());
	}
	
	if (!sheet->m_arWINDOW.empty())
	{
		sheet->m_arWINDOW[0]->serialize(xlsx_context->current_sheet().sheetViews());
	}	
	
	sheet->serialize_format(xlsx_context->current_sheet().sheetProperties());

	if (sheet->m_PROTECTION)
	{
		sheet->m_PROTECTION->serialize(xlsx_context->current_sheet().protection());
	}
	if (sheet->m_COLUMNS)
	{
		sheet->m_COLUMNS->serialize(xlsx_context->current_sheet().cols());
	}
	if (sheet->m_CELLTABLE)
	{
		sheet->m_CELLTABLE->serialize(xlsx_context->current_sheet().sheetData());
	}
	if (sheet->m_SORTANDFILTER)
	{
		sheet->m_SORTANDFILTER->serialize(xlsx_context->current_sheet().sheetSortAndFilters());
	}	
	if (sheet->m_PAGESETUP)
	{
		sheet->m_PAGESETUP->serialize(xlsx_context->current_sheet().pageProperties());
	}
	if (globals)
	{
		if (globals->m_HorizontalPageBreaks)
		{
			globals->m_HorizontalPageBreaks->serialize(xlsx_context->current_sheet().pageProperties());
		}
		if (globals->m_VerticalPageBreaks)
		{
			globals->m_VerticalPageBreaks->serialize(xlsx_context->current_sheet().pageProperties());
		}
		//if (globals->m_CalcMode)
		//{
		//	CP_XML_WRITER(xlsx_context->current_sheet().sheetCalcPr())
		//	{
		//		CP_XML_NODE(L"sheetCalcPr")
		//		{
		//			XLS::CalcMode *calcMode = dynamic_cast<XLS::CalcMode *>(globals->m_CalcMode.get());
		//			CP_XML_ATTR(L"fullCalcOnLoad", calcMode->nAutoRecalc > 0 ? 1 : 0);					
		//		}
		//	}
		//}
	}

	if (sheet->m_arCUSTOMVIEW.size() > 0)
	{
		CP_XML_WRITER(xlsx_context->current_sheet().customViews())    
		{
			CP_XML_NODE(L"customSheetViews")
            {
				for (size_t i = 0 ; i < sheet->m_arCUSTOMVIEW.size(); i++)
				{
					sheet->m_arCUSTOMVIEW[i]->serialize(CP_XML_STREAM());
				}
			}
		}
	}

	if (sheet->m_BACKGROUND)
	{
		convert(dynamic_cast<XLS::BACKGROUND*>(sheet->m_BACKGROUND.get()));
	}

	for (size_t i = 0 ; i < sheet->m_arHFPictureDrawing.size(); i++)
	{
		convert((ODRAW::OfficeArtDgContainer*)sheet->m_arHFPictureDrawing[i].get());
	}

	//for (size_t i = 0 ; i < sheet->m_arFEAT.size(); i++)
	//{
	//	convert(dynamic_cast<XLS::FEAT*>(sheet->m_arFEAT.get()));
	//}

	for (size_t i = 0 ; i < sheet->m_arFEAT11.size(); i++)
	{
		convert(dynamic_cast<XLS::FEAT11*>(sheet->m_arFEAT11[i].get()));
	}
}

void XlsConverter::convert (XLS::WorksheetSubstream* sheet)
{
	if (sheet == NULL) return;
	if (xls_global_info->sheets_info.empty()) return;

	std::wstring name = xls_global_info->sheets_info[sheet->ws_index_].name;
	if (name.empty()) 
		name = L"Sheet_" + std::to_wstring(sheet->ws_index_ + 1);

	xlsx_context->set_sheet_type(1);
	xlsx_context->set_sheet_name(name) ;
	xlsx_context->set_sheet_id(sheet->ws_index_ + 1);
	xlsx_context->set_sheet_state(xls_global_info->sheets_info[sheet->ws_index_].state);

	if (sheet->m_GLOBALS)
	{
		XLS::GLOBALS * globals  = dynamic_cast<XLS::GLOBALS *>(sheet->m_GLOBALS.get());
		XLS::COLUMNS * columns = dynamic_cast<XLS::COLUMNS *>(sheet->m_COLUMNS.get());

		if (columns)
		{
			globals->m_DefColWidth	= columns->m_DefColWidth; 
		}
		globals->m_DxGCol = sheet->m_DxGCol;		

		if (globals->is_dialog)
			xlsx_context->set_sheet_type(2);
	}

	convert_common(dynamic_cast<XLS::CommonSubstream*>(sheet));

	convert((XLS::OBJECTS*)sheet->m_OBJECTS.get(), sheet);

	if (sheet->m_Dimensions)
	{
		sheet->m_Dimensions->serialize(xlsx_context->current_sheet().dimension());
	}	
	if (sheet->m_arMergeCells.size() > 0)
	{
		CP_XML_WRITER(xlsx_context->current_sheet().mergeCells())    
		{
			CP_XML_NODE(L"mergeCells")
			{  		
                for (size_t i = 0 ; i < sheet->m_arMergeCells.size(); i++)
				{
					sheet->m_arMergeCells[i]->serialize(CP_XML_STREAM());
				}
			}
		}
	}
    for (size_t i = 0 ; i < sheet->m_arHLINK.size(); i++)
	{
		convert((XLS::HLINK*)sheet->m_arHLINK[i].get());
	}
	if (sheet->m_CONDFMTS)
	{
		sheet->m_CONDFMTS->serialize(xlsx_context->current_sheet().conditionalFormatting());
	}
	if (sheet->m_DVAL)
	{
		sheet->m_DVAL->serialize(xlsx_context->current_sheet().dataValidations());
	}
	if (!sheet->m_arNote.empty() && xls_global_info->Version < 0x0600)
	{
		xlsx_context->get_drawing_context().start_drawing(0);
		for (size_t i = 0 ; i < sheet->m_arNote.size(); i++)
		{
			xlsx_context->get_drawing_context().start_drawing(0x0019);
				convert(dynamic_cast<XLS::Note*>(sheet->m_arNote[i].get()));
			xlsx_context->get_drawing_context().end_drawing();
		}
		xlsx_context->get_drawing_context().end_group();
	}

	for (size_t i = 0; i < sheet->m_arQUERYTABLE.size(); i++)
	{
		convert(dynamic_cast<XLS::QUERYTABLE*>(sheet->m_arQUERYTABLE[i].get()));
	}
	for (size_t i = 0; i < sheet->m_arPIVOTVIEW.size(); i++)
	{
		convert((XLS::PIVOTVIEW*)sheet->m_arPIVOTVIEW[i].get());
	}
}

void XlsConverter::convert (XLS::MacroSheetSubstream* sheet)
{
	if (sheet == NULL) return;

	xls_global_info->current_sheet = sheet->ws_index_ + 1; 
	
	std::wstring name = xls_global_info->sheets_info[sheet->ws_index_].name;
	if (name.empty()) 
		name = L"MacroSheet_" + std::to_wstring(sheet->ws_index_ + 1);

	xlsx_context->set_sheet_type(4);
	xlsx_context->set_sheet_name(name) ;
	xlsx_context->set_sheet_id(sheet->ws_index_ + 1);
	xlsx_context->set_sheet_state(xls_global_info->sheets_info[sheet->ws_index_].state);

	if (sheet->m_GLOBALS)
	{
		XLS::GLOBALS * globals  = dynamic_cast<XLS::GLOBALS *>(sheet->m_GLOBALS.get());
		XLS::COLUMNS * columns = dynamic_cast<XLS::COLUMNS *>(sheet->m_COLUMNS.get());

		if (columns)
		{
			globals->m_DefColWidth	= columns->m_DefColWidth; 
		}
		globals->m_DxGCol = sheet->m_DxGCol;		

		if (globals->is_dialog)
			xlsx_context->set_sheet_type(2);
	}
	convert_common(dynamic_cast<XLS::CommonSubstream*>(sheet));

	convert((XLS::OBJECTS*)sheet->m_OBJECTS.get(), NULL);

	if (sheet->m_Dimensions)
	{
		sheet->m_Dimensions->serialize(xlsx_context->current_sheet().dimension());
	}
	
	if (!sheet->m_arNote.empty() && xls_global_info->Version < 0x0600)
	{
		xlsx_context->get_drawing_context().start_drawing(0);
		for (size_t i = 0 ; i < sheet->m_arNote.size(); i++)
		{
			xlsx_context->get_drawing_context().start_drawing(0x0019);
				convert(dynamic_cast<XLS::Note*>(sheet->m_arNote[i].get()));
			xlsx_context->get_drawing_context().end_drawing();
		}
		xlsx_context->get_drawing_context().end_group();
	}
}

void XlsConverter::convert(XLS::GlobalsSubstream* globals)
{
	if (globals == NULL) return;
	
	convert_theme();
	
	convert((XLS::FORMATTING*)globals->m_Formating.get());	

	convert((XLS::SHAREDSTRINGS*)globals->m_SHAREDSTRINGS.get());

    for (size_t i = 0 ; i < globals->m_arLBL.size(); i++)
	{
		convert((XLS::LBL*)globals->m_arLBL[i].get());
	}

    for (size_t i = 0 ; i < globals->m_arMSODRAWINGGROUP.size(); i++)
	{
		convert((XLS::MSODRAWINGGROUP*)globals->m_arMSODRAWINGGROUP[i].get());
	}

	for (size_t i = 0 ; i < globals->m_arHFPictureDrawing.size(); i++)
	{
		convert((ODRAW::OfficeArtDggContainer*)globals->m_arHFPictureDrawing[i].get());
	}
	globals->serialize_protection(xlsx_context->workbook_protection());
	
	globals->serialize_format(xlsx_context->workbook_format());

    for (size_t i = 0 ; i < globals->m_arWindow1.size(); i++)
	{
		globals->m_arWindow1[i]->serialize(xlsx_context->workbook_views());
	}
    for (size_t i = 0 ; i < globals->m_arUserBView.size(); i++)
	{
		globals->m_arUserBView[i]->serialize(xlsx_context->custom_views());
	}

	for (size_t i = 0 ; i < globals->m_arSUPBOOK.size(); i++)
	{
		convert((XLS::SUPBOOK*)globals->m_arSUPBOOK[i].get());
	}

	for (size_t i = 0 ; i < xls_global_info->arPIVOTCACHEDEFINITION.size(); i++)
	{
		convert((XLS::PIVOTCACHEDEFINITION*)xls_global_info->arPIVOTCACHEDEFINITION[i].get());
	}
}

void XlsConverter::convert_chart_sheet(XLS::ChartSheetSubstream* chartsheet)
{
	if (chartsheet == NULL) return;
		
	xls_global_info->current_sheet = chartsheet->ws_index_ + 1; 
	
	std::wstring name = xls_global_info->sheets_info[chartsheet->ws_index_].name;
	if (name.empty()) 
		name = L"ChartSheet_" + std::to_wstring(chartsheet->ws_index_ + 1);

	xlsx_context->set_sheet_type(3);
	xlsx_context->set_sheet_name(name) ;
	xlsx_context->set_sheet_id(chartsheet->ws_index_ + 1);
	xlsx_context->set_sheet_state(xls_global_info->sheets_info[chartsheet->ws_index_].state);

	convert_common(dynamic_cast<XLS::CommonSubstream*>(chartsheet));

	if (xlsx_context->get_drawing_context().start_drawing(0x0005))		
	{
		xlsx_context->get_drawing_context().set_id(1);
		convert(chartsheet);

		xlsx_context->get_drawing_context().end_drawing();
	}
}
typedef boost::unordered_map<XLS::FillInfo, int>	mapFillInfo;
typedef boost::unordered_map<XLS::BorderInfo, int>	mapBorderInfo;
typedef boost::unordered_map<XLS::FontInfo, int>	mapFontInfo;

void XlsConverter::convert(XLS::FORMATTING* formating)
{
	if (formating == NULL) return;

	std::wstringstream strm;
    CP_XML_WRITER(strm)    
    {
        CP_XML_NODE(L"styleSheet")
        {   
			CP_XML_ATTR(L"xmlns", L"http://schemas.openxmlformats.org/spreadsheetml/2006/main");
			CP_XML_ATTR(L"xmlns:mc", L"http://schemas.openxmlformats.org/markup-compatibility/2006");
			CP_XML_ATTR(L"mc:Ignorable", L"x14ac x16r2");
			CP_XML_ATTR(L"xmlns:x14ac", L"http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac");
			CP_XML_ATTR(L"xmlns:x16r2", L"http://schemas.microsoft.com/office/spreadsheetml/2015/02/main");
			
			CP_XML_NODE(L"numFmts")
			{
				CP_XML_ATTR(L"count", xls_global_info->m_mapNumFormats.size());
				for (std::map<_UINT16, XLS::BaseObjectPtr>::iterator it = xls_global_info->m_mapNumFormats.begin(); it != xls_global_info->m_mapNumFormats.end(); ++it)
				{
					XLS::Format* fmt = dynamic_cast<XLS::Format*>(it->second.get());

					if (fmt->ifmt < 5 || (fmt->ifmt > 8 && fmt->ifmt < 23) || (fmt->ifmt > 36 && fmt->ifmt < 41) || (fmt->ifmt > 44 && fmt->ifmt < 50))
						continue;

					std::map<_UINT16, _UINT16>::iterator pFind = xls_global_info->mapUsedFormatCode.find(fmt->ifmt);

					if (pFind != xls_global_info->mapUsedFormatCode.end())
					{
						CP_XML_STREAM() << L"<numFmt";
						{
							CP_XML_STREAM() << L" numFmtId=\"" << fmt->ifmt_used << L"\"";
							CP_XML_STREAM() << L" formatCode=\"" << fmt->stFormat << L"\"";
						}
						CP_XML_STREAM() << L"/>";
					}
				}
			}
			CP_XML_NODE(L"fonts")
			{
				std::vector<XLS::FontInfo> fonts_out;
				fonts_out.resize(xls_global_info->font_x_ids.size());

				for (mapFontInfo::iterator it = xls_global_info->font_x_ids.begin(); it != xls_global_info->font_x_ids.end(); ++it)
				{
					fonts_out[it->second] = it->first;
				}

				CP_XML_ATTR(L"count", fonts_out.size());
				for (size_t i = 0 ;i < fonts_out.size(); i++)
				{
					fonts_out[i].serialize(CP_XML_STREAM());
				}
			}
			CP_XML_NODE(L"fills")
			{
				std::vector<XLS::FillInfo> fills_out;
				fills_out.resize(xls_global_info->fill_x_ids.size());

				for (mapFillInfo::iterator it = xls_global_info->fill_x_ids.begin(); it != xls_global_info->fill_x_ids.end(); ++it)
				{
					fills_out[it->second] = it->first;
				}

				CP_XML_ATTR(L"count", fills_out.size());
				for (size_t i = 0 ;i < fills_out.size(); i++)
				{
					fills_out[i].serialize(CP_XML_STREAM());
				}
			}
			CP_XML_NODE(L"borders")
			{				
				std::vector<XLS::BorderInfo> borders_out;
				borders_out.resize(xls_global_info->border_x_ids.size());

				for (mapBorderInfo::iterator it = xls_global_info->border_x_ids.begin(); it != xls_global_info->border_x_ids.end(); ++it)
				{
					borders_out[it->second] = it->first;
				}
				
				CP_XML_ATTR(L"count", borders_out.size());
				for (size_t i = 0 ;i < borders_out.size(); i++)
				{
					borders_out[i].serialize(CP_XML_STREAM());
				}
			}

			formating->serialize(CP_XML_STREAM());
		}
	}
    
	output_document->get_xl_files().set_styles( oox::package::simple_element::create(L"styles.xml", strm.str()) );
}

std::wstring XlsConverter::GetTargetMoniker(XLS::BiffStructure *moniker)
{
	if (moniker == NULL) return L"";

    if (moniker->getClassName() == "URLMoniker")
	{
		OSHARED::URLMoniker* urlMoniker = dynamic_cast<OSHARED::URLMoniker* >(moniker);
		if (urlMoniker)return urlMoniker->url;
	}
    else if (moniker->getClassName() == "FileMoniker")
	{
		OSHARED::FileMoniker* fileMoniker = dynamic_cast<OSHARED::FileMoniker* >(moniker);
		if (fileMoniker)
		{
			if (!fileMoniker->unicodePath.empty()) return fileMoniker->unicodePath;
			else return std::wstring(fileMoniker->ansiPath.begin(), fileMoniker->ansiPath.end());//codePage ??? todooo
		}
	}

	return L"";
}

void XlsConverter::convert(XLS::MSODRAWINGGROUP * mso_drawing)
{
	if ( mso_drawing == NULL) return;
	XLS::MsoDrawingGroup * mso_group = dynamic_cast<XLS::MsoDrawingGroup*>(mso_drawing->m_MsoDrawingGroup.get());
	if (mso_group == NULL) return;

	//files 
	convert (dynamic_cast<ODRAW::OfficeArtBStoreContainer*>(mso_group->rgChildRec.m_OfficeArtBStoreContainer.get()));

		
}

std::wstring XlsConverter::WriteMediaFile(char *data, int size, std::wstring type_ext, int id)
{
	if (size < 1 || !data) return L"";
	
	if (id < 0)		id = xlsx_context->get_mediaitems().count_image + 1000; // 1000 - встроенные в поток , 3000 - footer/header

	xlsx_context->get_mediaitems().create_media_path(xlsx_path);

	bool res = false;
	std::wstring file_name = L"image" + std::to_wstring(id);
	
	if (type_ext == L"dib_data")
	{
		bool bPNG = false;
		int offset = 0, biSizeImage = 0;
		CBgraFrame frame;

		BITMAPINFOHEADER * header = (BITMAPINFOHEADER *)data;

		if (header->biWidth > 100000 || header->biHeight > 100000)
		{
			//biff8
			//Formulas Matriciais - A Outra Dimensão do Excel.xls	775x20 		todoooo найти еще файлы 
			//Planilha Bastter Blue 7.0 Free.xls 10x3836
			//biff 5
			//test-picture.xls
			offset = 12; //sizeof(BITMAPCOREHEADER)
			
			BITMAPCOREHEADER * header_core = (BITMAPCOREHEADER *)data;
		
			frame.put_Height	(header_core->bcHeight );
			frame.put_Width		(header_core->bcWidth );
			
			int sz_bitmap = header_core->bcHeight * header_core->bcWidth * header_core->bcBitCount/ 8;
			
			//if (header_core->bcWidth % 2 != 0 && sz_bitmap < size - offset)
			//	header_core->bcWidth++;
			///???? todooo непонятно .. в biff5 нужно флипать картинку, в biff8 не ясно ( - 
			
			int stride = - (size - offset) / header_core->bcHeight;
			frame.put_Stride	(stride/*header_core->bcBitCount * header_core->bcWidth /8 */);

			biSizeImage = size - offset;
			
			if (-stride >= header_core->bcWidth && header_core->bcBitCount >=24 )
			{
				bPNG = true;
			}
		}
		else
		{
			offset = 40; //sizeof(BITMAPINFOHEADER)

			frame.put_Height	(header->biHeight );
			frame.put_Width		(header->biWidth );
			
			int sz_bitmap = header->biHeight * header->biWidth * header->biBitCount/ 8;
			
			//if (header->biWidth % 2 != 0 && sz_bitmap < size -offset)
			//	header->biWidth++;
			
			int stride =  -(size - offset) / header->biHeight;

			if (-stride >= header->biWidth && header->biBitCount >= 24)
			{
				bPNG = true;
			}
			frame.put_Stride	(stride/*header->biBitCount * header->biWidth /8*/);
			
			biSizeImage = header->biSizeImage;
		}
		if (bPNG)
		{
			frame.put_Data((unsigned char*)data + offset);
			
			file_name += std::wstring(L".png");
			
			res = frame.SaveFile(xlsx_context->get_mediaitems().media_path() + file_name, 4/*CXIMAGE_FORMAT_PNG*/);
			frame.put_Data(NULL);

			if (res = false)
			{
				//
			}
		}
		else if (biSizeImage > 0)
		{
			//тут паттерные картинки
			file_name += std::wstring(L".bmp");
			NSFile::CFileBinary file;
			if (file.CreateFileW(xlsx_context->get_mediaitems().media_path() + file_name))
			{
				WORD vtType		= 0x4D42;				file.WriteFile((BYTE*)&vtType,	2);
				DWORD dwLen		= biSizeImage;			file.WriteFile((BYTE*)&dwLen,	4);
				DWORD dwRes		= 0;					file.WriteFile((BYTE*)&dwRes,	4);
				DWORD dwOffset	= 2;					file.WriteFile((BYTE*)&dwOffset, 4);
			
				file.WriteFile((BYTE*)data, size);
				file.CloseFile();
				res = true;
			}
		}
	}
	else if (type_ext == L"pict")
	{
		//NSFile::CFileBinary file;
		//std::wstring tempPICT = file.CreateTempFileWithUniqueName(xls_global_info->tempDirectory, L"pct");
		//if (file.CreateFileW(tempPICT))
		//{
		//	file.WriteFile((BYTE*)data, size);
		//	file.CloseFile();
		//}
		CBgraFrame bgraFrame;

		if (bgraFrame.Decode((BYTE*)data, size))
		{
			file_name += L".png";
			bgraFrame.SaveFile(xlsx_context->get_mediaitems().media_path() + file_name, 4); // png
		}
		//NSFile::CFileBinary::Remove(tempPICT);
	}
	else
	{
		file_name += type_ext;

		NSFile::CFileBinary file;
		if (file.CreateFileW(xlsx_context->get_mediaitems().media_path() + file_name))
		{		
			file.WriteFile((BYTE*)data, size);
			file.CloseFile();
		}
	}
//------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------
	res = true;
	if (res)
	{
		xlsx_context->get_mediaitems().add_image(L"media/" + file_name, id);
		return L"media/" + file_name;
	}
	return L"";
}

void XlsConverter::convert(ODRAW::OfficeArtBStoreContainer* art_bstore, int start_id)
{
	if (art_bstore == NULL) return;
	if (art_bstore->rgfb.size() < 1) return;

    for (size_t i = 0 ; i < art_bstore->rgfb.size(); i++)
	{
		int bin_id = i + start_id + 1;

		WriteMediaFile(art_bstore->rgfb[i]->pict_data, art_bstore->rgfb[i]->pict_size, art_bstore->rgfb[i]->pict_type, bin_id);
	}
}
void XlsConverter::convert(XLS::FEAT11 * shared_feature)
{
	if (!shared_feature) return;

	for (size_t i = 0; i < shared_feature->m_arFEAT.size(); i++)
	{
		xlsx_context->start_table();

		std::wstringstream strm;
		shared_feature->serialize(strm, i);

		xlsx_context->get_tables_context().add_table(strm.str());

		xlsx_context->end_table();	
	}
}

void XlsConverter::convert(XLS::HLINK * HLINK_)
{
	if (!HLINK_) return;
	XLS::HLink * hLink = dynamic_cast<XLS::HLink*>(HLINK_->m_HLink.get());
	if (!hLink) return;

	std::wstring target;
	
	bool bExternal = false;
	
	if (hLink->hyperlink.hlstmfHasMoniker)
	{
		target = GetTargetMoniker(hLink->hyperlink.oleMoniker.data.get());
		bExternal = true;
	}
	else if (hLink->hyperlink.hlstmfHasLocationStr)
	{
		target = hLink->hyperlink.location;
	}

	std::wstring display = hLink->hyperlink.displayName;

	if (display.empty())	display = target;

	xlsx_context->get_sheet_context().add_hyperlink( hLink->ref8.toString(), target, display, bExternal);
}

void XlsConverter::convert(XLS::LBL * def_name)
{
	if (def_name == NULL) return;

	def_name->serialize(xlsx_context->defined_names());
}
void XlsConverter::convert(XLS::IMDATA * imdata)
{
	if (imdata == NULL) return;

	if (imdata->lcb < 1 || imdata->pData == NULL) return;
	
	bool bInternal = false;

	std::wstring type_image;

	if (imdata->cf == 0x09 && imdata->env == 0x01)	type_image = L".wmf";
	if ((imdata->cf == 0x09 || imdata->cf == 0x02)
							&& imdata->env == 0x02)	type_image = L"pict";
	if (imdata->cf == 0x09)							type_image = L"dib_data";
	if (imdata->cf == 0x0e)							type_image = L"";			//native aka unknown

	std::wstring target = WriteMediaFile(imdata->pData.get(), imdata->lcb, type_image);
	xlsx_context->get_drawing_context().set_fill_texture(target);

}

void XlsConverter::convert(XLS::BACKGROUND * back)
{
	if (back == NULL) return;

	XLS::BkHim * bkHim = dynamic_cast<XLS::BkHim*>(back->m_BkHim.get());
	
	if (bkHim->lcb < 1 || bkHim->pData == NULL) return;
	
	bool bInternal = false;

	std::wstring target = WriteMediaFile(bkHim->pData.get(), bkHim->lcb, L"dib_data");

	std::wstring rId = xlsx_context->get_mediaitems().find_image(target, bInternal);
	
	xlsx_context->current_sheet().sheet_rels().add(oox::relationship(rId, oox::external_items::typeImage, std::wstring(L"../") + target, !bInternal));

	if (rId.empty()) return;

	CP_XML_WRITER(xlsx_context->current_sheet().picture_background())    
	{
		CP_XML_NODE(L"picture")
		{
			CP_XML_ATTR(L"r:id", rId);
		}
	}

}

void XlsConverter::convert_theme()
{
	if (xls_global_info->sTheme.empty()) return;
	
	oox::package::theme_content_ptr content = 
		oox::package::theme_content::create((char*)xls_global_info->sTheme.c_str(), xls_global_info->sTheme.length());
	output_document->get_xl_files().add_theme(content);
}

struct _group_object
{
	_group_object() {spgr = NULL; ind = count = 0;}
	ODRAW::OfficeArtSpgrContainer	*spgr;
	int ind;
	int count;
};
void XlsConverter::convert_old(XLS::OBJECTS* objects, XLS::WorksheetSubstream * sheet)
{
	int count = 0;
	
	for ( std::list<XLS::BaseObjectPtr>::iterator elem = objects->elements_.begin(); elem != objects->elements_.end(); elem++)
	{
		count++;
		short type_object = -1;

		XLS::OBJ			* OBJ			= dynamic_cast<XLS::OBJ*>		(elem->get());
		XLS::IMDATAOBJECT	* IMDATAOBJECT	= NULL;
		XLS::CHART			* CHART			= NULL;
		
		std::list<XLS::BaseObjectPtr>::iterator elem_next = boost::next(elem);
		if ( elem_next !=objects->elements_.end() )
		{
			IMDATAOBJECT	= dynamic_cast<XLS::IMDATAOBJECT*>	(elem_next->get());
			CHART			= dynamic_cast<XLS::CHART*>			(elem_next->get());
		}

		XLS::Obj					* obj		= OBJ			? dynamic_cast<XLS::Obj *>(OBJ->m_Obj.get()) : NULL;
		XLS::IMDATA					* image_obj	= IMDATAOBJECT	? dynamic_cast<XLS::IMDATA *>(IMDATAOBJECT->m_IMDATA.get())	: NULL;
		XLS::ChartSheetSubstream	* chart		= CHART			? dynamic_cast<XLS::ChartSheetSubstream *>(CHART->m_ChartSheetSubstream.get()) : NULL;		
		
		if (!obj)continue;
		
		type_object = obj->cmo.ot;
//-----------------------------------------------------------------------------
		if (type_object < 0)continue;
		
		if (type_object == 0) 
			continue;

		if (obj->cmo.fUIObj)
		{
			continue; // automatically inserted by the application
		}
		if (xlsx_context->get_drawing_context().start_drawing(type_object))
		{
			convert(obj->old_version.anchor.get());

			if (obj->old_version.bFill)
				xlsx_context->get_drawing_context().set_fill_old_version(obj->old_version.fill);
			else 
				xlsx_context->get_drawing_context().set_fill_type(oox::fillNone);	//no fill
			
			xlsx_context->get_drawing_context().set_name(obj->old_version.name);
			xlsx_context->get_drawing_context().set_line_old_version(obj->old_version.line);
			xlsx_context->get_drawing_context().set_flag_old_version(obj->old_version.flag, obj->old_version.flag2);

			for (size_t i = 0 ; i < obj->old_version.additional.size(); i++)
			{
				convert(obj->old_version.additional[i].get());
			}
			convert(image_obj);
			convert(chart);
			convert(obj);

			xlsx_context->get_drawing_context().end_drawing();
		}
		if (IMDATAOBJECT || CHART)
		{
			elem++;
			count++;
		}	
	}
}
void XlsConverter::convert(XLS::OBJECTS* objects, XLS::WorksheetSubstream * sheet)
{
	if (objects == NULL) return;

	if (xls_global_info->Version < 0x0600)
		return convert_old(objects, sheet);

	std::vector<_group_object> group_objects;

	_group_object gr;		
	gr.spgr		= dynamic_cast<ODRAW::OfficeArtSpgrContainer*>(objects->m_MsoDrawing.get()->rgChildRec.m_OfficeArtSpgrContainer.get());
	
	if (gr.spgr	== NULL) 
		return;

	gr.count	= gr.spgr->child_records.size();
	group_objects.push_back(gr);

	if ((group_objects.back().spgr) && (group_objects.back().ind < group_objects.back().spgr->child_records.size()))
	{
		ODRAW::OfficeArtSpContainer *s	= dynamic_cast<ODRAW::OfficeArtSpContainer*>(group_objects.back().spgr->child_records[group_objects.back().ind].get());
		if (s)
		{
			ODRAW::OfficeArtFSP *fsp = dynamic_cast<ODRAW::OfficeArtFSP*>(s->m_OfficeArtFSP.get());
			if ((fsp) && (fsp->fPatriarch)) group_objects.back().ind++;
		}
	}
	int count = 0;
	
	for ( std::list<XLS::BaseObjectPtr>::iterator elem = objects->elements_.begin(); elem != objects->elements_.end(); elem++)
	{
		count++;
		short type_object = -1;

		XLS::OBJ		* OBJ			= dynamic_cast<XLS::OBJ*>		(elem->get());

		XLS::TEXTOBJECT	* TEXTOBJECT	= NULL;
		XLS::CHART		* CHART			= NULL;
		
		std::list<XLS::BaseObjectPtr>::iterator elem_next = boost::next(elem);
		if ( elem_next !=objects->elements_.end() )
		{
			TEXTOBJECT	= dynamic_cast<XLS::TEXTOBJECT*>(elem_next->get());
			CHART		= dynamic_cast<XLS::CHART*>		(elem_next->get());
		}

		XLS::Obj					* obj		= NULL;
		XLS::TxO					* text_obj	= NULL; 
		XLS::ChartSheetSubstream	* chart		= NULL;

		if (OBJ)		obj			= dynamic_cast<XLS::Obj *>(OBJ->m_Obj.get());		
		if (TEXTOBJECT) text_obj	= dynamic_cast<XLS::TxO *>(TEXTOBJECT->m_TxO.get());
		if (CHART)		chart		= dynamic_cast<XLS::ChartSheetSubstream *>(CHART->m_ChartSheetSubstream.get());
		
		if (obj)	type_object = obj->cmo.ot;
		if (chart)	type_object = 0x0005;

		if (text_obj)
		{ 
			if (type_object < 0) type_object = 0x0006;			
		}

//-----------------------------------------------------------------------------
		if (type_object < 0) continue;
		if (group_objects.empty())
			break; /// что то с объектами не то ! 2006 02.xls

		if (type_object == 0)
		{
			_group_object gr;		
			if (group_objects.back().ind < group_objects.back().spgr->child_records.size())
			{
				gr.spgr		= dynamic_cast<ODRAW::OfficeArtSpgrContainer*>(group_objects.back().spgr->child_records[group_objects.back().ind++].get());
				gr.count	= gr.spgr ? gr.spgr->child_records.size() : 0;
				group_objects.push_back(gr);
			}
			else //сюда попадать не должно !!!!
				continue;
		}
		if (obj->cmo.fUIObj)
		{
			group_objects.back().ind++;
			continue; // automatically inserted by the application
		}
		
		ODRAW::OfficeArtSpContainer *sp = NULL;

		if ((group_objects.size() > 0) && (group_objects.back().spgr ) && ( group_objects.back().ind < group_objects.back().count))
		{
			sp	= dynamic_cast<ODRAW::OfficeArtSpContainer*>(group_objects.back().spgr->child_records[group_objects.back().ind++].get());
		}	
		
		if (xlsx_context->get_drawing_context().start_drawing(type_object))
		{
			convert(sp);

			if ((!sp) || (!sp->m_OfficeArtAnchor))
			{
				if ((group_objects.size() > 0) && (group_objects.back().spgr ) && ( group_objects.back().ind < group_objects.back().count))
				{
					sp	= dynamic_cast<ODRAW::OfficeArtSpContainer*>(group_objects.back().spgr->child_records[group_objects.back().ind++].get());
				}
				convert(sp, true);
			}			
			if (type_object == 0x19)
			{	
				text_obj->preserve_enabled = true;

				for (size_t i = 0 ; sheet && i < sheet->m_arNote.size(); i++)
				{
					XLS::Note* note = dynamic_cast<XLS::Note*>(sheet->m_arNote[i].get());
					if ((note) && (note->note_sh.idObj == obj->cmo.id))
					{
						convert(note);
						break;
					}
				}
			}
			convert(text_obj);
			convert(chart);
			convert(obj);

			xlsx_context->get_drawing_context().end_drawing();
		}
		if (TEXTOBJECT || CHART)
		{
			elem++;
			count++;
		}		
		
		while ((group_objects.size() >0) && (group_objects.back().ind >= group_objects.back().count))
		{
			group_objects.back().spgr = NULL;
			group_objects.pop_back();
			
			xlsx_context->get_drawing_context().end_group();
		}
	}
}
void XlsConverter::convert(ODRAW::OfficeArtSpgrContainer * spgr)
{
	if (spgr == NULL) return;
	if (spgr->anchor_type_ != ODRAW::OfficeArtRecord::CA_HF) return;

	for (size_t i = 0; i < spgr->child_records.size(); i++)
	{
		ODRAW::OfficeArtSpContainer* SpContainer = dynamic_cast<ODRAW::OfficeArtSpContainer*>(spgr->child_records[i].get());
		if (SpContainer)
		{
			ODRAW::OfficeArtFSP* fsp = dynamic_cast<ODRAW::OfficeArtFSP*>(SpContainer->m_OfficeArtFSP.get());
			if ((fsp) && (fsp->fHaveSpt))
			{
				int type_object = 2;//rect
				if (xlsx_context->get_drawing_context().start_drawing(type_object))
				{
					xlsx_context->get_drawing_context().set_mode_HF(true);
					convert(spgr->child_records[i].get());

					xlsx_context->get_drawing_context().end_drawing();
				}
			}
		}
	}
}
void XlsConverter::convert(ODRAW::OfficeArtSpContainer *sp, bool anchor_only)
{
	if (sp == NULL) return;

	if (!anchor_only)
	{
		convert(sp->m_OfficeArtFSP.get());

		for (size_t i = 0; i < sp->child_records.size(); i++)
		{
			convert(sp->child_records[i].get());
		}
	}
	convert(sp->m_OfficeArtAnchor.get());
}

void XlsConverter::convert(ODRAW::OfficeArtRecord * art)
{
	if (art == NULL) return;

	std::wstringstream strm;

	switch(art->get_type())
	{
	case XLS::typeOfficeArtFOPT://properties
		{
			convert(dynamic_cast<ODRAW::OfficeArtFOPT *>(art));
		}break;
	case XLS::typeOfficeArtTertiaryFOPT://properties
		{
			convert(dynamic_cast<ODRAW::OfficeArtTertiaryFOPT *>(art));
		}break;
	case XLS::typeOfficeArtFSP:
		{
			convert(dynamic_cast<ODRAW::OfficeArtFSP *>(art));
		}break;
	case XLS::typeOfficeArtFSPGR:
		{
			ODRAW::OfficeArtFSPGR * ch = dynamic_cast<ODRAW::OfficeArtFSPGR *>(art);

			xlsx_context->get_drawing_context().set_group_anchor(ch->_x, ch->_y, ch->_cx, ch->_cy);
		}break;
	case XLS::typeOfficeArtClientAnchorHF:
		{
			ODRAW::OfficeArtClientAnchorHF * hf = dynamic_cast<ODRAW::OfficeArtClientAnchorHF *>(art);
			xlsx_context->get_drawing_context().set_child_anchor(0, 0, hf->_cx * 3 / 5, hf->_cy * 3 / 5);
		}break;
	case XLS::typeOfficeArtChildAnchor:
		{
			ODRAW::OfficeArtChildAnchor * ch = dynamic_cast<ODRAW::OfficeArtChildAnchor *>(art);
			xlsx_context->get_drawing_context().set_child_anchor(ch->_x, ch->_y, ch->_cx, ch->_cy);
		}break;
	case XLS::typeOfficeArtClientAnchorSheet:
		{
			ODRAW::OfficeArtClientAnchorSheet * ch = dynamic_cast<ODRAW::OfficeArtClientAnchorSheet *>(art);
        
			ch->calculate();
			ch->calculate_1();
			
			if (xlsx_context->get_drawing_context().getType()	== oox::external_items::typeGroup &&
				xlsx_context->get_drawing_context().getLevel()	== 1)
			{
				xlsx_context->get_drawing_context().set_child_anchor(ch->_x, ch->_y, ch->_cx, ch->_cy);
			}
			xlsx_context->get_drawing_context().set_sheet_anchor(ch->colL, ch->_dxL, ch->rwT, ch->_dyT, ch->colR, ch->_dxR, ch->rwB, ch->_dyB,
				ch->_x, ch->_y, ch->_cx, ch->_cy);
		}break;
	case XLS::typeOfficeArtBStoreContainer:
		{
			convert (dynamic_cast<ODRAW::OfficeArtBStoreContainer *>(art), 3000);
		}break;
	case XLS::typeOfficeArtSpContainer:
		{
			convert (dynamic_cast<ODRAW::OfficeArtSpContainer *>(art));
		}break;
	case XLS::typeOfficeArtSpgrContainer:
		{
			convert (dynamic_cast<ODRAW::OfficeArtSpgrContainer *>(art));
		}break;
	case XLS::typeOfficeArtDgContainer:
		{
			ODRAW::OfficeArtDgContainer * dg = dynamic_cast<ODRAW::OfficeArtDgContainer *>(art);
        
			for (size_t i = 0 ; i < dg->child_records.size(); i++)	//a-la msodrawing for headers/footers
			{
				convert(dg->child_records[i].get());
			}

			for (size_t i = 0; i < dg->m_OfficeArtSpContainer.size(); i++)
			{
				convert(dg->m_OfficeArtSpContainer[i].get());
			}

			convert(dg->m_OfficeArtSpgrContainer.get());
		}break;
	case XLS::typeOfficeArtDggContainer:
	{		
		ODRAW::OfficeArtDggContainer* dg = dynamic_cast<ODRAW::OfficeArtDggContainer*>(art);

		convert(dg->m_OfficeArtBStoreContainer.get());
	}break;
	default:
		break;
	}
}

void XlsConverter::convert(ODRAW::OfficeArtFSP * fsp)
{
	if (fsp == NULL) return;

	if (fsp->fFlipH) xlsx_context->get_drawing_context().set_FlipH();
	if (fsp->fFlipV) xlsx_context->get_drawing_context().set_FlipV();

	xlsx_context->get_drawing_context().set_id(fsp->spid);
	xlsx_context->get_drawing_context().set_shape_id(fsp->shape_id);
}
void XlsConverter::convert_fill_style(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;
	
	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
			case ODRAW::fillType:
			{
				switch(props[i]->op)
				{
				case 1://fillPattern:
					{
						xlsx_context->get_drawing_context().set_fill_type(oox::fillPattern);
						//texture + change black to color2, white to color1
					}break;
					case 2://fillTexture :
					{
						xlsx_context->get_drawing_context().set_fill_type(oox::fillTexture);
						xlsx_context->get_drawing_context().set_fill_texture_mode(0);
					}break;
					case 3://fillPicture :
					{
						xlsx_context->get_drawing_context().set_fill_type(oox::fillTexture);
						xlsx_context->get_drawing_context().set_fill_texture_mode(1);
					}break;
					case 4://fillShadeCenter://1 color
					case 5://fillShadeShape:
					{
						xlsx_context->get_drawing_context().set_fill_type(oox::fillGradientOne);
					}break;//
					case 6://fillShadeTitle://2 colors and more
					case 7://fillShade : 
					case 8://fillShadeScale: 
					{
						xlsx_context->get_drawing_context().set_fill_type(oox::fillGradient);
					}break;
					case 9://fillBackground:
					{
						xlsx_context->get_drawing_context().set_fill_type(oox::fillNone);
					}break;	
					case 0:
					default:
					{ //undefined
						xlsx_context->get_drawing_context().set_fill_type(oox::fillUndefined);
					}break;
				}
			}break;
			case ODRAW::fillColor:
			case ODRAW::fillColorExt:
			{
				ODRAW::FillColor * fill = (ODRAW::FillColor *)(props[i].get());
				ODRAW::OfficeArtCOLORREF color((_UINT32)fill->op);
				if (!color.sColorRGB.empty())
					xlsx_context->get_drawing_context().set_fill_color(color.nColorRGB, color.sColorRGB);
				else if (color. fPaletteIndex)
				{
					std::map<int,  std::wstring>::iterator it = xls_global_info->colors_palette.find(color.index);
					if (it != xls_global_info->colors_palette.end())
					{					
						//убрать 0!!! todooo
						xlsx_context->get_drawing_context().set_fill_color(0, it->second);
					}
				}
				else
					xlsx_context->get_drawing_context().set_fill_color(color.index, color.fSchemeIndex ? 1 : 3 );
			}break;
			case ODRAW::fillOpacity:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_fill_opacity(fixed_point->dVal);
			}break;
			case ODRAW::fillBackColor:
			case ODRAW::fillBackColorExt:
			{
				ODRAW::FillColor * fill = (ODRAW::FillColor *)(props[i].get());
				ODRAW::OfficeArtCOLORREF color((_UINT32)fill->op);
				if (!color.sColorRGB.empty())
					xlsx_context->get_drawing_context().set_fill_color(color.nColorRGB,color.sColorRGB, true );
				else if (color. fPaletteIndex)
				{
					std::map<int,  std::wstring>::iterator it = xls_global_info->colors_palette.find(color.index);
					if (it != xls_global_info->colors_palette.end())
					{					
						//todooo убрать 0 !!!
						xlsx_context->get_drawing_context().set_fill_color(0, it->second, true );
					}
				}
				else
					xlsx_context->get_drawing_context().set_fill_color(color.index, color.fSchemeIndex ? 1 : 3, true );
			}break;
			case ODRAW::fillBackOpacity:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_fill_opacity(fixed_point->dVal, true);
			}break;
			case ODRAW::fillBlip:
			{
				std::wstring target;
				ODRAW::FillBlip *fillBlip = (ODRAW::FillBlip *)(props[i].get());
				if ((fillBlip) && (fillBlip->blip))
				{
					target = WriteMediaFile(fillBlip->blip->pict_data,fillBlip->blip->pict_size, fillBlip->blip->pict_type);
				}
				else
				{
					bool isIternal = false;
					std::wstring rId = xlsx_context->get_mediaitems().find_image(props[i]->op , target, isIternal);
				}
				xlsx_context->get_drawing_context().set_fill_texture(target);
			}break;
			case ODRAW::fillAngle:
			{
				ODRAW::FillAngle * angle = (ODRAW::FillAngle *)(props[i].get());
				xlsx_context->get_drawing_context().set_fill_angle(angle->dVal);
			}break;
			case ODRAW::fillFocus:
			{
				xlsx_context->get_drawing_context().set_fill_focus(props[i]->op);
			}break;
			case ODRAW::fillShadeType:
			{
				ODRAW::FillShadeType *shadeType = dynamic_cast<ODRAW::FillShadeType*>(props[i].get());
			}break;
			case ODRAW::fillShadePreset:
			{
			}break;
			case ODRAW::fillShadeColors:
			{
				ODRAW::FillShadeColors *shadeColors = dynamic_cast<ODRAW::FillShadeColors*>(props[i].get());

				for (size_t i = 0 ; (shadeColors) && (i < shadeColors->complex.data.size()); i++)
				{
					ODRAW::OfficeArtCOLORREF & color = shadeColors->complex.data[i].color;

					std::wstring strColor;
					if (!color.sColorRGB.empty())	strColor = color.sColorRGB;
					else if (color. fPaletteIndex)
					{
						std::map<int,  std::wstring>::iterator it = xls_global_info->colors_palette.find(color.index);
						if (it != xls_global_info->colors_palette.end())	strColor = it->second;
					}
					if (!strColor.empty())
						xlsx_context->get_drawing_context().add_fill_colors( shadeColors->complex.data[i].dPosition, strColor);
					else
					{
						xlsx_context->get_drawing_context().add_fill_colors( shadeColors->complex.data[i].dPosition, 
																									color.index, color.fSchemeIndex ? 1 : 3 );
					}
				}
			}break;
			case ODRAW::fillStyleBooleanProperties:
			{
				ODRAW::FillStyleBooleanProperties * bools = (ODRAW::FillStyleBooleanProperties *)(props[i].get());
				if (bools)
				{
					if (bools->fUsefFilled && bools->fFilled == false) 
						xlsx_context->get_drawing_context().set_fill_type(oox::fillNone);
				}
			}break;
			default:
			{
				i =i;
			}break;
		}
	}
}
void XlsConverter::convert_line_style(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
			case ODRAW::lineColor:
			{
				ODRAW::OfficeArtCOLORREF color((_UINT32)props[i]->op);
				if (!color.sColorRGB.empty())
					xlsx_context->get_drawing_context().set_line_color(color.nColorRGB, color.sColorRGB);
				else if (color. fPaletteIndex)
				{
					std::map<int,  std::wstring>::iterator it = xls_global_info->colors_palette.find(color.index);
					if (it != xls_global_info->colors_palette.end())
					{					
						//todooo убрать 0 !!
						xlsx_context->get_drawing_context().set_line_color(0, it->second);
					}
				}
				else
					xlsx_context->get_drawing_context().set_line_color(color.index, color.fSchemeIndex ? 1 : 3 );
			}break;
			case ODRAW::lineType:
			{
				xlsx_context->get_drawing_context().set_line_type(props[i]->op);
			}break;
			case ODRAW::lineFillBlip: //blip 
			{
			}break;
			case ODRAW::lineWidth: 
				xlsx_context->get_drawing_context().set_line_width(props[i]->op);
			{
			}break;
			case ODRAW::lineStyle:
			{
				xlsx_context->get_drawing_context().set_line_style(props[i]->op);
			}break;
			case ODRAW::lineDashing:
			{
				xlsx_context->get_drawing_context().set_line_dash(props[i]->op);
			}break;
        	case ODRAW::lineStartArrowhead:
			{
				xlsx_context->get_drawing_context().set_arrow_start(props[i]->op);
			}break;
        	case ODRAW::lineEndArrowhead:
			{
				xlsx_context->get_drawing_context().set_arrow_end(props[i]->op);
			}break;
        	case ODRAW::lineStartArrowWidth:
			{
				xlsx_context->get_drawing_context().set_arrow_start_width(props[i]->op);
			}break;
        	case ODRAW::lineStartArrowLength:
			{
				xlsx_context->get_drawing_context().set_arrow_start_length(props[i]->op);
			}break;
        	case ODRAW::lineEndArrowWidth:
			{
				xlsx_context->get_drawing_context().set_arrow_end_width(props[i]->op);
			}break;
        	case ODRAW::lineEndArrowLength:
			{
				xlsx_context->get_drawing_context().set_arrow_end_length(props[i]->op);
			}break;
			case ODRAW::lineStyleBooleanProperties:
			{
				ODRAW::LineStyleBooleanProperties * bools = (ODRAW::LineStyleBooleanProperties *)(props[i].get());
				if (bools)
				{
					if (bools->fUsefLine && bools->fLine == false) 
						xlsx_context->get_drawing_context().set_line_type(5); //no line

					if (bools->fUsefArrowheadsOK && bools->fArrowheadsOK)
					{
						xlsx_context->get_drawing_context().set_line_arrow(true);
					}
				}
			}break;
			case ODRAW::lineMiterLimit:
			{
				xlsx_context->get_drawing_context().set_line_miter(props[i]->op);
			}break;
			case ODRAW::lineJoinStyle:
			{
				xlsx_context->get_drawing_context().set_line_join(props[i]->op);
			}break;
			case ODRAW::lineEndCapStyle:
			{
				xlsx_context->get_drawing_context().set_line_endcap(props[i]->op);
			}break;
		}
	}
}
void XlsConverter::convert_blip(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
			case ODRAW::cropFromTop:
				{
					ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
					xlsx_context->get_drawing_context().set_picture_crop_top(fixed_point->dVal * 10);
				}break;
			case ODRAW::cropFromBottom:
				{
					ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
					xlsx_context->get_drawing_context().set_picture_crop_bottom(fixed_point->dVal * 10);
				}break;
			case ODRAW::cropFromLeft:
				{
					ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
					xlsx_context->get_drawing_context().set_picture_crop_left(fixed_point->dVal * 10);
				}break;
			case ODRAW::cropFromRight:
				{
					ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
					xlsx_context->get_drawing_context().set_picture_crop_right(fixed_point->dVal * 10);
				}break;
			case ODRAW::pib:
				{
					bool isIternal = false;
					std::wstring target;

					int id = props[i]->op;
					if (xlsx_context->get_drawing_context().get_mode_HF()) 
						id += 3000;
					
					std::wstring rId = xlsx_context->get_mediaitems().find_image(id , target, isIternal);
					xlsx_context->get_drawing_context().set_picture(target);
				}break;
			case ODRAW::pibName:
			{
				ODRAW::AnyString *str = dynamic_cast<ODRAW::AnyString*>(props[i].get());
				xlsx_context->get_drawing_context().set_picture_name(str->string_);
			}break;
			case ODRAW::pibFlags:
			{
			}break;
			case ODRAW::pictureTransparent:
			{
				ODRAW::OfficeArtCOLORREF color((_UINT32)props[i]->op);
				
				if (!color.sColorRGB.empty())
					xlsx_context->get_drawing_context().set_picture_transparent(color.nColorRGB, color.sColorRGB);
				//...
			}break;
			case ODRAW::pictureContrast:
			{
				int val = 0;
				if (props[i]->op == 0x7FFFFFFF)
				{
					val = 100;
				}
				else if (props[i]->op == 0x00010000)
				{
					val = 0;
				}
				else if (props[i]->op > 0x00010000)
				{
					val = 51. / (props[i]->op / 65536.);
					val = (50 - val) * 2;
				}
				else
				{
					val = (100. * props[i]->op / 65536. + 0.5) - 100;
				}
				xlsx_context->get_drawing_context().set_picture_contrast(val);
			}break;
			case ODRAW::pictureBrightness:
			{
				int val = ((_INT32)props[i]->op * 100. + 0.5) / 0x00008000;
				xlsx_context->get_drawing_context().set_picture_brightness(val);
			}break;
			case ODRAW::pictureGamma:
			{
			}break;
			case ODRAW::pictureId:
			{
			}break;
			case ODRAW::pictureDblCrMod:
			{
			}break;
			case ODRAW::pictureFillCrMod:
			{
			}break;
			case ODRAW::pictureLineCrMod:
			{
			}break;
			case ODRAW::pibPrint:
			{
			}break;
			case ODRAW::pibPrintName:
			{
			}break;
			case ODRAW::pibPrintFlags:
			{
			}break;
			case ODRAW::blipBooleanProperties:
			{				
				ODRAW::BlipBooleanProperties * bools = (ODRAW::BlipBooleanProperties *)(props[i].get());
				if (bools)
				{
					if (bools->fUsefPictureGray && bools->fPictureGray) 
						xlsx_context->get_drawing_context().set_picture_grayscale(true);
					if (bools->fUsefPictureBiLevel && bools->fPictureBiLevel) 
						xlsx_context->get_drawing_context().set_picture_biLevel(50);
				}

			}break;
		}
	}
}
void XlsConverter::convert_geometry(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	_CP_OPT(oox::_rect)			rect;
	std::vector<_CP_OPT(int)>	adjustValues(9);
	
	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
		case ODRAW::geoLeft:		if (!rect) rect = oox::_rect(); rect->x = props[i]->op; break;
			case ODRAW::geoTop:		if (!rect) rect = oox::_rect(); rect->y	= props[i]->op; break;
			case ODRAW::geoRight:	if (!rect) rect = oox::_rect(); rect->cx = props[i]->op; break;
			case ODRAW::geoBottom:	if (!rect) rect = oox::_rect(); rect->cy = props[i]->op; break;
			case ODRAW::shapePath:
				xlsx_context->get_drawing_context().set_custom_path(props[i]->op); break;
			case ODRAW::pVertices:
				{
					ODRAW::PVertices * v = (ODRAW::PVertices *)(props[i].get());
					xlsx_context->get_drawing_context().set_custom_verticles(v->complex.data);
				}break;
			case ODRAW::pSegmentInfo:
				{
					ODRAW::PSegmentInfo * s = (ODRAW::PSegmentInfo *)(props[i].get());
					xlsx_context->get_drawing_context().set_custom_segments(s->complex.data);
				}break;
			case ODRAW::adjustValue: //0x0147
			case ODRAW::adjust2Value:
			case ODRAW::adjust3Value:
			case ODRAW::adjust4Value:
			case ODRAW::adjust5Value:
			case ODRAW::adjust6Value:
			case ODRAW::adjust7Value:
			case ODRAW::adjust8Value:
			case ODRAW::adjust9Value:
			case ODRAW::adjust10Value:
			{
				adjustValues[props[i]->opid - 0x0147] = props[i]->op ;
			}break;
			case ODRAW::pConnectionSites:
			{
				ODRAW::PConnectionSites * a = (ODRAW::PConnectionSites *)(props[i].get());
				xlsx_context->get_drawing_context().set_custom_connection(a->complex.data);
			}break;
			case ODRAW::pConnectionSitesDir:
			{
				ODRAW::PConnectionSitesDir * a = (ODRAW::PConnectionSitesDir *)(props[i].get());
				xlsx_context->get_drawing_context().set_custom_connectionDir(a->complex.data);
			}break;
			case ODRAW::xLimo:
			{
				xlsx_context->get_drawing_context().set_custom_x_limo(props[i]->op);
			}break;
			case ODRAW::yLimo:
			{
				xlsx_context->get_drawing_context().set_custom_y_limo(props[i]->op);
			}break;
			case ODRAW::pAdjustHandles:
			{
				ODRAW::PAdjustHandles * a = (ODRAW::PAdjustHandles *)(props[i].get());
				xlsx_context->get_drawing_context().set_custom_adjustHandles(a->complex.data);
			}break;
			case ODRAW::pGuides:
			{
				ODRAW::PGuides* s = (ODRAW::PGuides *)(props[i].get());
				xlsx_context->get_drawing_context().set_custom_guides(s->complex.data);
			}break;
			case ODRAW::pInscribe:
			{
				ODRAW::PInscribe * a = (ODRAW::PInscribe *)(props[i].get());
				xlsx_context->get_drawing_context().set_custom_inscribe(a->complex.data);
			}break;
			//case ODRAW::cxk:
			//	{
			//		ODRAW::cxk * a = (ODRAW::cxk *)(props[i].get());
			//		xlsx_context->get_drawing_context().set_custom_cxk(a->complex.data);
			//	}break;
		}
	}
	if (rect)
	{
		rect->cy -= rect->y;
		rect->cx -= rect->x;

		xlsx_context->get_drawing_context().set_custom_rect(*rect);
	}
	
	xlsx_context->get_drawing_context().set_custom_adjustValues(adjustValues);
}
void XlsConverter::convert_geometry_text(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
		case ODRAW::gtextUNICODE://word art text
			{
				ODRAW::AnyString *str = dynamic_cast<ODRAW::AnyString*>(props[i].get());
				if (str) xlsx_context->get_drawing_context().set_wordart_text(str->string_);
			}break;
		case ODRAW::gtextFont:
			{
				ODRAW::AnyString *str = dynamic_cast<ODRAW::AnyString*>(props[i].get());
				if (str)
				{
					xlsx_context->get_drawing_context().set_wordart_font(str->string_);
				}
			}break;
		case ODRAW::gtextSize:
			{
				xlsx_context->get_drawing_context().set_wordart_size((INT)((props[i]->op >> 16) & 0x0000FFFF));
			}break;
		case ODRAW::gtextSpacing:
			{
				ODRAW::FixedPoint *val = dynamic_cast<ODRAW::FixedPoint*>(props[i].get());
				if (val) xlsx_context->get_drawing_context().set_wordart_spacing(val->dVal);
			}break;
		case ODRAW::gtextAlign:
			{
				switch (props[i]->op)
				{
				case ODRAW::alignTextLeft:
					xlsx_context->get_drawing_context().set_text_align(1);	break;
				case ODRAW::alignTextCenter:
					xlsx_context->get_drawing_context().set_text_align(2);	break;
				case ODRAW::alignTextRight:
					xlsx_context->get_drawing_context().set_text_align(3);	break;
				case ODRAW::alignTextWordJust:
					xlsx_context->get_drawing_context().set_text_align(4);	break;
				case ODRAW::alignTextLetterJust:
					xlsx_context->get_drawing_context().set_text_align(5);	break;
				}				
			}break;
		case 0xff:
			{				
				ODRAW::GeometryTextBooleanProperties *bools = dynamic_cast<ODRAW::GeometryTextBooleanProperties*>(props[i].get());
				if (bools) 
				{
					if (bools->fUsegFBold			&& bools->fBold)		xlsx_context->get_drawing_context().set_wordart_bold	(true); 
					if (bools->fUsegFItalic			&& bools->fItalic)		xlsx_context->get_drawing_context().set_wordart_italic	(true); 
					if (bools->fUsegFVertical		&& bools->fVertical)	xlsx_context->get_drawing_context().set_wordart_vertical(true); 
					if (bools->fUsegFUnderline		&& bools->fUnderline)	xlsx_context->get_drawing_context().set_wordart_underline(true); 
					if (bools->fUsegFStrikethrough	&& bools->fStrikethrough)xlsx_context->get_drawing_context().set_wordart_strike(true);

					//if (bools->fUsegFShrinkFit && bools->fShrinkFit)
				}
			}break;
		}
	}
}
void XlsConverter::convert_text(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	RECT text_margin = {0x00016530, 0x0000b298, 0x00016530, 0x0000b298};
	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
		case ODRAW::lTxid: break;
		case ODRAW::txdir: break;
		case ODRAW::dxTextLeft:		text_margin.left	= props[i]->op;	break;
		case ODRAW::dxTextRight:	text_margin.right	= props[i]->op;	break;			
		case ODRAW::dyTextTop:		text_margin.top		= props[i]->op;	break;
		case ODRAW::dyTextBottom:	text_margin.bottom	= props[i]->op;	break;
		case ODRAW::WrapText:
			{
				xlsx_context->get_drawing_context().set_text_wrap(props[i]->op);				
			}break;
		case ODRAW::txflTextFlow:
			{
				xlsx_context->get_drawing_context().set_text_vertical(props[i]->op);
			}break;
		case ODRAW::textBooleanProperties:
			{
				ODRAW::TextBooleanProperties *bools = dynamic_cast<ODRAW::TextBooleanProperties*>(props[i].get());
				if (bools)
				{
					if (bools->fUsefFitShapeToText)
					{
						xlsx_context->get_drawing_context().set_text_fit_shape(bools->fFitShapeToText);
					}
					if (bools->fUsefAutoTextMargin)
					{
					}
				}
			}break;
		case ODRAW::anchorText:
			{
				switch (props[i]->op)
				{
				case ODRAW::anchorTop:
				case ODRAW::anchorTopBaseline:
					{	
						xlsx_context->get_drawing_context().set_text_align		(1);
						xlsx_context->get_drawing_context().set_text_vert_align	(1);
					}break;
				case ODRAW::anchorMiddle:
					{
						xlsx_context->get_drawing_context().set_text_align		(1);
						xlsx_context->get_drawing_context().set_text_vert_align	(2);
					}break;						
				case ODRAW::anchorBottom:
				case ODRAW::anchorBottomBaseline:
					{
						xlsx_context->get_drawing_context().set_text_align		(1);
						xlsx_context->get_drawing_context().set_text_vert_align	(3);
					}break;
				case ODRAW::anchorTopCentered:
				case ODRAW::anchorTopCenteredBaseline:
					{
						xlsx_context->get_drawing_context().set_text_align		(2);
						xlsx_context->get_drawing_context().set_text_vert_align	(1);
					}break;
				case ODRAW::anchorMiddleCentered:
					{
						xlsx_context->get_drawing_context().set_text_align		(2);
						xlsx_context->get_drawing_context().set_text_vert_align	(2);
					}break;
				case ODRAW::anchorBottomCentered:
				case ODRAW::anchorBottomCenteredBaseline:
					{
						xlsx_context->get_drawing_context().set_text_align		(2);
						xlsx_context->get_drawing_context().set_text_vert_align	(3);
					}break;
				}
			}break;
		default:
			int j = 0;
			break;		
		}
	}
	xlsx_context->get_drawing_context().set_text_margin(text_margin);
}
void XlsConverter::convert_shadow(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	xlsx_context->get_drawing_context().set_shadow_enabled(true);

	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
			case ODRAW::shadowType:
			{
				xlsx_context->get_drawing_context().set_shadow_type(props[i]->op);
			}break;
			case ODRAW::shadowColor:
			{
				ODRAW::OfficeArtCOLORREF color((_UINT32)props[i]->op);
				
				if (!color.sColorRGB.empty())
					xlsx_context->get_drawing_context().set_shadow_color(color.nColorRGB, color.sColorRGB);
			}break;
			case ODRAW::shadowHighlight:
			{
				ODRAW::OfficeArtCOLORREF color((_UINT32)props[i]->op);
				
				if (!color.sColorRGB.empty())
					xlsx_context->get_drawing_context().set_shadow_highlight(color.nColorRGB, color.sColorRGB);
			}break;
			case ODRAW::shadowCrMod:
			{
			}break;
			case ODRAW::shadowOpacity:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_shadow_opacity(fixed_point->dVal);
			}break;
			case ODRAW::shadowOffsetX:
			{
				xlsx_context->get_drawing_context().set_shadow_offsetX((_INT32)props[i]->op);
			}break;
			case ODRAW::shadowOffsetY:
			{
				xlsx_context->get_drawing_context().set_shadow_offsetY((_INT32)props[i]->op);
			}break;
			//case ODRAW::shadowSecondOffsetX:
			//{
			//}break;
			//case ODRAW::shadowSecondOffsetY:
			//{
			//}break;
			case ODRAW::shadowScaleXToX:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_shadow_scaleX2X(fixed_point->dVal);
			}break;
			case ODRAW::shadowScaleYToX:
			{
			}break;
			case ODRAW::shadowScaleXToY:
			{
			}break;
			case ODRAW::shadowScaleYToY:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_shadow_scaleY2Y(fixed_point->dVal);
			}break;
			//case ODRAW::shadowPerspectiveX:
			//{
			//}break;
			//case ODRAW::shadowPerspectiveY:
			//{
			//}break;
			//case ODRAW::shadowWeight:
			//{
			//}break;
			case ODRAW::shadowOriginX:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_shadow_originX(fixed_point->dVal);
			}break;
			case ODRAW::shadowOriginY:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_shadow_originY(fixed_point->dVal);
			}break;
		}
	}
}
void XlsConverter::convert_shape(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	for (size_t i = 0 ; i < props.size() ; i++)
	{

	}
}
void XlsConverter::convert_group_shape(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	if (props.empty()) return;

	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
		case 0x380:
			{
				ODRAW::AnyString *str = dynamic_cast<ODRAW::AnyString*>(props[i].get());
				xlsx_context->get_drawing_context().set_name(str->string_);
			}break;
		case 0x381:
			{
				ODRAW::AnyString *str = dynamic_cast<ODRAW::AnyString*>(props[i].get());
				xlsx_context->get_drawing_context().set_description(str->string_);
			}break;
		case 0x0382:
			{
				ODRAW::PihlShape *pihlShape = dynamic_cast<ODRAW::PihlShape*>(props[i].get());
				if (pihlShape)
				{
					std::wstring	sTarget;					
					bool			bExternal = false;					
					
					if (pihlShape->complex.hyperlink.hlstmfHasMoniker)
					{
						sTarget = GetTargetMoniker(pihlShape->complex.hyperlink.oleMoniker.data.get());
						bExternal = true;
					}
					else if (pihlShape->complex.hyperlink.hlstmfHasLocationStr)
					{
						sTarget = pihlShape->complex.hyperlink.location;
					}

					std::wstring sDisplay = pihlShape->complex.hyperlink.displayName;
					if (sDisplay.empty())	sDisplay = sTarget;

					xlsx_context->get_drawing_context().set_hyperlink( sTarget, sDisplay, bExternal);				
				}
			}break;
		case 0x03A9:
			{
				ODRAW::MetroBlob *alternative_data = dynamic_cast<ODRAW::MetroBlob*>(props[i].get());
				if (alternative_data)
				{
					xlsx_context->get_drawing_context().set_alternative_drawing( alternative_data->xmlString);				
				}
			}break;
		case 0x03BF:
			{
				ODRAW::GroupShapeBooleanProperties *bools = dynamic_cast<ODRAW::GroupShapeBooleanProperties*>(props[i].get());
				if (bools)
				{
					if (bools->fHidden && bools->fUsefHidden)	
						xlsx_context->get_drawing_context().set_hidden(true);
				}
			}break;
		}
	}
}

void XlsConverter::convert(XLS::Note* note)
{
	if (note == NULL) return;

	note->note_sh.calculate();

	xlsx_context->get_comments_context().set_ref	(note->note_sh.ref_, note->note_sh.col, note->note_sh.row);
	xlsx_context->get_comments_context().set_author	(note->note_sh.stAuthor);
	xlsx_context->get_comments_context().set_visibly(note->note_sh.fShow);
	
	xlsx_context->get_drawing_context().set_object_id		(xlsx_context->get_comments_context().get_id());
	xlsx_context->get_drawing_context().set_object_visible	(note->note_sh.fShow);
	xlsx_context->get_drawing_context().set_object_anchor	(note->note_sh.col, note->note_sh.row);

	if (xls_global_info->Version < 0x0600)
	{
		//todooo размеры произвольные .. можно сделать оценку по размеру строки
		xlsx_context->get_drawing_context().set_sheet_anchor(0, 0, 0, 0, 0, 0, 0, 0, note->note_sh.x_, note->note_sh.y_, 120 * 12700., 64 * 12700.);
		xlsx_context->get_drawing_context().set_text(std::wstring(L"<t>") + note->note_sh.stText.value() + std::wstring(L"</t>"));
	}
}

void XlsConverter::convert_transform(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
{
	for (size_t i = 0 ; i < props.size() ; i++)
	{
		switch(props[i]->opid)
		{
			case 0x0004:
			{
				ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
				xlsx_context->get_drawing_context().set_rotation(fixed_point->dVal);
			}break;
		}
	}
}
void XlsConverter::convert(ODRAW::OfficeArtTertiaryFOPT	* fort)
{
	if (fort == NULL) return;

	convert_shape			(fort->fopt.Shape_props);
	convert_group_shape		(fort->fopt.GroupShape_props);
	convert_transform		(fort->fopt.Transform_props);
	convert_blip			(fort->fopt.Blip_props);
	convert_geometry		(fort->fopt.Geometry_props);
	convert_fill_style		(fort->fopt.FillStyle_props);
	convert_line_style		(fort->fopt.LineStyle_props);
	convert_shadow			(fort->fopt.Shadow_props);
	convert_text			(fort->fopt.Text_props);
	convert_geometry_text	(fort->fopt.GeometryText_props);
}
void XlsConverter::convert(ODRAW::OfficeArtFOPT * fort)
{
	if (fort == NULL) return;

	convert_shape			(fort->fopt.Shape_props);
	convert_group_shape		(fort->fopt.GroupShape_props);
	convert_transform		(fort->fopt.Transform_props);
	convert_geometry		(fort->fopt.Geometry_props);
	convert_fill_style		(fort->fopt.FillStyle_props);
	convert_blip			(fort->fopt.Blip_props);
	convert_line_style		(fort->fopt.LineStyle_props);
	convert_shadow			(fort->fopt.Shadow_props);
	convert_text			(fort->fopt.Text_props);
	convert_geometry_text	(fort->fopt.GeometryText_props);
}

void XlsConverter::convert(XLS::SHAREDSTRINGS* sharedstrings)
{
	int count = xls_global_info->startAddedSharedStrings + xls_global_info->arAddedSharedStrings.size();

	CP_XML_WRITER(xlsx_context->shared_strings())    
	{
		CP_XML_NODE(L"sst")
		{
			CP_XML_ATTR(L"uniqueCount", count);
			CP_XML_ATTR(L"xmlns", "http://schemas.openxmlformats.org/spreadsheetml/2006/main");
			if (sharedstrings)
			{	
				for (std::list<XLS::BaseObjectPtr>::iterator it = sharedstrings->elements_.begin(); it != sharedstrings->elements_.end(); ++it)
				{
					(*it)->serialize(CP_XML_STREAM());
				}
			}

			for (size_t i = 0 ; i < xls_global_info->arAddedSharedStrings.size(); i++)
			{
				CP_XML_NODE(L"si")
				{	
					CP_XML_NODE(L"t")
					{		
						CP_XML_ATTR(L"xml:space", "preserve");
						CP_XML_STREAM() << STR::escape_ST_Xstring(XmlUtils::EncodeXmlString(xls_global_info->arAddedSharedStrings[i]));
					}
				}
			}
		}
	}
}
void XlsConverter::convert(XLS::TxO * text_obj)
{
	if (text_obj == NULL) return;
	
	int rot = text_obj->rot;

	if (rot > 0)
	{
		switch(rot)
		{
		case 1: //text appears top to bottom; letters are upright
		{
			xlsx_context->get_drawing_context().set_text_vertical(5);		
		}break;
		case 2: //text is rotated 90 degrees counterclockwise
		{
			if		(text_obj->hAlignment == (unsigned char)1) text_obj->hAlignment = 3;
			else if (text_obj->hAlignment == (unsigned char)3) text_obj->hAlignment = 1;

			xlsx_context->get_drawing_context().set_text_vertical(2);	
		}break;
		case 3: //text is rotated 90 degrees clockwise
		{
			if		(text_obj->vAlignment == (unsigned char)1) text_obj->vAlignment = 3;
			else if (text_obj->vAlignment == (unsigned char)3) text_obj->vAlignment = 1;
		
			xlsx_context->get_drawing_context().set_text_vertical(3);
		}break;
		}

	}

	xlsx_context->get_drawing_context().set_text_align		(text_obj->hAlignment);
	xlsx_context->get_drawing_context().set_text_vert_align	(text_obj->vAlignment);
	
	std::wstringstream strm, strm_vml;

	text_obj->serialize(strm);	
	xlsx_context->get_drawing_context().set_text(strm.str());

	text_obj->serialize_vml(strm_vml);	
	xlsx_context->get_drawing_context().set_text_vml(strm_vml.str());

}

void XlsConverter::convert(XLS::Obj * obj)
{
	if ( obj == NULL ) return;

//controls & objects
	if ( obj->cmo.ot == 8 && obj->pictFmla.fExist && obj->pictFlags.fExist)
	{
		std::wstring info;
		if (obj->pictFmla.fmla.bFmlaExist)
		{
			if (obj->pictFmla.fmla.bInfoExist)
				info = obj->pictFmla.fmla.embedInfo.strClass.value();
		}
		if (obj->pictFlags.fCtl && obj->pictFlags.fPrstm && xls_global_info->controls_data.first)//Controls Storage
		{
		//binary data
			xlsx_context->get_mediaitems().create_activeX_path(xlsx_path);
			
			std::wstring target_bin;
			std::wstring objectId_bin = xlsx_context->get_mediaitems().add_control_activeX(target_bin);

			NSFile::CFileBinary file;
			if ( file.CreateFileW(xlsx_context->get_mediaitems().activeX_path() + target_bin) )
			{		
				file.WriteFile(xls_global_info->controls_data.first.get() + obj->pictFmla.lPosInCtlStm, obj->pictFmla.cbBufInCtlStm);
				file.CloseFile();
			}
			std::wstring objectId_xml = xlsx_context->start_activeX();	
			xlsx_context->get_drawing_context().set_control_activeX(objectId_xml);
	
			xlsx_context->current_activeX().setDataBinRid(objectId_bin, target_bin);
			xlsx_context->current_activeX().setProgId(info);
			xlsx_context->current_activeX().setLicense(obj->pictFmla.key.keyBuf);

		}
		else if (!obj->pictFlags.fPrstm) 
		{
			std::wstring object_stream;
			if (obj->pictFlags.fDde)	object_stream = L"LNK";
			else						object_stream = L"MBD";
		
			object_stream += XmlUtils::ToString(obj->pictFmla.lPosInCtlStm, L"%08X") + L"/";
			if (xls_file->storage_->isDirectory(object_stream))
			{
				xlsx_context->get_mediaitems().create_embeddings_path(xlsx_path);
				
				std::wstring target;

				if (xls_file->storage_->exists(object_stream + L"Workbook")) target = L".xls";
				if (xls_file->storage_->exists(object_stream + L"WordDocument")) target = L".doc";

				std::wstring objectId = xlsx_context->get_mediaitems().add_embedding(target, info);

				POLE::Storage *storageOle = new POLE::Storage((xlsx_context->get_mediaitems().embeddings_path() + target).c_str());

				if ((storageOle) && (storageOle->open(true, true)))
				{			
					xls_file->copy(0, object_stream, storageOle, false, true);

					storageOle->close();
					delete storageOle;
				}
				xlsx_context->current_sheet().sheet_rels().add(oox::relationship(
					objectId, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject", L"../embeddings/" + target));

				xlsx_context->get_drawing_context().set_ole_object(objectId, info);
			}
		}
		if (obj->pictFmla.key.fmlaLinkedCell.bFmlaExist)
		{
			std::wstring link = obj->pictFmla.key.fmlaLinkedCell.fmla.getAssembledFormula(true);
			xlsx_context->get_drawing_context().set_object_link(link);
		}
		if (obj->pictFmla.key.fmlaListFillRange.bFmlaExist)
		{
			std::wstring link = obj->pictFmla.key.fmlaListFillRange.fmla.getAssembledFormula(true);
			xlsx_context->get_drawing_context().set_object_fmlaRange(link);
		}
	}
	if (obj->sbs.fExist)
	{
		xlsx_context->get_drawing_context().set_object_x_val(obj->sbs.iVal);
		xlsx_context->get_drawing_context().set_object_x_min(obj->sbs.iMin);
		xlsx_context->get_drawing_context().set_object_x_max(obj->sbs.iMax);
		xlsx_context->get_drawing_context().set_object_x_inc(obj->sbs.dInc);
		xlsx_context->get_drawing_context().set_object_x_page(obj->sbs.dPage);
		xlsx_context->get_drawing_context().set_object_3D(!obj->sbs.fNo3d);
		xlsx_context->get_drawing_context().set_object_hscroll(obj->sbs.fHoriz);
		xlsx_context->get_drawing_context().set_object_dx(obj->sbs.dxScroll);
	}
	if (obj->list.fExist)
	{
		xlsx_context->get_drawing_context().set_object_x_sel(obj->list.iSel);
		xlsx_context->get_drawing_context().set_object_x_sel_type(obj->list.wListSelType);
		xlsx_context->get_drawing_context().set_object_lct(obj->list.lct);
		xlsx_context->get_drawing_context().set_object_3D(!obj->list.fNo3d);

		if (obj->list.fmla.bFmlaExist)
		{
			std::wstring link = obj->list.fmla.fmla.getAssembledFormula(true);
			xlsx_context->get_drawing_context().set_object_fmlaRange(link);
		}
		if (obj->list.dropData)
		{
			xlsx_context->get_drawing_context().set_object_drop_style(obj->list.dropData->wStyle);
			xlsx_context->get_drawing_context().set_object_drop_lines(obj->list.dropData->cLine);
		}
	}
	if (obj->checkBox.fExist)
	{
		xlsx_context->get_drawing_context().set_object_checked(obj->checkBox.fChecked);
		xlsx_context->get_drawing_context().set_object_3D(!obj->checkBox.fNo3d);
		//unsigned short accel;
	}
	if (obj->radioButton.fExist)
	{
	//unsigned short idRadNext;
	//Boolean<unsigned short> fFirstBtn;
	}
	if (obj->edit.fExist)
	{
		xlsx_context->get_drawing_context().set_object_multiLine(obj->edit.fMultiLine);
		xlsx_context->get_drawing_context().set_object_vscroll(obj->edit.fVScroll);
		//unsigned short ivtEdit;
		//unsigned short id;
	}
	bool full_ref = false;
	if (obj->cmo.ot > 0x06) full_ref = true;
	
	if (obj->linkFmla.fExist && obj->linkFmla.fmla.bFmlaExist)
	{		
		std::wstring link = obj->linkFmla.fmla.fmla.getAssembledFormula(full_ref);
		xlsx_context->get_drawing_context().set_object_link(link);
	}
	if (obj->macro.fExist && obj->macro.fmla.bFmlaExist)
	{
		std::wstring macro = obj->macro.fmla.fmla.getAssembledFormula(full_ref);
		xlsx_context->get_drawing_context().set_macro(macro);
	}
}

void XlsConverter::convert(XLS::ChartSheetSubstream* chart)
{
	if (chart == NULL) return;

	chart->serialize(xlsx_context->current_chart().chartData());	
	//convert(chart->m_OBJECTSCHART.get());непонятные какие то текстбоксы - пустые и бз привязок
}

void XlsConverter::convert(XLS::PIVOTVIEW* pivot_view)
{
	if (pivot_view == NULL) return;

	std::wstringstream strm;

	pivot_view->serialize(strm);

	int index_view = xlsx_context->get_pivots_context().add_view(strm.str(), pivot_view->indexCache);
	
	if (index_view > 0)
	{
		xlsx_context->current_sheet().sheet_rels().add(oox::relationship(L"pvId" + std::to_wstring(index_view),
			L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable",
			L"../pivotTables/pivotTable" + std::to_wstring(index_view) + L".xml"));
	}
}

void XlsConverter::convert(XLS::PIVOTCACHEDEFINITION* pivot_cached)
{
	if (pivot_cached == NULL) return;

	std::wstringstream strmD, strmR;

	pivot_cached->serialize_definitions(strmD);
	pivot_cached->serialize_records(strmR);

	xlsx_context->get_pivots_context().add_cache(strmD.str(), strmR.str());
	
	if (!xls_global_info->mapPivotCacheExternal.empty())
	{
		xlsx_context->get_pivots_context().add_cache_external(xls_global_info->mapPivotCacheExternal);
	}
}

void XlsConverter::convert(XLS::SUPBOOK* external)
{
	if (external == NULL) return;
	if (external->IsExternal() == false) return;

	xlsx_context->start_external();

	external->serialize(xlsx_context->current_external().externalData());

	if (!external->sExternPathLink.empty()) //??? 
	{
		xlsx_context->current_external().add_rels(false, L"rId1", external->sExternPathLink, oox::external_items::typeExternalLink);
	}

	xlsx_context->end_external();
}
void XlsConverter::convert(XLS::QUERYTABLE* query_table)
{
	if (query_table == NULL) return;

	std::wstringstream strm;		
	query_table->serialize(strm);

	xlsx_context->add_query_table(strm.str());
}