7.0.2 release

ChangeLog

@@ -1,3 +1,14 @@
+06-AUG-2017: 7.0.2
+
+- Improvements to Gliffy import
+- Uses filename for print preview title
+
+04-AUG-2017: 7.0.1
+
+- Improvements to Gliffy import
+- Improvements to Lucidchart import
+- Fixes PlantUML macro dialog
+
 03-AUG-2017: 7.0.0
 
 - Improvements to Gliffy import

VERSION

@@ -1 +1 @@
-7.0.0
+7.0.2

src/com/mxgraph/io/gliffy/importer/GliffyDiagramConverter.java

@@ -419,8 +419,10 @@ public class GliffyDiagramConverter
 				GliffyLine line = graphic.Line;
 				
 				cell.setEdge(true);
+				style.append("shape=filledEdge;fixDash=1;");
 				style.append("strokeWidth=" + line.strokeWidth).append(";");
 				style.append("strokeColor=" + line.strokeColor).append(";");
+				style.append("fillColor=" + line.fillColor).append(";");
 				style.append(ArrowMapping.get(line.startArrow).toString(true)).append(";");
 				style.append(ArrowMapping.get(line.endArrow).toString(false)).append(";");
 				style.append(DashStyleMapping.get(line.dashStyle));
@@ -448,7 +450,7 @@ public class GliffyDiagramConverter
 						 * draw.io's text offset is a float in the range of [-1,-1] (while still keeping the text within the line)
 						 * The equation that translates Gliffy offset to draw.io offset is : G*2 - 1 = D 
 						 */
-						mxGeometry mxGeo = new mxGeometry(graphic.Text.lineTValue != null ? graphic.Text.lineTValue * 2 -1 : GliffyText.DEFAULT_LINE_T_VALUE, 0, 0, 0);
+						mxGeometry mxGeo = new mxGeometry(graphic.Text.lineTValue != null ? graphic.Text.lineTValue * 2 -1 : 0, 0, 0, 0);
 						mxGeo.setOffset(new mxPoint());
 						cell.setGeometry(mxGeo);
 						

src/com/mxgraph/io/gliffy/importer/gliffyTranslation.properties

@@ -64,7 +64,7 @@ com.gliffy.shape.flowchart.flowchart_v1.default.double_arrow=mxgraph.arrows2.two
 # FLOWCHART V2
 #
 com.gliffy.shape.flowchart.flowchart_v2.default.process=mxgraph.flowchart.process;strokeWidth=5;gradientColor=#CCCCCC;gradientDirection=west
-com.gliffy.shape.flowchart.flowchart_v2.default.decision=mxgraph.flowchart.decision;strokeWidth=5;gradientColor=#CCCCCC;gradientDirection=west
+com.gliffy.shape.flowchart.flowchart_v2.default.decision=rhombus;rounded=1;strokeWidth=5;gradientColor=#CCCCCC;gradientDirection=west
 com.gliffy.shape.flowchart.flowchart_v2.default.document=mxgraph.flowchart.document;strokeWidth=5;gradientColor=#CCCCCC;gradientDirection=west
 com.gliffy.shape.flowchart.flowchart_v2.default.subroutine=mxgraph.flowchart.predefined_process;strokeWidth=5;gradientColor=#CCCCCC;gradientDirection=west
 com.gliffy.shape.flowchart.flowchart_v2.default.input_output=parallelogram;strokeWidth=5;gradientColor=#CCCCCC;gradientDirection=west

src/com/mxgraph/io/gliffy/model/GliffyText.java

@@ -7,9 +7,6 @@ import com.mxgraph.io.gliffy.importer.PostDeserializer;
 
 public class GliffyText implements PostDeserializer.PostDeserializable
 {
-	//places the text in the middle of the line
-	public static Double DEFAULT_LINE_T_VALUE = 0.5; 
-	
 	private String html;
 
 	private String valign;
@@ -29,7 +26,7 @@ public class GliffyText implements PostDeserializer.PostDeserializable
 
 	private Integer paddingTop;
 	
-	public Double lineTValue = DEFAULT_LINE_T_VALUE;
+	public Double lineTValue = 0.5;//places the text in the middle of the line
 
 	public Integer linePerpValue;
 

war/cache.manifest

@@ -1,7 +1,7 @@
 CACHE MANIFEST
 
 # THIS FILE WAS GENERATED. DO NOT MODIFY!
-# 08/03/2017 04:40 PM
+# 08/06/2017 10:55 PM
 
 app.html
 index.html?offline=1

war/index.html

@@ -28,7 +28,6 @@
 		 * - test=1: For developers only
 		 * - drawdev=1: For developers only
 		 * - export=URL for export: For developers only
-		 * - page=n: For developers only
 		 * - ignoremime=1: For developers only (see DriveClient.js). Use Cmd-S to override mime.
 		 * - createindex=1: For developers only (see etc/build/README)
 		 * - filesupport=0: For developers only (see Editor.js in core)

war/js/diagramly/Dialogs.js

@@ -151,6 +151,11 @@ var StorageDialog = function(editorUi, fn, rowLimit)
 				button.style.padding = '0px 10px 20px 10px';
 				button.style.top = '6px';
 			}
+			else if (mxClient.IS_FF)
+			{
+				label.style.paddingTop = '0px';
+				label.style.marginTop = '-2px';
+			}
 		}
 		
 		button.appendChild(label);

war/js/diagramly/Editor.js

@@ -1749,6 +1749,13 @@
 					pv.pageSelector = false;
 					pv.mathEnabled = false;
 					
+					var file = editorUi.getCurrentFile();
+					
+					if (file != null)
+					{
+						pv.title = file.getTitle();
+					}
+					
 					var writeHead = pv.writeHead;
 					
 					// Overridden to add custom fonts

war/js/diagramly/Extensions.js

@@ -555,6 +555,226 @@
 			'AWSSubnetBlock2' : ss + 'aws3.permissions;',
 //AWS Containers
 //			'AWSRoundedRectangleContainerBlock2' EXT
+//Azure Cloud
+			'ACAccessControlBlock' : ss + 'azure.access_control;',
+			'ACAPIAppsBlock' : ss + 'mscae.cloud.api_app;',
+			'ACAPIManagementBlock' : ss + 'mscae.cloud.api_management;',
+			'ACAppInsightsBlock' : ss + 'mscae.cloud.application_insights;',
+			'ACAppServicesBlock' : ss + 'mscae.cloud.app_service;',
+			'ACAutoscalingBlock' : ss + 'azure.autoscale;',
+			'ACAzureActiveDirectoryBlock' : ss + 'azure.azure_active_directory;',
+			'ACAzurealertBlock' : ss + 'azure.azure_alert;',
+			'ACAzureAutomationBlock' : ss + 'azure.automation;',
+			'ACAzureBatchBlock' : ss + 'mscae.cloud.azure_batch;',
+			'ACAzureRedisBlock' : ss + 'azure.azure_cache;',
+			'ACAzureFilesBlock' : ss + 'mscae.cloud.azure_files_service;',
+			'ACAzureloadbalancerBlock' : ss + 'mscae.cloud.azure_automatic_load_balancer;',
+			'ACAzureMarketplaceBlock' : ss + 'azure.azure_marketplace;',
+			'ACAzureRightManagementRMSBlock' : ss + 'mscae.cloud.azure_rights_management_rms;',
+			'ACAzureSDKBlock' : ss + 'azure.azure_sdk;',
+			'ACAzureSearchBlock' : ss + 'mscae.cloud.azure_search;',
+			'ACAzureSQLdatabaseBlock' : ss + 'azure.sql_database_sql_azure;',
+			'ACAzuresubscriptionBlock' : ss + 'azure.azure_subscription;',
+			'ACAzureWebsitesBlock' : ss + 'azure.azure_website;',
+			'ACBackupServiceBlock' : ss + 'azure.backup_service;',
+			'ACBitbucketcodesourceBlock' : ss + 'azure.bitbucket_code_source;',
+			'ACBizTalkServicesBlock' : ss + 'azure.biztalk_services;',
+			'ACCloudServiceBlock' : ss + 'azure.cloud_service;',
+			'ACCodePlexBlock' : ss + 'azure.codeplex_code_source;',
+//			'ACComputeBlock' NA
+			'ACContentDeliveryNetworkBlock' : ss + 'azure.content_delivery_network;',
+			'ACDataFactoryBlock' : ss + 'mscae.cloud.data_factory;',
+//			'ACDataservicesBlock' NA
+			'ACDocumentDBBlock' : ss + 'mscae.cloud.documentdb;',
+			'ACDropboxcodesourceBlock' : ss + 'azure.dropbox_code_source;',
+			'ACEventsHubBlock' : ss + 'mscae.cloud.event_hubs;',
+			'ACExpressRouteBlock' : ss + 'azure.express_route;',
+			'ACGitHubBlock' : ss + 'azure.github_code;',
+			'ACGitrepositoryBlock' : ss + 'azure.git_repository;',
+			'ACHDInsightBlock' : ss + 'mscae.cloud.hdinsight;',
+			'ACHealthmonitoringBlock' : ss + 'azure.health_monitoring;',
+			'ACHealthyBlock' : ss + 'azure.healthy;',
+			'ACHybridConnectionBlock' : ss + 'mscae.cloud.hybrid_connections;',
+			'ACBizTalkhybridconnectionBlock' : ss + 'mscae.cloud.hybrid_connection_manager;',
+			'ACKeyVaultBlock' : ss + 'mscae.cloud.key_vault;',
+			'ACLogicAppBlock' : ss + 'mscae.cloud.logic_app;',
+			'ACMachineLearningBlock' : ss + 'mscae.cloud.machine_learning;',
+			'ACMediaServicesBlock' : ss + 'azure.media_service;',
+			'ACMicrosoftaccountBlock' : ss + 'mscae.cloud.microsoft_account;',
+			'ACMicrosoftAzureBlock' : ss + 'mscae.cloud.microsoft_azure;',
+			'ACMobileEngagementBlock' : ss + 'mscae.cloud.mobile_engagement;',
+			'ACMobileServicesBlock' : ss + 'mscae.cloud.mobile_app;',
+			'ACMultiFactorAuthBlock' : ss + 'azure.multi_factor_authentication;',
+			'ACMySQLdatabaseBlock' : ss + 'azure.mysql_database;',
+			'ACNotificationHubsBlock' : ss + 'azure.notification_hub;',
+			'ACNotificationtopicBlock' : ss + 'azure.notification_topic;',
+			'ACOperationalInsightsBlock' : ss + 'mscae.cloud.operational_insights;',
+			'ACOSimageBlock' : ss + 'azure.operating_system_image;',
+			'ACRemoteAppBlock' : ss + 'mscae.cloud.remoteapp;',
+			'ACrpdRemotingfileBlock' : ss + 'azure.rdp_remoting_file;',
+			'ACSchedulerBlock' : ss + 'azure.scheduler;',
+			'ACServiceBusBlock' : ss + 'azure.service_bus;',
+			'ACServiceBusQueueBlock' : ss + 'azure.service_bus_queues;',
+			'ACServiceBusRelayBlock' : ss + 'azure.service_bus_relay;',
+			'ACServiceBusTopicBlock' : ss + 'azure.service_bus_topics_and_subscriptions;',
+			'ACServiceEndpointBlock' : ss + 'mscae.cloud.service_endpoint;',
+			'ACServicepackageBlock' : ss + 'mscae.cloud.service_package;',
+			'ACSiteRecoveryBlock' : ss + 'azure.hyper_v_recovery_manager;',
+			'ACSQLdatabasegenericBlock' : ss + 'azure.sql_database;',
+//			'ACSQLDatabasePremiumBlock' NA
+			'ACSQLdatasyncBlock' : ss + 'azure.sql_datasync;',
+			'ACSQLreportingdeprecatedBlock' : ss + 'azure.sql_reporting;',
+			'ACStartuptaskBlock' : ss + 'azure.startup_task;',
+			'ACStorageAzureBlock' : ss + 'mscae.cloud.azure_storage;',
+			'ACStorageblobBlock' : ss + 'azure.storage_blob;',
+			'ACStoragequeueBlock' : ss + 'azure.storage_queue;',
+			'ACStoragetableBlock' : ss + 'azure.storage_table;',
+			'ACStorSimpleBlock' : ss + 'azure.storsimple;',
+			'ACStreamAnalyticsBlock' : ss + 'mscae.cloud.stream_analytics;',
+			'ACTrafficManagerBlock' : ss + 'azure.traffic_manager;',
+			'ACAlienBlock' : ss + 'azure.unidentified_code_object;',
+			'ACVHDBlock' : ss + 'azure.vhd;',
+			'ACVHDdatadiskBlock' : ss + 'azure.vhd_data_disk;',
+			'ACVirtualmachineBlock' : ss + 'azure.virtual_machine;',
+			'ACVirtualmachinecontainerBlock' : ss + 'mscae.cloud.virtual_machine_container;',
+			'ACVirtualnetworkBlock' : ss + 'azure.virtual_network;',
+			'ACVisualStudioOnlineBlock' : ss + 'azure.visual_studio_online;',
+			'ACVMsymbolonlyBlock' : ss + 'azure.virtual_machine_feature;',
+			'ACWebJobsBlock' : ss + 'mscae.cloud.webjobs;',
+			'ACWebroleBlock' : ss + 'azure.web_role;',
+			'ACWebrolesBlock' : ss + 'azure.web_roles;',
+			'ACWorkaccountBlock' : ss + 'mscae.cloud.work_account;',
+			'ACWorkerroleBlock' : ss + 'azure.worker_role;',
+			'ACWorkerrolesBlock' : ss + 'azure.worker_roles;',
+			'ADNSBlock' : ss + 'mscae.cloud.azure_dns;',
+//			'AGatewayBlock' NA
+			'ACLoadBalancerBlock' : ss + 'mscae.cloud.azure_load_balancer_feature;',
+			'ACResourceGroupBlock' : ss + 'mscae.cloud.resource_group;',
+			'ACVPNGatewayBlock' : ss + 'mscae.cloud.vpn_gateway;',
+//Azure Enterprise
+			'AEActiveDirectoryFSPBlock' : ss + 'mscae.enterprise.d;',
+			'AEADFSBlock' : ss + 'mscae.enterprise.ad_fs;',
+			'AEAndroidPhoneBlock' : ss + 'mscae.enterprise.android_phone;',
+			'AEappblankfortextBlock' : ss + 'mscae.enterprise.application_blank;',
+			'AEAppGenericBlock' : ss + 'mscae.enterprise.app_generic;',
+			'AEAppserverBlock' : ss + 'mscae.enterprise.application_server;',
+			'AEBackuplocalBlock' : ss + 'mscae.enterprise.backup_local;',
+			'AEBackuponlineBlock' : ss + 'mscae.enterprise.backup_online;',
+			'AECalendarBlock' : ss + 'mscae.general.calendar;',
+			'AECertificateBlock' : ss + 'azure.certificate;',
+			'AEClientAppBlock' : ss + 'mscae.enterprise.client_application;',
+			'AECloudBlock' : ss + 'mscae.enterprise.internet;',
+			'AEClusterserverBlock' : ss + 'mscae.enterprise.cluster_server;',
+			'AECodefileBlock' : ss + 'azure.code_file;',
+			'AEConnectorsBlock' : ss + 'mscae.enterprise.connectors;',
+			'AEDatabasegenericBlock' : ss + 'mscae.enterprise.database_generic;',
+			'AEDatabaseserverBlock' : ss + 'mscae.enterprise.database_server;',
+			'AEDatabasesyncBlock' : ss + 'mscae.enterprise.database_synchronization;',
+			'AEDeviceBlock' : ss + 'mscae.enterprise.device;',
+			'AEDirectaccessBlock' : ss + 'mscae.enterprise.direct_access_feature;',
+			'AEDocumentBlock' : ss + 'mscae.enterprise.document;',
+			'AEDomaincontrollerBlock' : ss + 'mscae.enterprise.domain_controller;',
+			'AEEnterpriseBuildingBlock' : ss + 'azure.enterprise;',
+			'AEFilegeneralBlock' : ss + 'azure.file;',
+			'AEFilterBlock' : ss + 'mscae.enterprise.filter;',
+			'AEFirewallBlock' : ss + 'mscae.enterprise.firewall;',
+			'AEFolderBlock' : ss + 'mscae.enterprise.folder;',
+			'AEGatewayBlock' : ss + 'mscae.enterprise.gateway;',
+			'AEGenericcodeBlock' : ss + 'azure.code_file;',
+			'AEGraphBlock' : ss + 'mscae.general.graph;',
+			'AEHealthmonitoringBlock' : ss + 'azure.health_monitoring;',
+			'AEHealthyBlock' : ss + 'azure.healthy;',
+			'AEImportgenericBlock' : ss + 'mscae.enterprise.import_generic;',
+			'AEInternetBlock' : ss + 'mscae.enterprise.internet;',
+			'AEKeyboardBlock' : ss + 'mscae.enterprise.keyboard;',
+			'AEKeypermissionsBlock' : ss + 'mscae.enterprise.key_permissions;',
+			'AELaptopcomputerBlock' : ss + 'azure.laptop;',
+			'AELoadbalancerBlock' : ss + 'azure.load_balancer_generic;',
+			'AELoadTestingBlock' : ss + 'mscae.enterprise.load_testing;',
+			'AELockprotectedBlock' : ss + 'mscae.enterprise.lock;',
+			'AELockunprotectedBlock' : ss + 'mscae.enterprise.lock_unlocked;',
+			'AEMaintenanceBlock' : ss + 'mscae.enterprise.maintenance;',
+			'AEManagementconsoleBlock' : ss + 'mscae.enterprise.management_console;',
+			'AEMessageBlock' : ss + 'azure.message;',
+			'AEMonitorBlock' : ss + 'azure.computer;',
+			'AEMonitorrunningappsBlock' : ss + 'mscae.enterprise.monitor_running_apps;',
+			'AEMouseBlock' : ss + 'mscae.enterprise.mouse;',
+			'AENetworkcardBlock' : ss + 'mscae.enterprise.network_card;',
+			'AENotallowedBlock' : ss + 'mscae.general.not_allowed;',
+			'AEPerformanceBlock' : ss + 'mscae.enterprise.performance;',
+			'AEPerformancemonitorBlock' : ss + 'mscae.enterprise.performance_monitor;',
+			'AEPhoneBlock' : ss + 'azure.mobile;',
+			'AEPlugandplayBlock' : ss + 'mscae.enterprise.plug_and_play;',
+			'AEPowershellscriptfileBlock' : ss + 'azure.powershell_file;',
+			'AEProtocolstackBlock' : ss + 'mscae.enterprise.protocol_stack;',
+			'AEQueuegeneralBlock' : ss + 'azure.queue_generic;',
+			'AERMSconnectorBlock' : ss + 'mscae.enterprise.rms_connector;',
+			'AERouterBlock' : ss + 'mscae.enterprise.router;',
+			'AEScriptfileBlock' : ss + 'azure.script_file;',
+			'AESecurevirtualmachineBlock' : ss + 'mscae.enterprise.secure_virtual_machine;',
+			'AEServerbladeBlock' : ss + 'azure.server;',
+			'AEServerdirectoryBlock' : ss + 'mscae.enterprise.server_directory;',
+			'AEServerfarmBlock' : ss + 'mscae.enterprise.server_farm;',
+			'AEServergenericBlock' : ss + 'mscae.enterprise.server_generic;',
+			'AEServerrackBlock' : ss + 'azure.server_rack;',
+			'AESettingsBlock' : ss + 'mscae.enterprise.settings;',
+			'AESharedfolderBlock' : ss + 'mscae.enterprise.shared_folder;',
+			'AESmartcardBlock' : ss + 'mscae.enterprise.smartcard;',
+			'AEStorageBlock' : ss + 'mscae.enterprise.storage;',
+			'AETableBlock' : ss + 'mscae.enterprise.table;',
+			'AETabletBlock' : ss + 'azure.tablet;',
+			'AEToolBlock' : ss + 'mscae.enterprise.tool;',
+			'AETunnelBlock' : ss + 'mscae.general.tunnel;',
+			'AEUnhealthyBlock' : ss + 'mscae.enterprise.unhealthy;',
+			'AEUSBBlock' : ss + 'mscae.enterprise.usb;',
+			'AEUserBlock' : ss + 'azure.user;',
+			'AEVideoBlock' : ss + 'mscae.general.video;',
+			'AEVirtualmachineBlock' : ss + 'azure.virtual_machine_feature;',
+			'AEWebBlock' : ss + 'mscae.enterprise.web;',
+			'AEWebserverBlock' : ss + 'mscae.enterprise.web_server;',
+			'AEWindowsserverBlock' : ss + 'mscae.enterprise.windows_server;',
+			'AEWirelessconnectionBlock' : ss + 'mscae.enterprise.wireless_connection;',
+			'AEWorkstationclientBlock' : ss + 'mscae.enterprise.workstation_client;',
+			'AEXMLwebserviceBlock' : ss + 'mscae.enterprise.xml_web_service;',
+			'AGSAudioBlock' : ss + 'mscae.general.audio;',
+			'AGSBugBlock' : ss + 'mscae.general.bug;',
+			'AGSCablesettopTVboxBlock' : ss + 'mscae.general.cable_settop_tv_box;',
+			'AGSCalendarBlock' : ss + 'mscae.general.calendar;',
+			'AGSChartBlock' : ss + 'mscae.general.chart;',
+			'AGSCheckmarkSuccessBlock' : ss + 'mscae.general.checkmark;',
+			'AGSContinousCycleCircleBlock' : ss + 'mscae.general.continuous_cycle;',
+			'AGSCrossoutFailureBlock' : ss + 'mscae.general.crossout;',
+			'AGSCutandpasteBlock' : ss + 'mscae.general.cut_and_paste;',
+			'AGSFolderBlock' : ss + 'mscae.enterprise.folder;',
+			'AGSGamecontrollerBlock' : ss + 'mscae.general.game_controller;',
+			'AGSGearsBlock' : ss + 'mscae.general.gears;',
+			'AGSGraphBlock' : ss + 'mscae.general.graph;',
+			'AGSLikeBlock' : ss + 'mscae.general.like;',
+			'AGSNotallowedBlock' : ss + 'mscae.general.not_allowed;',
+			'AGSSliderbarhorizontalBlock' : ss + 'mscae.general.slider_bar_horizontal;',
+			'AGSSliderbarvertBlock' : ss + 'mscae.general.slider_bar_vertical;',
+			'AGSTasklistorBacklogBlock' : ss + 'mscae.general.task_list;',
+			'AGSTasksBlock' : ss + 'mscae.general.tasks;',
+			'AGSTunnelBlock' : ss + 'mscae.general.tunnel;',
+			'AGSUserBlock' : ss + 'azure.user;',
+			'AGSVideoBlock' : ss + 'mscae.general.video;',
+// Azure VMS			
+//			'AVMActiveDirectoryVMBlock' NA
+//			'AVMActiveDirectoryVMmultiBlock' NA
+//			'AVMAppServerVMBlock' NA
+//			'AVMAppServerVMmultiBlock' NA
+//			'AVMDatabaseServerVMBlock' NA
+//			'AVMDatabaseServerVMmultiBlock' NA
+//			'AVMDirectoryServerVMBlock' NA
+//			'AVMDirectoryServerVMmultiBlock' NA
+//			'AVMDomainServerVMBlock' NA
+//			'AVMDomainServerVMmultiBlock' NA
+//			'AVMFileServerVMBlock' NA
+//			'AVMFileServerVMmultiBlock' NA
+//			'AVMWebServerVMBlock' NA
+//			'AVMWebServerVMmultiBlock' NA
+//			'AVMWindowsServerVMBlock' NA
+//			'AVMWindowsServerVMmultiBlock' NA
 //Cisco Basic
 			'Cisco_cisco_androgenous_person' : s + 'cisco.people.androgenous_person;' + c,
 			'Cisco_cisco_atm_switch' : s + 'cisco.switches.atm_switch;' + c,
@@ -1801,12 +2021,22 @@
 					
 					// Fixes the case for horizontal swimlanes where we use horizontal=0
 					// and Lucid uses rotation
+					
+					//stencils to rotate counter clockwise 90 degrees
+					var rccw = ['AEUSBBlock', 'AGSCutandpasteBlock'];
+					
 					if (a.Class == 'AdvancedSwimLaneBlockRotated')
 					{
 						deg += 90;
 						cell.geometry.rotate90();
 					}
-					
+					else if (rccw.includes(a.Class))
+					{
+						deg -= 90;
+						cell.geometry.rotate90();
+						cell.geometry.rotate90();
+						cell.geometry.rotate90();
+					}
 					cell.style += 'rotation=' + deg + ';';
 				}
 				

war/js/diagramly/mxEdgeBridge.js

@@ -18,13 +18,16 @@
  */
 
 //TODO integrate this code in mxConnector
-mxConnector.prototype.checkLineIntersection = function (line1StartX, line1StartY, line1EndX, line1EndY,
-                              line2StartX, line2StartY, line2EndX, line2EndY)
+
+mxGraph.prototype.enableEdgeBridge = true;
+mxConnector.prototype.bridgeSize = 10;
+
+mxConnector.prototype.checkLineIntersection = function (line1Start, line1End, line2Start, line2End)
 {
   // if the lines intersect, the result contains the the
   // intersection point if both line segment 1 and line segment 2 contain the point
   // null otherwise
-  var denominator = ((line2EndY - line2StartY) * (line1EndX - line1StartX)) - ((line2EndX - line2StartX) * (line1EndY - line1StartY));
+  var denominator = ((line2End.y - line2Start.y) * (line1End.x - line1Start.x)) - ((line2End.x - line2Start.x) * (line1End.y - line1Start.y));
   
   if (denominator == 0) 
   {
@@ -32,16 +35,16 @@ mxConnector.prototype.checkLineIntersection = function (line1StartX, line1StartY
   }
   else
   {
-    var a = line1StartY - line2StartY;
-    var b = line1StartX - line2StartX;
-    var numerator1 = ((line2EndX - line2StartX) * a) - ((line2EndY - line2StartY) * b);
-    var numerator2 = ((line1EndX - line1StartX) * a) - ((line1EndY - line1StartY) * b);
+    var a = line1Start.y - line2Start.y;
+    var b = line1Start.x - line2Start.x;
+    var numerator1 = ((line2End.x - line2Start.x) * a) - ((line2End.y - line2Start.y) * b);
+    var numerator2 = ((line1End.x - line1Start.x) * a) - ((line1End.y - line1Start.y) * b);
     a = numerator1 / denominator;
     b = numerator2 / denominator;
 
     // if we cast these lines infinitely in both directions, they intersect here:
-    var x = line1StartX + (a * (line1EndX - line1StartX));
-    var y = line1StartY + (a * (line1EndY - line1StartY));
+    var x = line1Start.x + (a * (line1End.x - line1Start.x));
+    var y = line1Start.y + (a * (line1End.y - line1Start.y));
 
     if (a > 0 && a < 1 &&  b > 0 && b < 1) // on both lines?
       return new mxPoint(x, y);
@@ -50,25 +53,133 @@ mxConnector.prototype.checkLineIntersection = function (line1StartX, line1StartY
   }
 }
 
-//TODO Add curves support for curve edges
-//TODO Make the Bridge a curve (e.g. half a circle)
-mxConnector.prototype.mxConnectorPaintLine_orig = mxConnector.prototype.paintLine;
-mxConnector.prototype.paintLine = function(canvas, pts, rounded)
+//Code from https://stackoverflow.com/questions/27664298/calculating-intersection-point-of-quadratic-bezier-curve
+mxConnector.prototype.calcQLintersects = function (p1, p2, p3, a1, a2) 
 {
-    var ptsCln = pts;
-    //TODO most probably this is not needed!
-    if (this.state == null || !this.state.cell.isEdge()) 
+  //linear interpolation utility
+  var lerp=function(a,b,x){ return(a+x*(b-a)); };
+	
+  var intersections=[];
+
+  // inverse line normal
+  var normal={
+    x: a1.y-a2.y,
+    y: a2.x-a1.x,
+  }
+
+  // Q-coefficients
+  var c2={
+    x: p1.x + p2.x*-2 + p3.x,
+    y: p1.y + p2.y*-2 + p3.y
+  }
+
+  var c1={
+    x: p1.x*-2 + p2.x*2,
+    y: p1.y*-2 + p2.y*2,
+  }
+
+  var c0={
+    x: p1.x,
+    y: p1.y
+  }
+
+  // Transform to line 
+  var coefficient=a1.x*a2.y-a2.x*a1.y;
+  var a=normal.x*c2.x + normal.y*c2.y;
+  var b=(normal.x*c1.x + normal.y*c1.y)/a;
+  var c=(normal.x*c0.x + normal.y*c0.y + coefficient)/a;
+
+  // solve the roots
+  var roots=[];
+  d=b*b-4*c;
+  if(d>0){
+    var e=Math.sqrt(d);
+    roots.push((-b+Math.sqrt(d))/2);
+    roots.push((-b-Math.sqrt(d))/2);
+  }else if(d==0){
+    roots.push(-b/2);
+  }
+
+  // calc the solution points
+  for(var i=0;i<roots.length;i++){
+    var minX=Math.min(a1.x,a2.x);
+    var minY=Math.min(a1.y,a2.y);
+    var maxX=Math.max(a1.x,a2.x);
+    var maxY=Math.max(a1.y,a2.y);
+    var t = roots[i];
+    if (t>=0 && t<=1) {
+      // possible point -- pending bounds check
+      var point={
+        x:lerp(lerp(p1.x,p2.x,t),lerp(p2.x,p3.x,t),t),
+        y:lerp(lerp(p1.y,p2.y,t),lerp(p2.y,p3.y,t),t)
+      }
+      var x=point.x;
+      var y=point.y;
+      // bounds checks
+      if(a1.x==a2.x && y>=minY && y<=maxY){  
+        // vertical line
+        intersections.push(point);
+      }else if(a1.y==a2.y && x>=minX && x<=maxX){
+        // horizontal line
+        intersections.push(point);
+      }else if(x>=minX && y>=minY && x<=maxX && y<=maxY){
+        // line passed bounds check
+        intersections.push(point);
+      }
+    }
+  }
+  return intersections;
+};
+
+mxConnector.prototype.getOnLinePointAtDist = function(x1, x2, y1, y2)
+{
+  var dx = x1 - x2;
+  var dy = y1 - y2;
+  var d = Math.sqrt(dy * dy + dx * dx);
+  var t = this.bridgeSize / d;
+  
+  return new mxPoint((1 - t) * x1 + t * x2, (1 - t) * y1 + t * y2);
+};
+
+mxConnector.prototype.addBridgePoints = function(intersectPt, result, l2p1, l2p2, otherId, eState)
+{
+    //instead of reordering, get the order and the top edge has the bridge
+    var dx = result.x - l2p2.x;
+    var dy = result.y - l2p2.y;
+    var dist = Math.sqrt(dx * dx + dy * dy);
+    dx /= dist;
+    dy /= dist;
+    
+    intersectPt.push(this.getOnLinePointAtDist(result.x, l2p1.x, result.y, l2p1.y));
+    intersectPt.push(new mxPoint(result.x + this.bridgeSize * dy, result.y - this.bridgeSize * dx));
+    intersectPt.push(this.getOnLinePointAtDist(result.x, l2p2.x, result.y, l2p2.y));
+    
+    //add others id here since here is the actual bridge!
+    if (eState.oldIntersectIds != null) 
     {
-	   return null;
+      eState.oldIntersectIds[otherId] = true;
     }
+    else
+    	eState.oldIntersectIds = {otherId: true};
+
+};
+
+mxConnector.prototype.scalePoint = function (point, scale)
+{
+	return {x: point.x / scale, y: point.y / scale};
+};
+
+//TODO Add curves support for curve edges (paintCurvedLine) for curve intersecting another curve
+mxConnector.prototype.paintLine = function(canvas, pts, rounded)
+{
+	var arcSize = mxUtils.getValue(this.style, mxConstants.STYLE_ARCSIZE, mxConstants.LINE_ARCSIZE) / 2;
+	canvas.begin();
 
+    var ptsCln = pts;
     var state = this.state;
     var graph = state.view.graph;
-	//TODO the shift should be a configuration
-    var shift = 10; //graph.edgeBridgeSize;
     
-    //TODO add mxGraph bridges switch 
-    if (/*graph.enableEdgeBridge &&*/ !graph.isMouseDown)
+    if (graph.enableEdgeBridge && !graph.isMouseDown)
     {
       //during DnD we can save the extra calculations
       var model = graph.getModel();
@@ -77,11 +188,9 @@ mxConnector.prototype.paintLine = function(canvas, pts, rounded)
       
       if (state.oldIntersectIds) 
       {
-        var ids = state.oldIntersectIds;
-        
-        for (var i = 0; i < ids.length; i++)
+        for (var id in state.oldIntersectIds)
         {
-            var c = model.getCell(ids[i]);
+            var c = model.getCell(id);
             
             if (c != null) 
             {
@@ -96,6 +205,7 @@ mxConnector.prototype.paintLine = function(canvas, pts, rounded)
         }
         delete state.oldIntersectIds;
       }
+      
       //for each pair find the intersection
       for (var i = 0; i < pts.length - 1; i++)
 	  {
@@ -116,87 +226,103 @@ mxConnector.prototype.paintLine = function(canvas, pts, rounded)
         		  {
                     var eScale = eState.view.scale;
                     
-                    for (var j = 0; j < eState.absolutePoints.length - 1; j++)
-              	  	{
-                        var l1p1 = eState.absolutePoints[j];
-                        var l1p2 = eState.absolutePoints[j+1];
-                        //the absolute points of current edge is scaled before calling this function, so we have to scale others to get correct intersections
-                        var result = this.checkLineIntersection(l1p1.x / eScale, l1p1.y / eScale, l1p2.x / eScale, l1p2.y / eScale
-                          , l2p1.x, l2p1.y, l2p2.x, l2p2.y);
-                        
-                        if (result != null) 
-                        {
-                          var getEdgeOrder = function (edge1, edge2)
-                      	  {
-                            var p1 = edge1.getParent();
-                            var p2 = edge2.getParent();
-                            
-                            if (p1 == p2) 
-                            {
-                              return p1.getIndex(edge1) - p1.getIndex(edge2); //+ve edge1 on top, -ve edge2 on top
-                            } 
-                            else 
-                            {
-                              return 0; //not the same parent, so we cannot determine
-                            }
-                          };
-                          
-                          if (getEdgeOrder(state.cell, eState.cell) > 0) 
-                          {
-                            //instead of reordering, get the order and the top edge has the bridge
-                            var dx = result.x - l2p2.x;
-                            var dy = result.y - l2p2.y;
-                            var dist = Math.sqrt(dx * dx + dy * dy);
-                            dx /= dist;
-                            dy /= dist;
-                            
-                            var getOnLinePointAtDist = function(x1, x2, y1, y2)
-                            {
-                              var dx = x1 - x2;
-                              var dy = y1 - y2;
-                              var d = Math.sqrt(dy * dy + dx * dx);
-                              var t = shift / d;
-                              return new mxPoint((1 - t) * x1 + t * x2, (1 - t) * y1 + t * y2);
-                            }
-                            
-                            intersectPt.push(getOnLinePointAtDist(result.x, l2p1.x, result.y, l2p1.y));
-                            intersectPt.push(new mxPoint(result.x + shift * dy, result.y - shift * dx));
-                            intersectPt.push(getOnLinePointAtDist(result.x, l2p2.x, result.y, l2p2.y));
-
-                            //add others id here since here is the actual bridge!
-                            var otherId = state.cell.id;
-                            
-                            if (eState.oldIntersectIds != null) 
-                            {
-                              eState.oldIntersectIds.push(otherId);
-                            }
-                            
-                            eState.oldIntersectIds= [otherId];
-                          }
-                          else if (!noRedraw) 
-                          {
-                            eState.redrawEdge = true;
-                            eState.shape.redraw();
-                          }
-                        }
-                    }
-                  }
+                    if (eState.style == null || eState.style[mxConstants.STYLE_CURVED] != 1) //line edge
+                    {
+	                    for (var j = 0; j < eState.absolutePoints.length - 1; j++)
+	              	  	{
+	                        var l1p1 = eState.absolutePoints[j];
+	                        var l1p2 = eState.absolutePoints[j+1];
+	                        //the absolute points of current edge is scaled before calling this function, so we have to scale others to get correct intersections
+	                        var result = this.checkLineIntersection(this.scalePoint(l1p1, eScale), this.scalePoint(l1p2, eScale), l2p1, l2p2);
+	                        
+	                        if (result != null) 
+	                        {
+	                          var getEdgeOrder = function (edge1, edge2)
+	                      	  {
+	                            var p1 = edge1.getParent();
+	                            var p2 = edge2.getParent();
+	                            
+	                            if (p1 == p2) 
+	                            {
+	                              return p1.getIndex(edge1) - p1.getIndex(edge2); //+ve edge1 on top, -ve edge2 on top
+	                            } 
+	                            else 
+	                            {
+	                              return 0; //not the same parent, so we cannot determine
+	                            }
+	                          };
+	                          
+	                          if (getEdgeOrder(state.cell, eState.cell) > 0) //instead of reordering, get the order and the top edge has the bridge
+	                          {
+	                        	this.addBridgePoints(intersectPt, result, l2p1, l2p2, state.cell.id, eState);
+	                          }
+	                          else if (!noRedraw) 
+	                          {
+	                            eState.redrawEdge = true;
+	                            eState.shape.redraw();
+	                          }
+	                        }
+	                    }
+	                  }
+                      else //curve edge (guad Bezier)
+                	  {
+                    	  //We'll not check edge order here as always line will have bridges as it is better than curve bridges
+                    	  	var ePts = eState.absolutePoints;
+	                		var pt = this.scalePoint(ePts[0], eScale);
+	                		var n = ePts.length;
+                    		
+	                		var allPts = [];
+	                		
+                    		for (var k = 1; k < n - 2; k++)
+                    		{
+                    			var p0 = this.scalePoint(ePts[k], eScale);
+                    			var p1 = this.scalePoint(ePts[k + 1], eScale);
+                    			var ip = {x: (p0.x + p1.x) / 2, y: (p0.y + p1.y) / 2};
+                    			
+                    			allPts.push.apply(allPts, this.calcQLintersects(pt, p0, ip, l2p1, l2p2));
+                    			
+                    			pt = ip;
+                    		}
+                    		
+                    		var p0 = this.scalePoint(ePts[n - 2], eScale);
+                    		var p1 = this.scalePoint(ePts[n - 1], eScale);
+                    		
+                    		allPts.push.apply(allPts, this.calcQLintersects(pt, p0, p1, l2p1, l2p2));
+                    		
+                			if (allPts.length > 0)
+            				{
+                				for (var o = 0; o < allPts.length; o++)
+            					{
+                					this.addBridgePoints(intersectPt, allPts[o], l2p1, l2p2, state.cell.id, eState);
+            					}
+            				}
+                	  }
+        		  }
         	  }
               
           }
-          //sort points and then add them
-          intersectPt.sort(function(p1, p2) {
-              var dx1 = p1.x - l2p1.x;
-              var dy1 = p1.y - l2p1.y;
-              var d1 = dx1 * dx1 + dy1 * dy1;
-
-              var dx2 = p2.x - l2p1.x;
-              var dy2 = p2.y - l2p1.y;
-              var d2 = dx2 * dx2 + dy2 * dy2;
-
-              return d1 - d2;
-          });
-          ptsCln.push.apply(ptsCln, intersectPt);
+          
+          if (intersectPt.length > 0)
+    	  {
+              //sort points and then add them
+              intersectPt.sort(function(p1, p2) {
+                  var dx1 = p1.x - l2p1.x;
+                  var dy1 = p1.y - l2p1.y;
+                  var d1 = dx1 * dx1 + dy1 * dy1;
+
+                  var dx2 = p2.x - l2p1.x;
+                  var dy2 = p2.y - l2p1.y;
+                  var d2 = dx2 * dx2 + dy2 * dy2;
+
+                  return d1 - d2;
+              });
+    	  
+              ptsCln.push(intersectPt[0]);
+              this.addPoints(canvas, ptsCln, rounded, arcSize, false);
+              ptsCln = [intersectPt[intersectPt.length - 1]];
+              this.addPoints(canvas, intersectPt, true, arcSize, false);
+    	  }
+          
           ptsCln.push(l2p2);
       }
       
@@ -207,5 +333,6 @@ mxConnector.prototype.paintLine = function(canvas, pts, rounded)
 
     }
   
-    this.mxConnectorPaintLine_orig.call(this, canvas, ptsCln, rounded);
-};
+	this.addPoints(canvas, ptsCln, rounded, arcSize, false);
+	canvas.stroke();
+};

war/js/mxgraph/Shapes.js

@@ -2111,7 +2111,36 @@
 	};
 
 	mxCellRenderer.prototype.defaultShapes['display'] = DisplayShape;
+	
+	// FilledEdge shape
+	function FilledEdge()
+	{
+		mxConnector.call(this);
+	};
+	mxUtils.extend(FilledEdge, mxConnector);
+	
+	FilledEdge.prototype.origPaintEdgeShape = FilledEdge.prototype.paintEdgeShape;
+	FilledEdge.prototype.paintEdgeShape = function(c, pts, rounded)
+	{
+		FilledEdge.prototype.origPaintEdgeShape.apply(this, arguments);
+		if (c.state.strokeWidth >= 3)
+		{
+			var fillClr = mxUtils.getValue(this.style, 'fillColor', null);
+			
+			if (fillClr != null)
+			{
+				c.setStrokeColor(fillClr);
+				c.setStrokeWidth(c.state.strokeWidth - 2);
+			
+				FilledEdge.prototype.origPaintEdgeShape.apply(this, arguments);		
+			}
+		}
+	};
 
+	// Registers the link shape
+	mxCellRenderer.prototype.defaultShapes['filledEdge'] = FilledEdge;
+
+	
 	// Registers and defines the custom marker
 	mxMarker.addMarker('dash', function(c, shape, type, pe, unitX, unitY, size, source, sw, filled)
 	{

war/package.json

@@ -4,11 +4,13 @@
   "description": "draw.io desktop",
   "main": "electron.js",
   "scripts": {
-    "start": "electron ."
+    "start": "electron ./draw.io/war",
+    "sync": "node ./sync.js",
+    "release": "build"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/jgraph/draw.io.git"
+    "url": "git@github.com:jgraph/drawio-desktop.git"
   },
   "keywords": [
     "draw.io",
@@ -16,17 +18,18 @@
     "flowchart",
     "UML"
   ],
-  "author": "JGraph",
-  "license": "GPL-3.0",
+  "author": "JGraph <support@draw.io>",
+  "license": "Apache-2.0",
   "bugs": {
-    "url": "https://github.com/jgraph/draw.io/issues"
+    "url": "https://github.com/jgraph/drawio-desktop/issues"
   },
   "homepage": "https://github.com/jgraph/draw.io",
     "dependencies": {
     "electron-log": "^2.2.6",
-    "electron-updater": "^2.8.2"
+    "electron-updater": "^1.16.0"
   },
   "devDependencies": {
-    "electron": "^1.6.12"
+    "electron": "^1.7.2",
+    "electron-builder": "^18.1.0"
   }
 }