Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse code

Implement enhancement for swithable navigation modes: https://bugzill…

  • Loading branch information...
commit 82a9ca16ca7744b26401d1e6a27bbb58392f9873 1 parent de1ba99
Alex Eng authored October 06, 2011
1  server/zanata-war/src/main/java/org/zanata/webtrans/client/TransUnitNavigationView.java
@@ -24,7 +24,6 @@
24 24
 
25 25
 import org.zanata.common.ContentState;
26 26
 import org.zanata.webtrans.client.editor.table.NavigationMessages;
27  
-import org.zanata.webtrans.client.editor.table.TableConstants;
28 27
 
29 28
 import com.google.gwt.core.client.GWT;
30 29
 import com.google.gwt.event.dom.client.HasClickHandlers;
14  server/zanata-war/src/main/java/org/zanata/webtrans/client/editor/table/InlineTargetCellEditor.java
@@ -466,23 +466,23 @@ public void savePendingChange(boolean cancelIfUnchanged)
466 466
       }
467 467
    }
468 468
 
469  
-   private boolean fuzzyMode = true, newMode = true;
  469
+   private boolean newMode = true, fuzzyMode = true;
470 470
 
471 471
    public void saveAndMoveNextState(NavigationType nav)
472 472
    {
473 473
       savePendingChange(true);
474 474
       
475  
-      if (fuzzyMode && !newMode)
  475
+      if (newMode && fuzzyMode)
476 476
       {
477  
-         gotoFuzzyRow(nav);
  477
+         gotoFuzzyAndNewRow(nav);
478 478
       }
479  
-      else if (fuzzyMode && !newMode)
  479
+      else if (newMode)
480 480
       {
481 481
          gotoNewRow(nav);
482 482
       }
483  
-      else
  483
+      else if (fuzzyMode)
484 484
       {
485  
-         gotoFuzzyAndNewRow(nav);
  485
+         gotoFuzzyRow(nav);
486 486
       }
487 487
    }
488 488
 
@@ -612,7 +612,7 @@ public void autoSize()
612 612
 
613 613
    public void setNavMode(Map<ContentState, Boolean> configMap)
614 614
    {
615  
-      fuzzyMode = configMap.get(ContentState.NeedReview);
616 615
       newMode = configMap.get(ContentState.New);
  616
+      fuzzyMode = configMap.get(ContentState.NeedReview);
617 617
    }
618 618
 }
4  server/zanata-war/src/main/java/org/zanata/webtrans/client/editor/table/NavigationCacheCallback.java
@@ -23,7 +23,7 @@
23 23
 
24 24
 public interface NavigationCacheCallback
25 25
 {
26  
-   void nextFuzzy();
  26
+   void next(boolean isNewState, boolean isFuzzyState);
27 27
 
28  
-   void prevFuzzy();
  28
+   void prev(boolean isNewState, boolean isFuzzyState);
29 29
 }
186  server/zanata-war/src/main/java/org/zanata/webtrans/client/editor/table/TableEditorPresenter.java
@@ -143,9 +143,15 @@
143 143
    private final Identity identity;
144 144
    private TransUnit selectedTransUnit;
145 145
    // private int lastRowNum;
  146
+   private List<Long> transIdNextNewFuzzyCache = new ArrayList<Long>();
  147
+   private List<Long> transIdPrevNewFuzzyCache = new ArrayList<Long>();
  148
+
146 149
    private List<Long> transIdNextFuzzyCache = new ArrayList<Long>();
147 150
    private List<Long> transIdPrevFuzzyCache = new ArrayList<Long>();
148 151
 
  152
+   private List<Long> transIdNextNewCache = new ArrayList<Long>();
  153
+   private List<Long> transIdPrevNewCache = new ArrayList<Long>();
  154
+
149 155
    private int curRowIndex;
150 156
    private int curPage;
151 157
 
@@ -293,10 +299,10 @@ public void onTransUnitUpdated(TransUnitUpdatedEvent event)
293 299
             if (documentId != null && documentId.equals(event.getDocumentId()))
294 300
             {
295 301
                // Clear the cache
296  
-               if (!transIdNextFuzzyCache.isEmpty())
297  
-                  transIdNextFuzzyCache.clear();
298  
-               if (!transIdPrevFuzzyCache.isEmpty())
299  
-                  transIdPrevFuzzyCache.clear();
  302
+               if (!transIdNextNewFuzzyCache.isEmpty())
  303
+                  transIdNextNewFuzzyCache.clear();
  304
+               if (!transIdPrevNewFuzzyCache.isEmpty())
  305
+                  transIdPrevNewFuzzyCache.clear();
300 306
                // TODO this test never succeeds
301 307
                if (selectedTransUnit != null && selectedTransUnit.getId().equals(event.getTransUnit().getId()))
302 308
                {
@@ -652,7 +658,7 @@ public void nextFuzzyNewIndex(int row)
652 658
       {
653 659
          updatePageAndRowIndex(row);
654 660
          if (curRowIndex < display.getTableModel().getRowCount())
655  
-            gotoNextState();
  661
+            gotoNextState(true, true);
656 662
       }
657 663
 
658 664
       @Override
@@ -660,43 +666,39 @@ public void prevFuzzyNewIndex(int row)
660 666
       {
661 667
          updatePageAndRowIndex(row);
662 668
          if (curRowIndex > 0)
663  
-            gotoPrevState();
  669
+            gotoPrevState(true, true);
664 670
       }
665 671
 
666 672
       @Override
667 673
       public void nextFuzzyIndex(int row)
668 674
       {
669  
-         // TODO: ALEX
670 675
          updatePageAndRowIndex(row);
671 676
          if (curRowIndex < display.getTableModel().getRowCount())
672  
-            gotoNextState();
  677
+            gotoNextState(false, true);
673 678
       }
674 679
 
675 680
       @Override
676 681
       public void prevFuzzyIndex(int row)
677 682
       {
678  
-         // TODO: ALEX
679 683
          updatePageAndRowIndex(row);
680 684
          if (curRowIndex > 0)
681  
-            gotoPrevState();
  685
+            gotoPrevState(false, true);
682 686
       }
683 687
 
684 688
       @Override
685 689
       public void nextNewIndex(int row)
686 690
       {
687  
-         // TODO: ALEX
688 691
          updatePageAndRowIndex(row);
689 692
          if (curRowIndex < display.getTableModel().getRowCount())
690  
-            gotoNextState();
  693
+            gotoNextState(true, false);
691 694
       }
692 695
 
693 696
       @Override
694 697
       public void prevNewIndex(int row)
695 698
       {
696  
-         // TODO: ALEX
697 699
          updatePageAndRowIndex(row);
698 700
          if (curRowIndex > 0)
699  
-            gotoPrevState();
  701
+            gotoPrevState(true, false);
700 702
       }
701 703
 
702 704
       @Override
@@ -743,10 +745,10 @@ public void onFailure(Throwable caught)
743 745
 
744 746
    boolean isReqComplete = true;
745 747
 
746  
-   private void cacheNextFuzzy(final NavigationCacheCallback callBack)
  748
+   private void cacheNextState(final NavigationCacheCallback callBack, final List<Long> cacheList, final boolean isNewState, final boolean isFuzzyState)
747 749
    {
748 750
       isReqComplete = false;
749  
-      dispatcher.execute(new GetTransUnitsNavigation(selectedTransUnit.getId().getId(), 3, false, findMessage, true, true), new AsyncCallback<GetTransUnitsNavigationResult>()
  751
+      dispatcher.execute(new GetTransUnitsNavigation(selectedTransUnit.getId().getId(), 3, false, findMessage, isNewState, isFuzzyState), new AsyncCallback<GetTransUnitsNavigationResult>()
750 752
       {
751 753
          @Override
752 754
          public void onSuccess(GetTransUnitsNavigationResult result)
@@ -756,9 +758,9 @@ public void onSuccess(GetTransUnitsNavigationResult result)
756 758
             {
757 759
                for (Long offset : result.getUnits())
758 760
                {
759  
-                  transIdNextFuzzyCache.add(offset + curRowIndex);
  761
+                  cacheList.add(offset + curRowIndex);
760 762
                }
761  
-               callBack.nextFuzzy();
  763
+               callBack.next(isNewState, isFuzzyState);
762 764
             }
763 765
          }
764 766
 
@@ -770,10 +772,10 @@ public void onFailure(Throwable caught)
770 772
       });
771 773
    }
772 774
 
773  
-   private void cachePrevFuzzy(final NavigationCacheCallback callBack)
  775
+   private void cachePrevState(final NavigationCacheCallback callBack, final List<Long> cacheList, final boolean isNewState, final boolean isFuzzyState)
774 776
    {
775 777
       isReqComplete = false;
776  
-      dispatcher.execute(new GetTransUnitsNavigation(selectedTransUnit.getId().getId(), 3, true, findMessage, true, true), new AsyncCallback<GetTransUnitsNavigationResult>()
  778
+      dispatcher.execute(new GetTransUnitsNavigation(selectedTransUnit.getId().getId(), 3, true, findMessage, isNewState, isFuzzyState), new AsyncCallback<GetTransUnitsNavigationResult>()
777 779
       {
778 780
          @Override
779 781
          public void onSuccess(GetTransUnitsNavigationResult result)
@@ -783,9 +785,9 @@ public void onSuccess(GetTransUnitsNavigationResult result)
783 785
             {
784 786
                for (Long offset : result.getUnits())
785 787
                {
786  
-                  transIdPrevFuzzyCache.add(curRowIndex - offset);
  788
+                  cacheList.add(curRowIndex - offset);
787 789
                }
788  
-               callBack.prevFuzzy();
  790
+               callBack.prev(isNewState, isFuzzyState);
789 791
             }
790 792
          }
791 793
 
@@ -797,93 +799,135 @@ public void onFailure(Throwable caught)
797 799
       });
798 800
    }
799 801
 
800  
-   private void gotoPrevState()
  802
+   NavigationCacheCallback cacheCallback = new NavigationCacheCallback()
  803
+   {
  804
+      @Override
  805
+      public void next(boolean isNewState, boolean isFuzzyState)
  806
+      {
  807
+         gotoNextState(isNewState, isFuzzyState);
  808
+      }
  809
+
  810
+      @Override
  811
+      public void prev(boolean isNewState, boolean isFuzzyState)
  812
+      {
  813
+         gotoPrevState(isNewState, isFuzzyState);
  814
+      }
  815
+
  816
+   };
  817
+
  818
+   private void gotoNextState(boolean isNewState, boolean isFuzzyState)
  819
+   {
  820
+      if (isNewState && isFuzzyState)
  821
+      {
  822
+         Log.info("go to Next Fuzzy Or Untranslated State");
  823
+         transIdPrevNewFuzzyCache.clear();
  824
+         gotoNextState(transIdNextNewFuzzyCache, true, true);
  825
+      }
  826
+      else if (isNewState)
  827
+      {
  828
+         Log.info("go to Next Untranslated State");
  829
+         transIdPrevNewCache.clear();
  830
+         gotoNextState(transIdNextNewCache, true, false);
  831
+      }
  832
+      else if (isFuzzyState)
  833
+      {
  834
+         Log.info("go to Next Fuzzy State");
  835
+         transIdPrevFuzzyCache.clear();
  836
+         gotoNextState(transIdNextFuzzyCache, false, true);
  837
+      }
  838
+   }
  839
+
  840
+   private void gotoPrevState(boolean isNewState, boolean isFuzzyState)
801 841
    {
802  
-      Log.info("Previous FuzzyOrUntranslated State");
  842
+      if (isNewState && isFuzzyState)
  843
+      {
  844
+         Log.info("go to Prev Fuzzy Or Untranslated State");
  845
+         // Clean the cache for Next Fuzzy to avoid issues about cache is
  846
+         // obsolete
  847
+         transIdNextNewFuzzyCache.clear();
  848
+         gotoPrevState(transIdPrevNewFuzzyCache, true, true);
  849
+      }
  850
+      else if (isNewState)
  851
+      {
  852
+         Log.info("go to Prev Untranslated State");
  853
+         // Clean the cache for Next Fuzzy to avoid issues about cache is
  854
+         // obsolete
  855
+         transIdNextNewCache.clear();
  856
+         gotoPrevState(transIdPrevNewCache, true, false);
  857
+      }
  858
+      else if (isFuzzyState)
  859
+      {
  860
+         Log.info("go to Prev Fuzzy State");
  861
+         // Clean the cache for Next Fuzzy to avoid issues about cache is
  862
+         // obsolete
  863
+         transIdNextFuzzyCache.clear();
  864
+         gotoPrevState(transIdPrevFuzzyCache, false, true);
  865
+      }
  866
+   }
803 867
 
804  
-      // Clean the cache for Next Fuzzy to avoid issues about cache is
805  
-      // obsolete
806  
-      transIdNextFuzzyCache.clear();
807  
-      // If the catch of fuzzy row is empty and request is complete, generate
  868
+   private void gotoPrevState(List<Long> transIdPrevCache, boolean isNewState, boolean isFuzzyState)
  869
+   {
  870
+      // If the catch of row is empty and request is complete, generate
808 871
       // one
809  
-      if (transIdPrevFuzzyCache.isEmpty())
  872
+      if (transIdPrevCache.isEmpty())
810 873
       {
811 874
          if (isReqComplete)
812  
-            cachePrevFuzzy(cacheCallback);
  875
+            cachePrevState(cacheCallback, transIdPrevCache, isNewState, isFuzzyState);
813 876
       }
814 877
       else
815 878
       {
816  
-         int size = transIdPrevFuzzyCache.size();
817  
-         int offset = transIdPrevFuzzyCache.get(size - 1).intValue();
  879
+         int size = transIdPrevCache.size();
  880
+         int offset = transIdPrevCache.get(size - 1).intValue();
818 881
          if (curRowIndex > offset)
819 882
          {
820 883
             for (int i = 0; i < size; i++)
821 884
             {
822  
-               int fuzzyRowIndex = transIdPrevFuzzyCache.get(i).intValue();
823  
-               if (curRowIndex > fuzzyRowIndex)
  885
+               int newRowIndex = transIdPrevCache.get(i).intValue();
  886
+               if (curRowIndex > newRowIndex)
824 887
                {
825 888
                   display.getTargetCellEditor().cancelEdit();
826  
-                  tableModelHandler.gotoRow(fuzzyRowIndex);
  889
+                  tableModelHandler.gotoRow(newRowIndex);
827 890
                   break;
828 891
                }
829 892
             }
830 893
          }
831 894
          else
832 895
          {
833  
-            transIdPrevFuzzyCache.clear();
834  
-            cachePrevFuzzy(cacheCallback);
  896
+            transIdPrevCache.clear();
  897
+            cachePrevState(cacheCallback, transIdPrevCache, isNewState, isFuzzyState);
835 898
          }
836 899
       }
837 900
    }
838 901
 
839  
-   NavigationCacheCallback cacheCallback = new NavigationCacheCallback()
840  
-   {
841  
-      @Override
842  
-      public void nextFuzzy()
843  
-      {
844  
-         gotoNextState();
845  
-      }
846  
-
847  
-      @Override
848  
-      public void prevFuzzy()
849  
-      {
850  
-         gotoPrevState();
851  
-      }
852  
-
853  
-   };
854  
-
855  
-   private void gotoNextState()
  902
+   private void gotoNextState(List<Long> transIdNextCache, boolean isNewState, boolean isFuzzyState)
856 903
    {
857  
-      Log.info("go to Next FuzzyOrUntranslated State");
858  
-
859  
-      transIdPrevFuzzyCache.clear();
860  
-      // If the cache of next fuzzy is empty, generate one
861  
-      if (transIdNextFuzzyCache.isEmpty())
  904
+      // If the cache of next is empty, generate one
  905
+      if (transIdNextCache.isEmpty())
862 906
       {
863 907
          if (isReqComplete)
864  
-            cacheNextFuzzy(cacheCallback);
  908
+            cacheNextState(cacheCallback, transIdNextCache, isNewState, isFuzzyState);
865 909
       }
866 910
       else
867 911
       {
868  
-         int size = transIdNextFuzzyCache.size();
869  
-         int offset = transIdNextFuzzyCache.get(size - 1).intValue();
  912
+         int size = transIdNextCache.size();
  913
+         int offset = transIdNextCache.get(size - 1).intValue();
870 914
          if (curRowIndex < offset)
871 915
          {
872 916
             for (int i = 0; i < size; i++)
873 917
             {
874  
-               int fuzzyRowIndex = transIdNextFuzzyCache.get(i).intValue();
875  
-               if (curRowIndex < fuzzyRowIndex)
  918
+               int newRowIndex = transIdNextCache.get(i).intValue();
  919
+               if (curRowIndex < newRowIndex)
876 920
                {
877 921
                   display.getTargetCellEditor().cancelEdit();
878  
-                  tableModelHandler.gotoRow(fuzzyRowIndex);
  922
+                  tableModelHandler.gotoRow(newRowIndex);
879 923
                   break;
880 924
                }
881 925
             }
882 926
          }
883 927
          else
884 928
          {
885  
-            transIdNextFuzzyCache.clear();
886  
-            cacheNextFuzzy(cacheCallback);
  929
+            transIdNextCache.clear();
  930
+            cacheNextState(cacheCallback, transIdNextCache, isNewState, isFuzzyState);
887 931
          }
888 932
       }
889 933
    }
@@ -960,10 +1004,10 @@ public void selectTransUnit(TransUnit transUnit)
960 1004
          selectedTransUnit = transUnit;
961 1005
          Log.info("SelectedTransUnit " + selectedTransUnit.getId());
962 1006
          // Clean the cache when we click the new entry
963  
-         if (!transIdNextFuzzyCache.isEmpty())
964  
-            transIdNextFuzzyCache.clear();
965  
-         if (!transIdPrevFuzzyCache.isEmpty())
966  
-            transIdPrevFuzzyCache.clear();
  1007
+         if (!transIdNextNewFuzzyCache.isEmpty())
  1008
+            transIdNextNewFuzzyCache.clear();
  1009
+         if (!transIdPrevNewFuzzyCache.isEmpty())
  1010
+            transIdPrevNewFuzzyCache.clear();
967 1011
 
968 1012
          eventBus.fireEvent(new TransUnitSelectionEvent(selectedTransUnit));
969 1013
       }
19  server/zanata-war/src/main/java/org/zanata/webtrans/client/ui/ShortcutConfigPanel.java
@@ -28,6 +28,7 @@
28 28
 import org.zanata.common.ContentState;
29 29
 import org.zanata.webtrans.client.events.NavConfigChangeEvent;
30 30
 
  31
+import com.allen_sauer.gwt.log.client.Log;
31 32
 import com.google.gwt.event.logical.shared.ValueChangeEvent;
32 33
 import com.google.gwt.event.logical.shared.ValueChangeHandler;
33 34
 import com.google.gwt.user.client.ui.CheckBox;
@@ -58,7 +59,7 @@ public ShortcutConfigPanel(boolean autoHide, EventBus eventBus)
58 59
       this.eventBus = eventBus;
59 60
       init();
60 61
       bindEvent();
61  
-      setButtonValue(true, true);
  62
+      setDefaultValue();
62 63
    }
63 64
 
64 65
    private void init()
@@ -84,12 +85,13 @@ public void onValueChange(ValueChangeEvent<Boolean> event)
84 85
          {
85 86
             if (event.getValue() == false && untranslatedChk.getValue() == false)
86 87
             {
87  
-               setButtonValue(true, true);
  88
+               setDefaultValue();
88 89
             }
89 90
             else
90 91
             {
91 92
                configMap.put(ContentState.NeedReview, event.getValue());
92 93
             }
  94
+            Log.info("Navigation mode changed: Untranslated-" + untranslatedChk.getValue() + " Fuzzy-" + fuzzyChk.getValue());
93 95
             eventBus.fireEvent(new NavConfigChangeEvent(configMap));
94 96
          }
95 97
       });
@@ -101,25 +103,26 @@ public void onValueChange(ValueChangeEvent<Boolean> event)
101 103
          {
102 104
             if (event.getValue() == false && fuzzyChk.getValue() == false)
103 105
             {
104  
-               setButtonValue(true, true);
  106
+               setDefaultValue();
105 107
             }
106 108
             else
107 109
             {
108 110
                configMap.put(ContentState.New, event.getValue());
109 111
             }
  112
+            Log.info("Navigation mode changed: Untranslated-" + untranslatedChk.getValue() + " Fuzzy-" + fuzzyChk.getValue());
110 113
             eventBus.fireEvent(new NavConfigChangeEvent(configMap));
111 114
          }
112 115
       });
113 116
 
114 117
    }
115 118
 
116  
-   private void setButtonValue(boolean fuzzyValue, boolean untranslatedValue)
  119
+   private void setDefaultValue()
117 120
    {
118  
-      fuzzyChk.setValue(fuzzyValue);
119  
-      untranslatedChk.setValue(untranslatedValue);
  121
+      fuzzyChk.setValue(true);
  122
+      untranslatedChk.setValue(true);
120 123
 
121  
-      configMap.put(ContentState.NeedReview, fuzzyValue);
122  
-      configMap.put(ContentState.New, untranslatedValue);
  124
+      configMap.put(ContentState.NeedReview, true);
  125
+      configMap.put(ContentState.New, true);
123 126
    }
124 127
 
125 128
    public void toggleDisplay(final UIObject target)
11  server/zanata-war/src/main/java/org/zanata/webtrans/server/rpc/GetTransUnitNavigationHandler.java
@@ -94,7 +94,7 @@ public GetTransUnitsNavigationResult execute(GetTransUnitsNavigation action, Exe
94 94
                step++;
95 95
                HTextFlow textFlow = textFlowDAO.findById(textFlowId, false);
96 96
                HTextFlowTarget textFlowTarget = textFlow.getTargets().get(hLocale);
97  
-               if (checkStateAndValidate(action.isFuzzyState(), action.isNewState(), textFlowTarget))
  97
+               if (checkStateAndValidate(action.isNewState(), action.isFuzzyState(), textFlowTarget))
98 98
                {
99 99
                   results.add(step);
100 100
                   log.info("add navigation step: " + step);
@@ -118,7 +118,8 @@ public GetTransUnitsNavigationResult execute(GetTransUnitsNavigation action, Exe
118 118
             {
119 119
                step++;
120 120
                HTextFlowTarget textFlowTarget = textFlow.getTargets().get(hLocale);
121  
-               if (checkStateAndValidate(action.isFuzzyState(), action.isNewState(), textFlowTarget))
  121
+               log.info(action.isNewState() + ":" + action.isFuzzyState() + ":" + checkStateAndValidate(action.isNewState(), action.isFuzzyState(), textFlowTarget));
  122
+               if (checkStateAndValidate(action.isNewState(), action.isFuzzyState(), textFlowTarget))
122 123
                {
123 124
                   results.add(step);
124 125
                   log.info("add navigation step: " + step);
@@ -140,9 +141,9 @@ public void rollback(GetTransUnitsNavigation action, GetTransUnitsNavigationResu
140 141
    {
141 142
    }
142 143
 
143  
-   private boolean checkStateAndValidate(boolean isFuzzyState, boolean isNewState, HTextFlowTarget textFlowTarget)
  144
+   private boolean checkStateAndValidate(boolean isNewState, boolean isFuzzyState, HTextFlowTarget textFlowTarget)
144 145
    {
145  
-      if (isFuzzyState && isNewState)
  146
+      if (isNewState && isFuzzyState)
146 147
       {
147 148
          return isNewFuzzyState(textFlowTarget);
148 149
       }
@@ -159,7 +160,7 @@ else if (isNewState)
159 160
 
160 161
    private boolean isNewFuzzyState(HTextFlowTarget textFlowTarget)
161 162
    {
162  
-      return isNewState(textFlowTarget) || isFuzzyState(textFlowTarget);
  163
+      return textFlowTarget == null || textFlowTarget.getState() == ContentState.New || textFlowTarget.getState() == ContentState.NeedReview;
163 164
    }
164 165
 
165 166
    private boolean isFuzzyState(HTextFlowTarget textFlowTarget)
4  server/zanata-war/src/main/java/org/zanata/webtrans/shared/rpc/GetTransUnitsNavigation.java
@@ -38,14 +38,14 @@ private GetTransUnitsNavigation()
38 38
    {
39 39
    }
40 40
 
41  
-   public GetTransUnitsNavigation(Long id, int count, boolean reverse, String phrase, boolean isFuzzyState, boolean isNewState)
  41
+   public GetTransUnitsNavigation(Long id, int count, boolean reverse, String phrase, boolean isNewState, boolean isFuzzyState)
42 42
    {
43 43
       this.id = id;
44 44
       this.count = count;
45 45
       this.setReverse(reverse);
46 46
       this.phrase = phrase;
47  
-      this.isFuzzyState = isFuzzyState;
48 47
       this.isNewState = isNewState;
  48
+      this.isFuzzyState = isFuzzyState;
49 49
    }
50 50
 
51 51
 

0 notes on commit 82a9ca1

Please sign in to comment.
Something went wrong with that request. Please try again.