You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@corinthia.apache.org by ja...@apache.org on 2015/02/23 20:26:26 UTC

[1/3] incubator-corinthia git commit: Fix cursor position in empty caption

Repository: incubator-corinthia
Updated Branches:
  refs/heads/experimentzip 1baa03dc2 -> 5a745c873


Fix cursor position in empty caption

This commit fixes a bug where if you place the cursor inside an empty
figure or table caption, it's displayed at the left of the screen,
instead of directly after the "Table X: " or "Figure X: " generated
content.

We can't directly get the bounding rect of generated content, so we
temporarily insert a text node containing a single space character, get
the position to the right of that character, and then remove the text
node. This allows us to show the user the position at which text will be
inserted if they start entering text in the caption.


Project: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/commit/9a24b330
Tree: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/tree/9a24b330
Diff: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/diff/9a24b330

Branch: refs/heads/experimentzip
Commit: 9a24b33059ff0b804ad0eae5031531043d870edd
Parents: 13f9a17
Author: Peter Kelly <pe...@uxproductivity.com>
Authored: Mon Feb 23 22:30:43 2015 +0700
Committer: Peter Kelly <pe...@uxproductivity.com>
Committed: Mon Feb 23 22:30:43 2015 +0700

----------------------------------------------------------------------
 Editor/src/Position.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/9a24b330/Editor/src/Position.js
----------------------------------------------------------------------
diff --git a/Editor/src/Position.js b/Editor/src/Position.js
index e767a46..9751743 100644
--- a/Editor/src/Position.js
+++ b/Editor/src/Position.js
@@ -711,6 +711,16 @@ var Position_atPoint;
         return null;
     }
 
+    function findCaptionContainingPos(pos)
+    {
+        var node = Position_closestActualNode(pos);
+        for (; node != null; node = node.parentNode) {
+            if ((node._type == HTML_FIGCAPTION) || (node._type == HTML_CAPTION))
+                return node;
+        }
+        return null;
+    }
+
     function exactRectAtPos(pos)
     {
         var node = pos.node;
@@ -778,6 +788,21 @@ var Position_atPoint;
         if ((noteNode != null) && !nodeHasContent(noteNode)) // In empty footnote or endnote
             return zeroWidthMidRect(noteNode.getBoundingClientRect());
 
+        var captionNode = findCaptionContainingPos(pos);
+        if ((captionNode != null) && !nodeHasContent(captionNode)) {
+            // Even if an empty caption has generated content (e.g. "Figure X: ") preceding it,
+            // we can't directly get the rect of that generated content. So we temporarily insert
+            // a text node containing a single space character, get the position to the right of
+            // that character, and then remove the text node.
+            var space = DOM_createTextNode(document,String.fromCharCode(160));
+            DOM_appendChild(captionNode,space);
+            var range = new Range(space,1,space,1);
+            var rects = Range_getClientRects(range);
+            DOM_deleteNode(space);
+            if (rects.length > 0)
+                return rects[0];
+        }
+
         var paragraph = Text_findParagraphBoundaries(pos);
 
         var backRect = null;


[2/3] incubator-corinthia git commit: Added patch from Gabriela

Posted by ja...@apache.org.
Added patch from Gabriela

This patch need some extra work, when we are finished discussing coding standard


Project: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/commit/227d59d9
Tree: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/tree/227d59d9
Diff: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/diff/227d59d9

Branch: refs/heads/experimentzip
Commit: 227d59d949a3b37cad19da27717e1d603b753479
Parents: 9a24b33
Author: jani <ja...@apache.org>
Authored: Mon Feb 23 19:42:14 2015 +0100
Committer: jani <ja...@apache.org>
Committed: Mon Feb 23 19:42:14 2015 +0100

----------------------------------------------------------------------
 DocFormats/api/src/Operations.c | 160 +++++++++++++++++++++++++----------
 1 file changed, 113 insertions(+), 47 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-corinthia/blob/227d59d9/DocFormats/api/src/Operations.c
----------------------------------------------------------------------
diff --git a/DocFormats/api/src/Operations.c b/DocFormats/api/src/Operations.c
index 6978ffd..156d85a 100644
--- a/DocFormats/api/src/Operations.c
+++ b/DocFormats/api/src/Operations.c
@@ -41,13 +41,15 @@ struct DFAbstractDocument {
 
 DFConcreteDocument *DFConcreteDocumentNew(DFStorage *storage)
 {
-    DFConcreteDocument *concrete = (DFConcreteDocument *)calloc(1,sizeof(DFConcreteDocument));
+    DFConcreteDocument *concrete = 
+      (DFConcreteDocument *)calloc(1,sizeof(DFConcreteDocument));
     concrete->retainCount = 1;
     concrete->storage = DFStorageRetain(storage);
     return concrete;
 }
 
-DFConcreteDocument *DFConcreteDocumentCreateFile(const char *filename, DFError **error)
+DFConcreteDocument
+*DFConcreteDocumentCreateFile(const char *filename, DFError **error)
 {
     DFFileFormat format = DFFileFormatFromFilename(filename);
     switch (format) {
@@ -57,20 +59,24 @@ DFConcreteDocument *DFConcreteDocumentCreateFile(const char *filename, DFError *
         case DFFileFormatOdt:
         case DFFileFormatOds:
         case DFFileFormatOdp: {
-            DFStorage *storage = DFStorageCreateZip(filename,error);
+            DFStorage *storage = DFStorageCreateZip(filename, error);
             if (storage == NULL)
                 return NULL;;
-            DFConcreteDocument *concrete = DFConcreteDocumentNew(storage);
+            DFConcreteDocument *concrete =
+              DFConcreteDocumentNew(storage);
             DFStorageRelease(storage);
             return concrete;
         }
         default:
-            DFErrorFormat(error,"Unsupported format for DFConcreteDocumentCreateFile");
+            DFErrorFormat(error,
+                          "Unsupported format for "
+                          "DFConcreteDocumentCreateFile");
             return NULL;
     }
 }
 
-DFConcreteDocument *DFConcreteDocumentOpenFile(const char *filename, DFError **error)
+DFConcreteDocument 
+*DFConcreteDocumentOpenFile(const char *filename, DFError **error)
 {
     DFFileFormat format = DFFileFormatFromFilename(filename);
     switch (format) {
@@ -83,17 +89,20 @@ DFConcreteDocument *DFConcreteDocumentOpenFile(const char *filename, DFError **e
             DFStorage *storage = DFStorageOpenZip(filename,error);
             if (storage == NULL)
                 return NULL;;
-            DFConcreteDocument *concrete = DFConcreteDocumentNew(storage);
+            DFConcreteDocument *concrete =
+              DFConcreteDocumentNew(storage);
             DFStorageRelease(storage);
             return concrete;
         }
         default:
-            DFErrorFormat(error,"Unsupported format for DFConcreteDocumentCreateFile");
+            DFErrorFormat(error,"Unsupported format for" 
+                          "DFConcreteDocumentCreateFile");
             return NULL;
     }
 }
 
-DFConcreteDocument *DFConcreteDocumentRetain(DFConcreteDocument *concrete)
+DFConcreteDocument 
+*DFConcreteDocumentRetain(DFConcreteDocument *concrete)
 {
     if (concrete != NULL)
         concrete->retainCount++;
@@ -111,13 +120,15 @@ void DFConcreteDocumentRelease(DFConcreteDocument *concrete)
 
 DFAbstractDocument *DFAbstractDocumentNew(DFStorage *storage)
 {
-    DFAbstractDocument *abstract = (DFAbstractDocument *)calloc(1,sizeof(DFAbstractDocument));
+    DFAbstractDocument *abstract =
+      (DFAbstractDocument *)calloc(1,sizeof(DFAbstractDocument));
     abstract->retainCount = 1;
     abstract->storage = DFStorageRetain(storage);
     return abstract;
 }
 
-DFAbstractDocument *DFAbstractDocumentRetain(DFAbstractDocument *abstract)
+DFAbstractDocument
+*DFAbstractDocumentRetain(DFAbstractDocument *abstract)
 {
     if (abstract != NULL)
         abstract->retainCount++;
@@ -139,26 +150,34 @@ DFDocument *DFAbstractDocumentGetHTML(DFAbstractDocument *abstract)
     return abstract->htmlDoc;
 }
 
-void DFAbstractDocumentSetHTML(DFAbstractDocument *abstract, DFDocument *htmlDoc)
+void DFAbstractDocumentSetHTML(DFAbstractDocument *abstract,
+                               DFDocument *htmlDoc)
 {
     DFDocumentRelease(abstract->htmlDoc);
     abstract->htmlDoc = DFDocumentRetain(htmlDoc);
 }
 
-int DFGet(DFConcreteDocument *concrete, DFAbstractDocument *abstract, DFError **error)
+int DFGet(DFConcreteDocument *concrete,
+          DFAbstractDocument *abstract,
+          DFError **error)
 {
     if (DFStorageFormat(abstract->storage) != DFFileFormatHTML) {
-        DFErrorFormat(error,"Abstract document must be in HTML format");
+        DFErrorFormat(error,
+                      "Abstract document must be in HTML format");
         return 0;
     }
 
     DFDocument *htmlDoc = NULL;
     switch (DFStorageFormat(concrete->storage)) {
         case DFFileFormatDocx:
-            htmlDoc = WordGet(concrete->storage,abstract->storage,error);
+            htmlDoc = WordGet(concrete->storage,
+                              abstract->storage,
+                              error);
             break;
         case DFFileFormatOdt:
-            htmlDoc = ODFTextGet(concrete->storage,abstract->storage,error);
+            htmlDoc = ODFTextGet(concrete->storage,
+                                 abstract->storage,
+                                 error);
             break;
         default:
             DFErrorFormat(error,"Unsupported file format");
@@ -173,20 +192,29 @@ int DFGet(DFConcreteDocument *concrete, DFAbstractDocument *abstract, DFError **
     return 1;
 }
 
-int DFPut(DFConcreteDocument *concreteDoc, DFAbstractDocument *abstractDoc, DFError **error)
+int DFPut(DFConcreteDocument *concreteDoc,
+          DFAbstractDocument *abstractDoc,
+          DFError **error)
 {
     if (DFStorageFormat(abstractDoc->storage) != DFFileFormatHTML) {
-        DFErrorFormat(error,"Abstract document must be in HTML format");
+        DFErrorFormat(error,
+                      "Abstract document must be in HTML format");
         return 0;
     }
 
     int ok = 0;
     switch (DFStorageFormat(concreteDoc->storage)) {
         case DFFileFormatDocx:
-            ok = WordPut(concreteDoc->storage,abstractDoc->storage,abstractDoc->htmlDoc,error);
+            ok = WordPut(concreteDoc->storage,
+                         abstractDoc->storage,
+                         abstractDoc->htmlDoc,
+                         error);
             break;
         case DFFileFormatOdt:
-            ok = ODFTextPut(concreteDoc->storage,abstractDoc->storage,abstractDoc->htmlDoc,error);
+            ok = ODFTextPut(concreteDoc->storage,
+                            abstractDoc->storage,
+                            abstractDoc->htmlDoc,
+                            error);
             break;
         default:
             DFErrorFormat(error,"Unsupported file format");
@@ -195,20 +223,29 @@ int DFPut(DFConcreteDocument *concreteDoc, DFAbstractDocument *abstractDoc, DFEr
     return ok;
 }
 
-int DFCreate(DFConcreteDocument *concreteDoc, DFAbstractDocument *abstractDoc, DFError **error)
+int DFCreate(DFConcreteDocument *concreteDoc,
+             DFAbstractDocument *abstractDoc,
+             DFError **error)
 {
     if (DFStorageFormat(abstractDoc->storage) != DFFileFormatHTML) {
-        DFErrorFormat(error,"Abstract document must be in HTML format");
+        DFErrorFormat(error,
+                      "Abstract document must be in HTML format");
         return 0;
     }
 
     int ok = 0;
     switch (DFStorageFormat(concreteDoc->storage)) {
         case DFFileFormatDocx:
-            ok = WordCreate(concreteDoc->storage,abstractDoc->storage,abstractDoc->htmlDoc,error);
+            ok = WordCreate(concreteDoc->storage,
+                            abstractDoc->storage,
+                            abstractDoc->htmlDoc,
+                            error);
             break;
         case DFFileFormatOdt:
-            ok = ODFTextCreate(concreteDoc->storage,abstractDoc->storage,abstractDoc->htmlDoc,error);
+            ok = ODFTextCreate(concreteDoc->storage,
+                               abstractDoc->storage,
+                               abstractDoc->htmlDoc,
+                               error);
             break;
         default:
             DFErrorFormat(error,"Unsupported file format");
@@ -217,34 +254,48 @@ int DFCreate(DFConcreteDocument *concreteDoc, DFAbstractDocument *abstractDoc, D
     return ok;
 }
 
-int DFGetFile(const char *concreteFilename, const char *abstractFilename, DFError **error)
+int DFGetFile(const char *concreteFilename,
+              const char *abstractFilename,
+              DFError **error)
 {
     int r = 0;
     char *abstractPath = DFPathDirName(abstractFilename);
-    DFStorage *abstractStorage = DFStorageNewFilesystem(abstractPath,DFFileFormatHTML);
+    DFStorage *abstractStorage =
+      DFStorageNewFilesystem(abstractPath, DFFileFormatHTML);
     DFConcreteDocument *concreteDoc = NULL;
     DFAbstractDocument *abstractDoc = NULL;
 
-    concreteDoc = DFConcreteDocumentOpenFile(concreteFilename,error);
+    concreteDoc = DFConcreteDocumentOpenFile(concreteFilename, error);
     if (concreteDoc == NULL) {
-        DFErrorFormat(error,"%s: %s",concreteFilename,DFErrorMessage(error));
+        DFErrorFormat(error, "%s: %s",
+                      concreteFilename,
+                      DFErrorMessage(error));
         goto end;
     }
 
     abstractDoc = DFAbstractDocumentNew(abstractStorage);
 
-    if (!DFGet(concreteDoc,abstractDoc,error) || (abstractDoc->htmlDoc == NULL)) {
-        DFErrorFormat(error,"%s: %s",concreteFilename,DFErrorMessage(error));
+    if (!DFGet(concreteDoc, abstractDoc, error)
+        || (abstractDoc->htmlDoc == NULL)) {
+        DFErrorFormat(error, "%s: %s",
+                      concreteFilename,
+                      DFErrorMessage(error));
         goto end;
     }
 
     if (DFFileExists(abstractFilename)) {
-        DFErrorFormat(error,"%s: File already exists",abstractFilename);
+        DFErrorFormat(error,
+                      "%s: File already exists",
+                      abstractFilename);
         goto end;
     }
 
-    if (!DFSerializeXMLFile(abstractDoc->htmlDoc,0,0,abstractFilename,error)) {
-        DFErrorFormat(error,"%s: %s",abstractFilename,DFErrorMessage(error));
+    if (!DFSerializeXMLFile(abstractDoc->htmlDoc,
+                            0, 0,
+                            abstractFilename,error)) {
+        DFErrorFormat(error, "%s: %s",
+                      abstractFilename,
+                      DFErrorMessage(error));
         goto end;
     }
 
@@ -258,31 +309,38 @@ end:
     return r;
 }
 
-int DFPutFile(const char *concreteFilename, const char *abstractFilename, DFError **error)
+int DFPutFile(const char *concreteFilename,
+              const char *abstractFilename,
+              DFError **error)
 {
     int ok = 0;
     DFDocument *htmlDoc2 = NULL;
     char *abstractPath = DFPathDirName(abstractFilename);
-    DFStorage *abstractStorage2 = DFStorageNewFilesystem(abstractPath,DFFileFormatHTML);
+    DFStorage *abstractStorage2 =
+      DFStorageNewFilesystem(abstractPath, DFFileFormatHTML);
     DFConcreteDocument *concreteDoc = NULL;
     DFAbstractDocument *abstractDoc = NULL;
 
-    htmlDoc2 = DFParseHTMLFile(abstractFilename,0,error);
+    htmlDoc2 = DFParseHTMLFile(abstractFilename, 0, error);
     if (htmlDoc2 == NULL) {
-        DFErrorFormat(error,"%s: %s",abstractFilename,DFErrorMessage(error));
+        DFErrorFormat(error,"%s: %s",
+                      abstractFilename,
+                      DFErrorMessage(error));
         goto end;
     }
 
-    concreteDoc = DFConcreteDocumentOpenFile(concreteFilename,error);
+    concreteDoc = DFConcreteDocumentOpenFile(concreteFilename, error);
     if (concreteDoc == NULL) {
-        DFErrorFormat(error,"%s: %s",concreteFilename,DFErrorMessage(error));
+        DFErrorFormat(error, "%s: %s",
+                      concreteFilename,
+                      DFErrorMessage(error));
         goto end;
     }
 
     abstractDoc = DFAbstractDocumentNew(abstractStorage2);
     abstractDoc->htmlDoc = DFDocumentRetain(htmlDoc2);
 
-    ok = DFPut(concreteDoc,abstractDoc,error);
+    ok = DFPut(concreteDoc, abstractDoc, error);
 
 end:
     DFDocumentRelease(htmlDoc2);
@@ -293,31 +351,39 @@ end:
     return ok;
 }
 
-int DFCreateFile(const char *concreteFilename, const char *abstractFilename, DFError **error)
+int DFCreateFile(const char *concreteFilename,
+                 const char *abstractFilename,
+                 DFError **error)
 {
     int ok = 0;
     DFDocument *htmlDoc = NULL;
     char *abstractPath = DFPathDirName(abstractFilename);
-    DFStorage *abstractStorage = DFStorageNewFilesystem(abstractPath,DFFileFormatHTML);
+    DFStorage *abstractStorage =
+      DFStorageNewFilesystem(abstractPath, DFFileFormatHTML);
     DFConcreteDocument *concreteDoc = NULL;
     DFAbstractDocument *abstractDoc = NULL;
 
-    htmlDoc = DFParseHTMLFile(abstractFilename,0,error);
+    htmlDoc = DFParseHTMLFile(abstractFilename, 0, error);
     if (htmlDoc == NULL) {
-        DFErrorFormat(error,"%s: %s",abstractFilename,DFErrorMessage(error));
+        DFErrorFormat(error,"%s: %s",
+                      abstractFilename,
+                      DFErrorMessage(error));
         goto end;
     }
 
-    concreteDoc = DFConcreteDocumentCreateFile(concreteFilename,error);
+    concreteDoc =
+      DFConcreteDocumentCreateFile(concreteFilename, error);
     if (concreteDoc == NULL) {
-        DFErrorFormat(error,"%s: %s",concreteFilename,DFErrorMessage(error));
+        DFErrorFormat(error, "%s: %s",
+                      concreteFilename,
+                      DFErrorMessage(error));
         goto end;
     }
 
     abstractDoc = DFAbstractDocumentNew(abstractStorage);
     abstractDoc->htmlDoc = DFDocumentRetain(htmlDoc);
 
-    ok = DFCreate(concreteDoc,abstractDoc,error);
+    ok = DFCreate(concreteDoc, abstractDoc, error);
 
 end:
     DFDocumentRelease(htmlDoc);


[3/3] incubator-corinthia git commit: Merge branch 'master' into experimentzip

Posted by ja...@apache.org.
Merge branch 'master' into experimentzip


Project: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/commit/5a745c87
Tree: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/tree/5a745c87
Diff: http://git-wip-us.apache.org/repos/asf/incubator-corinthia/diff/5a745c87

Branch: refs/heads/experimentzip
Commit: 5a745c873148ddbdf2127786ded9faec8afbc930
Parents: 1baa03d 227d59d
Author: jani <ja...@apache.org>
Authored: Mon Feb 23 20:25:51 2015 +0100
Committer: jani <ja...@apache.org>
Committed: Mon Feb 23 20:25:51 2015 +0100

----------------------------------------------------------------------
 DocFormats/api/src/Operations.c | 160 +++++++++++++++++++++++++----------
 Editor/src/Position.js          |  25 ++++++
 2 files changed, 138 insertions(+), 47 deletions(-)
----------------------------------------------------------------------