public IExportUtility CreateExportUtility(MapType mapType, ExportType exportType)
{
IExportUtility exportUtil = null;
switch (mapType)
{
case MapType.IBIS:
switch (exportType)
{
case ExportType.Compendium:
exportUtil = new CompendiumExportUtility(MapManager);
break;
case ExportType.GlymaXml:
exportUtil = new GlymaXmlExportUtility(MapManager);
break;
case ExportType.PDF:
exportUtil = new PdfExportUtility(MapManager);
break;
case ExportType.Word:
exportUtil = new WordExportUtility(MapManager);
break;
}
break;
//TODO: Handle other map types with other export utilities.
}
return exportUtil;
}
private void InitializeConstructor(ExportType type)
{
switch (type)
{
case ExportType.CSharpObject:
formattingSettings = new CodeFormattingSettings(CodeLanguages.CSharp);
extension = ".cs";
break;
case ExportType.Json:
formattingSettings = new CodeFormattingSettings(CodeLanguages.JavaScript);
extension = ".json";
break;
case ExportType.Xml:
formattingSettings = new CodeFormattingSettings(CodeLanguages.Xml);
extension = ".xml";
break;
}
InitializeComponent();
foreach (string textKey in _dicTexts.Keys)
{
RadPageViewPage pageViewPage = new RadPageViewPage(textKey);
radPageViewGeneratedText.Pages.Add(pageViewPage);
}
scintillaDisplayObjects.Dock = DockStyle.Fill;
DisplayText(radPageViewGeneratedText.Pages[0]);
}
public void ExportStats(ExportType type)
{
Messenger.Send(new ExportStatsMessage
{
ExportType = type
});
}
/// <summary>
/// Fires the ExportRequested event
/// </summary>
/// <param name="eExportType">The type of export requested</param>
public void FireExportRequestedEvent(ExportType eExportType)
{
if (null != ExportRequested)
{
ExportRequested(this, new ExportEventArgs(eExportType));
}
}
/// <summary>
/// 导出总运单号
/// </summary>
/// <param name="dataSource">总运单</param>
/// <param name="dataSource2">子运单数据</param>
/// <param name="hawbtype">导出类型</param>
public NpoiHelper(MAWB dataSource,IList<HAWB> dataSource2,ExportType hawbtype)
{
if (dataSource == null) throw new ArgumentNullException("dataSource", @"总运单不能为空");
_mawbDataSource = dataSource;
_hawbDataSources = dataSource2;
_hawbtype=hawbtype;
}
public SiteExport(Guid siteID, ExportType exportWhat)
{
SiteData s = null;
List<ContentPageExport> pages = new List<ContentPageExport>();
s = SiteData.GetSiteByID(siteID);
if (exportWhat == ExportType.AllData) {
pages = ContentImportExportUtils.ExportAllSiteContent(siteID);
} else {
if (exportWhat == ExportType.ContentData) {
List<ContentPageExport> lst = ContentImportExportUtils.ExportPages(siteID);
pages = pages.Union(lst).ToList();
}
if (exportWhat == ExportType.BlogData) {
List<ContentPageExport> lst = ContentImportExportUtils.ExportPosts(siteID);
pages = pages.Union(lst).ToList();
}
}
this.TheUsers = (from u in ExtendedUserData.GetUserList()
select new SiteExportUser {
Email = u.Email,
Login = u.UserName,
FirstName = u.FirstName,
LastName = u.LastName,
UserNickname = u.UserNickName
}).ToList();
SetVals(s, pages);
}
public ExportParamaters(bool exludePrivateProperties, bool excludePropertiesNotInClass, int maxDepth, ExportType exportType)
{
ExludePrivateProperties = exludePrivateProperties;
ExcludePropertiesNotInClass = excludePropertiesNotInClass;
MaxDepth = maxDepth;
ExportType = exportType;
}
public FormDisplayGeneratedText(Dictionary<string, string> dicTexts, ExportType type)
{
_dicTexts = dicTexts;
_type = type;
InitializeConstructor(_type);
SetScintillaMargins(dicTexts);
}
private void cbExportType_SelectedIndexChanged(object sender, EventArgs e)
{
var exts = new Dictionary<ExportType, String> { {ExportType.Binary,".bin"}, {ExportType.Picture,".png"} };
exportType = (ExportType)cbExportType.SelectedIndex;
Filename = System.IO.Path.ChangeExtension(Filename, exts[exportType]);
tbFileName.Text = Filename;
ofOpenDialog.FileName = Filename;
}
public ExportEventArgs(ExportType type, IExportElement document, bool sendByEmail, string fileName)
{
Settings = new ExportSettings();
SetTitle(fileName);
ExportType = type;
SendByEmail = sendByEmail;
ExportDocument(document);
}
public ExportDocumentResult(string html, ExportType exportType, bool sendEmail, ExportEventArgs.ExportSettings settings)
{
_Options = new ExportEventArgs(html, "export")
{
ExportType = exportType,
SendByEmail = sendEmail,
Settings = settings
};
_ExportType = exportType;
_SendEmail = sendEmail;
}
/// <summary>
/// 对所有内置程序集的导出标记应用
/// </summary>
/// <param name="category">导出类型</param>
/// <param name="exportCfg">该导出配置实例</param>
public static void ExportApply(ExportType category, Action<Type, APIExportAttribute> exportCfg)
{
foreach (Assembly loadedAssembly in AppDomain.CurrentDomain.GetAssemblies())
{
#region 跳过全局缓存程序集和微软公司的程序集
if (loadedAssembly.GlobalAssemblyCache || loadedAssembly.ReflectionOnly) continue;
object[] asmCom = loadedAssembly.GetCustomAttributes(typeof(AssemblyCompanyAttribute), true);
if (asmCom != null && asmCom.Length > 0)
{
AssemblyCompanyAttribute asmCompany = (AssemblyCompanyAttribute)asmCom[0];
if (asmCompany.Company.Equals("Microsoft Corporation", StringComparison.InvariantCultureIgnoreCase)) continue;
}
#endregion
asmCom = loadedAssembly.GetCustomAttributes(typeof(APIExportAttribute), true);
if (asmCom == null || asmCom.Length < 1) continue;
try
{
#region 循环查找注册类型及方法
foreach (Type innerType in loadedAssembly.GetTypes())
{
if (innerType.IsAbstract || innerType.IsInterface || innerType.IsGenericType || innerType.IsNotPublic)
{
//|| !innerType.IsSubclassOf(typeof(NetTask.Core.XmlDefineTask))
//System.Diagnostics.Debugger.Log(0, "Info", "Skipped:" + innerType.FullName + Environment.NewLine);
continue;
}
object[] pAttr = innerType.GetCustomAttributes(typeof(APIExportAttribute), false);
if (pAttr == null || pAttr.Length < 1)
{
continue;
}
else
{
APIExportAttribute cfg = (APIExportAttribute)pAttr[0];
if (cfg.Category == category)
{
exportCfg(innerType, cfg);
}
}
}
#endregion
}
catch (Exception typeLoadEx)
{
if (typeLoadEx.InnerException != null) typeLoadEx = typeLoadEx.InnerException;
System.Diagnostics.Trace.TraceError("* 查找Assembly[{0}]时获取全部类型出现异常:{1}", loadedAssembly.FullName, typeLoadEx.Message);
}
}
}
public static void WriteToCSV(DataTable dt, ExportType exportType, string viewName)
{
StringBuilder sb = new StringBuilder();
string attachment = String.Format("attachment; filename={0}.csv", exportType);
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.ClearHeaders();
HttpContext.Current.Response.ClearContent();
HttpContext.Current.Response.AddHeader("content-disposition", attachment);
HttpContext.Current.Response.ContentType = "text/csv";
HttpContext.Current.Response.AddHeader("Pragma", "public");
DBAdminDA DA = new DBAdminDA();
using (DataTable dtc = DA.GetColumns(viewName)) {
foreach (DataRow dr in dtc.Rows) {
AddColumn(dr["COLUMN_NAME"].ToString(), sb, false);
}
HttpContext.Current.Response.Write(sb.ToString());
HttpContext.Current.Response.Write(Environment.NewLine);
}
DA = null;
foreach(DataRow row in dt.Rows) {
sb = new StringBuilder();
foreach(DataColumn column in dt.Columns) {
if (exportType.Equals(ExportType.Donation)) {
if (column.ColumnName.Equals("CreditCardNumber") || column.ColumnName.Equals("SecurityCode")) {
AddColumn(Security.Decrypt(row[column].ToString()), sb, true);
} else {
AddColumn(row[column].ToString(), sb, false);
}
} else if (exportType.Equals(ExportType.Membership)) {
if (column.ColumnName.Equals("Message")) {
AddColumn("", sb, false); //omit from exported data
} else if (column.ColumnName.Equals("CreditCardNumber") || column.ColumnName.Equals("SecurityCode")) {
AddColumn(Security.Decrypt(row[column].ToString()), sb, true);
} else {
AddColumn(row[column].ToString(), sb, false);
}
}
else if (exportType.Equals(ExportType.BigBookSaleVolunteer) || exportType.Equals(ExportType.BookAndPlantSaleVolunteer) || exportType.Equals(ExportType.AnniversaryBookSaleVolunteer))
{
AddColumn(row[column].ToString(), sb, true);
} else {
AddColumn(row[column].ToString(), sb, false);
}
}
HttpContext.Current.Response.Write(sb.ToString());
HttpContext.Current.Response.Write(Environment.NewLine);
}
HttpContext.Current.Response.End();
}
public static void ExportGridView(GridView gridView, string fileName, ExportType exportType)
{
const string m_Http_Attachment = "attachment;filename=";
const string m_Http_Content = "content-disposition";
HttpResponse m_Response = HttpContext.Current.Response;
m_Response.Clear();
m_Response.ClearContent();
m_Response.ClearHeaders();
m_Response.Buffer = true;
m_Response.AddHeader(m_Http_Content, m_Http_Attachment + fileName);
m_Response.ContentEncoding = Encoding.UTF8;
m_Response.Cache.SetCacheability(HttpCacheability.NoCache);
StringWriter m_StringWriter = new StringWriter();
HtmlTextWriter m_HtmlWriter = new HtmlTextWriter(m_StringWriter);
gridView.AllowPaging = false;
gridView.HeaderStyle.Font.Bold = true;
gridView.DataBind();
ClearControls(gridView);
try
{
gridView.RenderControl(m_HtmlWriter);
}
catch (Exception ex) { ex.ToString(); }
string m_gridViewText = m_StringWriter.ToString();
switch (exportType)
{
case ExportType.Excel:
ExportHelper.ExportToExcelWord(m_gridViewText, "application/vnd.ms-excel", m_Response);
break;
case ExportType.CSV:
ExportHelper.ExportToCsv(m_gridViewText, "application/csv", m_Response);
break;
case ExportType.Word:
ExportHelper.ExportToExcelWord(m_gridViewText, "application/vnd.ms-word", m_Response);
break;
default:
ExportHelper.ExportToExcelWord(m_gridViewText, "application/vnd.ms-excel", m_Response);
break;
}
}
/// <summary>
/// 开始导出
/// </summary>
/// <param name="localConfig"></param>
/// <param name="exportType"></param>
/// <param name="outputStream"></param>
/// <param name="features"></param>
/// <param name="useShareTexture"></param>
/// <param name="progressCallback"></param>
/// <param name="cancellationToken"></param>
private void StartExport(AppLocalConfig localConfig, ExportType exportType, Stream outputStream, Dictionary <FeatureType, bool> features, bool useShareTexture, Action <int> progressCallback, CancellationToken cancellationToken)
{
using (var log = new RuntimeLog())
{
var config = new ExportConfig();
config.TargetPath = localConfig.LastTargetPath;
config.ExportType = exportType;
config.OutputStream = outputStream;
config.Features = features?.Keys.ToList() ?? new List <FeatureType>();
config.Trace = log.Log;
#region Add Plugin - CreatePropDb
{
var cliPath = Path.Combine(
App.GetHomePath(),
@"Tools",
@"CreatePropDb",
@"CreatePropDbCLI.exe");
if (File.Exists(cliPath))
{
config.Addins.Add(new ExportPlugin(
FeatureType.GenerateModelsDb,
cliPath,
new[] { @"-i", config.TargetPath }
));
}
}
#endregion
#region Add Plugin - CreateThumbnail
{
var cliPath = Path.Combine(
App.GetHomePath(),
@"Tools",
@"CreateThumbnail",
@"CreateThumbnailCLI.exe");
if (File.Exists(cliPath))
{
config.Addins.Add(new ExportPlugin(
FeatureType.GenerateThumbnail,
cliPath,
new[] { @"-i", config.TargetPath }
));
}
}
#endregion
Exporter.ExportToSvf(config, x => progressCallback?.Invoke((int)x), cancellationToken);
}
}
public IDataExporter CreateDataExporter(ExportType type)
{
switch (type)
{
case ExportType.Csv:
return(new CsvDataExporter());
case ExportType.Excel:
return(new ExcelDataExporter());
default:
throw new ArgumentException(nameof(type));
}
}
public void Zy_ExportPatientFee(int ybId, List <DataTable> dtList, string CaseNumber)
{
//if (dt == null || dt.Rows.Count == 0)
//{
// MessageBox.Show("数据源为空！");
// return;
//}
string sColumnName = "";
try
{
string sType = M_GetMedicalInsuranceData(ybId, "ExportPatientFee", "filetype");
sColumnName = M_GetMedicalInsuranceData(ybId, "ExportPatientFee", "columnNames");
string sSeparator = M_GetMedicalInsuranceData(ybId, "ExportPatientFee", "separator");
List <Dictionary <string, string> > columnNamesList = new List <Dictionary <string, string> >();
string[] sColumnNames = sColumnName.Split('^');
for (int i = 0; i < sColumnNames.Length; i++)
{
Dictionary <string, string> dss = new Dictionary <string, string>();
string[] sColumnNamess = sColumnNames[i].Split('|');
foreach (string s in sColumnNamess)
{
dss.Add(s.Split(',')[0], s.Split(',')[1]);
}
columnNamesList.Add(dss);
}
ExportFile doExport = new ExportFile("zyfj" + CaseNumber, columnNamesList, sSeparator);
ExportType _exportType = sType.Trim() == "1" ? ExportType.Excel : ExportType.Txt;
if (doExport.InitShowDialog(_exportType))
{
if (doExport.DoExportWork(dtList))
{
doExport.OpenFile();
Zy_UploadzyPatFee(Convert.ToInt32(dtList[1].Rows[0]["PatListID"].ToString()), 1);
}
}
}
catch
{
MessageBox.Show("导出失败！");
return;
}
}
public bool DrawGUIList(EditorGUILayoutEx in_layout)
{
if (!_Initialized)
{
_Initialized = true;
UseTypeRow = Google2uGUIUtil.GetBool(Prefix + "UseTypeRow", UseTypeRow);
WorksheetExportType = Google2uGUIUtil.GetEnum(Prefix + "ExportType", WorksheetExportType);
}
var old = GUI.enabled;
if (WorksheetQueryStatus != QueryStatus.Idle && RowsDisplay.Length == 0)
{
GUI.enabled = false;
}
var newExportType = WorksheetExportType;
if (IsDataValid)
{
newExportType = (ExportType)EditorGUILayout.EnumPopup(WorksheetName, WorksheetExportType);
}
else if (WorksheetQueryStatus != QueryStatus.Idle)
{
EditorGUILayout.LabelField(WorksheetName,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_MESSAGE_QUERYING_CELLS) +
Google2u.Ellipses);
}
else
{
var oldColor = GUI.color;
if (GUI.GetNameOfFocusedControl() != WorksheetName + "Invalid")
{
GUI.color = Color.red;
}
GUI.SetNextControlName(WorksheetName + "Invalid");
newExportType = (ExportType)EditorGUILayout.EnumPopup(WorksheetName, WorksheetExportType);
GUI.color = oldColor;
}
if (newExportType != WorksheetExportType)
{
WorksheetExportType = Google2uGUIUtil.SetEnum(Prefix + "ExportType", newExportType);
}
GUI.enabled = old;
return(WorksheetExportType != ExportType.DoNotExport);
}
public byte[] Export(ExportType exportType, string[] parameters)
{
var now = DateTime.Now;
var lastmonth = DateTime.Today.AddMonths(-1);
var nextmonth = DateTime.Today.AddMonths(1);
var time = DateTime.Now.ToString("HH:mm:ss tt");
var no_time_Fine_Exp_Dat = DateTime.Today.AddMonths(1).ToString("d/M/yyyy");
var no_time_Date_Of_Offence = DateTime.Today.AddMonths(-1).ToString("d/M/yyyy");
var models = new List <NatisNotFoundModelAG>();
models.Add(
new NatisNotFoundModelAG
{
District = "All",
Court = "All",
Include = "Not Found",
IforceLogo = File.ReadAllBytes(@"C:\Users\agabone\Desktop\iforce.png"),
TicketNo = "23/79614/602/159853",
TicketDate = now,
VehicleRegisteration = "GH 873483",
ReportDate = no_time_Date_Of_Offence
});
for (int i = 0; i < 20; i++)
{
models.Add(
new NatisNotFoundModelAG
{
TicketNo = "22/65443/602/131510" + i,
TicketDate = DateTime.Today.AddMonths(-i),
VehicleRegisteration = "CF 87348" + i,
ReportDate = no_time_Date_Of_Offence,
});
}
if (exportType == ExportType.PDF)
{
return(StreamPdfReport(BuildReport(models)));
}
else if (exportType == ExportType.Excel)
{
return(StreamExcelReport(BuildReport(models)));
}
else
{
throw new NotSupportedException();
}
}
/// <summary>
/// Initializes a new instance of the ExportConfigurationResult class.
/// </summary>
/// <param name="id">Export configuration id</param>
/// <param name="exportType">Target resource type of export
/// configuration. Possible values include: 'BlobStorage',
/// 'AppInsights'</param>
/// <param name="creationTime">Creation time in ISO 8601 format</param>
/// <param name="state">State of the export job. Possible values
/// include: 'Enabled', 'Disabled', 'Pending', 'Deleted',
/// 'Invalid'</param>
/// <param name="lastRunTime">Latest time in ISO 8601 format when
/// export completed successfully</param>
/// <param name="stateInfo">Additional information about export
/// configuration state</param>
/// <param name="resourceGroup">resource group for the storage
/// account/App Insights resource</param>
/// <param name="resourceName">Storage accout or Appinsights resource
/// name</param>
public ExportConfigurationResult(string id, ExportType exportType, string creationTime, ExportState state, string lastRunTime = default(string), IList <ExportEntity?> exportEntities = default(IList <ExportEntity?>), string stateInfo = default(string), string resourceGroup = default(string), string resourceName = default(string), ExportConfiguration exportConfiguration = default(ExportConfiguration))
{
Id = id;
ExportType = exportType;
CreationTime = creationTime;
LastRunTime = lastRunTime;
ExportEntities = exportEntities;
State = state;
StateInfo = stateInfo;
ResourceGroup = resourceGroup;
ResourceName = resourceName;
ExportConfiguration = exportConfiguration;
CustomInit();
}
public static IExport CreateInstance(ExportType type,MyDocument doc)
{
switch (type)
{
case ExportType.Xls:
return new ExportExcel(doc);
case ExportType.Pdf:
return new ExportPdf(doc);
case ExportType.Txt:
return new ExportText(doc);
default:
throw new ArgumentException("该类型方法未实现");
}
}
private void ExportSelected(ExportType type)
{
try
{
ViewState["SelectedFolderName"] = tvFolders.SelectedNode.Text;
ViewState["SelectedFolderUri"] = tvFolders.SelectedValue;
List <string> messagesList = new List <string>();
foreach (GridViewRow row in MessagesGridView.Rows)
{
if (row.RowType == DataControlRowType.DataRow)
{
CheckBox chkRow = (row.Cells[0].FindControl("SelectedCheckBox") as CheckBox);
if (chkRow.Checked)
{
string UniqueUri = MessagesGridView.DataKeys[row.RowIndex].Value.ToString();
messagesList.Add(UniqueUri);
}
}
}
if (messagesList.Count() > 0)
{
ErrorsDiv.Visible = false;
if (type == ExportType.PST)
{
MailHelper.Current.ExportSelectedMessagesToPST(ViewState["SelectedFolderName"].ToString(), messagesList);
}
// else if (type == ExportType.PDF)
else // Any format which involves Aspose.Words for .NET
{
MailHelper.Current.ExportSelectedMessagesToAsposeWords(ViewState["SelectedFolderName"].ToString(), messagesList, type);
}
}
else
{
// Binding again to make sure paging works
RenderSelectedMessages(ViewState["SelectedFolderUri"].ToString());
ErrorsDiv.Visible = true;
ErrorLiteral.Text = "Please select one or more messages to export";
}
}
catch (Exception ex)
{
ErrorsDiv.Visible = true;
ErrorLiteral.Text = ex.ToString();
}
}
private static IGeneratorBackend GetGeneratorBackend(ExportType type)
{
switch (type)
{
case ExportType.Csv:
return(new CsvBackend());
case ExportType.ExcelXml:
return(new ClosedXmlExcelBackend());
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
/// <summary>
/// Export logs to the disk
/// </summary>
/// <param name="path">The path where logs should be stored</param>
/// <param name="logType">The type of logs that should be saved. Can be null if all logs should be saved</param>
/// <param name="exportType">The type of export that should be performed</param>
internal void Export(string path, LogType?logType, ExportType exportType)
{
if (_logList.Count == 0)
{
return;
}
List <Log> exportList;
if (logType != null)
{
exportList = new List <Log>();
foreach (Log l in _logList)
{
if (l.LogType == logType)
{
exportList.Add(l);
}
}
}
else
{
exportList = _logList;
}
if (exportList == null || exportList.Count == 0)
{
throw new ArgumentNullException();
}
// ReSharper disable once SwitchStatementMissingSomeCases
switch (exportType)
{
case ExportType.Html:
LogExporter.ExportHtml(path, exportList);
break;
default:
LogExporter.ExportTxt(path, exportList);
break;
case ExportType.Csv:
LogExporter.ExportCsv(path, exportList);
break;
case ExportType.Excel:
LogExporter.ExportExcel(path, exportList);
break;
}
}
public async Task <bool> PerformImportProcessing(ExportType exportType, string defaultDataPath, string apiIdentifier, string apiSessionToken, bool fetchLiveData)
{
OCMClient client = new OCMClient(IsSandboxedAPIMode);
var credentials = GetAPISessionCredentials(apiIdentifier, apiSessionToken);
CoreReferenceData coreRefData = null;
coreRefData = await client.GetCoreReferenceData();
string outputPath = "Data\\";
List <IImportProvider> providers = new List <IImportProvider>();
string inputDataPathPrefix = defaultDataPath;
// providers.Add(new ImportProvider_RWEMobility() { InputPath = inputDataPathPrefix + "rwe-mobility\\data.json.txt" });
//Working - Auto refreshed
//providers.Add(new ImportProvider_UKChargePointRegistry() { InputPath = inputDataPathPrefix + "chargepoints.dft.gov.uk\\data.json" });
/* providers.Add(new ImportProvider_BlinkNetwork() { InputPath = inputDataPathPrefix + "blinknetwork.com\\jsondata2.txt" });
* providers.Add(new ImportProvider_CarStations() { InputPath = inputDataPathPrefix + "carstations.com\\jsonresults.txt" });
* providers.Add(new ImportProvider_RWEMobility() { InputPath = inputDataPathPrefix + "rwe-mobility\\data.json.txt" });
*
* providers.Add(new ImportProvider_Mobie() { InputPath = inputDataPathPrefix + "mobie.pt\\data.json.txt" });
* providers.Add(new ImportProvider_AFDC() { InputPath = inputDataPathPrefix + "afdc\\data.json" });
* providers.Add(new ImportProvider_ESB_eCars() { InputPath = inputDataPathPrefix + "esb_ecars\\data.kml" });
*/
//providers.Add(new ImportProvider_AddEnergie(ImportProvider_AddEnergie.NetworkType.LeCircuitElectrique) { InputPath = inputDataPathPrefix + "addenergie\\StationsList.lecircuitelectrique.json" });
//providers.Add(new ImportProvider_AddEnergie(ImportProvider_AddEnergie.NetworkType.ReseauVER) { InputPath = inputDataPathPrefix + "addenergie\\StationsList.reseauver.json" });
//providers.Add(new ImportProvider_GenericExcel() { InputPath = inputDataPathPrefix + "catalonia\\catalonia.xlsx" , DefaultDataProvider=coreRefData.DataProviders.First(d=>d.ID==25)});
//Working -manual refresh
//providers.Add(new ImportProvider_NobilDotNo() { InputPath = inputDataPathPrefix + "nobil\\nobil.json.txt" });
//Dev
//providers.Add(new ImportProvider_CoulombChargepoint() { InputPath = inputDataPathPrefix + "coulomb\\data.json.txt" });
//providers.Add(new ImportProvider_ChademoGroup() { InputPath = inputDataPathPrefix + "chademo\\chademo_jp.kml", ImportType= ChademoImportType.Japan, DefaultCountryID=114});
//obsolete
//providers.Add(new ImportProvider_PODPoint() { InputPath = inputDataPathPrefix + "pod-point.com\\export.htm" });
//providers.Add(new ImportProvider_ChargeYourCar() { InputPath = inputDataPathPrefix + "chargeyourcar.org.uk\\data.htm" });
foreach (var provider in providers)
{
await PerformImport(exportType, fetchLiveData, credentials, coreRefData, outputPath, provider);
}
return(true);
}
/// <summary>
/// 设置导出Options
/// </summary>
/// <param name="type"></param>
/// <param name="option"></param>
public static void SetExportOption(ExportType type, Options option)
{
List <Options> list = null;
if (!exporterOption.TryGetValue(type, out list))
{
list = new List <Options>();
exporterOption.Add(type, list);
}
if (option.ExcelPath.Contains(Config.LANGUAGE) && type == ExportType.txt)
{
exportLanguageTotalCount++;
}
list.Add(option);
}
private InstaExportItem CreateInstaExportItem(ExportType exportType)
{
var description = InstaDescriptionHandler == null ? $"{view.Title}\n\n{view.Description}"
: InstaDescriptionHandler.CreateDescription(currentSubject.Subject, view.Title, view.Description, commonHashtags);
return(new InstaExportItem()
{
ExportType = exportType,
Subject = currentSubject.Subject,
Cover = view.CoverImage,
Photos = view.SubjectPhotos,
Location = instaLocation,
Description = description,
});
}
// Protected Methods (8)
protected void CheckExport()
{
ExportType type = this.SessionExportType;
if (type != ExportType.none)
{
this.SessionExportType = ExportType.none;
byte[] data = this.SessionExportData;
this.SessionExportData = null;
if (data != null)
{
ExportHelper.WriteDataToResponse(data, type);
}
}
}
public void SetData(ExportType type)
{
FileInfo fileInfo = new FileInfo(excelFullPath);
var first = typeof(ExportType).GetField(type.ToString()).GetFirstCustomAttribute <DescriptionAttribute>();
if (first != null)
{
tableName = fileInfo.Name.Replace(fileInfo.Extension, first.Description);
}
else
{
Debug.LogError("获取路径扩展名出错");
}
}
protected TableCell[] GetExportCells(String callBackID)
{
List <TableCell> cells = new List <TableCell>();
foreach (ExportType item in Enum.GetValues(typeof(ExportType)))
{
ExportType type = (ExportType)item;
if (type != ExportType.none &&
((this.ExportTypes & type) == type))
{
cells.Add(this.GetExportCell(type, callBackID));
}
}
return(cells.ToArray());
}
public void MakeLineChart([NotNull] string filename,
[NotNull] string yaxislabel,
[NotNull] LineSeriesEntry lineSeries,
[NotNull][ItemNotNull] List <AnnotationEntry> annotations,
double absoluteMinimum = 0,
ExportType exportType = ExportType.Png)
{
List <LineSeriesEntry> lineseriesList = new List <LineSeriesEntry> {
lineSeries
};
AddThread(yaxislabel,
() => InternalMakeLineChart(filename, yaxislabel, lineseriesList, annotations, absoluteMinimum, exportType),
filename);
}
public JsonResult DumpItems(CatalogJobParameter catalog,
RestoreAdminUserInfo restoreAdminUserInfo,
LoadedTreeItem selectedItem,
string notificationAddress,
ExportType exportType)
{
var password = RSAUtil.AsymmetricDecrypt(restoreAdminUserInfo.Password);
IRestoreServiceEx restore = RestoreFactory.Instance.NewRestoreServiceEx(restoreAdminUserInfo.UserAddress, password, string.Empty, restoreAdminUserInfo.Organization);
restore.CurrentRestoreCatalogJob = catalog;
restore.Destination = RestoreFactory.Instance.NewDumpDestination();
restore.Destination.ExportType = exportType;
restore.Destination.SetOtherInformation(notificationAddress);
restore.Restore(selectedItem);
return Json(new { IsSuccess = true });
}
private void Export(ExportType type)
{
string action = "匯出";
try {
string txtPath = string.Concat(@"E:\Data\Desktop\", txt_ExportName.Text, ".", type.ToString());
using (StreamWriter sw = new StreamWriter(txtPath))
{
sw.Write(richtxt_Output.Text);
}
MessageBox.Show(SystemMsg.succeed(action));
} catch (Exception ex) {
MessageBox.Show(SystemMsg.fail(action, ex.ToString()));
}
}
private IExportItem CreateExportItem(Publisher publisher, ExportType exportType)
{
var publisherType = publisher.GetType();
if (publisherType == typeof(VKPublisher))
{
return(CreateVKExportItem(exportType));
}
if (publisherType == typeof(InstagramPublisher))
{
return(CreateInstaExportItem(exportType));
}
throw new ArgumentException();
}
public async Task ExportDownload_SingleJsonFile()
{
_mockMediator.Setup(p => p.Send(It.IsAny <ExportTagsDataCommand>(), default))
.Returns(Task.FromResult(new ExportResult
{
ExportFormat = ExportFormat.SingleJsonFile,
Content = Array.Empty <byte>()
}));
var settingsController = CreateDataPortingController();
ExportType type = ExportType.Tags;
var result = await settingsController.ExportDownload(type, CancellationToken.None);
Assert.IsInstanceOf <FileContentResult>(result);
}
public static string GetExtensionForType(ExportType exportType, bool forcePng = false)
{
string extension = null;
switch (exportType)
{
case ExportType.SoundNodeWave:
extension = ".ogg";
break;
case ExportType.Texture2D:
extension = forcePng ? ".png" : ".tga";
break;
}
return(extension);
}
internal void InternalExport(string location, ExportType exportType, bool showMessage)
{
if (exportType == ExportType.ExcelFile)
{
this.CreateExcelReport(location);
}
else
{
this.CreateCSVReport(location);
if (showMessage)
{
FormsUtilities.InformationMessageBox("Data saved to '{0}'.", location);
}
}
}
public ExportOption(Dictionary <string, string> value, ExportType exportType, MapType mapType)
: this(exportType, mapType)
{
Value = value;
ShowDescription = value.GetPropertyBooleanValue("ShowDescription");
ShowImage = value.GetPropertyBooleanValue("ShowImage");
ShowVideo = value.GetPropertyBooleanValue("ShowVideo");
ShowPages = value.GetPropertyBooleanValue("ShowPages");
var selectedNodes = value.GetPropertyStringValue("SelectedNodes");
if (!string.IsNullOrEmpty(selectedNodes))
{
SelectedNodes = selectedNodes.ToGuidList();
}
}
public bool Export(string root, string package, string assetName, ExportType exportType, string destination, bool forceTgaToPng = false)
{
var tmpDir = GetTMPDir();
if (Directory.Exists(tmpDir))
{
Directory.Delete(tmpDir, true);
}
Directory.CreateDirectory(tmpDir);
// .\umodel.exe -game=ue3 -path="C:\Program Files (x86)\Steam\steamapps\common\HatinTime\HatinTimeGame\EditorCookedPC" -export HatinTime_Music_Metro4 Act_4_Pink_Paw_Station -sounds -out=".\test"
var res = Run($"-game=ue3 -path=\"{root}\" -3rdparty -export {package} {assetName}{(exportType == ExportType.SoundNodeWave ? " -sounds" : " " + exportType.ToString())} -out=\"{tmpDir}\"");
if (!res)
{
return(false);
}
var extension = GetExtensionForType(exportType);
var path = Path.Combine(tmpDir, package, exportType.ToString(), assetName + extension);
Debug.WriteLine("ExceptedPath: " + path);
if (File.Exists(path))
{
if (File.Exists(destination))
{
File.Delete(destination);
}
if (forceTgaToPng && exportType == ExportType.Texture2D)
{
using (var b = new TargaImage(path))
{
b.Image.Save(destination, ImageFormat.Png);
}
}
else
{
File.Move(path, destination);
}
return(true);
}
return(false);
}
public ExportResult ExportNlm(ArticleItem article, ExportType exportType, PublicationType?type = null)
{
// Capture some state
var username = _.UserContext.User?.Name ?? "Unknown User";
var articlePath = article._Path;
var articleId = article.Article_Number;
var currentTime = DateTime.UtcNow;
//TamerM - 2016-03-22: Log the normal case
_logger.Info($"Starting ExportNlm(): username:{username}, articleId:{articleId}, articlePath:{articlePath}, exportTime:{currentTime}");
var result = _innerService.ExportNlm(article, exportType, type);
var logMessage = new NlmLogMessage
{
ArticleId = articleId,
ArticlePath = articlePath,
Username = username,
ExportTime = currentTime,
ExportResult = result
};
// Log & report any export errors
if (!result.ExportSuccessful)
{
var errorMessage = string.Empty;
if (result.Exception != null)
{
errorMessage = "Error while exporting NLM: \n" + JsonConvert.SerializeObject(logMessage);
}
// Log & report on any validation errors
else if (!result.ValidationResult)
{
errorMessage = "NLM Export failed on validation. \n" + JsonConvert.SerializeObject(logMessage);
}
_logger.Error(errorMessage, result.Exception);
SendMail(errorMessage, articleId);
}
else
{
//TamerM - 2016-03-22: Log the normal case
_logger.Info($"ExportNlm() completed successfully");
}
return(result);
}
public static bool ExportAs <T>(IEnumerable <T> enumerable, ExportType exportType = ExportType.xls)
{
Type type = typeof(T);
var properties = type.GetProperties();
DataTable dataTable = new DataTable();
dataTable.TableName = type.Name;
DataColumn column;
DataRow row;
foreach (var property in properties)
{
column = new DataColumn();
column.DataType = property.PropertyType;
column.ColumnName = property.Name;
column.AutoIncrement = false;
column.Caption = property.Name;
column.ReadOnly = false;
column.Unique = false;
dataTable.Columns.Add(column);
}
foreach (var item in enumerable)
{
row = dataTable.NewRow();
foreach (var property in properties)
{
row[property.Name] = property.GetValue(item);
}
dataTable.Rows.Add(row);
}
if (dataTable.Rows.Count > 0)
{
switch (exportType)
{
case ExportType.xls:
return(ExportAsXls(dataTable));
}
}
return(false);
}
public virtual void Export(ExportType exportType)
{
var customExportImplControl = GetCustomExportImplementorControl();
if (customExportImplControl != null)
{
customExportImplControl.Export(exportType);
}
else
{
var printableControl = GetPrintableControl();
if (printableControl != null)
{
GridExport.ExportGrid(printableControl, exportType);
}
}
}
public static void ExportText(ExportType type)
{
string exportText = string.Empty;
switch( type )
{
case ExportType.ComponentBase:
exportText = ComponentBaseGraph();
break;
case ExportType.ObjectBase:
exportText = GameObjectBaseGraph();
break;
}
string exportFile = Path.GetFileNameWithoutExtension( UnityEditor.EditorApplication.currentScene ) + ".dot";
File.WriteAllText( exportFile, exportText);
}
public void ExportTo(ExportType fileType, string fileName)
{
if (View == null)
{
return;
}
switch (fileType)
{
case ExportType.XLSX:
View.ExportToXlsx(fileName);
break;
case ExportType.PDF:
View.ExportToPdf(fileName);
break;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Assemblyes file dialog filter.
/// </summary>
/// <returns>Created file dialog filter.</returns>
public static string AssemblyDialogFilter()
{
var filter = new StringBuilder();
for (int index = 0; index < EXPORT_TYPES.Length; ++index)
{
if (0 < filter.Length)
{
filter.Append('|');
}
ExportType type = EXPORT_TYPES[index];
filter.AppendFormat("{0}|*{1}", type.Name, type.FileExtension);
}
return(filter.ToString());
}
public void Mz_ExportPatientFee(int ybId, DataTable dt)
{
string sColumnName = "";
try
{
string sType = M_GetMedicalInsuranceData(ybId, "ExportPatientFee", "filetype");
sColumnName = M_GetMedicalInsuranceData(ybId, "ExportPatientFee", "columnNames");
string sSeparator = M_GetMedicalInsuranceData(ybId, "ExportPatientFee", "separator");
List <Dictionary <string, string> > columnNamesList = new List <Dictionary <string, string> >();
string[] sColumnNames = sColumnName.Split('^');
for (int i = 0; i < sColumnNames.Length; i++)
{
Dictionary <string, string> dss = new Dictionary <string, string>();
string[] sColumnNamess = sColumnNames[i].Split('|');
foreach (string s in sColumnNamess)
{
dss.Add(s.Split(',')[0], s.Split(',')[1]);
}
columnNamesList.Add(dss);
}
ExportFile doExport = new ExportFile("HIS病人费用目录", columnNamesList, sSeparator);
ExportType _exportType = sType.Trim() == "1" ? ExportType.Excel : ExportType.Txt;
if (doExport.InitShowDialog(_exportType))
{
//if (doExport.DoExportWork(dt))
// doExport.OpenFile();
}
}
catch
{
MessageBox.Show("导出失败！");
return;
}
//if (Zy_UploadzyPatFee(Convert.ToInt32(dtList[1].Rows[0]["PatListID"].ToString())))
//{
// iFrmMICostUpload.Refresh();
//}
}
private string GetLanguage(ExportType type)
{
switch (type)
{
case ExportType.Json:
return("js");
case ExportType.Xml:
return("xml");
case ExportType.CSharpObject:
return("cs");
default:
throw new ArgumentOutOfRangeException(nameof(type));
}
}
public static void ExportToFile(DataViewInfo CurrentDataViewInfo, String ExcelFileName, ExportType exportType)
{
MongoCollection mongoCol;
if (CurrentDataViewInfo == null)
{
mongoCol = SystemManager.GetCurrentCollection();
}
else
{
String collectionPath = CurrentDataViewInfo.strDBTag.Split(":".ToCharArray())[1];
String[] cp = collectionPath.Split("/".ToCharArray());
MongoServer mServer = SystemManager.GetCurrentServer();
mongoCol = mServer.GetDatabase(cp[(int) PathLv.DatabaseLv]).GetCollection(cp[(int) PathLv.CollectionLv]);
}
MongoCursor<BsonDocument> cursor;
//Query condition:
if (CurrentDataViewInfo != null && CurrentDataViewInfo.IsUseFilter)
{
cursor = mongoCol.FindAs<BsonDocument>(QueryHelper.GetQuery(CurrentDataViewInfo.mDataFilter.QueryConditionList))
.SetFields(QueryHelper.GetOutputFields(CurrentDataViewInfo.mDataFilter.QueryFieldList))
.SetSortOrder(QueryHelper.GetSort(CurrentDataViewInfo.mDataFilter.QueryFieldList));
}
else
{
cursor = mongoCol.FindAllAs<BsonDocument>();
}
List<BsonDocument> dataList = cursor.ToList();
switch (exportType)
{
case ExportType.Excel:
//ExportToExcel(dataList, ExcelFileName);
GC.Collect();
break;
case ExportType.Text:
ExportToJson(dataList, ExcelFileName);
break;
case ExportType.Xml:
break;
default:
break;
}
OnActionDone(new ActionDoneEventArgs(" Completeed "));
}
/// <summary>
/// Экпорт диаграммы в один из типов
/// </summary>
/// <param name="type">Тип для экспорта</param>
public void ExportDiagram(ExportType type)
{
SaveFileDialog saveDialog = new SaveFileDialog();
saveDialog.Filter = type + " файлы (*." + type + ")|*." + type;
bool? result = saveDialog.ShowDialog();
if (result == true)
switch (type)
{
case ExportType.pdf:
PdfExporter pdfExporter = new PdfExporter();
pdfExporter.Export(DiagramNetwork, saveDialog.FileName);
break;
case ExportType.svg:
SvgExporter svgExporter = new SvgExporter();
svgExporter.Export(DiagramNetwork, saveDialog.FileName);
break;
}
}
public ExportGenerator(IEnumerable<ExpressionWithSource> expressionsWithSources,
TypeRetriever retriever, ExportParamaters exportParamaters)
{
_type = exportParamaters.ExportType;
_expressionsWithSources = expressionsWithSources;
_maxDepth = exportParamaters.MaxDepth;
List<IRuleSet> ruleSets = new List<IRuleSet>();
if (exportParamaters.ExcludePropertiesNotInClass)
{
ruleSets.Add(new PropertyInClassRuleSet(retriever));
}
if (exportParamaters.ExludePrivateProperties)
{
ruleSets.Add(new AccessiblePropertiesRuleSet(retriever));
}
_ruleSetValidator = new RuleSetValidator(ruleSets);
}
public static IGenerator CreateGenerator(ExportType type, RuleSetValidator ruleSetValidator)
{
IGenerator generator = null;
switch (type)
{
case ExportType.Xml:
generator = new XmlGenerator(ruleSetValidator);
break;
case ExportType.Json:
generator = new JsonGenerator(ruleSetValidator);
break;
case ExportType.CSharpObject:
generator = new CSharpGenerator(ruleSetValidator);
break;
}
return generator;
}
public static void Export(object columns, IEnumerable data, ExportType type = ExportType.Xls)
{
Microsoft.Win32.SaveFileDialog fileDialog = new Microsoft.Win32.SaveFileDialog();
fileDialog.Filter = type == ExportType.Xls ? "(*.xls)|*.xls" : "(*.*)|*.*";
fileDialog.FileName = "data_" + DateTime.Now.ToString("yyyyMMddHHmmss");
if (fileDialog.ShowDialog() == true)
{
using (var stream = fileDialog.OpenFile())
{
var cols = GetDataColumns(columns);
if (cols != null)
DoExport(stream, cols, data, type);
else
DoExport(stream, data, type);
}
//TODO: open the folder of the file
var dialog = new ExportResultDialog(fileDialog.FileName);
dialog.Owner = Window.GetWindow(Application.Current.MainWindow);
dialog.ShowDialog();
}
}
/// <summary>
/// Exports the Data given
/// </summary>
/// <param name="type">Export Format</param>
/// <param name="data">A Data Object</param>
/// <param name="template">A Template to print the Data into</param>
/// <param name="basepath">The Basepath to create the file in</param>
/// <returns>The Path of the created Export</returns>
public static string DataExport(ExportType type, Exportable data, Template template, string basepath, ExportCount ec, string pathtohtmltopdf)
{
string path = basepath + "\\" + data.Filename(ec); //need to Add fileending
switch (type)
{
case ExportType.PDF:
path = exportPDF(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path, basepath, pathtohtmltopdf);
break;
case ExportType.Word:
path = exportWord(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.Excel:
path = exportExcel(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.TXT:
path = exportTXT(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.CSV:
path = exportCSV(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.HTML:
path = exportHTML(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path, basepath);
break;
case ExportType.XML:
path = exportXML(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.MarkDown:
path = exportMD(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
default:
break;
}
return path;
}
static void DoExport(Stream stream, IEnumerable data, ExportType type)
{
if (type == ExportType.Xls)
WriteToXls(stream, data);
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <param name="type"></param>
private async Task OnExportObject(object item, ExportType type)
{
if (item != null)
{
string initial = string.Empty;
string name = string.Empty;
string ext = string.Empty;
switch (type)
{
case ExportType.Style:
name = "Style";
ext = "style";
initial = (item as ShapeStyle).Name;
break;
case ExportType.Styles:
name = "Styles";
ext = "styles";
initial = (item as StyleLibrary).Name;
break;
case ExportType.StyleLibrary:
name = "StyleLibrary";
ext = "stylelibrary";
initial = (item as StyleLibrary).Name;
break;
case ExportType.StyleLibraries:
name = "StyleLibraries";
ext = "stylelibraries";
initial = (item as Project).Name;
break;
case ExportType.Group:
name = "Group";
ext = "group";
initial = (item as XGroup).Name;
break;
case ExportType.Groups:
name = "Groups";
ext = "groups";
initial = (item as GroupLibrary).Name;
break;
case ExportType.GroupLibrary:
name = "GroupLibrary";
ext = "grouplibrary";
initial = (item as GroupLibrary).Name;
break;
case ExportType.GroupLibraries:
name = "GroupLibraries";
ext = "grouplibraries";
initial = (item as Project).Name;
break;
case ExportType.Template:
name = "Template";
ext = "template";
initial = (item as Container).Name;
break;
case ExportType.Templates:
name = "Templates";
ext = "templates";
initial = (item as Project).Name;
break;
}
var dlg = new SaveFileDialog();
dlg.Filters.Add(new FileDialogFilter() { Name = name, Extensions = { ext } });
dlg.Filters.Add(new FileDialogFilter() { Name = "All", Extensions = { "*" } });
dlg.InitialFileName = initial;
var result = await dlg.ShowAsync(this);
if (result != null)
{
_context.ExportObject(result, item, type);
}
}
}
public static string GetItemSuffix(IItemBase itemBase, ExportType exportType)
{
if (exportType == ExportType.Msg)
return ".msg";
return GetItemSuffix(GetItemClass(itemBase));
}
/// <summary>
/// 导出树
/// </summary>
/// <param name="path">导出的路径</param>
/// <param name="type">导出类型</param>
public void ExportTree(string path, ExportType type)
{
if (path != null && path.Length > 0)
{
if (type == ExportType.Json)
{
this.treeHandler.Write(path, type);
}
else if (type == ExportType.Xml)
{
//暂时没有处理
}
}
}
protected void DrawSpreadsheetOptions(EditorGUILayoutEx in_layout, ExportType in_exportType,
Google2uWorksheet in_activeWorksheet)
{
ShowSpreadsheetOptions =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsOpen",
ShowSpreadsheetOptions);
var showWorkbookOptions = in_layout.BeginFadeArea(ShowSpreadsheetOptions,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_EXPORT_OPTIONS),
"workbook" + WorkbookName.Replace(' ', '_') + "_Options", in_layout.InnerBox, in_layout.InnerBoxHeader);
ShowSpreadsheetOptions = showWorkbookOptions.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsOpen", ShowSpreadsheetOptions);
if (showWorkbookOptions.Show())
{
var prefix = "workbook" + WorkbookName.Replace(' ', '_') + "_Option_";
ShowSpreadsheetOptionsLegacy =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsLegacyOpen",
ShowSpreadsheetOptionsLegacy);
var showWorkbookOptionsLegacy = in_layout.BeginFadeArea(ShowSpreadsheetOptionsLegacy,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_LEGACY_OPTIONS),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsLegacy", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsLegacy = showWorkbookOptionsLegacy.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsLegacyOpen",
ShowSpreadsheetOptionsLegacy);
if (showWorkbookOptionsLegacy.Show())
{
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_LOWERCASE_HEADER),
ref ExportOptions.LowercaseHeader, prefix + "LowercaseHeader");
}
in_layout.EndFadeArea();
ShowSpreadsheetOptionsWhitespace =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsWhitespaceOpen",
ShowSpreadsheetOptionsWhitespace);
var showWorkbookOptionsWhitespace = in_layout.BeginFadeArea(ShowSpreadsheetOptionsWhitespace,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_WHITESPACE),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsWhitespace", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsWhitespace = showWorkbookOptionsWhitespace.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsWhitespaceOpen",
ShowSpreadsheetOptionsWhitespace);
if (showWorkbookOptionsWhitespace.Show())
{
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_TRIM_STRINGS),
ref ExportOptions.TrimStrings, prefix + "TrimStrings");
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_TRIM_STRING_ARRAYS),
ref ExportOptions.TrimStringArrays, prefix + "TrimStringArrays");
}
in_layout.EndFadeArea();
ShowSpreadsheetOptionsArrayDelimiters =
Google2uGUIUtil.GetBool(
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsArrayDelimitersOpen",
ShowSpreadsheetOptionsArrayDelimiters);
var showWorkbookOptionsArrayDelimiters = in_layout.BeginFadeArea(ShowSpreadsheetOptionsArrayDelimiters,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_ARRAY_DELIMITERS),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsArrayDelimiters", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsArrayDelimiters = showWorkbookOptionsArrayDelimiters.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsArrayDelimitersOpen",
ShowSpreadsheetOptionsArrayDelimiters);
if (showWorkbookOptionsArrayDelimiters.Show())
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label(Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_NON_STRING));
var newArrayDelimiters = EditorGUILayout.Popup(ExportOptions.ArrayDelimiters,
ExportOptions.DelimiterOptionStrings, GUILayout.Width(100));
GUILayout.FlexibleSpace();
switch (newArrayDelimiters)
{
case 0: // , - Comma
GUILayout.Label("Example Int Array - 1,2,3,4");
break;
case 1: // | - Pipe
GUILayout.Label("Example Int Array - 1|2|3|4");
break;
case 2: // - Space
GUILayout.Label("Example Int Array - 1 2 3 4");
break;
}
EditorGUILayout.EndHorizontal();
if (newArrayDelimiters != ExportOptions.ArrayDelimiters)
{
Google2uGUIUtil.SetInt(prefix + "ArrayDelimiters", newArrayDelimiters);
ExportOptions.ArrayDelimiters = newArrayDelimiters;
in_activeWorksheet.UpdateValidation = true;
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label(Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_STRINGS));
var newStringArrayDelimiters = EditorGUILayout.Popup(ExportOptions.StringArrayDelimiters,
ExportOptions.DelimiterOptionStrings, GUILayout.Width(100));
GUILayout.FlexibleSpace();
switch (newStringArrayDelimiters)
{
case 0: // , - Comma
GUILayout.Label("Example String Array - Hello,Hola,Bonjour");
break;
case 1: // | - Pipe
GUILayout.Label("Example String Array - Hello|Hola|Bonjour");
break;
case 2: // - Space
GUILayout.Label("Example String Array - Hello Hola Bonjour");
break;
}
EditorGUILayout.EndHorizontal();
if (newStringArrayDelimiters != ExportOptions.StringArrayDelimiters)
{
Google2uGUIUtil.SetInt(prefix + "StringArrayDelimiters", newStringArrayDelimiters);
ExportOptions.StringArrayDelimiters = newStringArrayDelimiters;
in_activeWorksheet.UpdateValidation = true;
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label(Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_COMPLEX_TYPES));
var newComplexTypeDelimiters = EditorGUILayout.Popup(ExportOptions.ComplexTypeDelimiters,
ExportOptions.DelimiterOptionStrings, GUILayout.Width(100));
GUILayout.FlexibleSpace();
switch (newComplexTypeDelimiters)
{
case 0: // , - Comma
GUILayout.Label("Example Vector - 1,2,3");
break;
case 1: // | - Pipe
GUILayout.Label("Example Vector - 1|2|3");
break;
case 2: // - Space
GUILayout.Label("Example Vector - 1 2 3");
break;
}
EditorGUILayout.EndHorizontal();
if (newComplexTypeDelimiters != ExportOptions.ComplexTypeDelimiters)
{
Google2uGUIUtil.SetInt(prefix + "ComplexTypeDelimiters", newComplexTypeDelimiters);
ExportOptions.ComplexTypeDelimiters = newComplexTypeDelimiters;
in_activeWorksheet.UpdateValidation = true;
}
var tmpDelimStrings = new List<string>();
var tmpDelimInts = new List<int>();
var curDelim = 0;
for (var i = 0; i < ExportOptions.DelimiterOptionStrings.Length; ++i)
{
if (i == ExportOptions.ComplexTypeDelimiters)
continue;
tmpDelimStrings.Add(ExportOptions.DelimiterOptionStrings[i]);
if (ExportOptions.ComplexArrayDelimiters == i)
curDelim = tmpDelimInts.Count;
tmpDelimInts.Add(i);
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label(Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_COMPLEX_ARRAYS));
var newComplexArrayDelimiters = EditorGUILayout.Popup(curDelim,
tmpDelimStrings.ToArray(), GUILayout.Width(100));
newComplexArrayDelimiters = tmpDelimInts[newComplexArrayDelimiters];
GUILayout.FlexibleSpace();
switch (newComplexArrayDelimiters)
{
case 0: // , - Comma
{
switch (ExportOptions.ComplexTypeDelimiters)
{
case 0: // , - Comma
GUILayout.Label("Cannot use Comma as both Complex Type and Complex Array delimiters");
break;
case 1: // | - Pipe
GUILayout.Label("Example Vector Array - 1,2,3|4,5,6|7,8,9");
break;
case 2: // - Space
GUILayout.Label("Example Vector Array - 1,2,3 4,5,6 7,8,9");
break;
}
}
break;
case 1: // | - Pipe
{
switch (ExportOptions.ComplexTypeDelimiters)
{
case 0: // , - Comma
GUILayout.Label("Example Vector Array - 1|2|3,4|5|6,7|8|9");
break;
case 1: // | - Pipe
GUILayout.Label("Cannot use Pipe as both Complex Type and Complex Array delimiters");
break;
case 2: // - Space
GUILayout.Label("Example Vector Array - 1|2|3 4|5|6 7|8|9");
break;
}
}
break;
case 2: // - Space
{
switch (ExportOptions.ComplexTypeDelimiters)
{
case 0: // , - Comma
GUILayout.Label("Example Vector Array - 1 2 3,4 5 6,7 8 9");
break;
case 1: // | - Pipe
GUILayout.Label("Example Vector Array - 1 2 3|4 5 6|7 8 9");
break;
case 2: // - Space
GUILayout.Label("Cannot use Space as both Complex Type and Complex Array delimiters");
break;
}
}
break;
}
EditorGUILayout.EndHorizontal();
if (newComplexArrayDelimiters != ExportOptions.ComplexArrayDelimiters)
{
Google2uGUIUtil.SetInt(prefix + "ComplexArrayDelimiters", newComplexArrayDelimiters);
ExportOptions.ComplexArrayDelimiters = newComplexArrayDelimiters;
}
}
in_layout.EndFadeArea();
if (in_exportType == ExportType.ObjectDatabase)
{
ShowSpreadsheetOptionsObjectDB =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsObjectDBOpen",
ShowSpreadsheetOptionsObjectDB);
var showWorkbookOptionsObjectDB = in_layout.BeginFadeArea(ShowSpreadsheetOptionsObjectDB,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GAME_OBJECT_DATABASE) + " " +
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CREATION_OPTIONS),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsObjectDB", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsObjectDB = showWorkbookOptionsObjectDB.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsObjectDBOpen",
ShowSpreadsheetOptionsObjectDB);
if (showWorkbookOptionsObjectDB.Show())
{
EditorGUILayout.LabelField("Global Options");
EditorGUILayout.Separator();
ExportOptions.ExportDatabaseGameObject =
EditorGUILayout.ObjectField(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GAME_OBJECT_DATABASE) +
": ", ExportOptions.ExportDatabaseGameObject, typeof (GameObject), true) as GameObject;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GENERATE_PLAYMAKER),
ref ExportOptions.GeneratePlaymakerActions, prefix + "GeneratePlaymakerActions");
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_PERSIST_SCENE_LOADING),
ref ExportOptions.UseDoNotDestroy, prefix + "UseDoNotDestroy");
var oldObjectDBCullColumns = ExportOptions.ObjectDBCullColumns;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_COLUMNS),
ref ExportOptions.ObjectDBCullColumns, prefix + "ObjectDBCullColumns");
if (oldObjectDBCullColumns != ExportOptions.ObjectDBCullColumns)
in_activeWorksheet.UpdateValidation = true;
var oldObjectDBCullRows = ExportOptions.ObjectDBCullRows;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_ROWS),
ref ExportOptions.ObjectDBCullRows, prefix + "ObjectDBCullRows");
if (oldObjectDBCullRows != ExportOptions.ObjectDBCullRows)
in_activeWorksheet.UpdateValidation = true;
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Local Options - " + in_activeWorksheet.WorksheetName);
EditorGUILayout.Separator();
var overrideObject =
EditorGUILayout.ObjectField(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GAME_OBJECT_DATABASE) +
": ",
ExportOptions.GetOverrideObjectDatabaseGameObject(in_activeWorksheet.WorksheetName),
typeof (GameObject), true) as GameObject;
if (overrideObject != null)
ExportOptions.SetOverrideObjectDatabaseGameObject(in_activeWorksheet.WorksheetName,
overrideObject);
}
in_layout.EndFadeArea();
}
if (in_exportType == ExportType.StaticDatabase)
{
ShowSpreadsheetOptionsStaticDB =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsStaticDBOpen",
ShowSpreadsheetOptionsObjectDB);
var showWorkbookOptionsStaticDB = in_layout.BeginFadeArea(ShowSpreadsheetOptionsStaticDB,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_STATIC_DATABASE) + " " +
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CREATION_OPTIONS),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsStaticDB", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsStaticDB = showWorkbookOptionsStaticDB.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsStaticDBOpen",
ShowSpreadsheetOptionsStaticDB);
if (showWorkbookOptionsStaticDB.Show())
{
var oldStaticDBCullColumns = ExportOptions.StaticDBCullColumns;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_COLUMNS),
ref ExportOptions.StaticDBCullColumns, prefix + "StaticDBCullColumns");
if (oldStaticDBCullColumns != ExportOptions.StaticDBCullColumns)
in_activeWorksheet.UpdateValidation = true;
var oldStaticDBCullRows = ExportOptions.StaticDBCullRows;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_ROWS),
ref ExportOptions.StaticDBCullRows, prefix + "StaticDBCullRows");
if (oldStaticDBCullRows != ExportOptions.StaticDBCullRows)
in_activeWorksheet.UpdateValidation = true;
}
in_layout.EndFadeArea();
}
if (in_exportType == ExportType.JSON)
{
ShowSpreadsheetOptionsJSON =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONOpen",
ShowSpreadsheetOptionsJSON);
var showWorkbookOptionsJSON = in_layout.BeginFadeArea(ShowSpreadsheetOptionsJSON,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_JSON_FORMATTING),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSON", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsJSON = showWorkbookOptionsJSON.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONOpen",
ShowSpreadsheetOptionsJSON);
if (showWorkbookOptionsJSON.Show())
{
var oldEscapeUnicode = ExportOptions.EscapeUnicode;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_ESCAPE_UNICODE),
ref ExportOptions.EscapeUnicode, prefix + "EscapeUnicode");
if (oldEscapeUnicode != ExportOptions.EscapeUnicode)
in_activeWorksheet.UpdateValidation = true;
var oldJSONCellArrayToString = ExportOptions.JSONCellArrayToString;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CONVERT_CELL_ARRAYS),
ref ExportOptions.JSONCellArrayToString, prefix + "JSONCellArrayToString");
if (oldJSONCellArrayToString != ExportOptions.JSONCellArrayToString)
in_activeWorksheet.UpdateValidation = true;
var oldJSONExportClass = ExportOptions.JSONExportClass;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_JSON_EXPORT_CLASS),
ref ExportOptions.JSONExportClass, prefix + "JSONExportClass");
if (oldJSONExportClass != ExportOptions.JSONExportClass)
in_activeWorksheet.UpdateValidation = true;
var oldExportType = ExportOptions.JSONExportType;
ExportOptions.JSONExportType =
(Google2uExportOptions.ExportType) EditorGUILayout.EnumPopup(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_JSON_EXPORT_TYPE) + ":",
ExportOptions.JSONExportType);
if (oldExportType != ExportOptions.JSONExportType)
{
Google2uGUIUtil.SetEnum(prefix + "JSONExportType", ExportOptions.JSONExportType);
in_activeWorksheet.UpdateValidation = true;
}
var oldJSONCullColumns = ExportOptions.JSONCullColumns;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_COLUMNS),
ref ExportOptions.JSONCullColumns, prefix + "JSONCullColumns");
if (oldJSONCullColumns != ExportOptions.JSONCullColumns)
in_activeWorksheet.UpdateValidation = true;
var oldJSONCullRows = ExportOptions.JSONCullRows;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_ROWS),
ref ExportOptions.JSONCullRows, prefix + "JSONCullRows");
if (oldJSONCullRows != ExportOptions.JSONCullRows)
in_activeWorksheet.UpdateValidation = true;
var oldJSONIgnoreIDColumn = ExportOptions.JSONIgnoreIDColumn;
EditorGUILayoutEx.ToggleInput(
"Ignore ID Column",
ref ExportOptions.JSONIgnoreIDColumn, prefix + "JSONIgnoreIDColumn");
if (oldJSONIgnoreIDColumn != ExportOptions.JSONIgnoreIDColumn)
in_activeWorksheet.UpdateValidation = true;
}
in_layout.EndFadeArea();
ShowSpreadsheetPreviewJSON =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONPreviewOpen",
ShowSpreadsheetPreviewJSON);
var showWorkbookPreviewJSON = in_layout.BeginFadeArea(ShowSpreadsheetPreviewJSON,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_JSON_OBJECT_PREVIEW),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONPreviewOpen", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetPreviewJSON = showWorkbookPreviewJSON.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONPreviewOpen",
ShowSpreadsheetPreviewJSON);
if (showWorkbookPreviewJSON.Show())
{
var oldEnabled = GUI.enabled;
if (!in_activeWorksheet.IsDataValid)
GUI.enabled = false;
GUI.SetNextControlName("JSONPREVIEW");
if (
GUILayout.Button(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GENERATE_PREVIEW)))
{
_JSONPreviewString = Google2u.ExportJsonObjectString(in_activeWorksheet, ExportOptions, true);
}
var textSize = in_layout.CellHeader.CalcSize(new GUIContent(_JSONPreviewString));
_JSONPreviewScrollPos = EditorGUILayout.BeginScrollView(_JSONPreviewScrollPos, false, false,
GUILayout.MinHeight(250));
var newString = EditorGUILayout.TextArea(_JSONPreviewString, GUILayout.ExpandHeight(true),
GUILayout.ExpandWidth(true), GUILayout.MinWidth(textSize.x), GUILayout.MinHeight(textSize.y));
if (newString != _JSONPreviewString)
GUI.FocusControl("JSONPREVIEW");
GUI.enabled = oldEnabled;
EditorGUILayout.EndScrollView();
}
in_layout.EndFadeArea();
ShowSpreadsheetPreviewJSONClass =
Google2uGUIUtil.GetBool(
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONPreviewClassOpen",
ShowSpreadsheetPreviewJSONClass);
var showWorkbookPreviewJSONClass = in_layout.BeginFadeArea(ShowSpreadsheetPreviewJSONClass,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_JSON_CLASS_PREVIEW),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONPreviewClassOpen", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetPreviewJSONClass = showWorkbookPreviewJSONClass.Open;
Google2uGUIUtil.SetBool(
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsJSONPreviewClassOpen",
ShowSpreadsheetPreviewJSONClass);
if (showWorkbookPreviewJSONClass.Show())
{
var oldEnabled = GUI.enabled;
if (!in_activeWorksheet.IsDataValid)
GUI.enabled = false;
GUI.SetNextControlName("JSONPREVIEWCLASS");
if (
GUILayout.Button(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GENERATE_CLASS)))
{
_JSONPreviewClassString = Google2u.ExportJsonObjectClassString(in_activeWorksheet,
ExportOptions);
}
var textSize = in_layout.CellHeader.CalcSize(new GUIContent(_JSONPreviewClassString));
_JSONPreviewClassScrollPos = EditorGUILayout.BeginScrollView(_JSONPreviewClassScrollPos, false,
false, GUILayout.MinHeight(250));
var newString = EditorGUILayout.TextArea(_JSONPreviewClassString, GUILayout.ExpandHeight(true),
GUILayout.ExpandWidth(true), GUILayout.MinWidth(textSize.x), GUILayout.MinHeight(textSize.y));
if (newString != _JSONPreviewClassString)
GUI.FocusControl("JSONPREVIEWCLASS");
GUI.enabled = oldEnabled;
EditorGUILayout.EndScrollView();
}
in_layout.EndFadeArea();
}
if (in_exportType == ExportType.CSV)
{
ShowSpreadsheetOptionsCSV =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsCSVOpen",
ShowSpreadsheetOptionsCSV);
var showWorkbookOptionsCSV = in_layout.BeginFadeArea(ShowSpreadsheetOptionsCSV,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CSV_FORMATTING),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsCSV", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsCSV = showWorkbookOptionsCSV.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsCSVOpen",
ShowSpreadsheetOptionsCSV);
if (showWorkbookOptionsCSV.Show())
{
var oldEscapeCSVStrings = ExportOptions.EscapeCSVStrings;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_ESCAPE_STRINGS),
ref ExportOptions.EscapeCSVStrings, prefix + "EscapeCSVStrings");
if (oldEscapeCSVStrings != ExportOptions.EscapeCSVStrings)
in_activeWorksheet.UpdateValidation = true;
var oldCSVCullColumns = ExportOptions.CSVCullColumns;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_COLUMNS),
ref ExportOptions.CSVCullColumns, prefix + "CSVCullColumns");
if (oldCSVCullColumns != ExportOptions.CSVCullColumns)
in_activeWorksheet.UpdateValidation = true;
var oldCSVCullRows = ExportOptions.CSVCullRows;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_ROWS),
ref ExportOptions.CSVCullRows, prefix + "CSVCullRows");
if (oldCSVCullRows != ExportOptions.CSVCullRows)
in_activeWorksheet.UpdateValidation = true;
var oldCSVConvertLineBreaks = ExportOptions.CSVConvertLineBreaks;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_ESCAPE_LINE_BREAKS),
ref ExportOptions.CSVConvertLineBreaks, prefix + "CSVConvertLineBreaks");
if (oldCSVConvertLineBreaks != ExportOptions.CSVConvertLineBreaks)
in_activeWorksheet.UpdateValidation = true;
}
in_layout.EndFadeArea();
ShowSpreadsheetPreviewCSV =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsCSVPreviewOpen",
ShowSpreadsheetPreviewCSV);
var showWorkbookPreviewCSV = in_layout.BeginFadeArea(ShowSpreadsheetPreviewCSV,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CSV_PREVIEW),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsCSVPreviewOpen", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetPreviewCSV = showWorkbookPreviewCSV.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsCSVPreviewOpen",
ShowSpreadsheetPreviewCSV);
if (showWorkbookPreviewCSV.Show())
{
var oldEnabled = GUI.enabled;
if (!in_activeWorksheet.IsDataValid)
GUI.enabled = false;
GUI.SetNextControlName("CSVPREVIEW");
if (
GUILayout.Button(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GENERATE_PREVIEW)))
{
_CSVPreviewString = Google2u.ExportCsvString(in_activeWorksheet, ExportOptions);
}
var textSize = in_layout.CellHeader.CalcSize(new GUIContent(_CSVPreviewString));
_CSVPreviewScrollPos = EditorGUILayout.BeginScrollView(_CSVPreviewScrollPos, false, false,
GUILayout.MinHeight(250));
var newString = EditorGUILayout.TextArea(_CSVPreviewString, GUILayout.ExpandHeight(true),
GUILayout.ExpandWidth(true), GUILayout.MinWidth(textSize.x), GUILayout.MinHeight(textSize.y));
if (newString != _CSVPreviewString)
GUI.FocusControl("CSVPREVIEW");
GUI.enabled = oldEnabled;
EditorGUILayout.EndScrollView();
}
in_layout.EndFadeArea();
}
if (in_exportType == ExportType.NGUI)
{
ShowSpreadsheetOptionsNGUI =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsNGUIOpen",
ShowSpreadsheetOptionsNGUI);
var showWorkbookOptionsNGUI = in_layout.BeginFadeArea(ShowSpreadsheetOptionsNGUI,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_NGUI_FORMATTING),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsNGUI", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsNGUI = showWorkbookOptionsNGUI.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsNGUIOpen",
ShowSpreadsheetOptionsNGUI);
if (showWorkbookOptionsNGUI.Show())
{
var oldEscapeNGUIStrings = ExportOptions.EscapeNGUIStrings;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_ESCAPE_STRINGS),
ref ExportOptions.EscapeNGUIStrings, prefix + "EscapeNGUIStrings");
if (oldEscapeNGUIStrings != ExportOptions.EscapeNGUIStrings)
in_activeWorksheet.UpdateValidation = true;
var oldNGUICullColumns = ExportOptions.NGUICullColumns;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_COLUMNS),
ref ExportOptions.NGUICullColumns, prefix + "NGUICullColumns");
if (oldNGUICullColumns != ExportOptions.NGUICullColumns)
in_activeWorksheet.UpdateValidation = true;
var oldNGUICullRows = ExportOptions.NGUICullRows;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_ROWS),
ref ExportOptions.NGUICullRows, prefix + "NGUICullRows");
if (oldNGUICullRows != ExportOptions.NGUICullRows)
in_activeWorksheet.UpdateValidation = true;
var oldNGUIConvertLineBreaks = ExportOptions.NGUIConvertLineBreaks;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_ESCAPE_LINE_BREAKS),
ref ExportOptions.NGUIConvertLineBreaks, prefix + "NGUIConvertLineBreaks");
if (oldNGUIConvertLineBreaks != ExportOptions.NGUIConvertLineBreaks)
in_activeWorksheet.UpdateValidation = true;
var oldNGUILegacyExport = ExportOptions.NGUILegacyExport;
// TODO: Localize
EditorGUILayoutEx.ToggleInput(
"Use NGUI Legacy Export",
ref ExportOptions.NGUILegacyExport, prefix + "NGUILegacyExport");
if (oldNGUILegacyExport != ExportOptions.NGUILegacyExport)
in_activeWorksheet.UpdateValidation = true;
}
in_layout.EndFadeArea();
ShowSpreadsheetPreviewNGUI =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsNGUIPreviewOpen",
ShowSpreadsheetPreviewNGUI);
var showWorkbookPreviewNGUI = in_layout.BeginFadeArea(ShowSpreadsheetPreviewNGUI,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_NGUI_PREVIEW),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsNGUIPreviewOpen", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetPreviewNGUI = showWorkbookPreviewNGUI.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsNGUIPreviewOpen",
ShowSpreadsheetPreviewNGUI);
if (showWorkbookPreviewNGUI.Show())
{
var oldEnabled = GUI.enabled;
if (!in_activeWorksheet.IsDataValid)
GUI.enabled = false;
GUI.SetNextControlName("NGUIPREVIEW");
if (
GUILayout.Button(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GENERATE_PREVIEW)))
{
if (ExportOptions.NGUILegacyExport)
_NGUIPreviewString = Google2u.ExportNGUILegacyString(in_activeWorksheet, ExportOptions);
else
_NGUIPreviewString = Google2u.ExportNGUIString(in_activeWorksheet, ExportOptions);
}
var textSize = in_layout.CellHeader.CalcSize(new GUIContent(_NGUIPreviewString));
_NGUIPreviewScrollPos = EditorGUILayout.BeginScrollView(_NGUIPreviewScrollPos, false, false,
GUILayout.MinHeight(250));
var newString = EditorGUILayout.TextArea(_NGUIPreviewString, GUILayout.ExpandHeight(true),
GUILayout.ExpandWidth(true), GUILayout.MinWidth(textSize.x), GUILayout.MinHeight(textSize.y));
if (newString != _NGUIPreviewString)
GUI.FocusControl("NGUIPREVIEW");
GUI.enabled = oldEnabled;
EditorGUILayout.EndScrollView();
}
in_layout.EndFadeArea();
}
if (in_exportType == ExportType.XML)
{
ShowSpreadsheetOptionsXML =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsXMLOpen",
ShowSpreadsheetOptionsXML);
var showWorkbookOptionsXML = in_layout.BeginFadeArea(ShowSpreadsheetOptionsXML,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_XML_FORMATTING),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsXML", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetOptionsXML = showWorkbookOptionsXML.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsXMLOpen",
ShowSpreadsheetOptionsXML);
if (showWorkbookOptionsXML.Show())
{
var oldXMLCellArrayToString = ExportOptions.XMLCellArrayToString;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CONVERT_CELL_ARRAYS),
ref ExportOptions.XMLCellArrayToString, prefix + "XMLCellArrayToString");
if (oldXMLCellArrayToString != ExportOptions.XMLCellArrayToString)
in_activeWorksheet.UpdateValidation = true;
var oldXMLCullColumns = ExportOptions.XMLCullColumns;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_COLUMNS),
ref ExportOptions.XMLCullColumns, prefix + "XMLCullColumns");
if (oldXMLCullColumns != ExportOptions.XMLCullColumns)
in_activeWorksheet.UpdateValidation = true;
var oldXMLCullRows = ExportOptions.XMLCullRows;
EditorGUILayoutEx.ToggleInput(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_CULL_ROWS),
ref ExportOptions.XMLCullRows, prefix + "XMLCullRows");
if (oldXMLCullRows != ExportOptions.XMLCullRows)
in_activeWorksheet.UpdateValidation = true;
}
in_layout.EndFadeArea();
ShowSpreadsheetPreviewXML =
Google2uGUIUtil.GetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsXMLPreviewOpen",
ShowSpreadsheetPreviewXML);
var showWorkbookPreviewXML = in_layout.BeginFadeArea(ShowSpreadsheetPreviewXML,
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_XML_PREVIEW),
"workbook" + WorkbookName.Replace(' ', '_') + "_OptionsXMLPreviewOpen", in_layout.OuterBox,
in_layout.OuterBoxHeader);
ShowSpreadsheetPreviewXML = showWorkbookPreviewXML.Open;
Google2uGUIUtil.SetBool("workbook" + WorkbookName.Replace(' ', '_') + "_OptionsXMLPreviewOpen",
ShowSpreadsheetPreviewXML);
if (showWorkbookPreviewXML.Show())
{
var oldEnabled = GUI.enabled;
if (!in_activeWorksheet.IsDataValid)
GUI.enabled = false;
GUI.SetNextControlName("XMLPREVIEW");
if (
GUILayout.Button(
Google2u.LocalizationInfo.Localize(Localization.rowIds.ID_LABEL_GENERATE_PREVIEW)))
{
_XMLPreviewString = Google2u.ExportXMLString(in_activeWorksheet, ExportOptions);
}
var textSize = in_layout.CellHeader.CalcSize(new GUIContent(_XMLPreviewString));
_XMLPreviewScrollPos = EditorGUILayout.BeginScrollView(_XMLPreviewScrollPos, false, false,
GUILayout.MinHeight(250));
var newString = EditorGUILayout.TextArea(_XMLPreviewString, GUILayout.ExpandHeight(true),
GUILayout.ExpandWidth(true), GUILayout.MinWidth(textSize.x), GUILayout.MinHeight(textSize.y));
if (newString != _XMLPreviewString)
GUI.FocusControl("XMLPREVIEW");
GUI.enabled = oldEnabled;
EditorGUILayout.EndScrollView();
}
in_layout.EndFadeArea();
}
}
in_layout.EndFadeArea();
}
static void DoExport(Stream stream, IEnumerable<DataGridColumn> columns, IEnumerable data, ExportType type)
{
if (type == ExportType.Xls)
WriteToXls(stream, columns, data);
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="item"></param>
/// <param name="type"></param>
public void ExportObject(string path, object item, ExportType type)
{
try
{
switch (type)
{
case ExportType.Style:
{
var json = _serializer.Serialize(item as ShapeStyle);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.Styles:
{
var json = _serializer.Serialize((item as StyleLibrary).Styles);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.StyleLibrary:
{
var json = _serializer.Serialize((item as StyleLibrary));
Utf8TextFile.Write(path, json);
}
break;
case ExportType.StyleLibraries:
{
var json = _serializer.Serialize((item as Project).StyleLibraries);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.Group:
{
var json = _serializer.Serialize(item as XGroup);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.Groups:
{
var json = _serializer.Serialize((item as GroupLibrary).Groups);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.GroupLibrary:
{
var json = _serializer.Serialize(item as GroupLibrary);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.GroupLibraries:
{
var json = _serializer.Serialize((item as Project).GroupLibraries);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.Template:
{
var json = _serializer.Serialize(item as Container);
Utf8TextFile.Write(path, json);
}
break;
case ExportType.Templates:
{
var json = _serializer.Serialize((item as Project).Templates);
Utf8TextFile.Write(path, json);
}
break;
}
}
catch (Exception ex)
{
if (_editor.Log != null)
{
_editor.Log.LogError("{0}{1}{2}",
ex.Message,
Environment.NewLine,
ex.StackTrace);
}
}
}
