[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Texmacs-dev] Displaying table grids

From: Norbert Nemec
Subject: Re: [Texmacs-dev] Displaying table grids
Date: Sun, 20 Dec 2009 22:33:31 +0000
User-agent: Thunderbird (X11/20090817)

OK, here is a new version of the patch. It does now display the table grid just one px wide. To achive a smooth and symmetric look, I had to change the 'outline' function, shifting some of the lines by one pixel. The visual appearance seems fine to me.

Unfortunately, the whole logic for outline rectangles is integer based and does not have access to the subpixel precision of individual elements. Therefore, the elements are first rounded to integer positions and then shifted by individual pixels. Theoretically, the display should be somewhat more precise if the rectangle manipulations could be done before rounding to exact pixels. In practice, I am not sure whether anyone would notice the difference.

The slightly awkward details remain:

* the cyan rectangles and the red selection have two pixels space on the top and the bottom and none at the sides. This makes sense. The gray table grid does not have this spacing, because there is no room for it. This also makes sense. The combination leads to tables having double lines at the top and the bottom but single lines at the sides.

* the eqnarray* display still does not deal with the interparagraph space in any special way.

In both cases, I do not what a proper and consistent solution should look like. Furthermore, I found the current implementation tricky enough and have no idea how to implement anything that involves obtaining more information about the document than the box geometries that are used at the moment.

Anyone who want to give it a try is free to improve upon this solution.


Joris van der Hoeven wrote:
Dear Norbert,

On Mon, Dec 14, 2009 at 09:39:09PM +0000, Norbert Nemec wrote:
in fact, I had initially intended to make the lines 1px wide just as you describe. After some fiddling I found that it always ended up looking strangely asymmetric. The problem is that the cyan environment frames are always 1px-wide lines outside the box, defining the box boundaries to sit exactly between pixels. A 1px wide line can therefore only sit either to the left or to the right of the box boundary. Any way you choose this, it looks crooked. The only solution to allow good-looking 1px-wide grids would be to shift the cyan box guides as well as the red selection markers.

Hmm, I still would like to see this.

Ultimately, though, I found that 2px lines actually have the advantage that they can be displayed in fainter gray while still giving the same visual impact. This should reduce the visual clutter with the black page content.

As for the eqnarray* grids - indeed that look takes some getting used to. After using it for some time, I actually began to like it. I am not quite sure how to change this cleanly. Currently, the whole code is really simple, drawing a rectangle around each cell individually. Trying to find adjacent cells and then determining the line between is certainly much more messy and may be quite tricky to get correct for cell spans etc.

I think that one ultimately gets used to about any convention.
Nevertheless, the first impression is important, and it still seems
a bit messy to me. But I think that it should be possible to do
something about it. Also true that the implementation will be non trivial;
the current solution is definitely the easiest one.

Actually, do you have an idea what the mechanism is that causes the space between the lines in eqnarray* ? I never managed to cause the same effect in a table.

This is just the interparagraph space.

Currently, my own major grievance with the table grid code is that cell borders are hidden *behind* the grid. I tried to put the visual hints behind the text, but this did not work nicely with overlays (which I use heavily in one special layout). As I said, alpha-channel rastering would be the perfect solution for this...

Yes, we should try to implement alpha rendering sometime soon;
this should be possible with the Qt port.

Best wishes, --Joris

PS: happy christmas to everybody on the list;
I will be off for a long week.

Texmacs-dev mailing list

>From f29e27747d8908cb6d36d38416e1d01813c03b10 Mon Sep 17 00:00:00 2001
From: Norbert Nemec <address@hidden>
Date: Sun, 20 Dec 2009 22:16:06 +0000
Subject: [PATCH] Display table grid (very faint gray). Also change color of 
environment boxes from intense cyan to faint gray cyan and put them behind the 
displayed content.

 src/src/Edit/Interface/edit_interface.cpp |   37 ++++++++++++++++++----------
 src/src/Edit/Interface/edit_interface.hpp |    3 +-
 src/src/Edit/Interface/edit_repaint.cpp   |   10 ++++++-
 src/src/Kernel/Types/rectangles.cpp       |   21 +++++++++++++++-
 src/src/Kernel/Types/rectangles.hpp       |    1 +
 5 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/src/src/Edit/Interface/edit_interface.cpp 
index a035b5a..aa9f72f 100644
--- a/src/src/Edit/Interface/edit_interface.cpp
+++ b/src/src/Edit/Interface/edit_interface.cpp
@@ -261,26 +261,36 @@ is_graphical (tree t) {
-edit_interface_rep::compute_env_rects (path p, rectangles& rs, bool recurse) {
+edit_interface_rep::compute_env_rects (path p,
+    rectangles& rs, rectangles& tcrs, bool recurse) {
   p= path_up (p);
   if (p == rp) return;
   tree st= subtree (et, p);
-  if (is_atomic (st) ||
+  if(is_func(st,TABLE)) {
+    rectangles r;
+    for(int i=0;i<N(st);i++)
+        if(is_func(st[i],ROW))
+            for(int j=0;j<N(st[i]);j++) {
+                selection sel= eb->find_check_selection (p*i*j*0,p*i*j*1);
+                r << outline_narrow(sel->rs,pixel);
+            }
+    tcrs << simplify(r);
+    compute_env_rects (p, rs, tcrs, recurse);
+  } else if (is_atomic (st) ||
       drd->is_child_enforcing (st) ||
       //is_document (st) || is_concat (st) ||
-      is_func (st, TABLE) || is_func (st, SUBTABLE) ||
+      is_func (st, SUBTABLE) ||
       is_func (st, ROW) || is_func (st, TFORMAT) ||
       is_graphical (st) ||
       (is_func (st, WITH) && is_graphical (st[N(st)-1])) ||
       (is_func (st, WITH) && is_func (st[N(st)-1], TEXT_AT)) ||
       (is_compound (st, "math", 1) &&
        is_compound (subtree (et, path_up (p)), "input")))
-    compute_env_rects (p, rs, recurse);
+    compute_env_rects (p, rs, tcrs, recurse);
   else {
     int new_mode= DRD_ACCESS_NORMAL;
     if (get_init_string (MODE) == "src") new_mode= DRD_ACCESS_SOURCE;
     int old_mode= set_access_mode (new_mode);
-    tree st= subtree (et, p);
     if (is_accessible_cursor (et, p * right_index (st)) || in_source ()) {
       bool right;
       path p1= p * 0, p2= p * 1, q1, q2;
@@ -294,7 +304,7 @@ edit_interface_rep::compute_env_rects (path p, rectangles& 
rs, bool recurse) {
       rs << outline (sel->rs, pixel);
     set_access_mode (old_mode);
-    if (recurse) compute_env_rects (p, rs, recurse);
+    if (recurse) compute_env_rects (p, rs, tcrs, recurse);
@@ -457,8 +467,14 @@ edit_interface_rep::apply_changes () {
     oc= copy (cu);
     rectangles old_rects= env_rects;
+    rectangles old_tc_rects= tblcell_rects;
     env_rects= rectangles ();
-    compute_env_rects (path_up (tp), env_rects, true);
+    tblcell_rects= rectangles ();
+    compute_env_rects (path_up (tp), env_rects, tblcell_rects, true);
+    if (tblcell_rects != old_tc_rects) {
+      invalidate (old_tc_rects);
+      invalidate (tblcell_rects);
+    }
     if (env_rects != old_rects) {
       invalidate (old_rects);
       invalidate (env_rects);
@@ -473,12 +489,7 @@ edit_interface_rep::apply_changes () {
     if (made_selection) {
       table_selection= selection_active_table ();
       selection sel; selection_get (sel);
-      /*
-      selection_rects=
-       simplify (::correct (thicken (sel->rs, pixel, pixel) - sel->rs));
-      */
-      selection_rects= simplify (::correct (thicken (sel->rs, pixel, 3*pixel) -
-                                           thicken (sel->rs, 0, 2*pixel)));
+      selection_rects= outline (sel->rs, pixel);
       invalidate (selection_rects);
diff --git a/src/src/Edit/Interface/edit_interface.hpp 
index 05cf7d8..dbf5c85 100644
--- a/src/src/Edit/Interface/edit_interface.hpp
+++ b/src/src/Edit/Interface/edit_interface.hpp
@@ -55,6 +55,7 @@ protected:
   bool          table_selection;
   rectangles    selection_rects;
   rectangles    env_rects;
+  rectangles    tblcell_rects;
   cursor        oc;
   bool          temp_invalid_cursor;
   array<string> completions;
@@ -110,7 +111,7 @@ public:
   void animate ();
   /* miscellaneous */
-  void compute_env_rects (path p, rectangles& rs, bool recurse);
+  void compute_env_rects (path p, rectangles& rs, rectangles& trs, bool 
   void cursor_visible ();
   void selection_visible ();
   void full_screen_mode (bool flag);
diff --git a/src/src/Edit/Interface/edit_repaint.cpp 
index 69a1efd..08a2a6b 100644
--- a/src/src/Edit/Interface/edit_repaint.cpp
+++ b/src/src/Edit/Interface/edit_repaint.cpp
@@ -35,9 +35,15 @@ edit_interface_rep::draw_text (renderer ren, rectangles& l) {
 edit_interface_rep::draw_env (renderer ren) {
   if (!full_screen) {
-    rectangles rs= env_rects;
+    rectangles rs= tblcell_rects;
     while (!is_nil (rs)) {
-      ren->set_color (rgb_color (0, 255, 255));
+      ren->set_color (rgb_color (224, 224, 224));
+      ren->fill (rs->item->x1, rs->item->y1, rs->item->x2, rs->item->y2);
+      rs= rs->next;
+    }
+    rs= env_rects;
+    while (!is_nil (rs)) {
+      ren->set_color (rgb_color (162, 224, 224));
       ren->fill (rs->item->x1, rs->item->y1, rs->item->x2, rs->item->y2);
       rs= rs->next;
diff --git a/src/src/Kernel/Types/rectangles.cpp 
index 5c44903..a3fd794 100644
--- a/src/src/Kernel/Types/rectangles.cpp
+++ b/src/src/Kernel/Types/rectangles.cpp
@@ -193,9 +193,26 @@ thicken (rectangles l, SI width, SI height) {
+halfshift (rectangles rs,SI pixel) {
+  if (is_nil (rs)) return rs;
+  rectangle& r= rs->item;
+  return rectangles (rectangle (r->x1, r->y1, r->x2+pixel, r->y2+pixel),
+                     halfshift (rs->next,pixel));
 outline (rectangles rs, SI pixel) {
-  return simplify (correct (thicken (rs, pixel, 3*pixel) -
-                           thicken (rs, 0, 2*pixel)));
+  return simplify (correct (
+    thicken (halfshift (rs,pixel), 0, 2*pixel)
+    - thicken (halfshift(rs,pixel), -pixel, pixel)
+  ));
+outline_narrow (rectangles rs,SI pixel) {
+  return simplify (correct (
+    halfshift (rs,pixel) - thicken (halfshift(rs,pixel), -pixel, -pixel)
+  ));
diff --git a/src/src/Kernel/Types/rectangles.hpp 
index 9021eef..c4f4758 100644
--- a/src/src/Kernel/Types/rectangles.hpp
+++ b/src/src/Kernel/Types/rectangles.hpp
@@ -51,6 +51,7 @@ rectangles operator / (rectangles l, int d);
 rectangles translate (rectangles l, SI x, SI y);
 rectangles thicken (rectangles l, SI width, SI height);
 rectangles outline (rectangles l, SI pixel);
+rectangles outline_narrow (rectangles l, SI pixel);
 rectangles correct (rectangles l);
 rectangles simplify (rectangles l);
 rectangle  least_upper_bound (rectangles l);

reply via email to

[Prev in Thread] Current Thread [Next in Thread]